From 01f91238535c847611057ff0306e45cf21b9bb96 Mon Sep 17 00:00:00 2001
From: Guillaume Dalle <22795598+gdalle@users.noreply.github.com>
Date: Wed, 5 Jul 2023 12:06:41 +0200
Subject: [PATCH 01/41] Fix weird dispatch of * with zero arguments (#50411)

(cherry picked from commit d70ee20077a97ca9598b42bfc19bee21c949579a)
---
 stdlib/LinearAlgebra/src/givens.jl | 4 +++-
 test/operators.jl                  | 7 +++++++
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/stdlib/LinearAlgebra/src/givens.jl b/stdlib/LinearAlgebra/src/givens.jl
index c37df41f9567c..4668d5f542a91 100644
--- a/stdlib/LinearAlgebra/src/givens.jl
+++ b/stdlib/LinearAlgebra/src/givens.jl
@@ -417,7 +417,9 @@ function *(G1::Givens{S}, G2::Givens{T}) where {S,T}
     TS = promote_type(T, S)
     Rotation{TS}([convert(AbstractRotation{TS}, G2), convert(AbstractRotation{TS}, G1)])
 end
-*(G::Givens{T}...) where {T} = Rotation([reverse(G)...])
+function *(G::Givens{T}, Gs::Givens{T}...) where {T}
+    return Rotation([reverse(Gs)..., G])
+end
 function *(G::Givens{S}, R::Rotation{T}) where {S,T}
     TS = promote_type(T, S)
     Rotation(vcat(convert(AbstractRotation{TS}, R).rotations, convert(AbstractRotation{TS}, G)))
diff --git a/test/operators.jl b/test/operators.jl
index 46cf6c7526299..715212a80a54f 100644
--- a/test/operators.jl
+++ b/test/operators.jl
@@ -154,6 +154,13 @@ Base.convert(::Type{T19714}, ::Int) = T19714()
 Base.promote_rule(::Type{T19714}, ::Type{Int}) = T19714
 @test T19714()/1 === 1/T19714() === T19714()
 
+@testset "operators with zero argument" begin
+    @test_throws(MethodError, +())
+    @test_throws(MethodError, *())
+    @test isempty(methods(+, ()))
+    @test isempty(methods(*, ()))
+end
+
 # pr #17155 and #33568
 @testset "function composition" begin
     @test (uppercase∘(x->string(x,base=16)))(239487) == "3A77F"

From 7d01eaa2dc951b353dfc7d29fb34d804847b8344 Mon Sep 17 00:00:00 2001
From: Valentin Churavy <vchuravy@users.noreply.github.com>
Date: Wed, 5 Jul 2023 12:11:13 +0200
Subject: [PATCH 02/41] Remove dynamic dispatch from _wait/wait2 (#50202)

Co-authored-by: Gabriel Baraldi <baraldigabriel@gmail.com>
(cherry picked from commit e025877105630311b7f07d470d3cecda11a3e5d7)
---
 base/task.jl | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/base/task.jl b/base/task.jl
index 4fbb51fde3e8e..f7a82b9c42ab9 100644
--- a/base/task.jl
+++ b/base/task.jl
@@ -303,13 +303,14 @@ end
 # just wait for a task to be done, no error propagation
 function _wait(t::Task)
     if !istaskdone(t)
-        lock(t.donenotify)
+        donenotify = t.donenotify::ThreadSynchronizer
+        lock(donenotify)
         try
             while !istaskdone(t)
-                wait(t.donenotify)
+                wait(donenotify)
             end
         finally
-            unlock(t.donenotify)
+            unlock(donenotify)
         end
     end
     nothing
@@ -330,13 +331,14 @@ function _wait2(t::Task, waiter::Task)
             tid = Threads.threadid()
             ccall(:jl_set_task_tid, Cint, (Any, Cint), waiter, tid-1)
         end
-        lock(t.donenotify)
+        donenotify = t.donenotify::ThreadSynchronizer
+        lock(donenotify)
         if !istaskdone(t)
-            push!(t.donenotify.waitq, waiter)
-            unlock(t.donenotify)
+            push!(donenotify.waitq, waiter)
+            unlock(donenotify)
             return nothing
         else
-            unlock(t.donenotify)
+            unlock(donenotify)
         end
     end
     schedule(waiter)

From f250b760285701729cb2ec09db01a7ce9d16171b Mon Sep 17 00:00:00 2001
From: Loong <wangl.cc@outlook.com>
Date: Wed, 5 Jul 2023 18:12:43 +0800
Subject: [PATCH 03/41] Check input expresion in numbered prompt (#50064)

(cherry picked from commit 7e3c706a879ae6d381737e13ce9b3275d083a86a)
---
 stdlib/REPL/src/REPL.jl  | 1 +
 stdlib/REPL/test/repl.jl | 4 ++++
 2 files changed, 5 insertions(+)

diff --git a/stdlib/REPL/src/REPL.jl b/stdlib/REPL/src/REPL.jl
index f8bb442ad6ec4..1328a87f1a77d 100644
--- a/stdlib/REPL/src/REPL.jl
+++ b/stdlib/REPL/src/REPL.jl
@@ -1418,6 +1418,7 @@ function out_transform(@nospecialize(x), n::Ref{Int})
 end
 
 function get_usings!(usings, ex)
+    ex isa Expr || return usings
     # get all `using` and `import` statements which are at the top level
     for (i, arg) in enumerate(ex.args)
         if Base.isexpr(arg, :toplevel)
diff --git a/stdlib/REPL/test/repl.jl b/stdlib/REPL/test/repl.jl
index 8a6c6a3445e0a..f0d5052ff9e32 100644
--- a/stdlib/REPL/test/repl.jl
+++ b/stdlib/REPL/test/repl.jl
@@ -1652,6 +1652,10 @@ fake_repl() do stdin_write, stdout_read, repl
     @test !contains(s, "ERROR")
     @test contains(s, "Test Passed")
 
+    # Test for https://github.com/JuliaLang/julia/issues/49319
+    s = sendrepl2("# comment", "In [16]")
+    @test !contains(s, "ERROR")
+
     write(stdin_write, '\x04')
     Base.wait(repltask)
 end

From afb80a119aa60dedc0a5920d1a291033aa7455b6 Mon Sep 17 00:00:00 2001
From: Adnan Alhomssi <adnan.alhomssi@relational.ai>
Date: Wed, 5 Jul 2023 12:16:01 +0200
Subject: [PATCH 04/41] Use tempdir() to store heap snapshot files instead of
 abspatch ~= rootdir (#50026)

(cherry picked from commit 877b368d78f9fbb6bb698f40f6e9c725ef057bd0)
---
 stdlib/Profile/src/Profile.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stdlib/Profile/src/Profile.jl b/stdlib/Profile/src/Profile.jl
index 71bbfc70ee937..f0323d0334b1a 100644
--- a/stdlib/Profile/src/Profile.jl
+++ b/stdlib/Profile/src/Profile.jl
@@ -1234,7 +1234,7 @@ function take_heap_snapshot(filepath::String, all_one::Bool=false)
     return filepath
 end
 function take_heap_snapshot(all_one::Bool=false)
-    f = abspath("$(getpid())_$(time_ns()).heapsnapshot")
+    f = joinpath(tempdir(), "$(getpid())_$(time_ns()).heapsnapshot")
     return take_heap_snapshot(f, all_one)
 end
 

From 019e08f63aa61010db863ebcf15d325884a4050d Mon Sep 17 00:00:00 2001
From: William Moses <gh@wsmoses.com>
Date: Wed, 5 Jul 2023 07:32:13 -0400
Subject: [PATCH 05/41] Add CPU feature helper function (#50402)

(cherry picked from commit 435c1c1a2c9db60be89b82bb9438916ac891a1ff)
---
 src/jl_exported_funcs.inc  | 1 +
 src/processor.h            | 2 ++
 src/processor_arm.cpp      | 5 +++++
 src/processor_fallback.cpp | 5 +++++
 src/processor_x86.cpp      | 5 +++++
 test/sysinfo.jl            | 3 +++
 6 files changed, 21 insertions(+)

diff --git a/src/jl_exported_funcs.inc b/src/jl_exported_funcs.inc
index fd824131bdbda..6875e36d6da6a 100644
--- a/src/jl_exported_funcs.inc
+++ b/src/jl_exported_funcs.inc
@@ -212,6 +212,7 @@
     XX(jl_get_binding_or_error) \
     XX(jl_get_binding_wr) \
     XX(jl_get_cpu_name) \
+    XX(jl_get_cpu_features) \
     XX(jl_get_current_task) \
     XX(jl_get_default_sysimg_path) \
     XX(jl_get_excstack) \
diff --git a/src/processor.h b/src/processor.h
index 3e83bbb2247d6..2255cf4c10daa 100644
--- a/src/processor.h
+++ b/src/processor.h
@@ -221,6 +221,8 @@ jl_image_t jl_init_processor_pkgimg(void *hdl);
 
 // Return the name of the host CPU as a julia string.
 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
 // For debugging only
 JL_DLLEXPORT void jl_dump_host_cpu(void);
diff --git a/src/processor_arm.cpp b/src/processor_arm.cpp
index 0797fa4381f9d..0a8090a8a6d9c 100644
--- a/src/processor_arm.cpp
+++ b/src/processor_arm.cpp
@@ -1802,6 +1802,11 @@ 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_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 1aebde6dab90a..d50edc8e9b621 100644
--- a/src/processor_fallback.cpp
+++ b/src/processor_fallback.cpp
@@ -164,6 +164,11 @@ 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 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 e129b1239c7df..b9e7d8c0f0daf 100644
--- a/src/processor_x86.cpp
+++ b/src/processor_x86.cpp
@@ -1042,6 +1042,11 @@ 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_image_t jl_init_processor_sysimg(void *hdl)
 {
     if (!jit_targets.empty())
diff --git a/test/sysinfo.jl b/test/sysinfo.jl
index 3a16dc73b4f6a..cb943cfd38843 100644
--- a/test/sysinfo.jl
+++ b/test/sysinfo.jl
@@ -10,6 +10,9 @@ Base.Sys.loadavg()
 @test Base.libllvm_path() isa Symbol
 @test contains(String(Base.libllvm_path()), "LLVM")
 
+@test length(ccall(:jl_get_cpu_name, String, ())) != 0
+@test length(ccall(:jl_get_cpu_features, String, ())) >= 0
+
 if Sys.isunix()
     mktempdir() do tempdir
         firstdir = joinpath(tempdir, "first")

From 0ae05d3033c1f3130b195e41b5668da5f9798652 Mon Sep 17 00:00:00 2001
From: Diogo Netto <61364108+d-netto@users.noreply.github.com>
Date: Wed, 5 Jul 2023 17:33:43 -0300
Subject: [PATCH 06/41] update halfpages pointer after actually sweeping pages
 (#50387)

(cherry picked from commit c09a199ead2c5301d721369fe87a3d11c99ed8f1)
---
 src/gc.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/gc.c b/src/gc.c
index 9fd93b7340d56..edc0fdb49c4a5 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -1542,7 +1542,6 @@ static void gc_sweep_pool(int sweep_full)
                 pg->nfree = (GC_PAGE_SZ - (last_p - gc_page_data(last_p - 1))) / p->osize;
                 pg->has_young = 1;
             }
-            p->newpages = NULL;
         }
         jl_gc_pagemeta_t *pg = ptls2->page_metadata_lazily_freed;
         while (pg != NULL) {
@@ -1564,6 +1563,10 @@ static void gc_sweep_pool(int sweep_full)
                 pg = pg2;
             }
             ptls2->page_metadata_allocd = allocd;
+            for (int i = 0; i < JL_GC_N_POOLS; i++) {
+                jl_gc_pool_t *p = &ptls2->heap.norm_pools[i];
+                p->newpages = NULL;
+            }
         }
     }
 

From 51207fa7984d4df419e7266dbe8d5e3e76bf074c Mon Sep 17 00:00:00 2001
From: Gabriel Baraldi <baraldigabriel@gmail.com>
Date: Fri, 7 Jul 2023 11:55:56 -0300
Subject: [PATCH 07/41] Optimize getfield lowering to avoid boxing in some
 cases (#50444)

(cherry picked from commit 0718995f97c0d3df7f3f488523dd305c942efcf7)
---
 src/codegen.cpp           | 39 +++++++++++++++++++++++++++++++++++++++
 src/datatype.c            |  3 +--
 src/jl_exported_funcs.inc |  1 +
 src/julia.h               |  1 +
 src/rtutils.c             |  5 +++++
 test/compiler/codegen.jl  | 12 ++++++++++++
 6 files changed, 59 insertions(+), 2 deletions(-)

diff --git a/src/codegen.cpp b/src/codegen.cpp
index 122170ae3fa97..04f7564dd3e33 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -739,6 +739,13 @@ static const auto jlundefvarerror_func = new JuliaFunction<>{
             {PointerType::get(JuliaType::get_jlvalue_ty(C), AddressSpace::CalleeRooted)}, false); },
     get_attrs_noreturn,
 };
+static const auto jlhasnofield_func = new JuliaFunction<>{
+    XSTR(jl_has_no_field_error),
+    [](LLVMContext &C) { return FunctionType::get(getVoidTy(C),
+            {PointerType::get(JuliaType::get_jlvalue_ty(C), AddressSpace::CalleeRooted),
+             PointerType::get(JuliaType::get_jlvalue_ty(C), AddressSpace::CalleeRooted)}, false); },
+    get_attrs_noreturn,
+};
 static const auto jlboundserrorv_func = new JuliaFunction<TypeFnContextAndSizeT>{
     XSTR(jl_bounds_error_ints),
     [](LLVMContext &C, Type *T_size) { return FunctionType::get(getVoidTy(C),
@@ -3318,6 +3325,8 @@ static jl_llvm_functions_t
         jl_value_t *jlrettype,
         jl_codegen_params_t &params);
 
+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,
                               jl_expr_t *ex, bool is_promotable)
@@ -3819,6 +3828,19 @@ static bool emit_builtin_call(jl_codectx_t &ctx, jl_cgval_t *ret, jl_value_t *f,
                 return true;
             }
         }
+        else if (fld.typ == (jl_value_t*)jl_symbol_type) {
+            if (jl_is_datatype(utt) && !jl_is_namedtuple_type(utt)) { // TODO: Look into this for NamedTuple
+                if (jl_struct_try_layout(utt) && (jl_datatype_nfields(utt) == 1)) {
+                    jl_svec_t *fn = jl_field_names(utt);
+                    assert(jl_svec_len(fn) == 1);
+                    Value *typ_sym = literal_pointer_val(ctx, jl_svecref(fn, 0));
+                    Value *cond = ctx.builder.CreateICmpEQ(mark_callee_rooted(ctx, typ_sym), mark_callee_rooted(ctx, boxed(ctx, fld)));
+                    emit_hasnofield_error_ifnot(ctx, cond, utt->name->name, fld);
+                    *ret = emit_getfield_knownidx(ctx, obj, 0, utt, order);
+                    return true;
+                }
+            }
+        }
         // TODO: generic getfield func with more efficient calling convention
         return false;
     }
@@ -4612,6 +4634,22 @@ static void undef_var_error_ifnot(jl_codectx_t &ctx, Value *ok, jl_sym_t *name)
     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;
+    assert(name.typ == (jl_value_t*)jl_symbol_type);
+    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(jlhasnofield_func),
+                          {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);
+    ctx.builder.SetInsertPoint(ifok);
+}
+
 // returns a jl_ppvalue_t location for the global variable m.s
 // if the reference currently bound or assign == true,
 //   pbnd will also be assigned with the binding address
@@ -9011,6 +9049,7 @@ static void init_jit_functions(void)
     add_named_global(jlatomicerror_func, &jl_atomic_error);
     add_named_global(jlthrow_func, &jl_throw);
     add_named_global(jlundefvarerror_func, &jl_undefined_var_error);
+    add_named_global(jlhasnofield_func, &jl_has_no_field_error);
     add_named_global(jlboundserrorv_func, &jl_bounds_error_ints);
     add_named_global(jlboundserror_func, &jl_bounds_error_int);
     add_named_global(jlvboundserror_func, &jl_bounds_error_tuple_int);
diff --git a/src/datatype.c b/src/datatype.c
index 95c3b11c9abdc..905959fb80e0a 100644
--- a/src/datatype.c
+++ b/src/datatype.c
@@ -1558,8 +1558,7 @@ JL_DLLEXPORT int jl_field_index(jl_datatype_t *t, jl_sym_t *fld, int err)
         }
     }
     if (err)
-        jl_errorf("type %s has no field %s", jl_symbol_name(t->name->name),
-                  jl_symbol_name(fld));
+        jl_has_no_field_error(t->name->name, fld);
     return -1;
 }
 
diff --git a/src/jl_exported_funcs.inc b/src/jl_exported_funcs.inc
index 6875e36d6da6a..c2b2a1578fd76 100644
--- a/src/jl_exported_funcs.inc
+++ b/src/jl_exported_funcs.inc
@@ -510,6 +510,7 @@
     XX(jl_uncompress_argname_n) \
     XX(jl_uncompress_ir) \
     XX(jl_undefined_var_error) \
+    XX(jl_has_no_field_error) \
     XX(jl_value_ptr) \
     XX(jl_ver_is_release) \
     XX(jl_ver_major) \
diff --git a/src/julia.h b/src/julia.h
index d2eb9a98a4a42..5af8a5bc1a170 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -1790,6 +1790,7 @@ JL_DLLEXPORT void JL_NORETURN jl_type_error_rt(const char *fname,
                                                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_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,
                                               jl_value_t *t JL_MAYBE_UNROOTED);
diff --git a/src/rtutils.c b/src/rtutils.c
index 01ea11014a6db..eefd1b25f9bc4 100644
--- a/src/rtutils.c
+++ b/src/rtutils.c
@@ -134,6 +134,11 @@ JL_DLLEXPORT void JL_NORETURN jl_undefined_var_error(jl_sym_t *var)
     jl_throw(jl_new_struct(jl_undefvarerror_type, var));
 }
 
+JL_DLLEXPORT void JL_NORETURN jl_has_no_field_error(jl_sym_t *type_name, jl_sym_t *var)
+{
+    jl_errorf("type %s has no field %s", jl_symbol_name(type_name), jl_symbol_name(var));
+}
+
 JL_DLLEXPORT void JL_NORETURN jl_atomic_error(char *str) // == jl_exceptionf(jl_atomicerror_type, "%s", str)
 {
     jl_value_t *msg = jl_pchar_to_string((char*)str, strlen(str));
diff --git a/test/compiler/codegen.jl b/test/compiler/codegen.jl
index e93ecd232498f..85013ce30d2ca 100644
--- a/test/compiler/codegen.jl
+++ b/test/compiler/codegen.jl
@@ -820,3 +820,15 @@ end
 # issue 48917, hoisting load to above the parent
 f48917(x, w) = (y = (a=1, b=x); z = (; a=(a=(1, w), b=(3, y))))
 @test f48917(1,2) == (a = (a = (1, 2), b = (3, (a = 1, b = 1))),)
+
+# https://github.com/JuliaLang/julia/issues/50317 getproperty allocation on struct with 1 field
+struct Wrapper50317
+    lock::ReentrantLock
+end
+const MONITOR50317 = Wrapper50317(ReentrantLock())
+issue50317() = @noinline MONITOR50317.lock
+issue50317()
+let res = @timed issue50317()
+    @test res.bytes == 0
+    return res # must return otherwise the compiler may eliminate the result entirely
+end

From 4cf3007e4a897cec7db222b3a58e6a6f268dfc5f Mon Sep 17 00:00:00 2001
From: Kevin Song <chips@ksong.dev>
Date: Sat, 8 Jul 2023 14:54:20 -0500
Subject: [PATCH 08/41] docs: Fix a `!!! note` which was miscapitalized
 (#50474)

(cherry picked from commit 236c23b7945a578dd630cdf6af81ecbf7aafacf6)
---
 doc/src/manual/multi-threading.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/src/manual/multi-threading.md b/doc/src/manual/multi-threading.md
index 056ceb1363fd7..63902f1b7902b 100644
--- a/doc/src/manual/multi-threading.md
+++ b/doc/src/manual/multi-threading.md
@@ -292,7 +292,7 @@ sum_multi_good (generic function with 1 method)
 julia> sum_multi_good(1:1_000_000)
 500000500000
 ```
-!!! Note
+!!! note
     Buffers should not be managed based on `threadid()` i.e. `buffers = zeros(Threads.nthreads())` because concurrent tasks
     can yield, meaning multiple concurrent tasks may use the same buffer on a given thread, introducing risk of data races.
     Further, when more than one thread is available tasks may change thread at yield points, which is known as

From 85d7b42a66a1274a725e068ab4b741017555cefa Mon Sep 17 00:00:00 2001
From: Diogo Netto <61364108+d-netto@users.noreply.github.com>
Date: Sun, 9 Jul 2023 21:40:14 -0300
Subject: [PATCH 09/41] relax assertion involving pg->nold to reflect that it
 may be a bit inaccurate with parallel marking (#50466)

(cherry picked from commit 8e877cbb01d2c26a3fdcb7b9302f4d3ead229f9f)
---
 src/gc.c | 35 +++++++++++++++++++++--------------
 1 file changed, 21 insertions(+), 14 deletions(-)

diff --git a/src/gc.c b/src/gc.c
index edc0fdb49c4a5..dd3fa308a3867 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -854,7 +854,7 @@ STATIC_INLINE void gc_setmark_pool_(jl_ptls_t ptls, jl_taggedvalue_t *o,
     if (mark_mode == GC_OLD_MARKED) {
         ptls->gc_cache.perm_scanned_bytes += page->osize;
         static_assert(sizeof(_Atomic(uint16_t)) == sizeof(page->nold), "");
-        jl_atomic_fetch_add_relaxed((_Atomic(uint16_t)*)&page->nold, 1);
+        page->nold++;
     }
     else {
         ptls->gc_cache.scanned_bytes += page->osize;
@@ -1374,20 +1374,27 @@ static jl_taggedvalue_t **gc_sweep_page(jl_gc_pool_t *p, jl_gc_pagemeta_t **allo
         nfree = (GC_PAGE_SZ - GC_PAGE_OFFSET) / osize;
         goto done;
     }
-    // For quick sweep, we might be able to skip the page if the page doesn't
-    // have any young live cell before marking.
-    if (!sweep_full && !pg->has_young) {
-        assert(!prev_sweep_full || pg->prev_nold >= pg->nold);
-        if (!prev_sweep_full || pg->prev_nold == pg->nold) {
-            // the position of the freelist begin/end in this page
-            // is stored in its metadata
-            if (pg->fl_begin_offset != (uint16_t)-1) {
-                *pfl = page_pfl_beg(pg);
-                pfl = (jl_taggedvalue_t**)page_pfl_end(pg);
+    // note that `pg->nold` may not be accurate with multithreaded marking since
+    // two threads may race when trying to set the mark bit in `gc_try_setmark_tag`.
+    // We're basically losing a bit of precision in the sweep phase at the cost of
+    // making the mark phase considerably cheaper.
+    // See issue #50419
+    if (jl_n_markthreads == 0) {
+        // For quick sweep, we might be able to skip the page if the page doesn't
+        // have any young live cell before marking.
+        if (!sweep_full && !pg->has_young) {
+            assert(!prev_sweep_full || pg->prev_nold >= pg->nold);
+            if (!prev_sweep_full || pg->prev_nold == pg->nold) {
+                // the position of the freelist begin/end in this page
+                // is stored in its metadata
+                if (pg->fl_begin_offset != (uint16_t)-1) {
+                    *pfl = page_pfl_beg(pg);
+                    pfl = (jl_taggedvalue_t**)page_pfl_end(pg);
+                }
+                freedall = 0;
+                nfree = pg->nfree;
+                goto done;
             }
-            freedall = 0;
-            nfree = pg->nfree;
-            goto done;
         }
     }
 

From 7401107927b4ed745fb47a088ef2723eb1cc470e Mon Sep 17 00:00:00 2001
From: Lionel Zoubritzky <Liozou@users.noreply.github.com>
Date: Mon, 10 Jul 2023 12:16:28 +0200
Subject: [PATCH 10/41] Fix compat annotation for italic printstyled (#50490)

(cherry picked from commit 206e59ac539dc640cd0e7bf4c430bd6fe7706f3f)
---
 base/util.jl | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/base/util.jl b/base/util.jl
index 4dcb819292ff8..3ccdd0a37ae68 100644
--- a/base/util.jl
+++ b/base/util.jl
@@ -135,8 +135,8 @@ See also [`print`](@ref), [`println`](@ref), [`show`](@ref).
 
 !!! compat "Julia 1.7"
     Keywords except `color` and `bold` were added in Julia 1.7.
-!!! compat "Julia 1.9"
-    Support for italic output was added in Julia 1.9.
+!!! compat "Julia 1.10"
+    Support for italic output was added in Julia 1.10.
 """
 @constprop :none printstyled(io::IO, msg...; bold::Bool=false, italic::Bool=false, underline::Bool=false, blink::Bool=false, reverse::Bool=false, hidden::Bool=false, color::Union{Int,Symbol}=:normal) =
     with_output_color(print, color, io, msg...; bold=bold, italic=italic, underline=underline, blink=blink, reverse=reverse, hidden=hidden)

From d6eaa7c095b576433fb482bfbf23934b1683583f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Andr=C3=A9s=20Riedemann?=
 <38795484+longemen3000@users.noreply.github.com>
Date: Mon, 10 Jul 2023 10:21:37 -0400
Subject: [PATCH 11/41] correction in `Base.isassigned` with `Tridiagonal`
 boundscheck error (#50488)

See https://github.com/JuliaLang/julia/pull/49827#discussion_r1252566082

(cherry picked from commit e2e34f6987d93ed5b80259c2af5a33c888180043)
---
 stdlib/LinearAlgebra/src/tridiag.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stdlib/LinearAlgebra/src/tridiag.jl b/stdlib/LinearAlgebra/src/tridiag.jl
index 13f6a1bb70756..174b368a8615a 100644
--- a/stdlib/LinearAlgebra/src/tridiag.jl
+++ b/stdlib/LinearAlgebra/src/tridiag.jl
@@ -620,7 +620,7 @@ function diag(M::Tridiagonal{T}, n::Integer=0) where T
 end
 
 @inline function Base.isassigned(A::Tridiagonal, i::Int, j::Int)
-    @boundscheck checkbounds(A, i, j)
+    @boundscheck checkbounds(Bool, A, i, j) || return false
     if i == j
         return @inbounds isassigned(A.d, i)
     elseif i == j + 1

From 2753ef9942d119987f6a2f7e9b80795073644d51 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Mon, 17 Jul 2023 12:46:58 +0900
Subject: [PATCH 12/41] remove `:boundscheck` argument from `Core._svec_ref`
 (#50561)

`Core._svec_ref` has accepted `boundscheck`-value as the first argument
since it was added in #45062. Nonetheless, `Core._svec_ref` simply calls
`jl_svec_ref` in either the interpreter or the codegen, and thus the
`boundscheck` value isn't utilized in any optimizations. Rather, even
worse, this `boundscheck`-argument negatively influences the effect
analysis (xref #50167 for details) and has caused type inference
regressions as reported in #50544.

For these reasons, this commit simply eliminates the `boundscheck`
argument from `Core._svec_ref`. Consequently,
`getindex(::SimpleVector, ::Int)` is now being concrete-eval eligible.

closes #50544
---
 base/compiler/ssair/inlining.jl |  2 +-
 base/compiler/ssair/passes.jl   |  6 +++---
 base/essentials.jl              |  2 +-
 src/builtins.c                  |  8 +++-----
 test/compiler/inference.jl      | 16 ++++++++++++++++
 test/core.jl                    |  4 ++++
 6 files changed, 28 insertions(+), 10 deletions(-)

diff --git a/base/compiler/ssair/inlining.jl b/base/compiler/ssair/inlining.jl
index 170725f231761..505a517e1bf98 100644
--- a/base/compiler/ssair/inlining.jl
+++ b/base/compiler/ssair/inlining.jl
@@ -1817,7 +1817,7 @@ 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, false, spvals_ssa, spidx), Any)))
+        effect_free_and_nothrow(NewInstruction(Expr(:call, Core._svec_ref, spvals_ssa, spidx), Any)))
     tcheck_not = nothing
     if do_isdefined
         tcheck = insert_node!(
diff --git a/base/compiler/ssair/passes.jl b/base/compiler/ssair/passes.jl
index 9a312bec8f202..3df55e38b3512 100644
--- a/base/compiler/ssair/passes.jl
+++ b/base/compiler/ssair/passes.jl
@@ -810,10 +810,10 @@ function perform_lifting!(compact::IncrementalCompact,
 end
 
 function lift_svec_ref!(compact::IncrementalCompact, idx::Int, stmt::Expr)
-    length(stmt.args) != 4 && return
+    length(stmt.args) != 3 && return
 
-    vec = stmt.args[3]
-    val = stmt.args[4]
+    vec = stmt.args[2]
+    val = stmt.args[3]
     valT = argextype(val, compact)
     (isa(valT, Const) && isa(valT.val, Int)) || return
     valI = valT.val::Int
diff --git a/base/essentials.jl b/base/essentials.jl
index 97f32483a6b14..c0d871608b1a9 100644
--- a/base/essentials.jl
+++ b/base/essentials.jl
@@ -741,7 +741,7 @@ end
 
 # SimpleVector
 
-@eval getindex(v::SimpleVector, i::Int) = (@_foldable_meta; Core._svec_ref($(Expr(:boundscheck)), v, i))
+getindex(v::SimpleVector, i::Int) = (@_foldable_meta; Core._svec_ref(v, i))
 function length(v::SimpleVector)
     @_total_meta
     t = @_gc_preserve_begin v
diff --git a/src/builtins.c b/src/builtins.c
index b664b8d73710f..4f75fd79eadcc 100644
--- a/src/builtins.c
+++ b/src/builtins.c
@@ -1655,11 +1655,9 @@ JL_CALLABLE(jl_f__compute_sparams)
 
 JL_CALLABLE(jl_f__svec_ref)
 {
-    JL_NARGS(_svec_ref, 3, 3);
-    jl_value_t *b = args[0];
-    jl_svec_t *s = (jl_svec_t*)args[1];
-    jl_value_t *i = (jl_value_t*)args[2];
-    JL_TYPECHK(_svec_ref, bool, b);
+    JL_NARGS(_svec_ref, 2, 2);
+    jl_svec_t *s = (jl_svec_t*)args[0];
+    jl_value_t *i = (jl_value_t*)args[1];
     JL_TYPECHK(_svec_ref, simplevector, (jl_value_t*)s);
     JL_TYPECHK(_svec_ref, long, i);
     size_t len = jl_svec_len(s);
diff --git a/test/compiler/inference.jl b/test/compiler/inference.jl
index ded9438037733..cb16cb604881b 100644
--- a/test/compiler/inference.jl
+++ b/test/compiler/inference.jl
@@ -5014,3 +5014,19 @@ let 𝕃 = Core.Compiler.SimpleInferenceLattice.instance
         map(T -> Issue49785{S,T}, (a = S,))
     end isa Vector
 end
+
+# `getindex(::SimpleVector, ::Int)` shuold be concrete-evaluated
+@eval Base.return_types() do
+    $(Core.svec(1,Int,nothing))[2]
+end |> only == Type{Int}
+# https://github.com/JuliaLang/julia/issues/50544
+struct Issue50544{T<:Tuple}
+    t::T
+end
+Base.@propagate_inbounds f_issue50544(x, i, ii...) = f_issue50544(f_issue50544(x, i), ii...)
+Base.@propagate_inbounds f_issue50544(::Type{Issue50544{T}}, i) where T = T.parameters[i]
+g_issue50544(T...) = Issue50544{Tuple{T...}}
+h_issue50544(x::T) where T = g_issue50544(f_issue50544(T, 1), f_issue50544(T, 2, 1))
+let x = Issue50544((1, Issue50544((2.0, 'x'))))
+    @test only(Base.return_types(h_issue50544, (typeof(x),))) == Type{Issue50544{Tuple{Int,Float64}}}
+end
diff --git a/test/core.jl b/test/core.jl
index f0439afeed23c..13f4640210f51 100644
--- a/test/core.jl
+++ b/test/core.jl
@@ -8040,3 +8040,7 @@ bar50293(@nospecialize(u)) = (Base.issingletontype(u.a), baz50293(u.a))
 let u = Union{Type{Union{}}, Type{Any}}, ab = bar50293(u)
     @test ab[1] == ab[2] == false
 end
+
+# `SimpleVector`-operations should be concrete-eval eligible
+@test Core.Compiler.is_foldable(Base.infer_effects(length, (Core.SimpleVector,)))
+@test Core.Compiler.is_foldable(Base.infer_effects(getindex, (Core.SimpleVector,Int)))

From b9a279cf1316107a5eea19af6335cc9661db7770 Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Tue, 11 Jul 2023 08:33:41 -0400
Subject: [PATCH 13/41] Profile: Add specifying dir for `take_heap_snapshot`
 and handling if current dir is unwritable (#50476)

Co-authored-by: Valentin Churavy <vchuravy@users.noreply.github.com>
(cherry picked from commit 0f6bfd6cd8fc6993fefb98a011b2659179f1853a)
---
 stdlib/Profile/src/Profile.jl | 33 ++++++++++++++++++++++++---------
 1 file changed, 24 insertions(+), 9 deletions(-)

diff --git a/stdlib/Profile/src/Profile.jl b/stdlib/Profile/src/Profile.jl
index f0323d0334b1a..c37cdd0af0368 100644
--- a/stdlib/Profile/src/Profile.jl
+++ b/stdlib/Profile/src/Profile.jl
@@ -1215,14 +1215,16 @@ 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)
+    Profile.take_heap_snapshot(all_one::Bool=false; dir::String)
 
 Write a snapshot of the heap, in the JSON format expected by the Chrome
-Devtools Heap Snapshot viewer (.heapsnapshot extension), to a file
-(`\$pid_\$timestamp.heapsnapshot`) in the current directory, or the given
-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.
+Devtools Heap Snapshot viewer (.heapsnapshot extension) to a file
+(`\$pid_\$timestamp.heapsnapshot`) in the current directory by default (or tempdir if
+the current directory is unwritable), or in `dir` if given, or the given
+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.
 """
 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)))
@@ -1233,9 +1235,22 @@ function take_heap_snapshot(filepath::String, all_one::Bool=false)
     end
     return filepath
 end
-function take_heap_snapshot(all_one::Bool=false)
-    f = joinpath(tempdir(), "$(getpid())_$(time_ns()).heapsnapshot")
-    return take_heap_snapshot(f, all_one)
+function take_heap_snapshot(all_one::Bool=false; dir::Union{Nothing,S}=nothing) where {S <: AbstractString}
+    fname = "$(getpid())_$(time_ns()).heapsnapshot"
+    if isnothing(dir)
+        wd = pwd()
+        fpath = joinpath(wd, fname)
+        try
+            touch(fpath)
+            rm(fpath; force=true)
+        catch
+            @warn "Cannot write to current directory `$(pwd())` so saving heap snapshot to `$(tempdir())`" maxlog=1 _id=Symbol(wd)
+            fpath = joinpath(tempdir(), fname)
+        end
+    else
+        fpath = joinpath(expanduser(dir), fname)
+    end
+    return take_heap_snapshot(fpath, all_one)
 end
 
 

From 30b81267c5d87be3d45892ea0e11f7060ef772f2 Mon Sep 17 00:00:00 2001
From: Bagaev Dmitry <bvdmitri@gmail.com>
Date: Wed, 12 Jul 2023 04:36:22 +0200
Subject: [PATCH 14/41] fix typo in the --gcthreads argument description
 (#50461)

(cherry picked from commit e64d2013ca91e8babc01ebbfb5025da04eeea803)
---
 src/jloptions.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/jloptions.c b/src/jloptions.c
index 129ba9df2510e..e81c34d37ef47 100644
--- a/src/jloptions.c
+++ b/src/jloptions.c
@@ -131,8 +131,8 @@ static const char opts[]  =
     "                           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=M[,N]         Use M threads for the mark phase of GC and N (0 or 1) threads for the concurrent sweeping phase of GC.\n"
-    "                           M is set to half of the number of compute threads and N is set to 0 if unspecified.\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"
@@ -838,7 +838,7 @@ JL_DLLEXPORT void jl_parse_opts(int *argcp, char ***argvp)
                 char *endptri;
                 long nsweepthreads = strtol(&endptr[1], &endptri, 10);
                 if (errno != 0 || endptri == &endptr[1] || *endptri != 0 || nsweepthreads < 0 || nsweepthreads > 1)
-                    jl_errorf("julia: --gcthreads=<n>,<m>; n must be 0 or 1");
+                    jl_errorf("julia: --gcthreads=<n>,<m>; m must be 0 or 1");
                 jl_options.nsweepthreads = (int8_t)nsweepthreads;
             }
             break;

From 8827eb3e927ec2559458b2a7d00739b12b407c04 Mon Sep 17 00:00:00 2001
From: Cody Tapscott <84105208+topolarity@users.noreply.github.com>
Date: Thu, 13 Jul 2023 11:54:09 -0400
Subject: [PATCH 15/41] ssair: Correctly handle stmt insertion at end of basic
 block (#50528)

In the presence of `attach_after` insertions, we have to be careful to
extend the basic block to include everything up to the last insertion.
We were accounting for "new" nodes (before the compaction point), but
not "pending" nodes (after the compaction point).

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

(cherry picked from commit cdec4c21bdfffa9b198b8ecdde83aa082ebfc4e9)
---
 base/compiler/ssair/ir.jl | 22 ++++++++++++++++------
 test/compiler/ssair.jl    | 27 +++++++++++++++++++++++++++
 2 files changed, 43 insertions(+), 6 deletions(-)

diff --git a/base/compiler/ssair/ir.jl b/base/compiler/ssair/ir.jl
index 5c6751c1e1dda..d133b88721238 100644
--- a/base/compiler/ssair/ir.jl
+++ b/base/compiler/ssair/ir.jl
@@ -1508,10 +1508,20 @@ function finish_current_bb!(compact::IncrementalCompact, active_bb::Int,
     return skipped
 end
 
-function attach_after_stmt_after(compact::IncrementalCompact, idx::Int)
-    compact.new_nodes_idx > length(compact.perm) && return false
-    entry = compact.ir.new_nodes.info[compact.perm[compact.new_nodes_idx]]
-    return entry.pos == idx && entry.attach_after
+"""
+    stmts_awaiting_insertion(compact::IncrementalCompact, idx::Int)
+
+Returns true if there are new/pending instructions enqueued for insertion into
+`compact` on any instruction in the range `1:idx`. Otherwise, returns false.
+"""
+function stmts_awaiting_insertion(compact::IncrementalCompact, idx::Int)
+
+    new_node_waiting = compact.new_nodes_idx <= length(compact.perm) &&
+        compact.ir.new_nodes.info[compact.perm[compact.new_nodes_idx]].pos <= idx
+    pending_node_waiting = !isempty(compact.pending_perm) &&
+        compact.pending_nodes.info[compact.pending_perm[1]].pos <= idx
+
+    return new_node_waiting || pending_node_waiting
 end
 
 function process_newnode!(compact::IncrementalCompact, new_idx::Int, new_node_entry::Instruction, new_node_info::NewNodeInfo, idx::Int, active_bb::Int, do_rename_ssa::Bool)
@@ -1523,7 +1533,7 @@ function process_newnode!(compact::IncrementalCompact, new_idx::Int, new_node_en
     compact.result_idx = result_idx
     # If this instruction has reverse affinity and we were at the end of a basic block,
     # finish it now.
-    if new_node_info.attach_after && idx == last(bb.stmts)+1 && !attach_after_stmt_after(compact, idx-1)
+    if new_node_info.attach_after && idx == last(bb.stmts)+1 && !stmts_awaiting_insertion(compact, idx-1)
         active_bb += 1
         finish_current_bb!(compact, active_bb, old_result_idx)
     end
@@ -1653,7 +1663,7 @@ function iterate_compact(compact::IncrementalCompact)
     compact.result[old_result_idx] = compact.ir.stmts[idx]
     result_idx = process_node!(compact, old_result_idx, compact.ir.stmts[idx], idx, idx, active_bb, true)
     compact.result_idx = result_idx
-    if idx == last(bb.stmts) && !attach_after_stmt_after(compact, idx)
+    if idx == last(bb.stmts) && !stmts_awaiting_insertion(compact, idx)
         finish_current_bb!(compact, active_bb, old_result_idx)
         active_bb += 1
     end
diff --git a/test/compiler/ssair.jl b/test/compiler/ssair.jl
index 43f17d4ad69f2..98cab349b46ee 100644
--- a/test/compiler/ssair.jl
+++ b/test/compiler/ssair.jl
@@ -566,6 +566,33 @@ let ir = Base.code_ircode((Int,Int); optimize_until="inlining") do a, b
     @test call2.args[2] === SSAValue(2)
 end
 
+# Issue #50379 - insert_node!(::IncrementalCompact, ...) at end of basic block
+let ci = make_ci([
+        # block 1
+        #= %1: =# Core.Compiler.GotoIfNot(Expr(:boundscheck), 3),
+        # block 2
+        #= %2: =# Expr(:call, println, Argument(1)),
+        # block 3
+        #= %3: =# Core.PhiNode(),
+        #= %4: =# Core.Compiler.ReturnNode(),
+    ])
+    ir = Core.Compiler.inflate_ir(ci)
+
+    # Insert another call at end of "block 2"
+    compact = Core.Compiler.IncrementalCompact(ir)
+    new_inst = NewInstruction(Expr(:call, println, Argument(1)), Nothing)
+    insert_node!(compact, SSAValue(2), new_inst, #= attach_after =# true)
+
+    # Complete iteration
+    x = Core.Compiler.iterate(compact)
+    while x !== nothing
+        x = Core.Compiler.iterate(compact, x[2])
+    end
+    ir = Core.Compiler.complete(compact)
+
+    @test Core.Compiler.verify_ir(ir) === nothing
+end
+
 # insert_node! with new instruction with flag computed
 let ir = Base.code_ircode((Int,Int); optimize_until="inlining") do a, b
         a^b

From 5e793177bdb3724d80200d63d0c0865b030ffc7b Mon Sep 17 00:00:00 2001
From: Diogo Netto <61364108+d-netto@users.noreply.github.com>
Date: Thu, 13 Jul 2023 20:24:32 +0300
Subject: [PATCH 16/41] gc:  fix conservative GC support (#50533)

Ensure `internal_obj_base_ptr` checks whether objects past freelist
pointer are in freelist.

Fixes #50434

(cherry picked from commit dcca46b756b45ce23e35fb6d62561bf31555c4f3)
---
 src/gc.c | 20 +++++++++++++++++---
 1 file changed, 17 insertions(+), 3 deletions(-)

diff --git a/src/gc.c b/src/gc.c
index dd3fa308a3867..aa07695ac8bc0 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -1242,7 +1242,10 @@ static NOINLINE jl_taggedvalue_t *gc_add_page(jl_gc_pool_t *p) JL_NOTSAFEPOINT
     // in pool_alloc significantly
     jl_ptls_t ptls = jl_current_task->ptls;
     jl_gc_pagemeta_t *pg = pop_page_metadata_back(&ptls->page_metadata_lazily_freed);
-    if (pg == NULL) {
+    if (pg != NULL) {
+        gc_alloc_map_set(pg->data, GC_PAGE_ALLOCATED);
+    }
+    else {
         pg = jl_gc_alloc_page();
     }
     pg->osize = p->osize;
@@ -1449,6 +1452,7 @@ static jl_taggedvalue_t **gc_sweep_page(jl_gc_pool_t *p, jl_gc_pagemeta_t **allo
         push_page_metadata_back(allocd, pg);
     }
     else if (freed_lazily) {
+        gc_alloc_map_set(pg->data, GC_PAGE_LAZILY_FREED);
         push_page_metadata_back(lazily_freed, pg);
     }
     else {
@@ -4024,7 +4028,7 @@ JL_DLLEXPORT jl_value_t *jl_gc_internal_obj_base_ptr(void *p)
         jl_gc_pool_t *pool =
             gc_all_tls_states[meta->thread_n]->heap.norm_pools +
             meta->pool_n;
-        if (meta->fl_begin_offset == (uint16_t) -1) {
+        if (meta->fl_begin_offset == UINT16_MAX) {
             // case 2: this is a page on the newpages list
             jl_taggedvalue_t *newpages = pool->newpages;
             // Check if the page is being allocated from via newpages
@@ -4066,8 +4070,18 @@ JL_DLLEXPORT jl_value_t *jl_gc_internal_obj_base_ptr(void *p)
         // before the freelist pointer was either live during the last
         // sweep or has been allocated since.
         if (gc_page_data(cell) == gc_page_data(pool->freelist)
-            && (char *)cell < (char *)pool->freelist)
+            && (char *)cell < (char *)pool->freelist) {
             goto valid_object;
+        }
+        else {
+            jl_taggedvalue_t *v = pool->freelist;
+            while (v != NULL) {
+                if (v == cell) {
+                    return NULL;
+                }
+                v = v->next;
+            }
+        }
         // Not a freelist entry, therefore a valid object.
     valid_object:
         // We have to treat objects with type `jl_buff_tag` differently,

From 704513dcb2914d24c9d378d87abb1e91ed968d2a Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Thu, 13 Jul 2023 18:16:13 +0000
Subject: [PATCH 17/41] gc: remove over-eager assertion

Fixes #50451

(cherry picked from commit f4f1ecfe11dd0fe5e5fcc6f7220ddade49e5a96c)
---
 src/gf.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/gf.c b/src/gf.c
index 294e1fccb8783..036ed680b6446 100644
--- a/src/gf.c
+++ b/src/gf.c
@@ -1483,7 +1483,7 @@ 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 == ~(size_t)0 && "method cannot be added at the same time as method deleted");
+    assert(oldentry->max_world != 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;

From 2544e9f0d0035506d9f3388e78baf0f374fece58 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Thu, 13 Jul 2023 21:01:33 +0000
Subject: [PATCH 18/41] gf: remove unnecessary assert cycle==depth

We do not care about this condition (the point of this fast path is to
skip checking it).

Fix #50450

(cherry picked from commit 15bcf1bb2f53d7cd2a7348a555d2f9d1867ce271)
---
 src/gf.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/gf.c b/src/gf.c
index 036ed680b6446..00bc33b075255 100644
--- a/src/gf.c
+++ b/src/gf.c
@@ -3426,7 +3426,9 @@ static int sort_mlmatches(jl_array_t *t, size_t idx, arraylist_t *visited, array
                 }
             }
             if ((size_t)visited->items[idx] == 1) {
-                assert(cycle == depth);
+                // n.b. cycle might be < depth, if we had a cycle with a child
+                // idx, but since we are on the top of the stack, nobody
+                // observed that and so we are content to ignore this
                 size_t childidx = (size_t)arraylist_pop(stack);
                 assert(childidx == idx); (void)childidx;
                 assert(!subt || *found_minmax == 2);

From d3276e1b3babcda433e081a452cbcf8678d97462 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Fri, 14 Jul 2023 21:07:02 +0000
Subject: [PATCH 19/41] Expand kwcall lowering positional default check to
 vararg

Fixes the case from #50518, but we actually have two test cases in
the tests that also hit this (e.g. this one:
```
f40964(xs::Int...=1; k = 2) = (xs, k)
```), but just happened not to hit the bad codegen path. #50556,
once merged would have complained on those definitions as well,
without this fix.

(cherry picked from commit c27223607daaeee94ae477a1fdeab9b8784c9a8d)
---
 src/julia-syntax.scm | 2 +-
 test/keywordargs.jl  | 6 ++++++
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/julia-syntax.scm b/src/julia-syntax.scm
index cd11f46b1eb38..eb79dfc52f76c 100644
--- a/src/julia-syntax.scm
+++ b/src/julia-syntax.scm
@@ -555,7 +555,7 @@
           name positional-sparams
           `((|::|
              ;; if there are optional positional args, we need to be able to reference the function name
-             ,(if (any kwarg? pargl) (gensy) UNUSED)
+             ,(if (any kwarg? `(,@pargl ,@vararg)) (gensy) UNUSED)
              (call (core kwftype) ,ftype)) ,kwdecl ,@pargl ,@vararg)
           `(block
             ;; propagate method metadata to keyword sorter
diff --git a/test/keywordargs.jl b/test/keywordargs.jl
index 0aed0544b7e2e..43013ab1d721e 100644
--- a/test/keywordargs.jl
+++ b/test/keywordargs.jl
@@ -394,3 +394,9 @@ let m = first(methods(Core.kwcall, (NamedTuple,typeof(kwf1),Vararg)))
     @test Core.kwcall(1) == "hi 1"
     @test which(Core.kwcall, (Int,)).name === :kwcall
 end
+
+# issue #50518
+function f50518(xs...=["a", "b", "c"]...; debug=false)
+    return xs[1]
+end
+@test f50518() == f50518(;debug=false) == "a"

From 6aa1ab3396a8dbdd5fd7deb8936e12202ef1229a Mon Sep 17 00:00:00 2001
From: Daniel Karrasch <Daniel.Karrasch@posteo.de>
Date: Sun, 4 Jun 2023 15:10:21 +0200
Subject: [PATCH 20/41] Add unwrapping mechanism for triangular matrices

(cherry picked from commit e67ddaa7216ec0a56d6140e5013eb56eeff712f5)
---
 stdlib/LinearAlgebra/src/adjtrans.jl    |   8 +-
 stdlib/LinearAlgebra/src/bidiag.jl      |   4 +-
 stdlib/LinearAlgebra/src/hessenberg.jl  |   4 +-
 stdlib/LinearAlgebra/src/matmul.jl      |  16 +-
 stdlib/LinearAlgebra/src/triangular.jl  | 996 +++++++++++++-----------
 stdlib/LinearAlgebra/test/triangular.jl |  26 +-
 6 files changed, 550 insertions(+), 504 deletions(-)

diff --git a/stdlib/LinearAlgebra/src/adjtrans.jl b/stdlib/LinearAlgebra/src/adjtrans.jl
index 875e8cefcb66e..0d31e402aec00 100644
--- a/stdlib/LinearAlgebra/src/adjtrans.jl
+++ b/stdlib/LinearAlgebra/src/adjtrans.jl
@@ -64,10 +64,10 @@ end
 Adjoint(A) = Adjoint{Base.promote_op(adjoint,eltype(A)),typeof(A)}(A)
 Transpose(A) = Transpose{Base.promote_op(transpose,eltype(A)),typeof(A)}(A)
 
+# TODO: remove, is already replaced by wrapperop
 """
     adj_or_trans(::AbstractArray) -> adjoint|transpose|identity
     adj_or_trans(::Type{<:AbstractArray}) -> adjoint|transpose|identity
-
 Return [`adjoint`](@ref) from an `Adjoint` type or object and
 [`transpose`](@ref) from a `Transpose` type or object. Otherwise,
 return [`identity`](@ref). Note that `Adjoint` and `Transpose` have
@@ -94,9 +94,15 @@ inplace_adj_or_trans(::Type{<:AbstractArray}) = copyto!
 inplace_adj_or_trans(::Type{<:Adjoint}) = adjoint!
 inplace_adj_or_trans(::Type{<:Transpose}) = transpose!
 
+# unwraps Adjoint, Transpose, Symmetric, Hermitian
 _unwrap(A::Adjoint)   = parent(A)
 _unwrap(A::Transpose) = parent(A)
 
+# unwraps Adjoint and Transpose only
+_unwrap_at(A) = A
+_unwrap_at(A::Adjoint)   = parent(A)
+_unwrap_at(A::Transpose) = parent(A)
+
 Base.dataids(A::Union{Adjoint, Transpose}) = Base.dataids(A.parent)
 Base.unaliascopy(A::Union{Adjoint,Transpose}) = typeof(A)(Base.unaliascopy(A.parent))
 
diff --git a/stdlib/LinearAlgebra/src/bidiag.jl b/stdlib/LinearAlgebra/src/bidiag.jl
index 192272cc61e98..e0280a54f2b82 100644
--- a/stdlib/LinearAlgebra/src/bidiag.jl
+++ b/stdlib/LinearAlgebra/src/bidiag.jl
@@ -755,7 +755,7 @@ function ldiv!(c::AbstractVecOrMat, A::Bidiagonal, b::AbstractVecOrMat)
 end
 ldiv!(A::AdjOrTrans{<:Any,<:Bidiagonal}, b::AbstractVecOrMat) = @inline ldiv!(b, A, b)
 ldiv!(c::AbstractVecOrMat, A::AdjOrTrans{<:Any,<:Bidiagonal}, b::AbstractVecOrMat) =
-    (t = adj_or_trans(A); _rdiv!(t(c), t(b), t(A)); return c)
+    (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)
@@ -833,7 +833,7 @@ end
 rdiv!(A::AbstractMatrix, B::Bidiagonal) = @inline _rdiv!(A, A, B)
 rdiv!(A::AbstractMatrix, B::AdjOrTrans{<:Any,<:Bidiagonal}) = @inline _rdiv!(A, A, B)
 _rdiv!(C::AbstractMatrix, A::AbstractMatrix, B::AdjOrTrans{<:Any,<:Bidiagonal}) =
-    (t = adj_or_trans(B); ldiv!(t(C), t(B), t(A)); return C)
+    (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)
 
diff --git a/stdlib/LinearAlgebra/src/hessenberg.jl b/stdlib/LinearAlgebra/src/hessenberg.jl
index 179f93f2cd6f2..8b45a116c1a48 100644
--- a/stdlib/LinearAlgebra/src/hessenberg.jl
+++ b/stdlib/LinearAlgebra/src/hessenberg.jl
@@ -132,11 +132,11 @@ for T = (:Number, :UniformScaling, :Diagonal)
 end
 
 function *(H::UpperHessenberg, U::UpperOrUnitUpperTriangular)
-    HH = _mulmattri!(_initarray(*, eltype(H), eltype(U), H), H, U)
+    HH = mul!(_initarray(*, eltype(H), eltype(U), H), H, U)
     UpperHessenberg(HH)
 end
 function *(U::UpperOrUnitUpperTriangular, H::UpperHessenberg)
-    HH = _multrimat!(_initarray(*, eltype(U), eltype(H), H), U, H)
+    HH = mul!(_initarray(*, eltype(U), eltype(H), H), U, H)
     UpperHessenberg(HH)
 end
 
diff --git a/stdlib/LinearAlgebra/src/matmul.jl b/stdlib/LinearAlgebra/src/matmul.jl
index e375108f6a831..018ad20e538c8 100644
--- a/stdlib/LinearAlgebra/src/matmul.jl
+++ b/stdlib/LinearAlgebra/src/matmul.jl
@@ -8,10 +8,6 @@ AdjOrTransStridedMat{T} = Union{Adjoint{<:Any, <:StridedMatrix{T}}, Transpose{<:
 StridedMaybeAdjOrTransMat{T} = Union{StridedMatrix{T}, Adjoint{<:Any, <:StridedMatrix{T}}, Transpose{<:Any, <:StridedMatrix{T}}}
 StridedMaybeAdjOrTransVecOrMat{T} = Union{StridedVecOrMat{T}, AdjOrTrans{<:Any, <:StridedVecOrMat{T}}}
 
-_parent(A) = A
-_parent(A::Adjoint) = parent(A)
-_parent(A::Transpose) = parent(A)
-
 matprod(x, y) = x*y + x*y
 
 # dot products
@@ -115,14 +111,14 @@ end
 function (*)(A::StridedMaybeAdjOrTransMat{<:BlasReal}, B::StridedMaybeAdjOrTransMat{<:BlasReal})
     TS = promote_type(eltype(A), eltype(B))
     mul!(similar(B, TS, (size(A, 1), size(B, 2))),
-         wrapperop(A)(convert(AbstractArray{TS}, _parent(A))),
-         wrapperop(B)(convert(AbstractArray{TS}, _parent(B))))
+         wrapperop(A)(convert(AbstractArray{TS}, _unwrap(A))),
+         wrapperop(B)(convert(AbstractArray{TS}, _unwrap(B))))
 end
 function (*)(A::StridedMaybeAdjOrTransMat{<:BlasComplex}, B::StridedMaybeAdjOrTransMat{<:BlasComplex})
     TS = promote_type(eltype(A), eltype(B))
     mul!(similar(B, TS, (size(A, 1), size(B, 2))),
-         wrapperop(A)(convert(AbstractArray{TS}, _parent(A))),
-         wrapperop(B)(convert(AbstractArray{TS}, _parent(B))))
+         wrapperop(A)(convert(AbstractArray{TS}, _unwrap(A))),
+         wrapperop(B)(convert(AbstractArray{TS}, _unwrap(B))))
 end
 
 # Complex Matrix times real matrix: We use that it is generally faster to reinterpret the
@@ -131,13 +127,13 @@ function (*)(A::StridedMatrix{<:BlasComplex}, B::StridedMaybeAdjOrTransMat{<:Bla
     TS = promote_type(eltype(A), eltype(B))
     mul!(similar(B, TS, (size(A, 1), size(B, 2))),
          convert(AbstractArray{TS}, A),
-         wrapperop(B)(convert(AbstractArray{real(TS)}, _parent(B))))
+         wrapperop(B)(convert(AbstractArray{real(TS)}, _unwrap(B))))
 end
 function (*)(A::AdjOrTransStridedMat{<:BlasComplex}, B::StridedMaybeAdjOrTransMat{<:BlasReal})
     TS = promote_type(eltype(A), eltype(B))
     mul!(similar(B, TS, (size(A, 1), size(B, 2))),
          copymutable_oftype(A, TS), # remove AdjOrTrans to use reinterpret trick below
-         wrapperop(B)(convert(AbstractArray{real(TS)}, _parent(B))))
+         wrapperop(B)(convert(AbstractArray{real(TS)}, _unwrap(B))))
 end
 # the following case doesn't seem to benefit from the translation A*B = (B' * A')'
 function (*)(A::StridedMatrix{<:BlasReal}, B::StridedMatrix{<:BlasComplex})
diff --git a/stdlib/LinearAlgebra/src/triangular.jl b/stdlib/LinearAlgebra/src/triangular.jl
index 295a46f1522a5..c943945432bd0 100644
--- a/stdlib/LinearAlgebra/src/triangular.jl
+++ b/stdlib/LinearAlgebra/src/triangular.jl
@@ -464,9 +464,9 @@ end
 
 # Define `mul!` for (Unit){Upper,Lower}Triangular matrices times a number.
 # be permissive here and require compatibility later in _triscale!
-@inline mul!(A::UpperOrLowerTriangular, B::UpperOrLowerTriangular, C::Number, alpha::Number, beta::Number) =
+@inline mul!(A::AbstractTriangular, B::AbstractTriangular, C::Number, alpha::Number, beta::Number) =
     _triscale!(A, B, C, MulAddMul(alpha, beta))
-@inline mul!(A::UpperOrLowerTriangular, B::Number, C::UpperOrLowerTriangular, alpha::Number, beta::Number) =
+@inline mul!(A::AbstractTriangular, B::Number, C::AbstractTriangular, alpha::Number, beta::Number) =
     _triscale!(A, B, C, MulAddMul(alpha, beta))
 
 function _triscale!(A::UpperTriangular, B::UpperTriangular, c::Number, _add)
@@ -671,11 +671,60 @@ fillstored!(A::UnitUpperTriangular, x) = (fillband!(A.data, x, 1, size(A,2)-1);
 # BlasFloat routines #
 ######################
 
+# legacy stuff, to be removed
+_multrimat!(C, A, B) = _trimul!(C, A, B)
+_mulmattri!(C, A, B) = _trimul!(C, A, B)
+_uconvert_copyto!(c, b, oA) = (c .= Ref(oA) .\ b)
+_uconvert_copyto!(c::AbstractArray{T}, b::AbstractArray{T}, _) where {T} = copyto!(c, b)
+
+# which triangle to use of the underlying data
+uplo_char(::UpperOrUnitUpperTriangular) = 'U'
+uplo_char(::LowerOrUnitLowerTriangular) = 'L'
+uplo_char(::UpperOrUnitUpperTriangular{<:Any,<:AdjOrTrans}) = 'L'
+uplo_char(::LowerOrUnitLowerTriangular{<:Any,<:AdjOrTrans}) = 'U'
+uplo_char(::UpperOrUnitUpperTriangular{<:Any,<:Adjoint{<:Any,<:Transpose}}) = 'U'
+uplo_char(::LowerOrUnitLowerTriangular{<:Any,<:Adjoint{<:Any,<:Transpose}}) = 'L'
+uplo_char(::UpperOrUnitUpperTriangular{<:Any,<:Transpose{<:Any,<:Adjoint}}) = 'U'
+uplo_char(::LowerOrUnitLowerTriangular{<:Any,<:Transpose{<:Any,<:Adjoint}}) = 'L'
+
+isunit_char(::UpperTriangular) = 'N'
+isunit_char(::UnitUpperTriangular) = 'U'
+isunit_char(::LowerTriangular) = 'N'
+isunit_char(::UnitLowerTriangular) = 'U'
+
 lmul!(A::Tridiagonal, B::AbstractTriangular) = A*full!(B)
-mul!(C::AbstractVecOrMat, A::AbstractTriangular, B::AbstractVector) = _multrimat!(C, A, B)
-mul!(C::AbstractMatrix, A::AbstractTriangular, B::AbstractMatrix) = _multrimat!(C, A, B)
-mul!(C::AbstractMatrix, A::AbstractMatrix, B::AbstractTriangular) = _mulmattri!(C, A, B)
-mul!(C::AbstractMatrix, A::AbstractTriangular, B::AbstractTriangular) = _multrimat!(C, A, 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) =
+    lmul!(A, copyto!(C, B))
+_trimul!(C::AbstractMatrix, A::AbstractTriangular, B::AbstractMatrix) =
+    lmul!(A, inplace_adj_or_trans(B)(C, _unwrap_at(B)))
+_trimul!(C::AbstractMatrix, A::AbstractMatrix, B::AbstractTriangular) =
+    rmul!(inplace_adj_or_trans(A)(C, _unwrap_at(A)), B)
+_trimul!(C::AbstractMatrix, A::AbstractTriangular, B::AbstractTriangular) =
+    lmul!(A, copyto!(C, B))
+# redirect for UpperOrLowerTriangular
+_trimul!(C::AbstractVecOrMat, A::UpperOrLowerTriangular, B::AbstractVector) =
+    generic_trimatmul!(C, uplo_char(A), isunit_char(A), wrapperop(parent(A)), _unwrap_at(parent(A)), B)
+_trimul!(C::AbstractMatrix, A::UpperOrLowerTriangular, B::AbstractMatrix) =
+    generic_trimatmul!(C, uplo_char(A), isunit_char(A), wrapperop(parent(A)), _unwrap_at(parent(A)), B)
+_trimul!(C::AbstractMatrix, A::AbstractMatrix, B::UpperOrLowerTriangular) =
+    generic_mattrimul!(C, uplo_char(B), isunit_char(B), wrapperop(parent(B)), A, _unwrap_at(parent(B)))
+_trimul!(C::AbstractMatrix, A::UpperOrLowerTriangular, B::UpperOrLowerTriangular) =
+    generic_trimatmul!(C, uplo_char(A), isunit_char(A), wrapperop(parent(A)), _unwrap_at(parent(A)), B)
+# disambiguation with AbstractTriangular
+_trimul!(C::AbstractMatrix, A::UpperOrLowerTriangular, B::AbstractTriangular) =
+    generic_trimatmul!(C, uplo_char(A), isunit_char(A), wrapperop(parent(A)), _unwrap_at(parent(A)), B)
+_trimul!(C::AbstractMatrix, A::AbstractTriangular, B::UpperOrLowerTriangular) =
+    generic_mattrimul!(C, uplo_char(B), isunit_char(B), wrapperop(parent(B)), A, _unwrap_at(parent(B)))
+
+lmul!(A::AbstractTriangular, B::AbstractVecOrMat) = @inline _trimul!(B, A, B)
+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)
@@ -699,13 +748,22 @@ for (TA, TB) in ((:AbstractTriangular, :AbstractMatrix),
     end
 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)))
+_rdiv!(C::AbstractMatrix, A::AbstractMatrix, B::AbstractTriangular) =
+    rdiv!(inplace_adj_or_trans(A)(C, _unwrap_at(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)
+_rdiv!(C::AbstractMatrix, A::AbstractMatrix, B::UpperOrLowerTriangular) =
+    generic_mattridiv!(C, uplo_char(B), isunit_char(B), wrapperop(parent(B)), A, _unwrap_at(parent(B)))
 
-# generic fallback for AbstractTriangular matrices outside of the four subtypes provided here
-_multrimat!(C::AbstractVecOrMat, A::AbstractTriangular, B::AbstractVecOrMat) =
-    lmul!(A, inplace_adj_or_trans(B)(C, _parent(B)))
-_mulmattri!(C::AbstractMatrix, A::AbstractMatrix, B::AbstractTriangular) = rmul!(copyto!(C, A), B)
+ldiv!(A::AbstractTriangular, B::AbstractVecOrMat) = @inline _ldiv!(B, A, B)
+rdiv!(A::AbstractMatrix, B::AbstractTriangular)   = @inline _rdiv!(A, A, B)
 
-# preserve triangular structure in in-place multiplication
+# preserve triangular structure in in-place multiplication/division
 for (cty, aty, bty) in ((:UpperTriangular, :UpperTriangular, :UpperTriangular),
                         (:UpperTriangular, :UpperTriangular, :UnitUpperTriangular),
                         (:UpperTriangular, :UnitUpperTriangular, :UpperTriangular),
@@ -714,40 +772,41 @@ for (cty, aty, bty) in ((:UpperTriangular, :UpperTriangular, :UpperTriangular),
                         (:LowerTriangular, :LowerTriangular, :UnitLowerTriangular),
                         (:LowerTriangular, :UnitLowerTriangular, :LowerTriangular),
                         (:UnitLowerTriangular, :UnitLowerTriangular, :UnitLowerTriangular))
-    @eval function _multrimat!(C::$cty, A::$aty, B::$bty)
-        _multrimat!(parent(C), A, B)
-        return C
+    @eval begin
+        function _trimul!(C::$cty, A::$aty, B::$bty)
+            _trimul!(parent(C), A, B)
+            return C
+        end
+        function _ldiv!(C::$cty, A::$aty, B::$bty)
+            _ldiv!(parent(C), A, B)
+            return C
+        end
+        function _rdiv!(C::$cty, A::$aty, B::$bty)
+            _rdiv!(parent(C), A, B)
+            return C
+        end
     end
 end
 
-# direct multiplication/division
 for (t, uploc, isunitc) in ((:LowerTriangular, 'L', 'N'),
                             (:UnitLowerTriangular, 'L', 'U'),
                             (:UpperTriangular, 'U', 'N'),
                             (:UnitUpperTriangular, 'U', 'U'))
     @eval begin
-        # Vector multiplication
-        lmul!(A::$t{T,<:StridedMatrix}, b::StridedVector{T}) where {T<:BlasFloat} =
-            BLAS.trmv!($uploc, 'N', $isunitc, A.data, b)
-
-        # Matrix multiplication
-        lmul!(A::$t{T,<:StridedMatrix}, B::StridedMatrix{T}) where {T<:BlasFloat} =
-            BLAS.trmm!('L', $uploc, 'N', $isunitc, one(T), A.data, B)
-        rmul!(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) where {T<:BlasFloat} =
-            BLAS.trmm!('R', $uploc, 'N', $isunitc, one(T), B.data, A)
-
-        # Left division
-        ldiv!(A::$t{T,<:StridedMatrix}, B::StridedVecOrMat{T}) where {T<:BlasFloat} =
-            LAPACK.trtrs!($uploc, 'N', $isunitc, A.data, B)
-
-        # Right division
-        rdiv!(A::StridedMatrix{T}, B::$t{T,<:StridedMatrix}) where {T<:BlasFloat} =
-            BLAS.trsm!('R', $uploc, 'N', $isunitc, one(T), B.data, A)
-
         # Matrix inverse
         inv!(A::$t{T,S}) where {T<:BlasFloat,S<:StridedMatrix} =
             $t{T,S}(LAPACK.trtri!($uploc, $isunitc, A.data))
 
+        function inv(A::$t{T}) where {T}
+            S = typeof(inv(oneunit(T)))
+            if S <: BlasFloat || S === T # i.e. A is unitless
+                $t(ldiv!(convert(AbstractArray{S}, A), Matrix{S}(I, size(A))))
+            else
+                J = (one(T)*I)(size(A, 1))
+                $t(ldiv!(similar(A, S, size(A)), A, J))
+            end
+        end
+
         # Error bounds for triangular solve
         errorbounds(A::$t{T,<:StridedMatrix}, X::StridedVecOrMat{T}, B::StridedVecOrMat{T}) where {T<:BlasFloat} =
             LAPACK.trrfs!($uploc, 'N', $isunitc, A.data, B, X)
@@ -766,93 +825,18 @@ for (t, uploc, isunitc) in ((:LowerTriangular, 'L', 'N'),
     end
 end
 
-# adjoint/transpose multiplication ('uploc' reversed)
-for (t, uploc, isunitc) in ((:LowerTriangular, 'U', 'N'),
-                            (:UnitLowerTriangular, 'U', 'U'),
-                            (:UpperTriangular, 'L', 'N'),
-                            (:UnitUpperTriangular, 'L', 'U'))
-    @eval begin
-        # Vector multiplication
-        lmul!(A::$t{<:Any,<:Transpose{T,<:StridedMatrix}}, b::StridedVector{T}) where {T<:BlasFloat} =
-            BLAS.trmv!($uploc, 'T', $isunitc, parent(parent(A)), b)
-        lmul!(A::$t{<:Any,<:Adjoint{T,<:StridedMatrix}}, b::StridedVector{T}) where {T<:BlasReal} =
-            BLAS.trmv!($uploc, 'T', $isunitc, parent(parent(A)), b)
-        lmul!(A::$t{<:Any,<:Adjoint{T,<:StridedMatrix}}, b::StridedVector{T}) where {T<:BlasComplex} =
-            BLAS.trmv!($uploc, 'C', $isunitc, parent(parent(A)), b)
-
-        # Matrix multiplication
-        lmul!(A::$t{<:Any,<:Transpose{T,<:StridedMatrix}}, B::StridedMatrix{T}) where {T<:BlasFloat} =
-            BLAS.trmm!('L', $uploc, 'T', $isunitc, one(T), parent(parent(A)), B)
-        lmul!(A::$t{<:Any,<:Adjoint{T,<:StridedMatrix}}, B::StridedMatrix{T}) where {T<:BlasComplex} =
-            BLAS.trmm!('L', $uploc, 'C', $isunitc, one(T), parent(parent(A)), B)
-        lmul!(A::$t{<:Any,<:Adjoint{T,<:StridedMatrix}}, B::StridedMatrix{T}) where {T<:BlasReal} =
-            BLAS.trmm!('L', $uploc, 'T', $isunitc, one(T), parent(parent(A)), B)
-
-        rmul!(A::StridedMatrix{T}, B::$t{<:Any,<:Transpose{T,<:StridedMatrix}}) where {T<:BlasFloat} =
-            BLAS.trmm!('R', $uploc, 'T', $isunitc, one(T), parent(parent(B)), A)
-        rmul!(A::StridedMatrix{T}, B::$t{<:Any,<:Adjoint{T,<:StridedMatrix}}) where {T<:BlasComplex} =
-            BLAS.trmm!('R', $uploc, 'C', $isunitc, one(T), parent(parent(B)), A)
-        rmul!(A::StridedMatrix{T}, B::$t{<:Any,<:Adjoint{T,<:StridedMatrix}}) where {T<:BlasReal} =
-            BLAS.trmm!('R', $uploc, 'T', $isunitc, one(T), parent(parent(B)), A)
-
-        # Left division
-        ldiv!(A::$t{<:Any,<:Transpose{T,<:StridedMatrix}}, B::StridedVecOrMat{T}) where {T<:BlasFloat} =
-            LAPACK.trtrs!($uploc, 'T', $isunitc, parent(parent(A)), B)
-        ldiv!(A::$t{<:Any,<:Adjoint{T,<:StridedMatrix}}, B::StridedVecOrMat{T}) where {T<:BlasReal} =
-            LAPACK.trtrs!($uploc, 'T', $isunitc, parent(parent(A)), B)
-        ldiv!(A::$t{<:Any,<:Adjoint{T,<:StridedMatrix}}, B::StridedVecOrMat{T}) where {T<:BlasComplex} =
-            LAPACK.trtrs!($uploc, 'C', $isunitc, parent(parent(A)), B)
-
-        # Right division
-        rdiv!(A::StridedMatrix{T}, B::$t{<:Any,<:Transpose{T,<:StridedMatrix}}) where {T<:BlasFloat} =
-            BLAS.trsm!('R', $uploc, 'T', $isunitc, one(T), parent(parent(B)), A)
-        rdiv!(A::StridedMatrix{T}, B::$t{<:Any,<:Adjoint{T,<:StridedMatrix}}) where {T<:BlasReal} =
-            BLAS.trsm!('R', $uploc, 'T', $isunitc, one(T), parent(parent(B)), A)
-        rdiv!(A::StridedMatrix{T}, B::$t{<:Any,<:Adjoint{T,<:StridedMatrix}}) where {T<:BlasComplex} =
-            BLAS.trsm!('R', $uploc, 'C', $isunitc, one(T), parent(parent(B)), A)
-    end
-end
-
-# redirect back to BLAS
-for t in (:UpperTriangular, :UnitUpperTriangular, :LowerTriangular, :UnitLowerTriangular)
-    @eval _multrimat!(C::StridedVecOrMat{T}, A::$t{T,<:StridedMatrix}, B::AbstractVecOrMat{T}) where {T<:BlasFloat} =
-        lmul!(A, copyto!(C, B))
-    @eval _multrimat!(C::StridedVecOrMat{T}, A::$t{<:Any,<:Adjoint{T,<:StridedMatrix}}, B::AbstractVecOrMat{T}) where {T<:BlasFloat} =
-        lmul!(A, copyto!(C, B))
-    @eval _multrimat!(C::StridedVecOrMat{T}, A::$t{<:Any,<:Transpose{T,<:StridedMatrix}}, B::AbstractVecOrMat{T}) where {T<:BlasFloat} =
-        lmul!(A, copyto!(C, B))
-    @eval _mulmattri!(C::StridedMatrix{T}, A::AbstractMatrix{T}, B::$t{T,<:StridedMatrix}) where {T<:BlasFloat} =
-        rmul!(copyto!(C, A), B)
-    @eval _mulmattri!(C::StridedMatrix{T}, A::AbstractMatrix{T}, B::$t{<:Any,<:Adjoint{T,<:StridedMatrix}}) where {T<:BlasFloat} =
-        rmul!(copyto!(C, A), B)
-    @eval _mulmattri!(C::StridedMatrix{T}, A::AbstractMatrix{T}, B::$t{<:Any,<:Transpose{T,<:StridedMatrix}}) where {T<:BlasFloat} =
-        rmul!(copyto!(C, A), B)
-
-    @eval ldiv!(C::StridedVecOrMat{T}, A::$t{T,<:StridedMatrix}, B::AbstractVecOrMat{T}) where {T<:BlasFloat} =
-        ldiv!(A, copyto!(C, B))
-    @eval ldiv!(C::StridedVecOrMat{T}, A::$t{<:Any,<:Adjoint{T,<:StridedMatrix}}, B::AbstractVecOrMat{T}) where {T<:BlasFloat} =
-        ldiv!(A, copyto!(C, B))
-    @eval ldiv!(C::StridedVecOrMat{T}, A::$t{<:Any,<:Transpose{T,<:StridedMatrix}}, B::AbstractVecOrMat{T}) where {T<:BlasFloat} =
-        ldiv!(A, copyto!(C, B))
-    @eval _rdiv!(C::StridedMatrix{T}, A::AbstractMatrix{T}, B::$t{T,<:StridedMatrix}) where {T<:BlasFloat} =
-        rdiv!(copyto!(C, A), B)
-    @eval _rdiv!(C::StridedMatrix{T}, A::AbstractMatrix{T}, B::$t{<:Any,<:Adjoint{T,<:StridedMatrix}}) where {T<:BlasFloat} =
-        rdiv!(copyto!(C, A), B)
-    @eval _rdiv!(C::StridedMatrix{T}, A::AbstractMatrix{T}, B::$t{<:Any,<:Transpose{T,<:StridedMatrix}}) where {T<:BlasFloat} =
-        rdiv!(copyto!(C, A), B)
-end
-
-for t in (:LowerTriangular, :UnitLowerTriangular, :UpperTriangular, :UnitUpperTriangular)
-    @eval function inv(A::$t{T}) where {T}
-        S = typeof(inv(oneunit(T)))
-        if S <: BlasFloat || S === T # i.e. A is unitless
-            $t(ldiv!(convert(AbstractArray{S}, A), Matrix{S}(I, size(A))))
-        else
-            J = (one(T)*I)(size(A, 1))
-            $t(ldiv!(similar(A, S, size(A)), A, J))
-        end
-    end
-end
+# multiplication
+generic_trimatmul!(c::StridedVector{T}, uploc, isunitc, tfun::Function, A::StridedMatrix{T}, b::AbstractVector{T}) where {T<:BlasFloat} =
+    BLAS.trmv!(uploc, tfun === identity ? 'N' : tfun === transpose ? 'T' : 'C', isunitc, A, c === b ? c : copyto!(c, b))
+generic_trimatmul!(C::StridedMatrix{T}, uploc, isunitc, tfun::Function, A::StridedMatrix{T}, B::AbstractMatrix{T}) where {T<:BlasFloat} =
+    BLAS.trmm!('L', uploc, tfun === identity ? 'N' : tfun === transpose ? 'T' : 'C', isunitc, one(T), A, C === B ? C : copyto!(C, B))
+generic_mattrimul!(C::StridedMatrix{T}, uploc, isunitc, tfun::Function, A::AbstractMatrix{T}, B::StridedMatrix{T}) where {T<:BlasFloat} =
+    BLAS.trmm!('R', uploc, tfun === identity ? 'N' : tfun === transpose ? 'T' : 'C', isunitc, one(T), B, C === A ? C : copyto!(C, A))
+# division
+generic_trimatdiv!(C::StridedVecOrMat{T}, uploc, isunitc, tfun::Function, A::StridedMatrix{T}, B::AbstractVecOrMat{T}) where {T<:BlasFloat} =
+    LAPACK.trtrs!(uploc, tfun === identity ? 'N' : tfun === transpose ? 'T' : 'C', isunitc, A, C === B ? C : copyto!(C, B))
+generic_mattridiv!(C::StridedMatrix{T}, uploc, isunitc, tfun::Function, A::AbstractMatrix{T}, B::StridedMatrix{T}) where {T<:BlasFloat} =
+    BLAS.trsm!('R', uploc, tfun === identity ? 'N' : tfun === transpose ? 'T' : 'C', isunitc, one(T), B, C === A ? C : copyto!(C, A))
 
 errorbounds(A::AbstractTriangular{T,<:AbstractMatrix}, X::AbstractVecOrMat{T}, B::AbstractVecOrMat{T}) where {T<:Union{BigFloat,Complex{BigFloat}}} =
     error("not implemented yet! Please submit a pull request.")
@@ -930,17 +914,11 @@ for (t, unitt) in ((UpperTriangular, UnitUpperTriangular),
             end
             $t(B)
         end
-
-        lmul!(A::$t, B::AbstractVecOrMat)     = @inline _multrimat!(B, A, B)
-        lmul!(A::$unitt, B::AbstractVecOrMat) = @inline _multrimat!(B, A, B)
-
-        rmul!(A::AbstractMatrix, B::$t)     = @inline _mulmattri!(A, A, B)
-        rmul!(A::AbstractMatrix, B::$unitt) = @inline _mulmattri!(A, A, B)
     end
 end
 
 ## Generic triangular multiplication
-function _multrimat!(C::AbstractVecOrMat, A::UpperTriangular, B::AbstractVecOrMat)
+function generic_trimatmul!(C::AbstractVecOrMat, uploc, isunitc, tfun::Function, A::AbstractMatrix, B::AbstractVecOrMat)
     require_one_based_indexing(C, A, B)
     m, n = size(B, 1), size(B, 2)
     N = size(A, 1)
@@ -951,41 +929,58 @@ function _multrimat!(C::AbstractVecOrMat, A::UpperTriangular, B::AbstractVecOrMa
     if mc != N || nc != n
         throw(DimensionMismatch("output has dimensions ($mc,$nc), should have ($N,$n)"))
     end
-    @inbounds for j in 1:n
-        for i in 1:m
-            Cij = A.data[i,i] * B[i,j]
-            for k in i + 1:m
-                Cij += A.data[i,k] * B[k,j]
+    oA = oneunit(eltype(A))
+    unit = isunitc == 'U'
+    @inbounds if uploc == 'U'
+        if tfun === identity
+            for j in 1:n
+                for i in 1:m
+                    Cij = (unit ? oA : A[i,i]) * B[i,j]
+                    for k in i + 1:m
+                        Cij += A[i,k] * B[k,j]
+                    end
+                    C[i,j] = Cij
+                end
+            end
+        else # tfun in (transpose, adjoint)
+            for j in 1:n
+                for i in m:-1:1
+                    Cij = (unit ? oA : tfun(A[i,i])) * B[i,j]
+                    for k in 1:i - 1
+                        Cij += tfun(A[k,i]) * B[k,j]
+                    end
+                    C[i,j] = Cij
+                end
             end
-            C[i,j] = Cij
         end
-    end
-    return C
-end
-function _multrimat!(C::AbstractVecOrMat, A::UnitUpperTriangular, B::AbstractVecOrMat)
-    require_one_based_indexing(C, A, B)
-    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"))
-    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)"))
-    end
-    @inbounds for j in 1:n
-        for i in 1:m
-            Cij = oneunit(eltype(A)) * B[i,j]
-            for k in i + 1:m
-                Cij += A.data[i,k] * B[k,j]
+    else # uploc == 'L'
+        if tfun === identity
+            for j in 1:n
+                for i in m:-1:1
+                    Cij = (unit ? oA : A[i,i]) * B[i,j]
+                    for k in 1:i - 1
+                        Cij += A[i,k] * B[k,j]
+                    end
+                    C[i,j] = Cij
+                end
+            end
+        else # tfun in (transpose, adjoint)
+            for j in 1:n
+                for i in 1:m
+                    Cij = (unit ? oA : tfun(A[i,i])) * B[i,j]
+                    for k in i + 1:m
+                        Cij += tfun(A[k,i]) * B[k,j]
+                    end
+                    C[i,j] = Cij
+                end
             end
-            C[i,j] = Cij
         end
     end
     return C
 end
-function _multrimat!(C::AbstractVecOrMat, A::LowerTriangular, B::AbstractVecOrMat)
+# conjugate cases
+function generic_trimatmul!(C::AbstractVecOrMat, uploc, isunitc, ::Function, xA::AdjOrTrans, B::AbstractVecOrMat)
+    A = parent(xA)
     require_one_based_indexing(C, A, B)
     m, n = size(B, 1), size(B, 2)
     N = size(A, 1)
@@ -996,41 +991,33 @@ function _multrimat!(C::AbstractVecOrMat, A::LowerTriangular, B::AbstractVecOrMa
     if mc != N || nc != n
         throw(DimensionMismatch("output has dimensions ($mc,$nc), should have ($N,$n)"))
     end
-    @inbounds for j in 1:n
-        for i in m:-1:1
-            Cij = A.data[i,i] * B[i,j]
-            for k in 1:i - 1
-                Cij += A.data[i,k] * B[k,j]
+    oA = oneunit(eltype(A))
+    unit = isunitc == 'U'
+    @inbounds if uploc == 'U'
+        for j in 1:n
+            for i in 1:m
+                Cij = (unit ? oA : conj(A[i,i])) * B[i,j]
+                for k in i + 1:m
+                    Cij += conj(A[i,k]) * B[k,j]
+                end
+                C[i,j] = Cij
             end
-            C[i,j] = Cij
         end
-    end
-    return C
-end
-function _multrimat!(C::AbstractVecOrMat, A::UnitLowerTriangular, B::AbstractVecOrMat)
-    require_one_based_indexing(C, A, B)
-    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"))
-    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)"))
-    end
-    @inbounds for j in 1:n
-        for i in m:-1:1
-            Cij = oneunit(eltype(A)) * B[i,j]
-            for k in 1:i - 1
-                Cij += A.data[i,k] * B[k,j]
+    else # uploc == 'L'
+        for j in 1:n
+            for i in m:-1:1
+                Cij = (unit ? oA : conj(A[i,i])) * B[i,j]
+                for k in 1:i - 1
+                    Cij += conj(A[i,k]) * B[k,j]
+                end
+                C[i,j] = Cij
             end
-            C[i,j] = Cij
         end
     end
     return C
 end
 
-function _mulmattri!(C::AbstractMatrix, A::AbstractMatrix, B::UpperTriangular)
+function generic_mattrimul!(C::AbstractMatrix, uploc, isunitc, tfun::Function, A::AbstractMatrix, B::AbstractMatrix)
     require_one_based_indexing(C, A, B)
     m, n = size(A, 1), size(A, 2)
     N = size(B, 1)
@@ -1041,40 +1028,58 @@ function _mulmattri!(C::AbstractMatrix, A::AbstractMatrix, B::UpperTriangular)
     if mc != m || nc != N
         throw(DimensionMismatch("output has dimensions ($mc,$nc), should have ($m,$N)"))
     end
-    @inbounds for i in 1:m
-        for j in n:-1:1
-            Cij = A[i,j] * B.data[j,j]
-            for k in 1:j - 1
-                Cij += A[i,k] * B.data[k,j]
+    oB = oneunit(eltype(B))
+    unit = isunitc == 'U'
+    @inbounds if uploc == 'U'
+        if tfun === identity
+            for i in 1:m
+                for j in n:-1:1
+                    Cij = A[i,j] * (unit ? oB : B[j,j])
+                    for k in 1:j - 1
+                        Cij += A[i,k] * B[k,j]
+                    end
+                    C[i,j] = Cij
+                end
+            end
+        else # tfun in (transpose, adjoint)
+            for i in 1:m
+                for j in 1:n
+                    Cij = A[i,j] * (unit ? oB : tfun(B[j,j]))
+                    for k in j + 1:n
+                        Cij += A[i,k] * tfun(B[j,k])
+                    end
+                    C[i,j] = Cij
+                end
             end
-            C[i,j] = Cij
         end
-    end
-    return C
-end
-function _mulmattri!(C::AbstractMatrix, A::AbstractMatrix, B::UnitUpperTriangular)
-    require_one_based_indexing(C, A, B)
-    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"))
-    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)"))
-    end
-    @inbounds for i in 1:m
-        for j in n:-1:1
-            Cij = A[i,j] * oneunit(eltype(B))
-            for k in 1:j - 1
-                Cij += A[i,k] * B.data[k,j]
+    else # uploc == 'L'
+        if tfun === identity
+            for i in 1:m
+                for j in 1:n
+                    Cij = A[i,j] * (unit ? oB : B[j,j])
+                    for k in j + 1:n
+                        Cij += A[i,k] * B[k,j]
+                    end
+                    C[i,j] = Cij
+                end
+            end
+        else # tfun in (transpose, adjoint)
+            for i in 1:m
+                for j in n:-1:1
+                    Cij = A[i,j] * (unit ? oB : tfun(B[j,j]))
+                    for k in 1:j - 1
+                        Cij += A[i,k] * tfun(B[j,k])
+                    end
+                    C[i,j] = Cij
+                end
             end
-            C[i,j] = Cij
         end
     end
     return C
 end
-function _mulmattri!(C::AbstractMatrix, A::AbstractMatrix, B::LowerTriangular)
+# conjugate cases
+function generic_mattrimul!(C::AbstractMatrix, uploc, isunitc, ::Function, A::AbstractMatrix, xB::AdjOrTrans)
+    B = parent(xB)
     require_one_based_indexing(C, A, B)
     m, n = size(A, 1), size(A, 2)
     N = size(B, 1)
@@ -1085,199 +1090,263 @@ function _mulmattri!(C::AbstractMatrix, A::AbstractMatrix, B::LowerTriangular)
     if mc != m || nc != N
         throw(DimensionMismatch("output has dimensions ($mc,$nc), should have ($m,$N)"))
     end
-    @inbounds for i in 1:m
-        for j in 1:n
-            Cij = A[i,j] * B.data[j,j]
-            for k in j + 1:n
-                Cij += A[i,k] * B.data[k,j]
+    oB = oneunit(eltype(B))
+    unit = isunitc == 'U'
+    @inbounds if uploc == 'U'
+        for i in 1:m
+            for j in n:-1:1
+                Cij = A[i,j] * (unit ? oB : conj(B[j,j]))
+                for k in 1:j - 1
+                    Cij += A[i,k] * conj(B[k,j])
+                end
+                C[i,j] = Cij
             end
-            C[i,j] = Cij
         end
-    end
-    return C
-end
-function _mulmattri!(C::AbstractMatrix, A::AbstractMatrix, B::UnitLowerTriangular)
-    require_one_based_indexing(C, A, B)
-    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"))
-    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)"))
-    end
-    @inbounds for i in 1:m
-        for j in 1:n
-            Cij = A[i,j] * oneunit(eltype(B))
-            for k in j + 1:n
-                Cij += A[i,k] * B.data[k,j]
+    else # uploc == 'L'
+        for i in 1:m
+            for j in 1:n
+                Cij = A[i,j] * (unit ? oB : conj(B[j,j]))
+                for k in j + 1:n
+                    Cij += A[i,k] * conj(B[k,j])
+                end
+                C[i,j] = Cij
             end
-            C[i,j] = Cij
         end
     end
     return C
 end
 
 #Generic solver using naive substitution
+
+@inline _ustrip(a) = oneunit(a) \ a
+@inline _ustrip(a::Union{AbstractFloat,Integer,Complex,Rational}) = a
+
 # manually hoisting b[j] significantly improves performance as of Dec 2015
 # manually eliding bounds checking significantly improves performance as of Dec 2015
-# directly indexing A.data rather than A significantly improves performance as of Dec 2015
-# replacing repeated references to A.data with [Adata = A.data and references to Adata]
-# does not significantly impact performance as of Dec 2015
 # replacing repeated references to A.data[j,j] with [Ajj = A.data[j,j] and references to Ajj]
 # does not significantly impact performance as of Dec 2015
-ldiv!(A::AbstractTriangular, b::AbstractVecOrMat) = @inline ldiv!(b, A, b)
-function ldiv!(C::AbstractMatrix, A::AbstractTriangular, B::AbstractMatrix)
+# in the transpose and conjugate transpose naive substitution variants,
+# accumulating in z rather than b[j,k] significantly improves performance as of Dec 2015
+function generic_trimatdiv!(C::AbstractVecOrMat, uploc, isunitc, tfun::Function, A::AbstractMatrix, B::AbstractVecOrMat)
     require_one_based_indexing(C, A, B)
-    nA, mA = size(A)
-    n = size(B, 1)
-    if nA != n
-        throw(DimensionMismatch("second dimension of left hand side A, $mA, and first dimension of right hand side B, $n, must be equal"))
+    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"))
     end
     if size(C) != size(B)
         throw(DimensionMismatch("size of output, $(size(C)), does not match size of right hand side, $(size(B))"))
     end
-    @inbounds for (c, b) in zip(eachcol(C), eachcol(B))
-        ldiv!(c, A, b)
-    end
-    C
-end
-@inline function ldiv!(c::AbstractVector, A::AbstractTriangular, b::AbstractVector)
-    @boundscheck begin
-        require_one_based_indexing(c, A, b)
-        n = size(A, 2)
-        if !(n == length(b))
-            throw(DimensionMismatch("second dimension of left hand side A, $n, and length of right hand side b, $(length(b)), must be equal"))
-        end
-        if !(n == length(c))
-            throw(DimensionMismatch("length of output c, $(length(c)), does not match length of right hand side b, $(length(b))"))
-        end
-    end
-    return _ldiv!(c, A, b)
-end
-
-_uconvert_copyto!(c, b, oA) = (c .= Ref(oA) .\ b)
-_uconvert_copyto!(c::AbstractArray{T}, b::AbstractArray{T}, _) where {T} = copyto!(c, b)
-
-@inline _ustrip(a) = oneunit(a) \ a
-@inline _ustrip(a::Union{AbstractFloat,Integer,Complex,Rational}) = a
-
-# all of the following _ldiv! methods are "unsafe" in that they assume one-based indexing
-# and compatible sizes
-function _ldiv!(c::AbstractVector, A::UpperTriangular, b::AbstractVector)
-    n = size(A, 2)
-    c !== b && _uconvert_copyto!(c, b, oneunit(eltype(A)))
-    @inbounds for j in n:-1:1
-        ajj = A.data[j,j]
-        iszero(ajj) && throw(SingularException(j))
-        cj = c[j] = _ustrip(ajj) \ c[j]
-        for i in j-1:-1:1
-            c[i] -= _ustrip(A.data[i,j]) * cj
+    oA = oneunit(eltype(A))
+    @inbounds if uploc == 'U'
+        if isunitc == 'N'
+            if tfun === identity
+                for k in 1:n
+                    amm = A[m,m]
+                    iszero(amm) && throw(SingularException(m))
+                    Cm = C[m,k] = amm \ B[m,k]
+                    # fill C-column
+                    for i in m-1:-1:1
+                        C[i,k] = oA \ B[i,k] - _ustrip(A[i,m]) * Cm
+                    end
+                    for j in m-1:-1:1
+                        ajj = A[j,j]
+                        iszero(ajj) && throw(SingularException(j))
+                        Cj = C[j,k] = _ustrip(ajj) \ C[j,k]
+                        for i in j-1:-1:1
+                            C[i,k] -= _ustrip(A[i,j]) * Cj
+                        end
+                    end
+                end
+            else # tfun in (adjoint, transpose)
+                for k in 1:n
+                    for j in 1:m
+                        ajj = A[j,j]
+                        iszero(ajj) && throw(SingularException(j))
+                        Bj = B[j,k]
+                        for i in 1:j-1
+                            Bj -= tfun(A[i,j]) * C[i,k]
+                        end
+                        C[j,k] = tfun(ajj) \ Bj
+                    end
+                end
+            end
+        else # isunitc == 'U'
+            if tfun === identity
+                for k in 1:n
+                    Cm = C[m,k] = oA \ B[m,k]
+                    # fill C-column
+                    for i in m-1:-1:1
+                        C[i,k] = oA \ B[i,k] - _ustrip(A[i,m]) * Cm
+                    end
+                    for j in m-1:-1:1
+                        Cj = C[j,k]
+                        for i in 1:j-1
+                            C[i,k] -= _ustrip(A[i,j]) * Cj
+                        end
+                    end
+                end
+            else # tfun in (adjoint, transpose)
+                for k in 1:n
+                    for j in 1:m
+                        Bj = B[j,k]
+                        for i in 1:j-1
+                            Bj -= tfun(A[i,j]) * C[i,k]
+                        end
+                        C[j,k] = oA \ Bj
+                    end
+                end
+            end
         end
-    end
-    return c
-end
-function _ldiv!(c::AbstractVector, A::UnitUpperTriangular, b::AbstractVector)
-    n = size(A, 2)
-    c !== b && _uconvert_copyto!(c, b, oneunit(eltype(A)))
-    @inbounds for j in n:-1:1
-        cj = c[j]
-        for i in 1:j-1
-            c[i] -= _ustrip(A.data[i,j]) * cj
+    else # uploc == 'L'
+        if isunitc == 'N'
+            if tfun === identity
+                for k in 1:n
+                    a11 = A[1,1]
+                    iszero(a11) && throw(SingularException(1))
+                    C1 = C[1,k] = a11 \ B[1,k]
+                    # fill C-column
+                    for i in 2:m
+                        C[i,k] = oA \ B[i,k] - _ustrip(A[i,1]) * C1
+                    end
+                    for j in 2:m
+                        ajj = A[j,j]
+                        iszero(ajj) && throw(SingularException(j))
+                        Cj = C[j,k] = _ustrip(ajj) \ C[j,k]
+                        for i in j+1:m
+                            C[i,k] -= _ustrip(A[i,j]) * Cj
+                        end
+                    end
+                end
+            else # tfun in (adjoint, transpose)
+                for k in 1:n
+                    for j in m:-1:1
+                        ajj = A[j,j]
+                        iszero(ajj) && throw(SingularException(j))
+                        Bj = B[j,k]
+                        for i in j+1:m
+                            Bj -= tfun(A[i,j]) * C[i,k]
+                        end
+                        C[j,k] = tfun(ajj) \ Bj
+                    end
+                end
+            end
+        else # isunitc == 'U'
+            if tfun === identity
+                for k in 1:n
+                    C1 = C[1,k] = oA \ B[1,k]
+                    # fill C-column
+                    for i in 2:m
+                        C[i,k] = oA \ B[i,k] - _ustrip(A[i,1]) * C1
+                    end
+                    for j in 2:m
+                        Cj = C[j,k]
+                        for i in j+1:m
+                            C[i,k] -= _ustrip(A[i,j]) * Cj
+                        end
+                    end
+                end
+            else # tfun in (adjoint, transpose)
+                for k in 1:n
+                    for j in m:-1:1
+                        Bj = B[j,k]
+                        for i in j+1:m
+                            Bj -= tfun(A[i,j]) * C[i,k]
+                        end
+                        C[j,k] = oA \ Bj
+                    end
+                end
+            end
         end
     end
-    return c
+    return C
 end
-function _ldiv!(c::AbstractVector, A::LowerTriangular, b::AbstractVector)
-    n = size(A, 2)
-    c !== b && _uconvert_copyto!(c, b, oneunit(eltype(A)))
-    @inbounds for j in 1:n
-        ajj = A.data[j,j]
-        iszero(ajj) && throw(SingularException(j))
-        cj = c[j] = _ustrip(ajj) \ c[j]
-        for i in j+1:n
-            c[i] -= _ustrip(A.data[i,j]) * cj
-        end
+# conjugate cases
+function generic_trimatdiv!(C::AbstractVecOrMat, uploc, isunitc, ::Function, xA::AdjOrTrans, B::AbstractVecOrMat)
+    A = parent(xA)
+    require_one_based_indexing(C, A, B)
+    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"))
     end
-    return c
-end
-function _ldiv!(c::AbstractVector, A::UnitLowerTriangular, b::AbstractVector)
-    n = size(A, 2)
-    c !== b && _uconvert_copyto!(c, b, oneunit(eltype(A)))
-    @inbounds for j in 1:n
-        cj = c[j]
-        for i in j+1:n
-            c[i] -= _ustrip(A.data[i,j]) * cj
-        end
+    if size(C) != size(B)
+        throw(DimensionMismatch("size of output, $(size(C)), does not match size of right hand side, $(size(B))"))
     end
-    return c
-end
-
-
-# in the following transpose and conjugate transpose naive substitution variants,
-# accumulating in z rather than b[j,k] significantly improves performance as of Dec 2015
-function _ldiv!(c::AbstractVector, xA::UpperTriangular{<:Any,<:AdjOrTrans}, b::AbstractVector)
-    tfun = adj_or_trans(parent(xA))
-    A = parent(parent(xA))
-    n = size(A, 2)
-    @inbounds for j in n:-1:1
-        ajj = A[j,j]
-        iszero(ajj) && throw(SingularException(j))
-        bj = b[j]
-        for i in j+1:n
-            bj -= tfun(A[i,j]) * c[i]
-        end
-        c[j] = tfun(ajj) \ bj
-    end
-    return c
-end
-function _ldiv!(c::AbstractVector, xA::UnitUpperTriangular{<:Any,<:AdjOrTrans}, b::AbstractVector)
-    tfun = adj_or_trans(parent(xA))
-    A = parent(parent(xA))
     oA = oneunit(eltype(A))
-    n = size(A, 2)
-    @inbounds for j in n:-1:1
-        bj = b[j]
-        for i in j+1:n
-            bj -= tfun(A[i,j]) * c[i]
-        end
-        c[j] = oA \ bj
-    end
-    return c
-end
-function _ldiv!(c::AbstractVector, xA::LowerTriangular{<:Any,<:AdjOrTrans}, b::AbstractVector)
-    tfun = adj_or_trans(parent(xA))
-    A = parent(parent(xA))
-    n = size(A, 2)
-    @inbounds for j in 1:n
-        ajj = A[j,j]
-        iszero(ajj) && throw(SingularException(j))
-        bj = b[j]
-        for i in 1:j-1
-            bj -= tfun(A[i,j]) * c[i]
-        end
-        c[j] = tfun(ajj) \ bj
-    end
-    return c
-end
-function _ldiv!(c::AbstractVector, xA::UnitLowerTriangular{<:Any,<:AdjOrTrans}, b::AbstractVector)
-    tfun = adj_or_trans(parent(xA))
-    A = parent(parent(xA))
-    oA = oneunit(eltype(A))
-    n = size(A, 2)
-    @inbounds for j in 1:n
-        bj = b[j]
-        for i in 1:j-1
-            bj -= tfun(A[i,j]) * c[i]
+    @inbounds if uploc == 'U'
+        if isunitc == 'N'
+            for k in 1:n
+                amm = conj(A[m,m])
+                iszero(amm) && throw(SingularException(m))
+                Cm = C[m,k] = amm \ B[m,k]
+                # fill C-column
+                for i in m-1:-1:1
+                    C[i,k] = oA \ B[i,k] - _ustrip(conj(A[i,m])) * Cm
+                end
+                for j in m-1:-1:1
+                    ajj = conj(A[j,j])
+                    iszero(ajj) && throw(SingularException(j))
+                    Cj = C[j,k] = _ustrip(ajj) \ C[j,k]
+                    for i in j-1:-1:1
+                        C[i,k] -= _ustrip(conj(A[i,j])) * Cj
+                    end
+                end
+            end
+        else # isunitc == 'U'
+            for k in 1:n
+                Cm = C[m,k] = oA \ B[m,k]
+                # fill C-column
+                for i in m-1:-1:1
+                    C[i,k] = oA \ B[i,k] - _ustrip(conj(A[i,m])) * Cm
+                end
+                for j in m-1:-1:1
+                    Cj = C[j,k]
+                    for i in 1:j-1
+                        C[i,k] -= _ustrip(conj(A[i,j])) * Cj
+                    end
+                end
+            end
+        end
+    else # uploc == 'L'
+        if isunitc == 'N'
+            for k in 1:n
+                a11 = conj(A[1,1])
+                iszero(a11) && throw(SingularException(1))
+                C1 = C[1,k] = a11 \ B[1,k]
+                # fill C-column
+                for i in 2:m
+                    C[i,k] = oA \ B[i,k] - _ustrip(conj(A[i,1])) * C1
+                end
+                for j in 2:m
+                    ajj = conj(A[j,j])
+                    iszero(ajj) && throw(SingularException(j))
+                    Cj = C[j,k] = _ustrip(ajj) \ C[j,k]
+                    for i in j+1:m
+                        C[i,k] -= _ustrip(conj(A[i,j])) * Cj
+                    end
+                end
+            end
+        else # isunitc == 'U'
+            for k in 1:n
+                C1 = C[1,k] = oA \ B[1,k]
+                # fill C-column
+                for i in 2:m
+                    C[i,k] = oA \ B[i,k] - _ustrip(conj(A[i,1])) * C1
+                end
+                for j in 1:m
+                    Cj = C[j,k]
+                    for i in j+1:m
+                        C[i,k] -= _ustrip(conj(A[i,j])) * Cj
+                    end
+                end
+            end
         end
-        c[j] = oA \ bj
     end
-    return c
+    return C
 end
 
-rdiv!(A::AbstractMatrix, B::AbstractTriangular) = @inline _rdiv!(A, A, B)
-function _rdiv!(C::AbstractMatrix, A::AbstractMatrix, B::UpperTriangular)
+function generic_mattridiv!(C::AbstractMatrix, uploc, isunitc, tfun::Function, A::AbstractMatrix, B::AbstractMatrix)
     require_one_based_indexing(C, A, B)
     m, n = size(A)
     if size(B, 1) != n
@@ -1286,39 +1355,61 @@ function _rdiv!(C::AbstractMatrix, A::AbstractMatrix, B::UpperTriangular)
     if size(C) != size(A)
         throw(DimensionMismatch("size of output, $(size(C)), does not match size of left hand side, $(size(A))"))
     end
-    @inbounds for i in 1:m
-        for j in 1:n
-            Aij = A[i,j]
-            for k in 1:j - 1
-                Aij -= C[i,k]*B.data[k,j]
+    oB = oneunit(eltype(B))
+    unit = isunitc == 'U'
+    @inbounds if uploc == 'U'
+        if tfun === identity
+            for i in 1:m
+                for j in 1:n
+                    Aij = A[i,j]
+                    for k in 1:j - 1
+                        Aij -= C[i,k]*B[k,j]
+                    end
+                    unit || (iszero(B[j,j]) && throw(SingularException(j)))
+                    C[i,j] = Aij / (unit ? oB : B[j,j])
+                end
+            end
+        else # tfun in (adjoint, transpose)
+            for i in 1:m
+                for j in n:-1:1
+                    Aij = A[i,j]
+                    for k in j + 1:n
+                        Aij -= C[i,k]*tfun(B[j,k])
+                    end
+                    unit || (iszero(B[j,j]) && throw(SingularException(j)))
+                    C[i,j] = Aij / (unit ? oB : tfun(B[j,j]))
+                end
             end
-            iszero(B.data[j,j]) && throw(SingularException(j))
-            C[i,j] = Aij / B.data[j,j]
         end
-    end
-    C
-end
-function _rdiv!(C::AbstractMatrix, A::AbstractMatrix, B::UnitUpperTriangular)
-    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))"))
-    end
-    if size(C) != size(A)
-        throw(DimensionMismatch("size of output, $(size(C)), does not match size of left hand side, $(size(A))"))
-    end
-    @inbounds for i in 1:m
-        for j in 1:n
-            Aij = A[i,j]
-            for k in 1:j - 1
-                Aij -= C[i,k]*B.data[k,j]
+    else # uploc == 'L'
+        if tfun === identity
+            for i in 1:m
+                for j in n:-1:1
+                    Aij = A[i,j]
+                    for k in j + 1:n
+                        Aij -= C[i,k]*B[k,j]
+                    end
+                    unit || (iszero(B[j,j]) && throw(SingularException(j)))
+                    C[i,j] = Aij / (unit ? oB : B[j,j])
+                end
+            end
+        else # tfun in (adjoint, transpose)
+            for i in 1:m
+                for j in 1:n
+                    Aij = A[i,j]
+                    for k in 1:j - 1
+                        Aij -= C[i,k]*tfun(B[j,k])
+                    end
+                    unit || (iszero(B[j,j]) && throw(SingularException(j)))
+                    C[i,j] = Aij / (unit ? oB : tfun(B[j,j]))
+                end
             end
-            C[i,j] = Aij / oneunit(eltype(B))
         end
     end
-    C
+    return C
 end
-function _rdiv!(C::AbstractMatrix, A::AbstractMatrix, B::LowerTriangular)
+function generic_mattridiv!(C::AbstractMatrix, uploc, isunitc, ::Function, A::AbstractMatrix, xB::AdjOrTrans)
+    B = parent(xB)
     require_one_based_indexing(C, A, B)
     m, n = size(A)
     if size(B, 1) != n
@@ -1327,54 +1418,35 @@ function _rdiv!(C::AbstractMatrix, A::AbstractMatrix, B::LowerTriangular)
     if size(C) != size(A)
         throw(DimensionMismatch("size of output, $(size(C)), does not match size of left hand side, $(size(A))"))
     end
-    @inbounds for i in 1:m
-        for j in n:-1:1
-            Aij = A[i,j]
-            for k in j + 1:n
-                Aij -= C[i,k]*B.data[k,j]
+    oB = oneunit(eltype(B))
+    unit = isunitc == 'U'
+    if uploc == 'U'
+        @inbounds for i in 1:m
+            for j in 1:n
+                Aij = A[i,j]
+                for k in 1:j - 1
+                    Aij -= C[i,k]*conj(B[k,j])
+                end
+                unit || (iszero(B[j,j]) && throw(SingularException(j)))
+                C[i,j] = Aij / (unit ? oB : conj(B[j,j]))
             end
-            iszero(B.data[j,j]) && throw(SingularException(j))
-            C[i,j] = Aij / B.data[j,j]
         end
-    end
-    C
-end
-function _rdiv!(C::AbstractMatrix, A::AbstractMatrix, B::UnitLowerTriangular)
-    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))"))
-    end
-    if size(C) != size(A)
-        throw(DimensionMismatch("size of output, $(size(C)), does not match size of left hand side, $(size(A))"))
-    end
-    @inbounds for i in 1:m
-        for j in n:-1:1
-            Aij = A[i,j]
-            for k in j + 1:n
-                Aij -= C[i,k]*B.data[k,j]
+    else # uploc == 'L'
+        @inbounds for i in 1:m
+            for j in n:-1:1
+                Aij = A[i,j]
+                for k in j + 1:n
+                    Aij -= C[i,k]*conj(B[k,j])
+                end
+                unit || (iszero(B[j,j]) && throw(SingularException(j)))
+                C[i,j] = Aij / (unit ? oB : conj(B[j,j]))
             end
-            C[i,j] = Aij / oneunit(eltype(B))
         end
     end
-    C
+    return C
 end
 
-lmul!(A::UpperTriangular,     B::UpperTriangular) = UpperTriangular(lmul!(A, triu!(B.data)))
-lmul!(A::UnitUpperTriangular, B::UpperTriangular) = UpperTriangular(lmul!(A, triu!(B.data)))
-lmul!(A::LowerTriangular,     B::LowerTriangular) = LowerTriangular(lmul!(A, tril!(B.data)))
-lmul!(A::UnitLowerTriangular, B::LowerTriangular) = LowerTriangular(lmul!(A, tril!(B.data)))
-
-ldiv!(A::UpperTriangular,     B::UpperTriangular) = UpperTriangular(ldiv!(A, triu!(B.data)))
-ldiv!(A::UnitUpperTriangular, B::UpperTriangular) = UpperTriangular(ldiv!(A, triu!(B.data)))
-ldiv!(A::LowerTriangular,     B::LowerTriangular) = LowerTriangular(ldiv!(A, tril!(B.data)))
-ldiv!(A::UnitLowerTriangular, B::LowerTriangular) = LowerTriangular(ldiv!(A, tril!(B.data)))
-
-rdiv!(A::UpperTriangular, B::UpperTriangular)     = UpperTriangular(rdiv!(triu!(A.data), B))
-rdiv!(A::UpperTriangular, B::UnitUpperTriangular) = UpperTriangular(rdiv!(triu!(A.data), B))
-rdiv!(A::LowerTriangular, B::LowerTriangular)     = LowerTriangular(rdiv!(tril!(A.data), B))
-rdiv!(A::LowerTriangular, B::UnitLowerTriangular) = LowerTriangular(rdiv!(tril!(A.data), B))
-
+# these are needed because we don't keep track of left- and right-multiplication in tritrimul!
 rmul!(A::UpperTriangular, B::UpperTriangular)     = UpperTriangular(rmul!(triu!(A.data), B))
 rmul!(A::UpperTriangular, B::UnitUpperTriangular) = UpperTriangular(rmul!(triu!(A.data), B))
 rmul!(A::LowerTriangular, B::LowerTriangular)     = LowerTriangular(rmul!(tril!(A.data), B))
@@ -1394,11 +1466,7 @@ _inner_type_promotion(op, ::Type{TA}, ::Type{TB}) where {TA,TB} =
 ## The general promotion methods
 function *(A::AbstractTriangular, B::AbstractTriangular)
     TAB = _init_eltype(*, eltype(A), eltype(B))
-    if TAB <: BlasFloat
-        lmul!(convert(AbstractArray{TAB}, A), copy_similar(B, TAB))
-    else
-        mul!(similar(B, TAB, size(B)), A, B)
-    end
+    mul!(similar(B, TAB, size(B)), A, B)
 end
 
 for mat in (:AbstractVector, :AbstractMatrix)
@@ -1406,51 +1474,31 @@ for mat in (:AbstractVector, :AbstractMatrix)
     @eval function *(A::AbstractTriangular, B::$mat)
         require_one_based_indexing(B)
         TAB = _init_eltype(*, eltype(A), eltype(B))
-        if TAB <: BlasFloat
-            lmul!(convert(AbstractArray{TAB}, A), copy_similar(B, TAB))
-        else
-            mul!(similar(B, TAB, size(B)), A, B)
-        end
+        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)
         TAB = _inner_type_promotion(\, eltype(A), eltype(B))
-        if TAB <: BlasFloat
-            ldiv!(convert(AbstractArray{TAB}, A), copy_similar(B, TAB))
-        else
-            ldiv!(similar(B, TAB, size(B)), A, B)
-        end
+        ldiv!(similar(B, TAB, size(B)), A, B)
     end
     ### 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))
-        if TAB <: BlasFloat
-            ldiv!(convert(AbstractArray{TAB}, A), copy_similar(B, TAB))
-        else
-            ldiv!(similar(B, TAB, size(B)), A, B)
-        end
+        ldiv!(similar(B, TAB, size(B)), A, B)
     end
     ### Right division with triangle to the right hence lhs cannot be transposed. No quotients.
     @eval function /(A::$mat, B::Union{UnitUpperTriangular, UnitLowerTriangular})
         require_one_based_indexing(A)
         TAB = _inner_type_promotion(/, eltype(A), eltype(B))
-        if TAB <: BlasFloat
-            rdiv!(copy_similar(A, TAB), convert(AbstractArray{TAB}, B))
-        else
-            _rdiv!(similar(A, TAB, size(A)), A, B)
-        end
+        _rdiv!(similar(A, TAB, size(A)), A, B)
     end
     ### 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))
-        if TAB <: BlasFloat
-            rdiv!(copy_similar(A, TAB), convert(AbstractArray{TAB}, B))
-        else
-            _rdiv!(similar(A, TAB, size(A)), A, B)
-        end
+        _rdiv!(similar(A, TAB, size(A)), A, B)
     end
 end
 ### Multiplication with triangle to the right and hence lhs cannot be transposed.
@@ -1458,11 +1506,7 @@ end
 function *(A::AbstractMatrix, B::AbstractTriangular)
     require_one_based_indexing(A)
     TAB = _init_eltype(*, eltype(A), eltype(B))
-    if TAB <: BlasFloat
-        rmul!(copy_similar(A, TAB), convert(AbstractArray{TAB}, B))
-    else
-        mul!(similar(A, TAB, size(A)), A, B)
-    end
+    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)
diff --git a/stdlib/LinearAlgebra/test/triangular.jl b/stdlib/LinearAlgebra/test/triangular.jl
index 78fc2d5e0e74c..aaf433c95b7b0 100644
--- a/stdlib/LinearAlgebra/test/triangular.jl
+++ b/stdlib/LinearAlgebra/test/triangular.jl
@@ -326,7 +326,7 @@ for elty1 in (Float32, Float64, BigFloat, ComplexF32, ComplexF64, Complex{BigFlo
                                 (LowerTriangular, :L),
                                 (UnitLowerTriangular, :L))
 
-                debug && println("elty1: $elty1, A1: $t1, elty2: $elty2")
+                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')))
 
@@ -393,20 +393,20 @@ for elty1 in (Float32, Float64, BigFloat, ComplexF32, ComplexF64, Complex{BigFlo
                 @test_throws DimensionMismatch A2'  * offsizeA
                 @test_throws DimensionMismatch A2   * offsizeA
                 if (uplo1 == uplo2 && elty1 == elty2 != Int && t1 != UnitLowerTriangular && t1 != UnitUpperTriangular)
-                    @test rdiv!(copy(A1), copy(A2))::t1 ≈ A1/A2 ≈ Matrix(A1)/Matrix(A2)
-                    @test ldiv!(copy(A2), copy(A1))::t1 ≈ A2\A1 ≈ Matrix(A2)\Matrix(A1)
+                    @test rdiv!(copy(A1), A2)::t1 ≈ A1/A2 ≈ Matrix(A1)/Matrix(A2)
+                    @test ldiv!(A2, copy(A1))::t1 ≈ A2\A1 ≈ Matrix(A2)\Matrix(A1)
                 end
                 if (uplo1 != uplo2 && elty1 == elty2 != Int && t2 != UnitLowerTriangular && t2 != UnitUpperTriangular)
-                    @test lmul!(adjoint(copy(A1)), copy(A2)) ≈ A1'*A2 ≈ Matrix(A1)'*Matrix(A2)
-                    @test lmul!(transpose(copy(A1)), copy(A2)) ≈ transpose(A1)*A2 ≈ transpose(Matrix(A1))*Matrix(A2)
-                    @test ldiv!(adjoint(copy(A1)), copy(A2)) ≈ A1'\A2 ≈ Matrix(A1)'\Matrix(A2)
-                    @test ldiv!(transpose(copy(A1)), copy(A2)) ≈ transpose(A1)\A2 ≈ transpose(Matrix(A1))\Matrix(A2)
+                    @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)
                 end
                 if (uplo1 != uplo2 && elty1 == elty2 != Int && t1 != UnitLowerTriangular && t1 != UnitUpperTriangular)
-                    @test rmul!(copy(A1), adjoint(copy(A2))) ≈ A1*A2' ≈ Matrix(A1)*Matrix(A2)'
-                    @test rmul!(copy(A1), transpose(copy(A2))) ≈ A1*transpose(A2) ≈ Matrix(A1)*transpose(Matrix(A2))
-                    @test rdiv!(copy(A1), adjoint(copy(A2))) ≈ A1/A2' ≈ Matrix(A1)/Matrix(A2)'
-                    @test rdiv!(copy(A1), transpose(copy(A2))) ≈ A1/transpose(A2) ≈ Matrix(A1)/transpose(Matrix(A2))
+                    @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))
                 end
             end
         end
@@ -420,10 +420,10 @@ for elty1 in (Float32, Float64, BigFloat, ComplexF32, ComplexF64, Complex{BigFlo
             @test lmul!(Tri,copy(A1)) ≈ Tri*Matrix(A1)
             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, copy(A1))
+            mul!(C, Tri, A1)
             @test C ≈ Tri*Matrix(A1)
             Tri = Tridiagonal(rand(eltyB,n-1),rand(eltyB,n),rand(eltyB,n-1))
-            mul!(C, copy(A1), Tri)
+            mul!(C, A1, Tri)
             @test C ≈ Matrix(A1)*Tri
 
             # Triangular-dense Matrix/vector multiplication

From 703622d2512c5664376b26faa2c986af02ccc2bd Mon Sep 17 00:00:00 2001
From: N5N3 <2642243996@qq.com>
Date: Fri, 14 Jul 2023 22:27:37 +0800
Subject: [PATCH 21/41] Also record chained `innervars`

At present we only record direct `innervars` (`T` -> `S<:Val{T}`). And chained `innervars` might be ignored (`T` -> `S<:Val{V<:T}`\
This commit fix it.

(cherry picked from commit cd743379d4a97488a0d2388fb0520422b995067e)
---
 src/subtype.c   | 160 ++++++++++++++++++++++++++++++++++++------------
 test/subtype.jl |   7 ++-
 2 files changed, 128 insertions(+), 39 deletions(-)

diff --git a/src/subtype.c b/src/subtype.c
index 5b05bb288ffc4..efff6218dfb71 100644
--- a/src/subtype.c
+++ b/src/subtype.c
@@ -2721,32 +2721,33 @@ static jl_value_t *omit_bad_union(jl_value_t *u, jl_tvar_t *t)
         jl_tvar_t *var = ((jl_unionall_t *)u)->var;
         jl_value_t *ub = var->ub, *body = ((jl_unionall_t *)u)->body;
         assert(var != t);
-        if (!jl_has_typevar(var->lb, t)) {
-            JL_GC_PUSH3(&ub, &body, &var);
-            body = omit_bad_union(body, t);
-            if (!jl_has_typevar(body, var)) {
-                res = body;
+        JL_GC_PUSH3(&ub, &body, &var);
+        body = omit_bad_union(body, t);
+        if (!jl_has_typevar(body, var)) {
+            res = body;
+        }
+        else if (jl_has_typevar(var->lb, t)) {
+            res = jl_bottom_type;
+        }
+        else {
+            ub = omit_bad_union(ub, t);
+            if (ub == jl_bottom_type && var->lb != ub) {
+                res = jl_bottom_type;
             }
-            else {
-                ub = omit_bad_union(ub, t);
-                if (ub == jl_bottom_type && var->lb != ub) {
-                    res = jl_bottom_type;
+            else if (obviously_egal(var->lb, ub)) {
+                JL_TRY {
+                    res = jl_substitute_var(body, var, ub);
                 }
-                else if (obviously_egal(var->lb, ub)) {
-                    JL_TRY {
-                        res = jl_substitute_var(body, var, ub);
-                    }
-                    JL_CATCH {
-                        res = jl_bottom_type;
-                    }
+                JL_CATCH {
+                    res = jl_bottom_type;
                 }
-                else {
-                    if (ub != var->ub) {
-                        var = jl_new_typevar(var->name, var->lb, ub);
-                        body = jl_substitute_var(body, ((jl_unionall_t *)u)->var, (jl_value_t *)var);
-                    }
-                    res = jl_new_struct(jl_unionall_type, var, body);
+            }
+            else {
+                if (ub != var->ub) {
+                    var = jl_new_typevar(var->name, var->lb, ub);
+                    body = jl_substitute_var(body, ((jl_unionall_t *)u)->var, (jl_value_t *)var);
                 }
+                res = jl_new_struct(jl_unionall_type, var, body);
             }
         }
         JL_GC_POP();
@@ -2770,9 +2771,9 @@ static jl_value_t *omit_bad_union(jl_value_t *u, jl_tvar_t *t)
 // Caller might not have rooted `res`
 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;
+    jl_value_t *varval = NULL, *ilb = NULL, *iub = NULL, *nivar = NULL;
     jl_tvar_t *newvar = vb->var;
-    JL_GC_PUSH2(&res, &newvar);
+    JL_GC_PUSH5(&res, &newvar, &ilb, &iub, &nivar);
     // try to reduce var to a single value
     if (jl_is_long(vb->ub) && jl_is_typevar(vb->lb)) {
         varval = vb->ub;
@@ -2806,19 +2807,99 @@ static jl_value_t *finish_unionall(jl_value_t *res JL_MAYBE_UNROOTED, jl_varbind
         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) subtitute `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
+    //       is complete
+    int len = current_env_length(e);
+    int8_t *blinding_has_innerdep = (int8_t *)alloca(len);
+    memset(blinding_has_innerdep, 0, len);
+    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_subtitution = 0;
+                if (ilb != ivar->lb || iub != ivar->ub) {
+                    need_subtitution = 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_subtitution)
+                            btemp2->lb = jl_substitute_var(btemp2->lb, ivar, nivar);
+                        blinding_has_innerdep[envind] |= 1;
+                    }
+                    if (jl_has_typevar(btemp2->ub, ivar)) {
+                        if (need_subtitution)
+                            btemp2->ub = jl_substitute_var(btemp2->ub, ivar, nivar);
+                        blinding_has_innerdep[envind] |= 2;
+                    }
+                    envind++;
+                }
+            }
+        }
+    }
+    // II. Handle direct innervars.
     jl_varbinding_t *wrap = NULL;
+    int envind = 0;
     for (jl_varbinding_t *btemp = e->vars; btemp != NULL; btemp = btemp->prev) {
-        if (jl_has_typevar(btemp->lb, vb->var)) {
+        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_GC_POP();
                 return jl_bottom_type;
             }
             if (varval) {
-                JL_TRY {
-                    btemp->lb = jl_substitute_var(btemp->lb, vb->var, varval);
-                }
-                JL_CATCH {
-                    res = jl_bottom_type;
+                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;
+                    }
                 }
             }
             else if (btemp->lb == (jl_value_t*)vb->var) {
@@ -2827,7 +2908,7 @@ static jl_value_t *finish_unionall(jl_value_t *res JL_MAYBE_UNROOTED, jl_varbind
             else if (btemp->depth0 == vb->depth0 && !jl_has_typevar(vb->lb, btemp->var) && !jl_has_typevar(vb->ub, btemp->var)) {
                 // 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)
+                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;
             }
@@ -2836,8 +2917,9 @@ static jl_value_t *finish_unionall(jl_value_t *res JL_MAYBE_UNROOTED, jl_varbind
             }
             assert((jl_value_t*)btemp->var != btemp->lb);
         }
-        if (jl_has_typevar(btemp->ub, vb->var)) {
+        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) {
                     JL_GC_POP();
@@ -2845,11 +2927,13 @@ static jl_value_t *finish_unionall(jl_value_t *res JL_MAYBE_UNROOTED, jl_varbind
                 }
             }
             if (varval) {
-                JL_TRY {
-                    btemp->ub = jl_substitute_var(btemp->ub, vb->var, varval);
-                }
-                JL_CATCH {
-                    res = jl_bottom_type;
+                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;
+                    }
                 }
             }
             else if (btemp->ub == (jl_value_t*)vb->var) {
@@ -2860,7 +2944,7 @@ static jl_value_t *finish_unionall(jl_value_t *res JL_MAYBE_UNROOTED, jl_varbind
                 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)
+                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;
             }
diff --git a/test/subtype.jl b/test/subtype.jl
index de11689e9e7c4..19901897ebaaa 100644
--- a/test/subtype.jl
+++ b/test/subtype.jl
@@ -2552,8 +2552,13 @@ end
 @test !<:(Type{Vector{Union{Base.BitInteger, Base.IEEEFloat, StridedArray, Missing, Nothing, Val{T}}}} where {T}, Type{Array{T}} where {T})
 
 #issue 50195
-T50195{S} = Pair{S,Set{S}}
 let a = Tuple{Type{X} where X<:Union{Nothing, Val{X1} where {X4, X1<:(Pair{X2, Val{X2}} where X2<:Val{X4})}}},
     b = Tuple{Type{Y} where Y<:(Val{Y1} where {Y4<:Src, Y1<:(Pair{Y2, Val{Y2}} where Y2<:Union{Val{Y4}, Y4})})} where Src
     @test typeintersect(a, b) <: Any
 end
+
+#issue 50195
+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

From d5c9b5011a39df0350eee7989e3d850a74880eb0 Mon Sep 17 00:00:00 2001
From: Stefan Karpinski <stefan@karpinski.org>
Date: Mon, 17 Jul 2023 10:16:00 -0400
Subject: [PATCH 22/41] read(io, Char): fix read with too many leading ones
 (#50552)

Fixes #50532. The `read(io, Char)` method didn't correctly handle the
case where the lead byte starts with too many leading ones; this fix
makes it handle that case correctly, which makes `read(io, Char)` match
`collect(s)` in its interpretation of what a character is in all invalid
cases. Also fix and test `read(::File, Char)` which has the same bug.

(cherry picked from commit ffe1a0789a338a2b4e5199965319194ec4f6ab90)
---
 base/filesystem.jl |  5 +++--
 base/io.jl         |  4 ++--
 test/char.jl       | 30 +++++++++++++++++++++++++++++-
 3 files changed, 34 insertions(+), 5 deletions(-)

diff --git a/base/filesystem.jl b/base/filesystem.jl
index 63fe4281f6e59..d291dd3b31630 100644
--- a/base/filesystem.jl
+++ b/base/filesystem.jl
@@ -200,11 +200,12 @@ end
 
 function read(f::File, ::Type{Char})
     b0 = read(f, UInt8)
-    l = 8 * (4 - leading_ones(b0))
+    l = 0x08 * (0x04 - UInt8(leading_ones(b0)))
     c = UInt32(b0) << 24
-    if l < 24
+    if l ≤ 0x10
         s = 16
         while s ≥ l && !eof(f)
+            # this works around lack of peek(::File)
             p = position(f)
             b = read(f, UInt8)
             if b & 0xc0 != 0x80
diff --git a/base/io.jl b/base/io.jl
index 60a24831587cb..dce469fbfd2b7 100644
--- a/base/io.jl
+++ b/base/io.jl
@@ -800,9 +800,9 @@ end
 
 function read(io::IO, ::Type{Char})
     b0 = read(io, UInt8)::UInt8
-    l = 8(4-leading_ones(b0))
+    l = 0x08 * (0x04 - UInt8(leading_ones(b0)))
     c = UInt32(b0) << 24
-    if l < 24
+    if l ≤ 0x10
         s = 16
         while s ≥ l && !eof(io)::Bool
             peek(io) & 0xc0 == 0x80 || break
diff --git a/test/char.jl b/test/char.jl
index 1639c62ec819d..1d3579013ad18 100644
--- a/test/char.jl
+++ b/test/char.jl
@@ -1,7 +1,6 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
 @testset "basic properties" begin
-
     @test typemax(Char) == reinterpret(Char, typemax(UInt32))
     @test typemin(Char) == Char(0)
     @test typemax(Char) == reinterpret(Char, 0xffffffff)
@@ -214,6 +213,35 @@ end
     end
 end
 
+# issue #50532
+@testset "invalid read(io, Char)" begin
+    # byte values with different numbers of leading bits
+    B = UInt8[
+        0x3f, 0x4d, 0x52, 0x63, 0x81, 0x83, 0x89, 0xb6,
+        0xc0, 0xc8, 0xd3, 0xe3, 0xea, 0xeb, 0xf0, 0xf2,
+        0xf4, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
+    ]
+    f = tempname()
+    for b1 in B, b2 in B, t = 0:3
+        bytes = [b1, b2]
+        append!(bytes, rand(B, t))
+        s = String(bytes)
+        write(f, s)
+        @test s == read(f, String)
+        chars = collect(s)
+        ios = [IOBuffer(s), open(f), Base.Filesystem.open(f, 0)]
+        for io in ios
+            chars′ = Char[]
+            while !eof(io)
+                push!(chars′, read(io, Char))
+            end
+            @test chars == chars′
+            close(io)
+        end
+    end
+    rm(f)
+end
+
 @testset "overlong codes" begin
     function test_overlong(c::Char, n::Integer, rep::String)
         if isvalid(c)

From ba9a0e8b0c79655ee0ed82af198c11cc26e46de5 Mon Sep 17 00:00:00 2001
From: "Viral B. Shah" <ViralBShah@users.noreply.github.com>
Date: Mon, 10 Jul 2023 21:01:40 -0400
Subject: [PATCH 23/41] Update SparseArrays.jl stdlib for SuiteSparse 7
 (#48977)

* Use SparseArrays.jl updated to work with SuiteSparse 7, and with Int32 indices
* SuiteSparse_jll Update to v7.2.0 (Using @Wimmerer's SuiteSparse fork for 32-bit QR)

---------

Co-authored-by: Francois-Xavier Coudert <fxcoudert@gmail.com>
Co-authored-by: Will Kimmerer <kimmerer@mit.edu>
(cherry picked from commit b26f3b279c0c79e92666ee0077b06f6685d77c8b)
---
 Makefile                                      |  2 +-
 base/Makefile                                 |  2 +
 .../md5                                       |  1 +
 .../sha512                                    |  1 +
 .../md5                                       |  1 -
 .../sha512                                    |  1 -
 deps/checksums/suitesparse                    | 68 +++++++++---------
 deps/libsuitesparse.mk                        | 70 +++++++------------
 deps/libsuitesparse.version                   |  4 +-
 stdlib/SparseArrays.version                   |  2 +-
 stdlib/SuiteSparse_jll/Project.toml           |  4 +-
 stdlib/SuiteSparse_jll/src/SuiteSparse_jll.jl | 48 ++++++-------
 stdlib/SuiteSparse_jll/test/runtests.jl       |  6 +-
 13 files changed, 99 insertions(+), 111 deletions(-)
 create mode 100644 deps/checksums/SparseArrays-2c7f4d6d839e9a97027454a037bfa004c1eb34b0.tar.gz/md5
 create mode 100644 deps/checksums/SparseArrays-2c7f4d6d839e9a97027454a037bfa004c1eb34b0.tar.gz/sha512
 delete mode 100644 deps/checksums/SparseArrays-8affe9e499379616e33fc60a24bb31500e8423d7.tar.gz/md5
 delete mode 100644 deps/checksums/SparseArrays-8affe9e499379616e33fc60a24bb31500e8423d7.tar.gz/sha512

diff --git a/Makefile b/Makefile
index 5e9b4ccf5460a..1565014a0fa5e 100644
--- a/Makefile
+++ b/Makefile
@@ -196,7 +196,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 libcolamd libklu libldl librbio libspqr libsuitesparseconfig libumfpack
+JL_PRIVATE_LIBS-$(USE_SYSTEM_LIBSUITESPARSE) += libamd libbtf libcamd libccolamd libcholmod libcholmod_cuda libcolamd libklu libldl librbio libspqr libspqr_cuda 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 493302af78b02..ad2bb6a63ccc0 100644
--- a/base/Makefile
+++ b/base/Makefile
@@ -269,9 +269,11 @@ $(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-2c7f4d6d839e9a97027454a037bfa004c1eb34b0.tar.gz/md5 b/deps/checksums/SparseArrays-2c7f4d6d839e9a97027454a037bfa004c1eb34b0.tar.gz/md5
new file mode 100644
index 0000000000000..21131a800d4af
--- /dev/null
+++ b/deps/checksums/SparseArrays-2c7f4d6d839e9a97027454a037bfa004c1eb34b0.tar.gz/md5
@@ -0,0 +1 @@
+0369c2679e8b834009526dd4f402cfd8
diff --git a/deps/checksums/SparseArrays-2c7f4d6d839e9a97027454a037bfa004c1eb34b0.tar.gz/sha512 b/deps/checksums/SparseArrays-2c7f4d6d839e9a97027454a037bfa004c1eb34b0.tar.gz/sha512
new file mode 100644
index 0000000000000..df3b4cc3736e1
--- /dev/null
+++ b/deps/checksums/SparseArrays-2c7f4d6d839e9a97027454a037bfa004c1eb34b0.tar.gz/sha512
@@ -0,0 +1 @@
+b2573398a8e8f5bcd8195cc3aa68103b2b5ea66c1835d4bc4d808fb1e0d3fbd46cc2caa04a4f49813a4a4a7f88d2f95789fa080d1d940c0291b09416be0fd1e6
diff --git a/deps/checksums/SparseArrays-8affe9e499379616e33fc60a24bb31500e8423d7.tar.gz/md5 b/deps/checksums/SparseArrays-8affe9e499379616e33fc60a24bb31500e8423d7.tar.gz/md5
deleted file mode 100644
index 96861ba265b5f..0000000000000
--- a/deps/checksums/SparseArrays-8affe9e499379616e33fc60a24bb31500e8423d7.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-e6dc511b49e07a167848adc4e12690d8
diff --git a/deps/checksums/SparseArrays-8affe9e499379616e33fc60a24bb31500e8423d7.tar.gz/sha512 b/deps/checksums/SparseArrays-8affe9e499379616e33fc60a24bb31500e8423d7.tar.gz/sha512
deleted file mode 100644
index f503304f810e4..0000000000000
--- a/deps/checksums/SparseArrays-8affe9e499379616e33fc60a24bb31500e8423d7.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-f40fd137ccd6651fc8b697f57cfcbd8e3feccb99f6a6b32fbaa69cc0160b78cefc662b914ff8f4e48478ca48f9583318a6030d922d43ed66f8db59fd5985f768
diff --git a/deps/checksums/suitesparse b/deps/checksums/suitesparse
index 65db184c5cbca..05f25450114a5 100644
--- a/deps/checksums/suitesparse
+++ b/deps/checksums/suitesparse
@@ -1,36 +1,36 @@
-SuiteSparse-5.10.1.tar.gz/md5/68bb912f3cf3d2b01f30ebafef690302
-SuiteSparse-5.10.1.tar.gz/sha512/8f85c6d63b76cba95707dfa732c51200df7794cb4c2599dbd92100475747b8d02b05089a47096e85c60b89bc852a8e768e0670f24902a82d29494a80ccf2bb5f
+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.v5.10.1+6.aarch64-apple-darwin.tar.gz/md5/14cc0d3c7b5271246eb45c495c7a4e79
-SuiteSparse.v5.10.1+6.aarch64-apple-darwin.tar.gz/sha512/a56da81a5165bcdf49d1913799bffcaea84efd6f8740dd002f700eb4070313cac64be5359ba88d1f39fe976944e34ee6ed6575ceade2ae2d97b850e6a1aee0ae
-SuiteSparse.v5.10.1+6.aarch64-linux-gnu.tar.gz/md5/b93b047040e2db5e0277e52b9bd3feb7
-SuiteSparse.v5.10.1+6.aarch64-linux-gnu.tar.gz/sha512/e03a9ecafce9dcc6791dd202efac2f864bdf3a0a4524567801c092304c17ab15dae949abfb1fe2bc71b367a0e398260ccfdd91dad611860090df471b44e75ee3
-SuiteSparse.v5.10.1+6.aarch64-linux-musl.tar.gz/md5/22c44d9d82608724e1aa62d126fdf030
-SuiteSparse.v5.10.1+6.aarch64-linux-musl.tar.gz/sha512/39a3c11429cd3e6afa2f615dc4b0c8d16d7b94a423d76e598b3b48db2c47fe64d644233e2a672bd6654f8bd57da91dd7a787a3e4978f0f803237ab4ec6f97905
-SuiteSparse.v5.10.1+6.armv6l-linux-gnueabihf.tar.gz/md5/505ee3c0750a720ed1e4de670f81e220
-SuiteSparse.v5.10.1+6.armv6l-linux-gnueabihf.tar.gz/sha512/20fafbdd2df96427b95b730901663c255dafc415f3a8154e3364ec46ca2b205fa45a081f92272b81d7aed22b9f8373d2d4eee70ff8ab5ed8d1d80b6a340c8aad
-SuiteSparse.v5.10.1+6.armv6l-linux-musleabihf.tar.gz/md5/8e1821668cbca9c2d3c5cee5ad1746c8
-SuiteSparse.v5.10.1+6.armv6l-linux-musleabihf.tar.gz/sha512/58fb4ec10a537d101e0be8417648a4d0127444b3fe8a32498320aaaefc747f5cac3c7503b70775c1d708b077034060fe5ed8609e73bf9be22f9a8729abc4c73d
-SuiteSparse.v5.10.1+6.armv7l-linux-gnueabihf.tar.gz/md5/43d133a916e548ecae50671b92f64c6f
-SuiteSparse.v5.10.1+6.armv7l-linux-gnueabihf.tar.gz/sha512/f7f767c0e7eb45afe10941513695bfcc9e0628195cb9245a9c24700967f9cfa7cd0030cdcfaf47a76400d5dd3eb908c1f9ea5e44efd3054ed7bba47e664279a2
-SuiteSparse.v5.10.1+6.armv7l-linux-musleabihf.tar.gz/md5/7c3b2e19d3296002b1aa72b951421eec
-SuiteSparse.v5.10.1+6.armv7l-linux-musleabihf.tar.gz/sha512/7546ce844b03d0414168ab6d0925f848b14b35ed27cb545b41f2512bad44b7da4f39004e75657c7c572557ccb015177d3e0d346e2c3182b27a6ee602876ee0df
-SuiteSparse.v5.10.1+6.i686-linux-gnu.tar.gz/md5/e00a73f0fad92a266dd8d3774707f9b1
-SuiteSparse.v5.10.1+6.i686-linux-gnu.tar.gz/sha512/9cc2332a78d0490170d722d2f062d6f660fb3bd9042dd177c3683675d0f44306b93bf882cb79c0707ab79318280d08582431eb1c92334f2bb50946e942be0b16
-SuiteSparse.v5.10.1+6.i686-linux-musl.tar.gz/md5/71fb647a76ecc9e547df903535011b5b
-SuiteSparse.v5.10.1+6.i686-linux-musl.tar.gz/sha512/7806cd9179e46fa61b63a3f711b37289da72a48430912e564c88e3dcb4caaad8a9bd232d6f572f8270806d286e4a4eb9edfdcda29fe8d91dadb1b03d57eda76d
-SuiteSparse.v5.10.1+6.i686-w64-mingw32.tar.gz/md5/d4e6c9aba53b2107469cda6de9ca2724
-SuiteSparse.v5.10.1+6.i686-w64-mingw32.tar.gz/sha512/c0c49641c6e7f3f0333e3fa44ce62dcd4ad5942c74b2429aaeb49fd0d7b8c13c872150ae4d54cc5cfaae07a65a24a7d4ea731adc78db3d9341a54e5edb5c80f0
-SuiteSparse.v5.10.1+6.powerpc64le-linux-gnu.tar.gz/md5/5432dca00f7e0f42b7dbd16083537318
-SuiteSparse.v5.10.1+6.powerpc64le-linux-gnu.tar.gz/sha512/61946a7faa2a49613ea2c08a01f064b619c9ec134f0d9509eb42a96bebf2a63f5fb57b14702f25618def410658da8334bb6aa5200280956e573aa944476efef2
-SuiteSparse.v5.10.1+6.x86_64-apple-darwin.tar.gz/md5/ca175d433a02f91407e2921872c2b67c
-SuiteSparse.v5.10.1+6.x86_64-apple-darwin.tar.gz/sha512/14d9b01e2db8c04f9a1076bcbac022c6573728f708f31344825805fed53971e922aecebeb4b2f567a6b5f44ad27c0d66e142887ff4684c8679ab65b902538abf
-SuiteSparse.v5.10.1+6.x86_64-linux-gnu.tar.gz/md5/6c271ced91dbb1bf748efbaace1dac10
-SuiteSparse.v5.10.1+6.x86_64-linux-gnu.tar.gz/sha512/5984db9c101ef80d63024bc3b51821268349450deedd5aaea5fade0fc5932992379a0133c4f91711af134014835afea1bde518ae1e7efd482d556a97e54b0238
-SuiteSparse.v5.10.1+6.x86_64-linux-musl.tar.gz/md5/c7d55069969dbb98997687c847ab643d
-SuiteSparse.v5.10.1+6.x86_64-linux-musl.tar.gz/sha512/b54012765f7c7329125b41c3fb678e23888a858d3fd5a139c52bd980e383a308282238020754e795de6457fb312b61c39e6ab2d665ca5af95c65f52f0c354067
-SuiteSparse.v5.10.1+6.x86_64-unknown-freebsd.tar.gz/md5/e641be38c8205e362a7299c736aedad5
-SuiteSparse.v5.10.1+6.x86_64-unknown-freebsd.tar.gz/sha512/d55e85335bccb59210014c35233ad9e42f5d086f01a43fe0ee13f21cbb8555ea05f1d91c95a6d3f883477086851e123c4b0cde7cd2dcd8e08835fe9f685d5b25
-SuiteSparse.v5.10.1+6.x86_64-w64-mingw32.tar.gz/md5/45cad947fa962e1f192cb7b52a1f7b3c
-SuiteSparse.v5.10.1+6.x86_64-w64-mingw32.tar.gz/sha512/e6545c681ba7d2346baf8fafabdf25f2faf6ea54763d999b14499f30d235e90f34fd4f83430ea7f17c01adea0699dff6c4d7ae3cb938c749d6a15f8bf4f1519f
+SuiteSparse.v7.2.0+0.aarch64-apple-darwin.tar.gz/md5/1a10261e5bed293a66849c7a50605a1c
+SuiteSparse.v7.2.0+0.aarch64-apple-darwin.tar.gz/sha512/11ecce872aac1f30a3d4ce870920ebb03c7828d0fd740c3789d3f65c3f91ed3682372e9807b0593e2850ae9024450306451ee2e03866afee16b4169e4b5de1c6
+SuiteSparse.v7.2.0+0.aarch64-linux-gnu.tar.gz/md5/65e2e7ae54e94e00b306d17a1d08ed34
+SuiteSparse.v7.2.0+0.aarch64-linux-gnu.tar.gz/sha512/7714598448c6f98a7d931822f9ddb661a903342d4c8384648c1b7457511794ff95ad64266c9377a4a5856dcb1fb8864cb05eab1c7787fca58802473270313570
+SuiteSparse.v7.2.0+0.aarch64-linux-musl.tar.gz/md5/95eb68e02c04d075d6ecc974c3b44457
+SuiteSparse.v7.2.0+0.aarch64-linux-musl.tar.gz/sha512/1d7835106cd5baef701a3b670778a757d97ab9933f7da909e1e5521150f7e44bee30cf4dc7c1e9f57731366db0fca1b91d1cdfddbc53b7cc7457ca11534be6d7
+SuiteSparse.v7.2.0+0.armv6l-linux-gnueabihf.tar.gz/md5/5f627cc9c9d4d70e2f0d749e09926b1a
+SuiteSparse.v7.2.0+0.armv6l-linux-gnueabihf.tar.gz/sha512/5ae4b79b418b45d954bfb578ac384afd6fff10a602d16d8b503997ba15251a7db0e12da66061ffd27c23b7459ff56b4a5d200c7c8aaa4a33c608a88752535c15
+SuiteSparse.v7.2.0+0.armv6l-linux-musleabihf.tar.gz/md5/61b5ee7e2b50665caf15e7c4f7353048
+SuiteSparse.v7.2.0+0.armv6l-linux-musleabihf.tar.gz/sha512/854c0165bceeb8202aeeaa16e6ba1f643e8cb9bf0561816cf2c44d1c7334ba7c376ee9e9085316439ca7e27dd4e37814f4916382096a5889c6bb656d22a7fb8d
+SuiteSparse.v7.2.0+0.armv7l-linux-gnueabihf.tar.gz/md5/618b9687ce30e630a52f72a8f34cfb9f
+SuiteSparse.v7.2.0+0.armv7l-linux-gnueabihf.tar.gz/sha512/add77a8842faf6515d94dc1d000784247d13f0211a9bb3f98edbc65b5f8994c0101940875fa050ca7a4605aaf33ec14daeaaf6b837673b3b4c600d4c5c0f4876
+SuiteSparse.v7.2.0+0.armv7l-linux-musleabihf.tar.gz/md5/b84d7f98b953772517689478d6bfc121
+SuiteSparse.v7.2.0+0.armv7l-linux-musleabihf.tar.gz/sha512/2c461eb23194bf61d3166abd8eb308dc643d865ff07466a88a580aa5a040f3c4fbfeadf7c78e1a3ce737fe0602909ff2b25be439741d36a780a260ccfdc6ed83
+SuiteSparse.v7.2.0+0.i686-linux-gnu.tar.gz/md5/3a38deddb5c1952584782378892d9579
+SuiteSparse.v7.2.0+0.i686-linux-gnu.tar.gz/sha512/5d6a9090c1c275c2bdcdc8d510c6372913109c1a775819354922c0d0afc2bc13a27950ed0e8cb8e05bc94d245220e322d93879054e5082814b7796b305981987
+SuiteSparse.v7.2.0+0.i686-linux-musl.tar.gz/md5/8076c50a73ab08ce0b9374956c2dbf29
+SuiteSparse.v7.2.0+0.i686-linux-musl.tar.gz/sha512/e54bcfe7eb9b266514a35a3c48676b7a792b59830e44bfcd5dfcf35be790f534cc31bd2e63ce4da1a22fcb3b0afb0ebebcc94f0e596806d6e832c3f68195cc5b
+SuiteSparse.v7.2.0+0.i686-w64-mingw32.tar.gz/md5/361385833314fa6fbcd1f446ef6430e6
+SuiteSparse.v7.2.0+0.i686-w64-mingw32.tar.gz/sha512/576ef6a4242c6b999a143007aa073ba9e4d74246c297f60504052321c2bae202640cffe08fbcf69df1b093b12443382c9d11390f97b9d8754f10dcd32dd3e9c4
+SuiteSparse.v7.2.0+0.powerpc64le-linux-gnu.tar.gz/md5/64845ee8bb2f3f44a0837297e47e412d
+SuiteSparse.v7.2.0+0.powerpc64le-linux-gnu.tar.gz/sha512/5f935e497db4ebbcdfb96603a7ee9c6c520d7f4df04f65952305ceff4271ab637079e9144b98044c5f159b4bed0963df8c95ed1578d2828f1a2356e6d34d7042
+SuiteSparse.v7.2.0+0.x86_64-apple-darwin.tar.gz/md5/fb8b00d4ca63004fe8ab8c159128e01f
+SuiteSparse.v7.2.0+0.x86_64-apple-darwin.tar.gz/sha512/bcfb18c11be4b1147ff857e2ad0c881c9fc4ae16db8e88fb6e7e0448418c1fc4bff9ea8f1e6aa7202c277273c44c1afb3cc6c2bfcaa0735c7c09052f033248c7
+SuiteSparse.v7.2.0+0.x86_64-linux-gnu.tar.gz/md5/043594ee1cb90fd47b36acfa829fffb8
+SuiteSparse.v7.2.0+0.x86_64-linux-gnu.tar.gz/sha512/6a5bb3c85bb7e97b915f7dd40e8be1ed1bbbd5c756ef510deaecc8505b95bd42f3662f82e25c80055947060e0429e2ce427d4ff67b434acbe28d46b88279c65f
+SuiteSparse.v7.2.0+0.x86_64-linux-musl.tar.gz/md5/67c6d3a7fd8635a43bd86b2b1e986978
+SuiteSparse.v7.2.0+0.x86_64-linux-musl.tar.gz/sha512/d46be3f60102fc69707c3e7cc3d693c7ecb4d4307c636afde61e5fab3c46fcf32564716a11d2cfe47b4e541422d5b6e13fbcc3e8749764527b4f4132e8ce17fc
+SuiteSparse.v7.2.0+0.x86_64-unknown-freebsd.tar.gz/md5/124057f8455c9710fd1e6b4b4b469fb0
+SuiteSparse.v7.2.0+0.x86_64-unknown-freebsd.tar.gz/sha512/da0e56a8b1cf3967275cb64aea0b939d8982392f9ca1c3b268607e37c0b9bebbd456172c507c6dc2293989a0fe8df04ba1fea67442a4bb738cc8d894bea457a5
+SuiteSparse.v7.2.0+0.x86_64-w64-mingw32.tar.gz/md5/0f99c67d25c0fdd0f3c3e11f18925c43
+SuiteSparse.v7.2.0+0.x86_64-w64-mingw32.tar.gz/sha512/32fcd894cb4197970aa311f7bd12ccb91df7bbe27e389e793a2d3565c9c5c36c751f6dfa37e155cd2c2245be52f0a872dba032b78dc45c45d3fd7d7f2eeb773e
diff --git a/deps/libsuitesparse.mk b/deps/libsuitesparse.mk
index 7d79e03ee8d0e..16d4919031ca5 100644
--- a/deps/libsuitesparse.mk
+++ b/deps/libsuitesparse.mk
@@ -1,43 +1,31 @@
 ## LIBSUITESPARSE ##
 include $(SRCDIR)/libsuitesparse.version
 
-ifeq ($(USE_BLAS64), 1)
-UMFPACK_CONFIG := -DLONGBLAS='long long'
-CHOLMOD_CONFIG := -DLONGBLAS='long long'
-SPQR_CONFIG := -DLONGBLAS='long long'
-UMFPACK_CONFIG += -DSUN64
-CHOLMOD_CONFIG += -DSUN64
-SPQR_CONFIG += -DSUN64
-endif
-
-# Disable linking to libmetis
-CHOLMOD_CONFIG += -DNPARTITION
-
 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)
 
-SUITESPARSE_LIB := $(LDFLAGS) -L"$(abspath $(BUILDDIR))/SuiteSparse-$(LIBSUITESPARSE_VER)/lib"
-ifeq ($(OS), Darwin)
-SUITESPARSE_LIB += $(RPATH_ESCAPED_ORIGIN)
-endif
-LIBSUITESPARSE_MFLAGS := CC="$(CC) $(SANITIZE_OPTS)" CXX="$(CXX) $(SANITIZE_OPTS)" F77="$(FC)" \
-	  AR="$(AR)" RANLIB="$(RANLIB)" \
-	  BLAS="-L$(build_shlibdir) -lblastrampoline" \
-	  LAPACK="-L$(build_shlibdir) -lblastrampoline" \
-	  LDFLAGS="$(SUITESPARSE_LIB) $(SANITIZE_LDFLAGS)" CFOPENMP="" CUDA=no CUDA_PATH="" \
-	  UMFPACK_CONFIG="$(UMFPACK_CONFIG)" \
-	  CHOLMOD_CONFIG="$(CHOLMOD_CONFIG)" \
-	  SPQR_CONFIG="$(SPQR_CONFIG)"
-ifeq ($(OS),WINNT)
-LIBSUITESPARSE_MFLAGS += UNAME=Windows
-else
-LIBSUITESPARSE_MFLAGS += UNAME=$(OS)
-endif
+LIBSUITESPARSE_CMAKE_FLAGS := $(CMAKE_COMMON) \
+	  -DCMAKE_BUILD_TYPE=Release \
+	  -DENABLE_CUDA=0 \
+	  -DNFORTRAN=1 \
+	  -DNOPENMP=1 \
+	  -DNPARTITION=0 \
+	  -DNSTATIC=1 \
+	  -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"
 
 $(SRCCACHE)/SuiteSparse-$(LIBSUITESPARSE_VER).tar.gz: | $(SRCCACHE)
-	$(JLDOWNLOAD) $@ https://github.com/DrTimothyAldenDavis/SuiteSparse/archive/v$(LIBSUITESPARSE_VER).tar.gz
+	$(JLDOWNLOAD) $@ https://github.com/Wimmerer/SuiteSparse/archive/v$(LIBSUITESPARSE_VER).tar.gz
 
 $(BUILDDIR)/SuiteSparse-$(LIBSUITESPARSE_VER)/source-extracted: $(SRCCACHE)/SuiteSparse-$(LIBSUITESPARSE_VER).tar.gz
 	$(JLCHECKSUM) $<
@@ -48,19 +36,16 @@ $(BUILDDIR)/SuiteSparse-$(LIBSUITESPARSE_VER)/source-extracted: $(SRCCACHE)/Suit
 checksum-libsuitesparse: $(SRCCACHE)/SuiteSparse-$(LIBSUITESPARSE_VER).tar.gz
 	$(JLCHECKSUM) $<
 
-$(BUILDDIR)/SuiteSparse-$(LIBSUITESPARSE_VER)/SuiteSparse-shlib.patch-applied: $(BUILDDIR)/SuiteSparse-$(LIBSUITESPARSE_VER)/source-extracted
-	cd $(dir $@) && patch -p1 < $(SRCDIR)/patches/SuiteSparse-shlib.patch
-	echo 1 > $@
-$(BUILDDIR)/SuiteSparse-$(LIBSUITESPARSE_VER)/build-compiled: $(BUILDDIR)/SuiteSparse-$(LIBSUITESPARSE_VER)/SuiteSparse-shlib.patch-applied
-
 $(BUILDDIR)/SuiteSparse-$(LIBSUITESPARSE_VER)/build-compiled: | $(build_prefix)/manifest/blastrampoline
 
 $(BUILDDIR)/SuiteSparse-$(LIBSUITESPARSE_VER)/build-compiled: $(BUILDDIR)/SuiteSparse-$(LIBSUITESPARSE_VER)/source-extracted
-	$(MAKE) -C $(dir $<)SuiteSparse_config library config $(LIBSUITESPARSE_MFLAGS)
-	$(INSTALL_NAME_CMD)libsuitesparseconfig.$(SHLIB_EXT) $(dir $<)lib/libsuitesparseconfig.$(SHLIB_EXT)
-	for PROJ in $(LIBSUITESPARSE_PROJECTS); do \
-		$(MAKE) -C $(dir $<)$${PROJ} library $(LIBSUITESPARSE_MFLAGS) || exit 1; \
-		$(INSTALL_NAME_CMD)lib`echo $${PROJ} | tr A-Z a-z`.$(SHLIB_EXT) $(dir $<)lib/lib`echo $${PROJ} | tr A-Z a-z`.$(SHLIB_EXT) || exit 1; \
+	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
 	echo 1 > $@
 
@@ -78,11 +63,6 @@ $(BUILDDIR)/SuiteSparse-$(LIBSUITESPARSE_VER)/build-checked: $(BUILDDIR)/SuiteSp
 UNINSTALL_suitesparse := $(LIBSUITESPARSE_VER) manual_suitesparse $(LIBSUITESPARSE_LIBS)
 
 $(build_prefix)/manifest/libsuitesparse: $(BUILDDIR)/SuiteSparse-$(LIBSUITESPARSE_VER)/build-compiled | $(build_prefix)/manifest $(build_shlibdir)
-	for lib in $(LIBSUITESPARSE_LIBS); do \
-		cp -a $(dir $<)lib/lib$${lib} $(build_shlibdir) || exit 1; \
-	done
-	#cp -a $(dir $<)lib/* $(build_shlibdir)
-	#cp -a $(dir $<)include/* $(build_includedir)
 	echo $(UNINSTALL_libsuitesparse) > $@
 
 clean-libsuitesparse: uninstall-libsuitesparse
diff --git a/deps/libsuitesparse.version b/deps/libsuitesparse.version
index 2237db6f2d116..867e52304477c 100644
--- a/deps/libsuitesparse.version
+++ b/deps/libsuitesparse.version
@@ -2,4 +2,6 @@
 LIBSUITESPARSE_JLL_NAME := SuiteSparse
 
 ## source build
-LIBSUITESPARSE_VER := 5.10.1
+LIBSUITESPARSE_VER := 7.2.0
+LIBSUITESPARSE_BRANCH=guard-CXX_Standard
+LIBSUITESPARSE_SHA1=1b4edf467637dbf33a26eee9a6c20afa40c7c5ea
diff --git a/stdlib/SparseArrays.version b/stdlib/SparseArrays.version
index d4a548daef5d7..b29ce9b0306e1 100644
--- a/stdlib/SparseArrays.version
+++ b/stdlib/SparseArrays.version
@@ -1,4 +1,4 @@
 SPARSEARRAYS_BRANCH = main
-SPARSEARRAYS_SHA1 = 8affe9e499379616e33fc60a24bb31500e8423d7
+SPARSEARRAYS_SHA1 = 2c7f4d6d839e9a97027454a037bfa004c1eb34b0
 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 d1fb2c25fa68b..dd88fc967079b 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 = "5.10.1+6"
+version = "7.2.0+0"
 
 [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.7"
+julia = "1.9"
 
 [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 a347a91721bad..f245759aaf383 100644
--- a/stdlib/SuiteSparse_jll/src/SuiteSparse_jll.jl
+++ b/stdlib/SuiteSparse_jll/src/SuiteSparse_jll.jl
@@ -54,31 +54,31 @@ if Sys.iswindows()
     const libsuitesparseconfig = "libsuitesparseconfig.dll"
     const libumfpack = "libumfpack.dll"
 elseif Sys.isapple()
-    const libamd = "@rpath/libamd.2.dylib"
-    const libbtf = "@rpath/libbtf.1.dylib"
-    const libcamd = "@rpath/libcamd.2.dylib"
-    const libccolamd = "@rpath/libccolamd.2.dylib"
-    const libcholmod = "@rpath/libcholmod.3.dylib"
-    const libcolamd = "@rpath/libcolamd.2.dylib"
-    const libklu = "@rpath/libklu.1.dylib"
-    const libldl = "@rpath/libldl.2.dylib"
-    const librbio = "@rpath/librbio.2.dylib"
-    const libspqr = "@rpath/libspqr.2.dylib"
-    const libsuitesparseconfig = "@rpath/libsuitesparseconfig.5.dylib"
-    const libumfpack = "@rpath/libumfpack.5.dylib"
+    const libamd = "@rpath/libamd.3.dylib"
+    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 libcolamd = "@rpath/libcolamd.3.dylib"
+    const libklu = "@rpath/libklu.2.dylib"
+    const libldl = "@rpath/libldl.3.dylib"
+    const librbio = "@rpath/librbio.4.dylib"
+    const libspqr = "@rpath/libspqr.4.dylib"
+    const libsuitesparseconfig = "@rpath/libsuitesparseconfig.7.dylib"
+    const libumfpack = "@rpath/libumfpack.6.dylib"
 else
-    const libamd = "libamd.so.2"
-    const libbtf = "libbtf.so.1"
-    const libcamd = "libcamd.so.2"
-    const libccolamd = "libccolamd.so.2"
-    const libcholmod = "libcholmod.so.3"
-    const libcolamd = "libcolamd.so.2"
-    const libklu = "libklu.so.1"
-    const libldl = "libldl.so.2"
-    const librbio = "librbio.so.2"
-    const libspqr = "libspqr.so.2"
-    const libsuitesparseconfig = "libsuitesparseconfig.so.5"
-    const libumfpack = "libumfpack.so.5"
+    const libamd = "libamd.so.3"
+    const libbtf = "libbtf.so.2"
+    const libcamd = "libcamd.so.3"
+    const libccolamd = "libccolamd.so.3"
+    const libcholmod = "libcholmod.so.4"
+    const libcolamd = "libcolamd.so.3"
+    const libklu = "libklu.so.2"
+    const libldl = "libldl.so.3"
+    const librbio = "librbio.so.4"
+    const libspqr = "libspqr.so.4"
+    const libsuitesparseconfig = "libsuitesparseconfig.so.7"
+    const libumfpack = "libumfpack.so.6"
 end
 
 function __init__()
diff --git a/stdlib/SuiteSparse_jll/test/runtests.jl b/stdlib/SuiteSparse_jll/test/runtests.jl
index ca356951f99e2..d6d82a73e4a57 100644
--- a/stdlib/SuiteSparse_jll/test/runtests.jl
+++ b/stdlib/SuiteSparse_jll/test/runtests.jl
@@ -2,6 +2,10 @@
 
 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.
 @testset "SuiteSparse_jll" begin
-    @test ccall((:SuiteSparse_version, libsuitesparseconfig), Cint, (Ptr{Cint},), C_NULL) == 5010
+    @test ccall((:SuiteSparse_version, libsuitesparseconfig), Cint, (Ptr{Cint},), C_NULL) > 7000
 end

From 8fd5f279c8c81a8e59dec3852235c7dd5c88b143 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Thu, 13 Jul 2023 14:24:30 -0400
Subject: [PATCH 24/41] improve cat design / performance (#49322)

This used to make a lot of references to design issues with the
SparseArrays package (https://github.com/JuliaLang/julia/issues/2326 /
https://github.com/JuliaLang/julia/pull/20815), which result in a
non-sensical dispatch arrangement, and contribute to a slow loading
experience do to the nonsense Unions that must be checked by subtyping.

(cherry picked from commit 5a922fadfef083b83d983ac84f49a4460baa42ab)
---
 base/abstractarray.jl                         | 50 +++++++++----------
 base/array.jl                                 | 12 -----
 .../md5                                       |  1 -
 .../sha512                                    |  1 -
 .../md5                                       |  1 +
 .../sha512                                    |  1 +
 stdlib/LinearAlgebra/src/special.jl           | 26 ++--------
 stdlib/LinearAlgebra/src/uniformscaling.jl    | 14 +++---
 stdlib/SparseArrays.version                   |  2 +-
 test/abstractarray.jl                         | 50 +++++++++----------
 10 files changed, 63 insertions(+), 95 deletions(-)
 delete mode 100644 deps/checksums/SparseArrays-2c7f4d6d839e9a97027454a037bfa004c1eb34b0.tar.gz/md5
 delete mode 100644 deps/checksums/SparseArrays-2c7f4d6d839e9a97027454a037bfa004c1eb34b0.tar.gz/sha512
 create mode 100644 deps/checksums/SparseArrays-b4b0e721ada6e8cf5f6391aff4db307be69b0401.tar.gz/md5
 create mode 100644 deps/checksums/SparseArrays-b4b0e721ada6e8cf5f6391aff4db307be69b0401.tar.gz/sha512

diff --git a/base/abstractarray.jl b/base/abstractarray.jl
index 1417987847ec4..cfc5078cb005e 100644
--- a/base/abstractarray.jl
+++ b/base/abstractarray.jl
@@ -1651,7 +1651,7 @@ function _typed_hcat(::Type{T}, A::AbstractVecOrTuple{AbstractVecOrMat}) where T
     for j = 1:nargs
         Aj = A[j]
         if size(Aj, 1) != nrows
-            throw(ArgumentError("number of rows of each array must match (got $(map(x->size(x,1), A)))"))
+            throw(DimensionMismatch("number of rows of each array must match (got $(map(x->size(x,1), A)))"))
         end
         dense &= isa(Aj,Array)
         nd = ndims(Aj)
@@ -1686,7 +1686,7 @@ function _typed_vcat(::Type{T}, A::AbstractVecOrTuple{AbstractVecOrMat}) where T
     ncols = size(A[1], 2)
     for j = 2:nargs
         if size(A[j], 2) != ncols
-            throw(ArgumentError("number of columns of each array must match (got $(map(x->size(x,2), A)))"))
+            throw(DimensionMismatch("number of columns of each array must match (got $(map(x->size(x,2), A)))"))
         end
     end
     B = similar(A[1], T, nrows, ncols)
@@ -1984,16 +1984,14 @@ julia> cat(1, [2], [3;;]; dims=Val(2))
 
 # The specializations for 1 and 2 inputs are important
 # especially when running with --inline=no, see #11158
-# The specializations for Union{AbstractVecOrMat,Number} are necessary
-# to have more specialized methods here than in LinearAlgebra/uniformscaling.jl
 vcat(A::AbstractArray) = cat(A; dims=Val(1))
 vcat(A::AbstractArray, B::AbstractArray) = cat(A, B; dims=Val(1))
 vcat(A::AbstractArray...) = cat(A...; dims=Val(1))
-vcat(A::Union{AbstractVecOrMat,Number}...) = cat(A...; dims=Val(1))
+vcat(A::Union{AbstractArray,Number}...) = cat(A...; dims=Val(1))
 hcat(A::AbstractArray) = cat(A; dims=Val(2))
 hcat(A::AbstractArray, B::AbstractArray) = cat(A, B; dims=Val(2))
 hcat(A::AbstractArray...) = cat(A...; dims=Val(2))
-hcat(A::Union{AbstractVecOrMat,Number}...) = cat(A...; dims=Val(2))
+hcat(A::Union{AbstractArray,Number}...) = cat(A...; dims=Val(2))
 
 typed_vcat(T::Type, A::AbstractArray) = _cat_t(Val(1), T, A)
 typed_vcat(T::Type, A::AbstractArray, B::AbstractArray) = _cat_t(Val(1), T, A, B)
@@ -2055,8 +2053,8 @@ julia> hvcat((2,2,2), a,b,c,d,e,f) == hvcat(2, a,b,c,d,e,f)
 true
 ```
 """
-hvcat(rows::Tuple{Vararg{Int}}, xs::AbstractVecOrMat...) = typed_hvcat(promote_eltype(xs...), rows, xs...)
-hvcat(rows::Tuple{Vararg{Int}}, xs::AbstractVecOrMat{T}...) where {T} = typed_hvcat(T, rows, xs...)
+hvcat(rows::Tuple{Vararg{Int}}, xs::AbstractArray...) = typed_hvcat(promote_eltype(xs...), rows, xs...)
+hvcat(rows::Tuple{Vararg{Int}}, xs::AbstractArray{T}...) where {T} = typed_hvcat(T, rows, xs...)
 
 function typed_hvcat(::Type{T}, rows::Tuple{Vararg{Int}}, as::AbstractVecOrMat...) where T
     nbr = length(rows)  # number of block rows
@@ -2084,16 +2082,16 @@ function typed_hvcat(::Type{T}, rows::Tuple{Vararg{Int}}, as::AbstractVecOrMat..
             Aj = as[a+j-1]
             szj = size(Aj,2)
             if size(Aj,1) != szi
-                throw(ArgumentError("mismatched height in block row $(i) (expected $szi, got $(size(Aj,1)))"))
+                throw(DimensionMismatch("mismatched height in block row $(i) (expected $szi, got $(size(Aj,1)))"))
             end
             if c-1+szj > nc
-                throw(ArgumentError("block row $(i) has mismatched number of columns (expected $nc, got $(c-1+szj))"))
+                throw(DimensionMismatch("block row $(i) has mismatched number of columns (expected $nc, got $(c-1+szj))"))
             end
             out[r:r-1+szi, c:c-1+szj] = Aj
             c += szj
         end
         if c != nc+1
-            throw(ArgumentError("block row $(i) has mismatched number of columns (expected $nc, got $(c-1))"))
+            throw(DimensionMismatch("block row $(i) has mismatched number of columns (expected $nc, got $(c-1))"))
         end
         r += szi
         a += rows[i]
@@ -2115,7 +2113,7 @@ function hvcat(rows::Tuple{Vararg{Int}}, xs::T...) where T<:Number
     k = 1
     @inbounds for i=1:nr
         if nc != rows[i]
-            throw(ArgumentError("row $(i) has mismatched number of columns (expected $nc, got $(rows[i]))"))
+            throw(DimensionMismatch("row $(i) has mismatched number of columns (expected $nc, got $(rows[i]))"))
         end
         for j=1:nc
             a[i,j] = xs[k]
@@ -2144,14 +2142,14 @@ end
 hvcat(rows::Tuple{Vararg{Int}}, xs::Number...) = typed_hvcat(promote_typeof(xs...), rows, xs...)
 hvcat(rows::Tuple{Vararg{Int}}, xs...) = typed_hvcat(promote_eltypeof(xs...), rows, xs...)
 # the following method is needed to provide a more specific one compared to LinearAlgebra/uniformscaling.jl
-hvcat(rows::Tuple{Vararg{Int}}, xs::Union{AbstractVecOrMat,Number}...) = typed_hvcat(promote_eltypeof(xs...), rows, xs...)
+hvcat(rows::Tuple{Vararg{Int}}, xs::Union{AbstractArray,Number}...) = typed_hvcat(promote_eltypeof(xs...), rows, xs...)
 
 function typed_hvcat(::Type{T}, rows::Tuple{Vararg{Int}}, xs::Number...) where T
     nr = length(rows)
     nc = rows[1]
     for i = 2:nr
         if nc != rows[i]
-            throw(ArgumentError("row $(i) has mismatched number of columns (expected $nc, got $(rows[i]))"))
+            throw(DimensionMismatch("row $(i) has mismatched number of columns (expected $nc, got $(rows[i]))"))
         end
     end
     hvcat_fill!(Matrix{T}(undef, nr, nc), xs)
@@ -2319,7 +2317,7 @@ function _typed_hvncat(::Type{T}, ::Val{N}, as::AbstractArray...) where {T, N}
         Ndim += cat_size(as[i], N)
         nd = max(nd, cat_ndims(as[i]))
         for d ∈ 1:N - 1
-            cat_size(as[1], d) == cat_size(as[i], d) || throw(ArgumentError("mismatched size along axis $d in element $i"))
+            cat_size(as[1], d) == cat_size(as[i], d) || throw(DimensionMismatch("mismatched size along axis $d in element $i"))
         end
     end
 
@@ -2346,7 +2344,7 @@ function _typed_hvncat(::Type{T}, ::Val{N}, as...) where {T, N}
         nd = max(nd, cat_ndims(as[i]))
         for d ∈ 1:N-1
             cat_size(as[i], d) == 1 ||
-                throw(ArgumentError("all dimensions of element $i other than $N must be of length 1"))
+                throw(DimensionMismatch("all dimensions of element $i other than $N must be of length 1"))
         end
     end
 
@@ -2463,7 +2461,7 @@ function _typed_hvncat_dims(::Type{T}, dims::NTuple{N, Int}, row_first::Bool, as
                 for dd ∈ 1:N
                     dd == d && continue
                     if cat_size(as[startelementi], dd) != cat_size(as[i], dd)
-                        throw(ArgumentError("incompatible shape in element $i"))
+                        throw(DimensionMismatch("incompatible shape in element $i"))
                     end
                 end
             end
@@ -2500,18 +2498,18 @@ function _typed_hvncat_dims(::Type{T}, dims::NTuple{N, Int}, row_first::Bool, as
                     elseif currentdims[d] < outdims[d] # dimension in progress
                         break
                     else # exceeded dimension
-                        throw(ArgumentError("argument $i has too many elements along axis $d"))
+                        throw(DimensionMismatch("argument $i has too many elements along axis $d"))
                     end
                 end
             end
         elseif currentdims[d1] > outdims[d1] # exceeded dimension
-            throw(ArgumentError("argument $i has too many elements along axis $d1"))
+            throw(DimensionMismatch("argument $i has too many elements along axis $d1"))
         end
     end
 
     outlen = prod(outdims)
     elementcount == outlen ||
-        throw(ArgumentError("mismatched number of elements; expected $(outlen), got $(elementcount)"))
+        throw(DimensionMismatch("mismatched number of elements; expected $(outlen), got $(elementcount)"))
 
     # copy into final array
     A = cat_similar(as[1], T, outdims)
@@ -2572,8 +2570,8 @@ function _typed_hvncat_shape(::Type{T}, shape::NTuple{N, Tuple}, row_first, as::
             if d == 1 || i == 1 || wasstartblock
                 currentdims[d] += dsize
             elseif dsize != cat_size(as[i - 1], ad)
-                throw(ArgumentError("argument $i has a mismatched number of elements along axis $ad; \
-                                    expected $(cat_size(as[i - 1], ad)), got $dsize"))
+                throw(DimensionMismatch("argument $i has a mismatched number of elements along axis $ad; \
+                                         expected $(cat_size(as[i - 1], ad)), got $dsize"))
             end
 
             wasstartblock = blockcounts[d] == 1 # remember for next dimension
@@ -2583,15 +2581,15 @@ function _typed_hvncat_shape(::Type{T}, shape::NTuple{N, Tuple}, row_first, as::
                 if outdims[d] == -1
                     outdims[d] = currentdims[d]
                 elseif outdims[d] != currentdims[d]
-                    throw(ArgumentError("argument $i has a mismatched number of elements along axis $ad; \
-                                        expected $(abs(outdims[d] - (currentdims[d] - dsize))), got $dsize"))
+                    throw(DimensionMismatch("argument $i has a mismatched number of elements along axis $ad; \
+                                             expected $(abs(outdims[d] - (currentdims[d] - dsize))), got $dsize"))
                 end
                 currentdims[d] = 0
                 blockcounts[d] = 0
                 shapepos[d] += 1
                 d > 1 && (blockcounts[d - 1] == 0 ||
-                    throw(ArgumentError("shape in level $d is inconsistent; level counts must nest \
-                                        evenly into each other")))
+                    throw(DimensionMismatch("shape in level $d is inconsistent; level counts must nest \
+                                             evenly into each other")))
             end
         end
     end
diff --git a/base/array.jl b/base/array.jl
index 3a12b38c5bc26..825b5f9f7e206 100644
--- a/base/array.jl
+++ b/base/array.jl
@@ -2041,18 +2041,6 @@ function vcat(arrays::Vector{T}...) where T
 end
 vcat(A::Vector...) = cat(A...; dims=Val(1)) # more special than SparseArrays's vcat
 
-# disambiguation with LinAlg/special.jl
-# Union{Number,Vector,Matrix} is for LinearAlgebra._DenseConcatGroup
-# VecOrMat{T} is for LinearAlgebra._TypedDenseConcatGroup
-hcat(A::Union{Number,Vector,Matrix}...) = cat(A...; dims=Val(2))
-hcat(A::VecOrMat{T}...) where {T} = typed_hcat(T, A...)
-vcat(A::Union{Number,Vector,Matrix}...) = cat(A...; dims=Val(1))
-vcat(A::VecOrMat{T}...) where {T} = typed_vcat(T, A...)
-hvcat(rows::Tuple{Vararg{Int}}, xs::Union{Number,Vector,Matrix}...) =
-    typed_hvcat(promote_eltypeof(xs...), rows, xs...)
-hvcat(rows::Tuple{Vararg{Int}}, xs::VecOrMat{T}...) where {T} =
-    typed_hvcat(T, rows, xs...)
-
 _cat(n::Integer, x::Integer...) = reshape([x...], (ntuple(Returns(1), n-1)..., length(x)))
 
 ## find ##
diff --git a/deps/checksums/SparseArrays-2c7f4d6d839e9a97027454a037bfa004c1eb34b0.tar.gz/md5 b/deps/checksums/SparseArrays-2c7f4d6d839e9a97027454a037bfa004c1eb34b0.tar.gz/md5
deleted file mode 100644
index 21131a800d4af..0000000000000
--- a/deps/checksums/SparseArrays-2c7f4d6d839e9a97027454a037bfa004c1eb34b0.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-0369c2679e8b834009526dd4f402cfd8
diff --git a/deps/checksums/SparseArrays-2c7f4d6d839e9a97027454a037bfa004c1eb34b0.tar.gz/sha512 b/deps/checksums/SparseArrays-2c7f4d6d839e9a97027454a037bfa004c1eb34b0.tar.gz/sha512
deleted file mode 100644
index df3b4cc3736e1..0000000000000
--- a/deps/checksums/SparseArrays-2c7f4d6d839e9a97027454a037bfa004c1eb34b0.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-b2573398a8e8f5bcd8195cc3aa68103b2b5ea66c1835d4bc4d808fb1e0d3fbd46cc2caa04a4f49813a4a4a7f88d2f95789fa080d1d940c0291b09416be0fd1e6
diff --git a/deps/checksums/SparseArrays-b4b0e721ada6e8cf5f6391aff4db307be69b0401.tar.gz/md5 b/deps/checksums/SparseArrays-b4b0e721ada6e8cf5f6391aff4db307be69b0401.tar.gz/md5
new file mode 100644
index 0000000000000..55bc533861fc0
--- /dev/null
+++ b/deps/checksums/SparseArrays-b4b0e721ada6e8cf5f6391aff4db307be69b0401.tar.gz/md5
@@ -0,0 +1 @@
+e59c1c57b97e17a73eba758d65022bd7
diff --git a/deps/checksums/SparseArrays-b4b0e721ada6e8cf5f6391aff4db307be69b0401.tar.gz/sha512 b/deps/checksums/SparseArrays-b4b0e721ada6e8cf5f6391aff4db307be69b0401.tar.gz/sha512
new file mode 100644
index 0000000000000..2213bfe87ccfc
--- /dev/null
+++ b/deps/checksums/SparseArrays-b4b0e721ada6e8cf5f6391aff4db307be69b0401.tar.gz/sha512
@@ -0,0 +1 @@
+ad88ebe77aaf1580e6d7ee7649ac5b812a23b9d9bf947f26babe9dd79902f6da11aa69bf63f22f67f6eae92a4c6e665cc3b950bb7c648c623e9cb4b9cb4daac4
diff --git a/stdlib/LinearAlgebra/src/special.jl b/stdlib/LinearAlgebra/src/special.jl
index 1744a2301f48a..885f29fa1417b 100644
--- a/stdlib/LinearAlgebra/src/special.jl
+++ b/stdlib/LinearAlgebra/src/special.jl
@@ -330,27 +330,11 @@ end
 ==(A::Bidiagonal, B::SymTridiagonal) = iszero(_evview(B)) && iszero(A.ev) && A.dv == B.dv
 ==(B::SymTridiagonal, A::Bidiagonal) = A == B
 
-# concatenation
-const _SpecialArrays = Union{Diagonal, Bidiagonal, Tridiagonal, SymTridiagonal}
-const _Symmetric_DenseArrays{T,A<:Matrix} = Symmetric{T,A}
-const _Hermitian_DenseArrays{T,A<:Matrix} = Hermitian{T,A}
-const _Triangular_DenseArrays{T,A<:Matrix} = AbstractTriangular{T,A}
-const _Annotated_DenseArrays = Union{_SpecialArrays, _Triangular_DenseArrays, _Symmetric_DenseArrays, _Hermitian_DenseArrays}
-const _Annotated_Typed_DenseArrays{T} = Union{_Triangular_DenseArrays{T}, _Symmetric_DenseArrays{T}, _Hermitian_DenseArrays{T}}
-const _DenseConcatGroup = Union{Number, Vector, Adjoint{<:Any,<:Vector}, Transpose{<:Any,<:Vector}, Matrix, _Annotated_DenseArrays}
-const _TypedDenseConcatGroup{T} = Union{Vector{T}, Adjoint{T,Vector{T}}, Transpose{T,Vector{T}}, Matrix{T}, _Annotated_Typed_DenseArrays{T}}
-
-promote_to_array_type(::Tuple{Vararg{Union{_DenseConcatGroup,UniformScaling}}}) = Matrix
-
-Base._cat(dims, xs::_DenseConcatGroup...) = Base._cat_t(dims, promote_eltype(xs...), xs...)
-vcat(A::_DenseConcatGroup...) = Base.typed_vcat(promote_eltype(A...), A...)
-hcat(A::_DenseConcatGroup...) = Base.typed_hcat(promote_eltype(A...), A...)
-hvcat(rows::Tuple{Vararg{Int}}, xs::_DenseConcatGroup...) = Base.typed_hvcat(promote_eltype(xs...), rows, xs...)
-# For performance, specially handle the case where the matrices/vectors have homogeneous eltype
-Base._cat(dims, xs::_TypedDenseConcatGroup{T}...) where {T} = Base._cat_t(dims, T, xs...)
-vcat(A::_TypedDenseConcatGroup{T}...) where {T} = Base.typed_vcat(T, A...)
-hcat(A::_TypedDenseConcatGroup{T}...) where {T} = Base.typed_hcat(T, A...)
-hvcat(rows::Tuple{Vararg{Int}}, xs::_TypedDenseConcatGroup{T}...) where {T} = Base.typed_hvcat(T, rows, xs...)
+# TODO: remove these deprecations (used by SparseArrays in the past)
+const _DenseConcatGroup = Union{}
+const _SpecialArrays = Union{}
+
+promote_to_array_type(::Tuple) = Matrix
 
 # factorizations
 function cholesky(S::RealHermSymComplexHerm{<:Real,<:SymTridiagonal}, ::NoPivot = NoPivot(); check::Bool = true)
diff --git a/stdlib/LinearAlgebra/src/uniformscaling.jl b/stdlib/LinearAlgebra/src/uniformscaling.jl
index 21ae8a1bb913a..0b3168113acf7 100644
--- a/stdlib/LinearAlgebra/src/uniformscaling.jl
+++ b/stdlib/LinearAlgebra/src/uniformscaling.jl
@@ -408,7 +408,7 @@ end
 # so that we can re-use this code for sparse-matrix hcat etcetera.
 promote_to_arrays_(n::Int, ::Type, a::Number) = a
 promote_to_arrays_(n::Int, ::Type{Matrix}, J::UniformScaling{T}) where {T} = Matrix(J, n, n)
-promote_to_arrays_(n::Int, ::Type, A::AbstractVecOrMat) = A
+promote_to_arrays_(n::Int, ::Type, A::AbstractArray) = A
 promote_to_arrays(n,k, ::Type) = ()
 promote_to_arrays(n,k, ::Type{T}, A) where {T} = (promote_to_arrays_(n[k], T, A),)
 promote_to_arrays(n,k, ::Type{T}, A, B) where {T} =
@@ -417,17 +417,16 @@ promote_to_arrays(n,k, ::Type{T}, A, B, C) where {T} =
     (promote_to_arrays_(n[k], T, A), promote_to_arrays_(n[k+1], T, B), promote_to_arrays_(n[k+2], T, C))
 promote_to_arrays(n,k, ::Type{T}, A, B, Cs...) where {T} =
     (promote_to_arrays_(n[k], T, A), promote_to_arrays_(n[k+1], T, B), promote_to_arrays(n,k+2, T, Cs...)...)
-promote_to_array_type(A::Tuple{Vararg{Union{AbstractVecOrMat,UniformScaling,Number}}}) = Matrix
 
 _us2number(A) = A
 _us2number(J::UniformScaling) = J.λ
 
 for (f, _f, dim, name) in ((:hcat, :_hcat, 1, "rows"), (:vcat, :_vcat, 2, "cols"))
     @eval begin
-        @inline $f(A::Union{AbstractVecOrMat,UniformScaling}...) = $_f(A...)
+        @inline $f(A::Union{AbstractArray,UniformScaling}...) = $_f(A...)
         # if there's a Number present, J::UniformScaling must be 1x1-dimensional
-        @inline $f(A::Union{AbstractVecOrMat,UniformScaling,Number}...) = $f(map(_us2number, A)...)
-        function $_f(A::Union{AbstractVecOrMat,UniformScaling,Number}...; array_type = promote_to_array_type(A))
+        @inline $f(A::Union{AbstractArray,UniformScaling,Number}...) = $f(map(_us2number, A)...)
+        function $_f(A::Union{AbstractArray,UniformScaling,Number}...; array_type = promote_to_array_type(A))
             n = -1
             for a in A
                 if !isa(a, UniformScaling)
@@ -445,9 +444,8 @@ for (f, _f, dim, name) in ((:hcat, :_hcat, 1, "rows"), (:vcat, :_vcat, 2, "cols"
     end
 end
 
-hvcat(rows::Tuple{Vararg{Int}}, A::Union{AbstractVecOrMat,UniformScaling}...) = _hvcat(rows, A...)
-hvcat(rows::Tuple{Vararg{Int}}, A::Union{AbstractVecOrMat,UniformScaling,Number}...) = _hvcat(rows, A...)
-function _hvcat(rows::Tuple{Vararg{Int}}, A::Union{AbstractVecOrMat,UniformScaling,Number}...; array_type = promote_to_array_type(A))
+hvcat(rows::Tuple{Vararg{Int}}, A::Union{AbstractArray,UniformScaling,Number}...) = _hvcat(rows, A...)
+function _hvcat(rows::Tuple{Vararg{Int}}, A::Union{AbstractArray,UniformScaling,Number}...; array_type = promote_to_array_type(A))
     require_one_based_indexing(A...)
     nr = length(rows)
     sum(rows) == length(A) || throw(ArgumentError("mismatch between row sizes and number of arguments"))
diff --git a/stdlib/SparseArrays.version b/stdlib/SparseArrays.version
index b29ce9b0306e1..4290a1d2fc4ca 100644
--- a/stdlib/SparseArrays.version
+++ b/stdlib/SparseArrays.version
@@ -1,4 +1,4 @@
 SPARSEARRAYS_BRANCH = main
-SPARSEARRAYS_SHA1 = 2c7f4d6d839e9a97027454a037bfa004c1eb34b0
+SPARSEARRAYS_SHA1 = b4b0e721ada6e8cf5f6391aff4db307be69b0401
 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/test/abstractarray.jl b/test/abstractarray.jl
index 912e0d5883d12..6e2294fec1f64 100644
--- a/test/abstractarray.jl
+++ b/test/abstractarray.jl
@@ -683,8 +683,8 @@ function test_cat(::Type{TestAbstractArray})
     @test hcat() == Any[]
     @test vcat(1, 1.0, 3, 3.0) == [1.0, 1.0, 3.0, 3.0]
     @test hcat(1, 1.0, 3, 3.0) == [1.0 1.0 3.0 3.0]
-    @test_throws ArgumentError hcat(B1, B2)
-    @test_throws ArgumentError vcat(C1, C2)
+    @test_throws DimensionMismatch hcat(B1, B2)
+    @test_throws DimensionMismatch vcat(C1, C2)
 
     @test vcat(B) == B
     @test hcat(B) == B
@@ -713,9 +713,9 @@ function test_cat(::Type{TestAbstractArray})
     end
 
     @test_throws ArgumentError hvcat(7, 1:20...)
-    @test_throws ArgumentError hvcat((2), C1, C3)
-    @test_throws ArgumentError hvcat((1), C1, C2)
-    @test_throws ArgumentError hvcat((1), C2, C3)
+    @test_throws DimensionMismatch hvcat((2), C1, C3)
+    @test_throws DimensionMismatch hvcat((1), C1, C2)
+    @test_throws DimensionMismatch hvcat((1), C2, C3)
 
     tup = tuple(rand(1:10, i)...)
     @test hvcat(tup) == []
@@ -724,8 +724,8 @@ function test_cat(::Type{TestAbstractArray})
     @test_throws ArgumentError hvcat((2, 2), 1, 2, 3, 4, 5)
     @test_throws ArgumentError Base.typed_hvcat(Int, (2, 2), 1, 2, 3, 4, 5)
     # check for # of columns mismatch b/w rows
-    @test_throws ArgumentError hvcat((3, 2), 1, 2, 3, 4, 5, 6)
-    @test_throws ArgumentError Base.typed_hvcat(Int, (3, 2), 1, 2, 3, 4, 5, 6)
+    @test_throws DimensionMismatch hvcat((3, 2), 1, 2, 3, 4, 5, 6)
+    @test_throws DimensionMismatch Base.typed_hvcat(Int, (3, 2), 1, 2, 3, 4, 5, 6)
 
     # 18395
     @test isa(Any["a" 5; 2//3 1.0][2,1], Rational{Int})
@@ -1344,7 +1344,7 @@ end
 
     @test Int[t...; 3 4] == [1 2; 3 4]
     @test Int[0 t...; t... 0] == [0 1 2; 1 2 0]
-    @test_throws ArgumentError Int[t...; 3 4 5]
+    @test_throws DimensionMismatch Int[t...; 3 4 5]
 end
 
 @testset "issue #39896, modified getindex " begin
@@ -1398,15 +1398,15 @@ using Base: typed_hvncat
     @test [1;;] == fill(1, (1,1))
 
     for v in (1, fill(1), fill(1,1,1), fill(1, 1, 1, 1))
-        @test_throws ArgumentError [v; v;; v]
-        @test_throws ArgumentError [v; v;; v; v; v]
-        @test_throws ArgumentError [v; v; v;; v; v]
-        @test_throws ArgumentError [v; v;; v; v;;; v; v;; v; v;; v; v]
-        @test_throws ArgumentError [v; v;; v; v;;; v; v]
-        @test_throws ArgumentError [v; v;; v; v;;; v; v; v;; v; v]
-        @test_throws ArgumentError [v; v;; v; v;;; v; v;; v; v; v]
+        @test_throws DimensionMismatch [v; v;; v]
+        @test_throws DimensionMismatch [v; v;; v; v; v]
+        @test_throws DimensionMismatch [v; v; v;; v; v]
+        @test_throws DimensionMismatch [v; v;; v; v;;; v; v;; v; v;; v; v]
+        @test_throws DimensionMismatch [v; v;; v; v;;; v; v]
+        @test_throws DimensionMismatch [v; v;; v; v;;; v; v; v;; v; v]
+        @test_throws DimensionMismatch [v; v;; v; v;;; v; v;; v; v; v]
         # ensure a wrong shape with the right number of elements doesn't pass through
-        @test_throws ArgumentError [v; v;; v; v;;; v; v; v; v]
+        @test_throws DimensionMismatch [v; v;; v; v;;; v; v; v; v]
 
         @test [v; v;; v; v] == fill(1, ndims(v) == 3 ? (2, 2, 1) : (2,2))
         @test [v; v;; v; v;;;] == fill(1, 2, 2, 1)
@@ -1474,7 +1474,7 @@ using Base: typed_hvncat
     end
 
     # reject shapes that don't nest evenly between levels (e.g. 1 + 2 does not fit into 2)
-    @test_throws ArgumentError hvncat(((1, 2, 1), (2, 2), (4,)), true, [1 2], [3], [4], [1 2; 3 4])
+    @test_throws DimensionMismatch hvncat(((1, 2, 1), (2, 2), (4,)), true, [1 2], [3], [4], [1 2; 3 4])
 
     # zero-length arrays are handled appropriately
     @test [zeros(Int, 1, 2, 0) ;;; 1 3] == [1 3;;;]
@@ -1489,18 +1489,18 @@ using Base: typed_hvncat
     for v1 ∈ (zeros(Int, 0, 0), zeros(Int, 0, 0, 0, 0), zeros(Int, 0, 0, 0, 0, 0, 0, 0))
         for v2 ∈ (1, [1])
             for v3 ∈ (2, [2])
-                @test_throws ArgumentError [v1 ;;; v2]
-                @test_throws ArgumentError [v1 ;;; v2 v3]
-                @test_throws ArgumentError [v1 v1 ;;; v2 v3]
+                @test_throws DimensionMismatch [v1 ;;; v2]
+                @test_throws DimensionMismatch [v1 ;;; v2 v3]
+                @test_throws DimensionMismatch [v1 v1 ;;; v2 v3]
             end
         end
     end
     v1 = zeros(Int, 0, 0, 0)
     for v2 ∈ (1, [1])
         for v3 ∈ (2, [2])
-            @test_throws ArgumentError [v1 ;;; v2 v3]
-            @test_throws ArgumentError [v1 ;;; v2]
-            @test_throws ArgumentError [v1 v1 ;;; v2 v3]
+            @test_throws DimensionMismatch [v1 ;;; v2 v3]
+            @test_throws DimensionMismatch [v1 ;;; v2]
+            @test_throws DimensionMismatch [v1 v1 ;;; v2 v3]
         end
     end
 
@@ -1568,8 +1568,8 @@ using Base: typed_hvncat
     @test Array{Int, 3}(undef, 0, 0, 0) == typed_hvncat(Int, 3) isa Array{Int, 3}
 
     # Issue 43933 - semicolon precedence mistake should produce an error
-    @test_throws ArgumentError [[1 1]; 2 ;; 3 ; [3 4]]
-    @test_throws ArgumentError [[1 ;;; 1]; 2 ;;; 3 ; [3 ;;; 4]]
+    @test_throws DimensionMismatch [[1 1]; 2 ;; 3 ; [3 4]]
+    @test_throws DimensionMismatch [[1 ;;; 1]; 2 ;;; 3 ; [3 ;;; 4]]
 
     @test [[1 2; 3 4] [5; 6]; [7 8] 9;;;] == [1 2 5; 3 4 6; 7 8 9;;;]
 

From 2c3f79b21c1fb14bf6a630158c8b21d8537bc9df Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Mon, 17 Jul 2023 14:54:17 -0400
Subject: [PATCH 25/41] precompile: ensure globals are not accidentally created
 where disallowed (#50541)

Usually this is caught by use of `eval`, but we should try to move away
from that broad rule to specific functions such as this one, such that
eventually we can remove that rule from `eval`.

Fix #50538

(cherry picked from commit 3a9345c0b0157b6664ed5c28a9ff255cbc7357b0)
---
 src/module.c       | 80 ++++++++++++++++++++++++++++++++--------------
 src/staticdata.c   |  6 ++++
 src/toplevel.c     | 24 ++++----------
 test/precompile.jl | 31 ++++++++++++++++++
 test/staged.jl     |  2 ++
 5 files changed, 102 insertions(+), 41 deletions(-)

diff --git a/src/module.c b/src/module.c
index 89c4c6cdb674e..59bd308d99a41 100644
--- a/src/module.c
+++ b/src/module.c
@@ -190,16 +190,44 @@ static jl_binding_t *new_binding(jl_module_t *mod, jl_sym_t *name)
     return b;
 }
 
+extern jl_mutex_t jl_modules_mutex;
+
+static void check_safe_newbinding(jl_module_t *m, jl_sym_t *var)
+{
+    if (jl_current_task->ptls->in_pure_callback)
+        jl_errorf("new globals cannot be created in a generated function");
+    if (jl_options.incremental && jl_generating_output()) {
+        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);
+            for (i = 0; i < l; i++) {
+                if (m == (jl_module_t*)jl_array_ptr_ref(jl_module_init_order, i)) {
+                    open = 1;
+                    break;
+                }
+            }
+        }
+        JL_UNLOCK(&jl_modules_mutex);
+        if (!open) {
+            jl_errorf("Creating a new global in closed module `%s` (`%s`) breaks incremental compilation "
+                      "because the side effects will not be permanent.",
+                      jl_symbol_name(m->name), jl_symbol_name(var));
+        }
+    }
+}
+
 static jl_module_t *jl_binding_dbgmodule(jl_binding_t *b, jl_module_t *m, jl_sym_t *var) JL_GLOBALLY_ROOTED;
 
 // get binding for assignment
 JL_DLLEXPORT jl_binding_t *jl_get_binding_wr(jl_module_t *m JL_PROPAGATES_ROOT, jl_sym_t *var)
 {
     jl_binding_t *b = jl_get_module_binding(m, var, 1);
-
-    if (b) {
-        jl_binding_t *b2 = NULL;
-        if (!jl_atomic_cmpswap(&b->owner, &b2, b) && b2 != b) {
+    jl_binding_t *b2 = jl_atomic_load_relaxed(&b->owner);
+    if (b2 != b) {
+        if (b2 == NULL)
+            check_safe_newbinding(m, var);
+        if (b2 != NULL || (!jl_atomic_cmpswap(&b->owner, &b2, b) && b2 != b)) {
             jl_module_t *from = jl_binding_dbgmodule(b, m, var);
             if (from == m)
                 jl_errorf("cannot assign a value to imported variable %s.%s",
@@ -209,7 +237,6 @@ JL_DLLEXPORT jl_binding_t *jl_get_binding_wr(jl_module_t *m JL_PROPAGATES_ROOT,
                           jl_symbol_name(from->name), jl_symbol_name(var), jl_symbol_name(m->name));
         }
     }
-
     return b;
 }
 
@@ -223,29 +250,31 @@ JL_DLLEXPORT jl_module_t *jl_get_module_of_binding(jl_module_t *m, jl_sym_t *var
 }
 
 // get binding for adding a method
-// like jl_get_binding_wr, but has different error paths
+// like jl_get_binding_wr, but has different error paths and messages
 JL_DLLEXPORT jl_binding_t *jl_get_binding_for_method_def(jl_module_t *m, jl_sym_t *var)
 {
     jl_binding_t *b = jl_get_module_binding(m, var, 1);
-
-    jl_binding_t *b2 = NULL;
-    if (!jl_atomic_cmpswap(&b->owner, &b2, b) && b2 != b) {
-        jl_value_t *f = jl_atomic_load_relaxed(&b2->value);
-        jl_module_t *from = jl_binding_dbgmodule(b, m, var);
-        if (f == NULL) {
-            // we must have implicitly imported this with using, so call jl_binding_dbgmodule to try to get the name of the module we got this from
-            jl_errorf("invalid method definition in %s: exported function %s.%s does not exist",
-                      jl_symbol_name(m->name), jl_symbol_name(from->name), jl_symbol_name(var));
-        }
-        // TODO: we might want to require explicitly importing types to add constructors
-        //       or we might want to drop this error entirely
-        if (!b->imported && !(b2->constp && jl_is_type(f) && strcmp(jl_symbol_name(var), "=>") != 0)) {
-            jl_errorf("invalid method definition in %s: function %s.%s must be explicitly imported to be extended",
-                      jl_symbol_name(m->name), jl_symbol_name(from->name), jl_symbol_name(var));
+    jl_binding_t *b2 = jl_atomic_load_relaxed(&b->owner);
+    if (b2 != b) {
+        if (b2 == NULL)
+            check_safe_newbinding(m, var);
+        if (b2 != NULL || (!jl_atomic_cmpswap(&b->owner, &b2, b) && b2 != b)) {
+            jl_value_t *f = jl_atomic_load_relaxed(&b2->value);
+            jl_module_t *from = jl_binding_dbgmodule(b, m, var);
+            if (f == NULL) {
+                // we must have implicitly imported this with using, so call jl_binding_dbgmodule to try to get the name of the module we got this from
+                jl_errorf("invalid method definition in %s: exported function %s.%s does not exist",
+                          jl_symbol_name(m->name), jl_symbol_name(from->name), jl_symbol_name(var));
+            }
+            // TODO: we might want to require explicitly importing types to add constructors
+            //       or we might want to drop this error entirely
+            if (!b->imported && !(b2->constp && jl_is_type(f) && strcmp(jl_symbol_name(var), "=>") != 0)) {
+                jl_errorf("invalid method definition in %s: function %s.%s must be explicitly imported to be extended",
+                          jl_symbol_name(m->name), jl_symbol_name(from->name), jl_symbol_name(var));
+            }
+            return b2;
         }
-        return b2;
     }
-
     return b;
 }
 
@@ -761,7 +790,10 @@ JL_DLLEXPORT void jl_set_global(jl_module_t *m JL_ROOTING_ARGUMENT, jl_sym_t *va
 JL_DLLEXPORT void jl_set_const(jl_module_t *m JL_ROOTING_ARGUMENT, jl_sym_t *var, jl_value_t *val JL_ROOTED_ARGUMENT)
 {
     // this function is mostly only used during initialization, so the data races here are not too important to us
-    jl_binding_t *bp = jl_get_binding_wr(m, var);
+    jl_binding_t *bp = jl_get_module_binding(m, var, 1);
+    jl_binding_t *b2 = NULL;
+    if (!jl_atomic_cmpswap(&bp->owner, &b2, bp) && b2 != bp)
+        jl_errorf("invalid redefinition of constant %s", jl_symbol_name(var));
     if (jl_atomic_load_relaxed(&bp->value) == NULL) {
         jl_value_t *old_ty = NULL;
         jl_atomic_cmpswap_relaxed(&bp->ty, &old_ty, (jl_value_t*)jl_any_type);
diff --git a/src/staticdata.c b/src/staticdata.c
index df080bc68c88f..c05422fd10969 100644
--- a/src/staticdata.c
+++ b/src/staticdata.c
@@ -1234,6 +1234,12 @@ static void jl_write_values(jl_serializer_state *s) JL_GC_DISABLED
                 jl_binding_t *b = (jl_binding_t*)v;
                 if (b->globalref == NULL || jl_object_in_image((jl_value_t*)b->globalref->mod))
                     jl_error("Binding cannot be serialized"); // no way (currently) to recover its identity
+                // Assign type Any to any owned bindings that don't have a type.
+                // We don't want these accidentally managing to diverge later in different compilation units.
+                if (jl_atomic_load_relaxed(&b->owner) == b) {
+                    jl_value_t *old_ty = NULL;
+                    jl_atomic_cmpswap_relaxed(&b->ty, &old_ty, (jl_value_t*)jl_any_type);
+                }
             }
         }
 
diff --git a/src/toplevel.c b/src/toplevel.c
index 51ff93488426f..46ae3f3cf0314 100644
--- a/src/toplevel.c
+++ b/src/toplevel.c
@@ -944,8 +944,10 @@ JL_DLLEXPORT jl_value_t *jl_toplevel_eval(jl_module_t *m, jl_value_t *v)
 }
 
 // Check module `m` is open for `eval/include`, or throw an error.
-static void jl_check_open_for(jl_module_t *m, const char* funcname)
+JL_DLLEXPORT void jl_check_top_level_effect(jl_module_t *m, char *fname)
 {
+    if (jl_current_task->ptls->in_pure_callback)
+        jl_errorf("%s cannot be used in a generated function", fname);
     if (jl_options.incremental && jl_generating_output()) {
         if (m != jl_main_module) { // TODO: this was grand-fathered in
             JL_LOCK(&jl_modules_mutex);
@@ -965,25 +967,15 @@ static void jl_check_open_for(jl_module_t *m, const char* funcname)
                 jl_errorf("Evaluation into the closed module `%s` breaks incremental compilation "
                           "because the side effects will not be permanent. "
                           "This is likely due to some other module mutating `%s` with `%s` during "
-                          "precompilation - don't do this.", name, name, funcname);
+                          "precompilation - don't do this.", name, name, fname);
             }
         }
     }
 }
 
-JL_DLLEXPORT void jl_check_top_level_effect(jl_module_t *m, char *fname)
-{
-    if (jl_current_task->ptls->in_pure_callback)
-        jl_errorf("%s cannot be used in a generated function", fname);
-    jl_check_open_for(m, fname);
-}
-
 JL_DLLEXPORT jl_value_t *jl_toplevel_eval_in(jl_module_t *m, jl_value_t *ex)
 {
-    jl_task_t *ct = jl_current_task;
-    if (ct->ptls->in_pure_callback)
-        jl_error("eval cannot be used in a generated function");
-    jl_check_open_for(m, "eval");
+    jl_check_top_level_effect(m, "eval");
     jl_value_t *v = NULL;
     int last_lineno = jl_lineno;
     const char *last_filename = jl_filename;
@@ -1029,10 +1021,7 @@ static jl_value_t *jl_parse_eval_all(jl_module_t *module, jl_value_t *text,
     if (!jl_is_string(text) || !jl_is_string(filename)) {
         jl_errorf("Expected `String`s for `text` and `filename`");
     }
-    jl_task_t *ct = jl_current_task;
-    if (ct->ptls->in_pure_callback)
-        jl_error("cannot use include inside a generated function");
-    jl_check_open_for(module, "include");
+    jl_check_top_level_effect(module, "include");
 
     jl_value_t *result = jl_nothing;
     jl_value_t *ast = NULL;
@@ -1045,6 +1034,7 @@ static jl_value_t *jl_parse_eval_all(jl_module_t *module, jl_value_t *text,
         jl_errorf("jl_parse_all() must generate a top level expression");
     }
 
+    jl_task_t *ct = jl_current_task;
     int last_lineno = jl_lineno;
     const char *last_filename = jl_filename;
     size_t last_age = ct->world_age;
diff --git a/test/precompile.jl b/test/precompile.jl
index 62d862c384040..d76a5a9a16f85 100644
--- a/test/precompile.jl
+++ b/test/precompile.jl
@@ -1771,6 +1771,37 @@ precompile_test_harness("Issue #48391") do load_path
     @test_throws ErrorException isless(x, x)
 end
 
+precompile_test_harness("Issue #50538") do load_path
+    write(joinpath(load_path, "I50538.jl"),
+        """
+        module I50538
+        const newglobal = try
+            Base.newglobal = false
+        catch ex
+            ex isa ErrorException || rethrow()
+            ex
+        end
+        const newtype = try
+            Core.set_binding_type!(Base, :newglobal)
+        catch ex
+            ex isa ErrorException || rethrow()
+            ex
+        end
+        global undefglobal
+        end
+        """)
+    ji, ofile = Base.compilecache(Base.PkgId("I50538"))
+    @eval using I50538
+    @test I50538.newglobal.msg == "Creating a new global in closed module `Base` (`newglobal`) breaks incremental compilation because the side effects will not be permanent."
+    @test I50538.newtype.msg == "Creating a new global in closed module `Base` (`newglobal`) breaks incremental compilation because the side effects will not be permanent."
+    @test_throws(ErrorException("cannot set type for global I50538.undefglobal. It already has a value or is already set to a different type."),
+                 Core.set_binding_type!(I50538, :undefglobal, Int))
+    Core.set_binding_type!(I50538, :undefglobal, Any)
+    @test Core.get_binding_type(I50538, :undefglobal) === Any
+    @test !isdefined(I50538, :undefglobal)
+end
+
+
 empty!(Base.DEPOT_PATH)
 append!(Base.DEPOT_PATH, original_depot_path)
 empty!(Base.LOAD_PATH)
diff --git a/test/staged.jl b/test/staged.jl
index df351d8d47b96..5204f5f6ca777 100644
--- a/test/staged.jl
+++ b/test/staged.jl
@@ -308,6 +308,8 @@ end
 @generated function f33243()
     :(global x33243 = 2)
 end
+@test_throws ErrorException f33243()
+global x33243
 @test f33243() === 2
 @test x33243 === 2
 

From 208e9283545d211c33700774b6da72de1a6ed693 Mon Sep 17 00:00:00 2001
From: Diogo Netto <61364108+d-netto@users.noreply.github.com>
Date: Tue, 18 Jul 2023 00:32:56 -0300
Subject: [PATCH 26/41] use atomic compare exchange when setting the GC
 mark-bit (#50576)

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

(cherry picked from commit 2cee483bcedf7ad838a765581f9aace09b75f448)
---
 src/gc.c | 47 ++++++++++++++++++++++-------------------------
 1 file changed, 22 insertions(+), 25 deletions(-)

diff --git a/src/gc.c b/src/gc.c
index aa07695ac8bc0..732684db332ed 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -799,7 +799,7 @@ STATIC_INLINE void gc_queue_big_marked(jl_ptls_t ptls, bigval_t *hdr,
 FORCE_INLINE int gc_try_setmark_tag(jl_taggedvalue_t *o, uint8_t mark_mode) JL_NOTSAFEPOINT
 {
     assert(gc_marked(mark_mode));
-    uintptr_t tag = jl_atomic_load_relaxed((_Atomic(uintptr_t)*)&o->header);
+    uintptr_t tag = o->header;
     if (gc_marked(tag))
         return 0;
     if (mark_reset_age) {
@@ -813,9 +813,13 @@ FORCE_INLINE int gc_try_setmark_tag(jl_taggedvalue_t *o, uint8_t mark_mode) JL_N
         tag = tag | mark_mode;
         assert((tag & 0x3) == mark_mode);
     }
-    jl_atomic_store_relaxed((_Atomic(uintptr_t)*)&o->header, tag); //xchg here was slower than
-    verify_val(jl_valueof(o));                                     //potentially redoing work because of a stale tag.
-    return 1;
+    // XXX: note that marking not only sets the GC bits but also updates the
+    // page metadata for pool allocated objects.
+    // The second step is **not** idempotent, so we need a compare exchange here
+    // (instead of a pair of load&store) to avoid marking an object twice
+    tag = jl_atomic_exchange_relaxed((_Atomic(uintptr_t)*)&o->header, tag);
+    verify_val(jl_valueof(o));
+    return !gc_marked(tag);
 }
 
 // This function should be called exactly once during marking for each big
@@ -854,7 +858,7 @@ STATIC_INLINE void gc_setmark_pool_(jl_ptls_t ptls, jl_taggedvalue_t *o,
     if (mark_mode == GC_OLD_MARKED) {
         ptls->gc_cache.perm_scanned_bytes += page->osize;
         static_assert(sizeof(_Atomic(uint16_t)) == sizeof(page->nold), "");
-        page->nold++;
+        jl_atomic_fetch_add_relaxed((_Atomic(uint16_t)*)&page->nold, 1);
     }
     else {
         ptls->gc_cache.scanned_bytes += page->osize;
@@ -1377,27 +1381,20 @@ static jl_taggedvalue_t **gc_sweep_page(jl_gc_pool_t *p, jl_gc_pagemeta_t **allo
         nfree = (GC_PAGE_SZ - GC_PAGE_OFFSET) / osize;
         goto done;
     }
-    // note that `pg->nold` may not be accurate with multithreaded marking since
-    // two threads may race when trying to set the mark bit in `gc_try_setmark_tag`.
-    // We're basically losing a bit of precision in the sweep phase at the cost of
-    // making the mark phase considerably cheaper.
-    // See issue #50419
-    if (jl_n_markthreads == 0) {
-        // For quick sweep, we might be able to skip the page if the page doesn't
-        // have any young live cell before marking.
-        if (!sweep_full && !pg->has_young) {
-            assert(!prev_sweep_full || pg->prev_nold >= pg->nold);
-            if (!prev_sweep_full || pg->prev_nold == pg->nold) {
-                // the position of the freelist begin/end in this page
-                // is stored in its metadata
-                if (pg->fl_begin_offset != (uint16_t)-1) {
-                    *pfl = page_pfl_beg(pg);
-                    pfl = (jl_taggedvalue_t**)page_pfl_end(pg);
-                }
-                freedall = 0;
-                nfree = pg->nfree;
-                goto done;
+    // For quick sweep, we might be able to skip the page if the page doesn't
+    // have any young live cell before marking.
+    if (!sweep_full && !pg->has_young) {
+        assert(!prev_sweep_full || pg->prev_nold >= pg->nold);
+        if (!prev_sweep_full || pg->prev_nold == pg->nold) {
+            // the position of the freelist begin/end in this page
+            // is stored in its metadata
+            if (pg->fl_begin_offset != (uint16_t)-1) {
+                *pfl = page_pfl_beg(pg);
+                pfl = (jl_taggedvalue_t**)page_pfl_end(pg);
             }
+            freedall = 0;
+            nfree = pg->nfree;
+            goto done;
         }
     }
 

From 388c734310b5eb36b9bbb2822ab67af1bb9a332a Mon Sep 17 00:00:00 2001
From: "Steven G. Johnson" <stevenj@alum.mit.edu>
Date: Mon, 3 Jul 2023 14:27:12 -0400
Subject: [PATCH 27/41] add replace(io, str, patterns...) (#48625)

(cherry picked from commit ce1b420ff12454e3414c8f37dea7c00979224ba5)
---
 NEWS.md                 |  2 ++
 base/strings/util.jl    | 72 ++++++++++++++++++++++++++++++++---------
 doc/src/base/strings.md |  2 +-
 test/strings/util.jl    | 22 +++++++++++++
 4 files changed, 81 insertions(+), 17 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index e6ce618b3938d..81f744158d58e 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -67,6 +67,8 @@ New library features
 * A `CartesianIndex` is now treated as a "scalar" for broadcasting ([#47044]).
 * `printstyled` now supports italic output ([#45164]).
 * `parent` and `parentindices` support `SubString`s
+* `replace(string, pattern...)` now supports an optional `IO` argument to
+  write the output to a stream rather than returning a string ([#48625]).
 
 Standard library changes
 ------------------------
diff --git a/base/strings/util.jl b/base/strings/util.jl
index 7a42d7fecfc91..c818d723d688f 100644
--- a/base/strings/util.jl
+++ b/base/strings/util.jl
@@ -700,12 +700,11 @@ _free_pat_replacer(x) = nothing
 _pat_replacer(x::AbstractChar) = isequal(x)
 _pat_replacer(x::Union{Tuple{Vararg{AbstractChar}},AbstractVector{<:AbstractChar},Set{<:AbstractChar}}) = in(x)
 
-function replace(str::String, pat_repl::Vararg{Pair,N}; count::Integer=typemax(Int)) where N
-    count == 0 && return str
+# note: leave str untyped here to make it easier for packages like StringViews to hook in
+function _replace_init(str, pat_repl::NTuple{N, Pair}, count::Int) where N
     count < 0 && throw(DomainError(count, "`count` must be non-negative."))
-    n = 1
-    e1 = nextind(str, lastindex(str)) # sizeof(str)
-    i = a = firstindex(str)
+    e1 = nextind(str, lastindex(str)) # sizeof(str)+1
+    a = firstindex(str)
     patterns = map(p -> _pat_replacer(first(p)), pat_repl)
     replaces = map(last, pat_repl)
     rs = map(patterns) do p
@@ -716,11 +715,14 @@ function replace(str::String, pat_repl::Vararg{Pair,N}; count::Integer=typemax(I
         r isa Int && (r = r:r) # findnext / performance fix
         return r
     end
-    if all(>(e1), map(first, rs))
-        foreach(_free_pat_replacer, patterns)
-        return str
-    end
-    out = IOBuffer(sizehint=floor(Int, 1.2sizeof(str)))
+    return e1, patterns, replaces, rs, all(>(e1), map(first, rs))
+end
+
+# note: leave str untyped here to make it easier for packages like StringViews to hook in
+function _replace_finish(io::IO, str, count::Int,
+                         e1::Int, patterns::Tuple, replaces::Tuple, rs::Tuple)
+    n = 1
+    i = a = firstindex(str)
     while true
         p = argmin(map(first, rs)) # TODO: or argmin(rs), to pick the shortest first match ?
         r = rs[p]
@@ -728,9 +730,9 @@ function replace(str::String, pat_repl::Vararg{Pair,N}; count::Integer=typemax(I
         j > e1 && break
         if i == a || i <= k
             # copy out preserved portion
-            GC.@preserve str unsafe_write(out, pointer(str, i), UInt(j-i))
+            GC.@preserve str unsafe_write(io, pointer(str, i), UInt(j-i))
             # copy out replacement string
-            _replace(out, replaces[p], str, r, patterns[p])
+            _replace(io, replaces[p], str, r, patterns[p])
         end
         if k < j
             i = j
@@ -755,13 +757,39 @@ function replace(str::String, pat_repl::Vararg{Pair,N}; count::Integer=typemax(I
         n += 1
     end
     foreach(_free_pat_replacer, patterns)
-    write(out, SubString(str, i))
-    return String(take!(out))
+    write(io, SubString(str, i))
+    return io
+end
+
+# note: leave str untyped here to make it easier for packages like StringViews to hook in
+function _replace_(io::IO, str, pat_repl::NTuple{N, Pair}, count::Int) where N
+    if count == 0
+        write(io, str)
+        return io
+    end
+    e1, patterns, replaces, rs, notfound = _replace_init(str, pat_repl, count)
+    if notfound
+        foreach(_free_pat_replacer, patterns)
+        write(io, str)
+        return io
+    end
+    return _replace_finish(io, str, count, e1, patterns, replaces, rs)
 end
 
+# note: leave str untyped here to make it easier for packages like StringViews to hook in
+function _replace_(str, pat_repl::NTuple{N, Pair}, count::Int) where N
+    count == 0 && return str
+    e1, patterns, replaces, rs, notfound = _replace_init(str, pat_repl, count)
+    if notfound
+        foreach(_free_pat_replacer, patterns)
+        return str
+    end
+    out = IOBuffer(sizehint=floor(Int, 1.2sizeof(str)))
+    return String(take!(_replace_finish(out, str, count, e1, patterns, replaces, rs)))
+end
 
 """
-    replace(s::AbstractString, pat=>r, [pat2=>r2, ...]; [count::Integer])
+    replace([io::IO], s::AbstractString, pat=>r, [pat2=>r2, ...]; [count::Integer])
 
 Search for the given pattern `pat` in `s`, and replace each occurrence with `r`.
 If `count` is provided, replace at most `count` occurrences.
@@ -774,6 +802,11 @@ If `pat` is a regular expression and `r` is a [`SubstitutionString`](@ref), then
 references in `r` are replaced with the corresponding matched text.
 To remove instances of `pat` from `string`, set `r` to the empty `String` (`""`).
 
+The return value is a new string after the replacements.  If the `io::IO` argument
+is supplied, the transformed string is instead written to `io` (returning `io`).
+(For example, this can be used in conjunction with an [`IOBuffer`](@ref) to re-use
+a pre-allocated buffer array in-place.)
+
 Multiple patterns can be specified, and they will be applied left-to-right
 simultaneously, so only one pattern will be applied to any character, and the
 patterns will only be applied to the input text, not the replacements.
@@ -781,6 +814,9 @@ patterns will only be applied to the input text, not the replacements.
 !!! compat "Julia 1.7"
     Support for multiple patterns requires version 1.7.
 
+!!! compat "Julia 1.10"
+    The `io::IO` argument requires version 1.10.
+
 # Examples
 ```jldoctest
 julia> replace("Python is a programming language.", "Python" => "Julia")
@@ -799,8 +835,12 @@ julia> replace("abcabc", "a" => "b", "b" => "c", r".+" => "a")
 "bca"
 ```
 """
+replace(io::IO, s::AbstractString, pat_f::Pair...; count=typemax(Int)) =
+    _replace_(io, String(s), pat_f, Int(count))
+
 replace(s::AbstractString, pat_f::Pair...; count=typemax(Int)) =
-    replace(String(s), pat_f..., count=count)
+    _replace_(String(s), pat_f, Int(count))
+
 
 # TODO: allow transform as the first argument to replace?
 
diff --git a/doc/src/base/strings.md b/doc/src/base/strings.md
index 263c0019788c3..226e8aa92a989 100644
--- a/doc/src/base/strings.md
+++ b/doc/src/base/strings.md
@@ -51,7 +51,7 @@ Base.findlast(::AbstractChar, ::AbstractString)
 Base.findprev(::AbstractString, ::AbstractString, ::Integer)
 Base.occursin
 Base.reverse(::Union{String,SubString{String}})
-Base.replace(s::AbstractString, ::Pair...)
+Base.replace(::IO, s::AbstractString, ::Pair...)
 Base.eachsplit
 Base.split
 Base.rsplit
diff --git a/test/strings/util.jl b/test/strings/util.jl
index 5218310c5c1c7..8b58c2f36d8c4 100644
--- a/test/strings/util.jl
+++ b/test/strings/util.jl
@@ -333,6 +333,28 @@ end
     # Issue 36953
     @test replace("abc", "" => "_", count=1) == "_abc"
 
+    # tests for io::IO API (in addition to internals exercised above):
+    let buf = IOBuffer()
+        replace(buf, "aaa", 'a' => 'z', count=0)
+        replace(buf, "aaa", 'a' => 'z', count=1)
+        replace(buf, "bbb", 'a' => 'z')
+        replace(buf, "aaa", 'a' => 'z')
+        @test String(take!(buf)) == "aaazaabbbzzz"
+    end
+    let tempfile = tempname()
+        try
+            open(tempfile, "w") do f
+                replace(f, "aaa", 'a' => 'z', count=0)
+                replace(f, "aaa", 'a' => 'z', count=1)
+                replace(f, "bbb", 'a' => 'z')
+                replace(f, "aaa", 'a' => 'z')
+                print(f, "\n")
+            end
+            @test read(tempfile, String) == "aaazaabbbzzz\n"
+        finally
+            rm(tempfile, force=true)
+        end
+    end
 end
 
 @testset "replace many" begin

From 57690af9043955765ba5e24ce5ce786b4ed23071 Mon Sep 17 00:00:00 2001
From: "Steven G. Johnson" <stevenj@alum.mit.edu>
Date: Thu, 6 Jul 2023 03:58:09 -0400
Subject: [PATCH 28/41] avoid potential type-instability in _replace_(str, ...)
 (#50424)

(cherry picked from commit 0b54ded93b693189c8efe25ac0bc4efbce4e0a06)
---
 base/strings/util.jl | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/base/strings/util.jl b/base/strings/util.jl
index c818d723d688f..c77d45255a735 100644
--- a/base/strings/util.jl
+++ b/base/strings/util.jl
@@ -778,11 +778,11 @@ end
 
 # note: leave str untyped here to make it easier for packages like StringViews to hook in
 function _replace_(str, pat_repl::NTuple{N, Pair}, count::Int) where N
-    count == 0 && return str
+    count == 0 && return String(str)
     e1, patterns, replaces, rs, notfound = _replace_init(str, pat_repl, count)
     if notfound
         foreach(_free_pat_replacer, patterns)
-        return str
+        return String(str)
     end
     out = IOBuffer(sizehint=floor(Int, 1.2sizeof(str)))
     return String(take!(_replace_finish(out, str, count, e1, patterns, replaces, rs)))

From 4bcdfd768041b2938efbe0d714d05d222618ab13 Mon Sep 17 00:00:00 2001
From: Oscar Smith <oscardssmith@gmail.com>
Date: Wed, 12 Jul 2023 23:50:40 -0400
Subject: [PATCH 29/41] Merge pull request #50525 from
 oscardssmith/fix-generic_lu_fact-check=false

only check that values are finite in `generic_lufact`  when `check=true`

(cherry picked from commit 824cdf1231051189d9ee917fd48139670590c13f)
---
 stdlib/LinearAlgebra/src/lu.jl  | 2 +-
 stdlib/LinearAlgebra/test/lu.jl | 7 +++++++
 2 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/stdlib/LinearAlgebra/src/lu.jl b/stdlib/LinearAlgebra/src/lu.jl
index 5d69090f27e44..f45386fa7649c 100644
--- a/stdlib/LinearAlgebra/src/lu.jl
+++ b/stdlib/LinearAlgebra/src/lu.jl
@@ -133,7 +133,7 @@ lu!(A::AbstractMatrix, pivot::Union{RowMaximum,NoPivot,RowNonZero} = lupivottype
     generic_lufact!(A, pivot; check = check)
 function generic_lufact!(A::AbstractMatrix{T}, pivot::Union{RowMaximum,NoPivot,RowNonZero} = lupivottype(T);
                          check::Bool = true) where {T}
-    LAPACK.chkfinite(A)
+    check && LAPACK.chkfinite(A)
     # Extract values
     m, n = size(A)
     minmn = min(m,n)
diff --git a/stdlib/LinearAlgebra/test/lu.jl b/stdlib/LinearAlgebra/test/lu.jl
index aa73bee6ddc38..25a75e13233f0 100644
--- a/stdlib/LinearAlgebra/test/lu.jl
+++ b/stdlib/LinearAlgebra/test/lu.jl
@@ -464,4 +464,11 @@ end
     @test Matrix(F1) ≈ Matrix(F2) ≈ C
 end
 
+@testset "matrix with Nonfinite" begin
+    lu(fill(NaN, 2, 2), check=false)
+    lu(fill(Inf, 2, 2), check=false)
+    LinearAlgebra.generic_lufact!(fill(NaN, 2, 2), check=false)
+    LinearAlgebra.generic_lufact!(fill(Inf, 2, 2), check=false)
+end
+
 end # module TestLU

From 016edf2adbe6e4ca473efbbd639b4e771b77568e Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Wed, 19 Jul 2023 13:48:18 -0400
Subject: [PATCH 30/41] gf: make method overwrite/delete an error during
 precompile (#50578)

Previously, this was only a WARNING message, which was often missed
during CI runs.

Closes https://github.com/JuliaLang/julia/issues/50451

(cherry picked from commit de2c37a507657f0344377f80d8c6239cc86c60bd)
---
 src/gf.c | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/src/gf.c b/src/gf.c
index 00bc33b075255..935fd1e60db78 100644
--- a/src/gf.c
+++ b/src/gf.c
@@ -1568,8 +1568,8 @@ static void method_overwrite(jl_typemap_entry_t *newentry, jl_method_t *oldvalue
         jl_printf(s, ".\n");
         jl_uv_flush(s);
     }
-    if (jl_options.incremental && jl_generating_output())
-        jl_printf(JL_STDERR, "  ** incremental compilation may be fatally broken for this module **\n\n");
+    if (jl_generating_output())
+        jl_error("Method overwriting is not permitted during Module precompile.");
 }
 
 static void update_max_args(jl_methtable_t *mt, jl_value_t *type)
@@ -1860,6 +1860,8 @@ static jl_typemap_entry_t *do_typemap_search(jl_methtable_t *mt JL_PROPAGATES_RO
 
 static void jl_method_table_invalidate(jl_methtable_t *mt, jl_typemap_entry_t *methodentry, 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);
     method->deleted_world = methodentry->max_world = max_world;
@@ -1911,9 +1913,6 @@ 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)
 {
-    if (jl_options.incremental && jl_generating_output())
-        jl_printf(JL_STDERR, "WARNING: method deletion during Module precompile may lead to undefined behavior"
-                             "\n  ** incremental compilation may be fatally broken for this module **\n\n");
     jl_typemap_entry_t *methodentry = do_typemap_search(mt, method);
     JL_LOCK(&mt->writelock);
     // Narrow the world age on the method to make it uncallable

From a5d78d040fc6435bf273b4c7dddd278089c23743 Mon Sep 17 00:00:00 2001
From: Valentin Churavy <v.churavy@gmail.com>
Date: Wed, 12 Jul 2023 04:26:09 -0400
Subject: [PATCH 31/41] Fix visibility of assert on GCC12/13

(cherry picked from commit 28720ff2509cf4566c5f8e103be2615a3d37a380)
---
 src/julia_assert.h | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/julia_assert.h b/src/julia_assert.h
index 4b120fd9e845b..13cbdbcd36f5b 100644
--- a/src/julia_assert.h
+++ b/src/julia_assert.h
@@ -10,6 +10,7 @@
 // Files that need `assert` should include this file after all other includes.
 // All files should also check `JL_NDEBUG` instead of `NDEBUG`.
 
+#pragma GCC visibility push(default)
 #ifdef NDEBUG
 #  ifndef JL_NDEBUG
 #    undef NDEBUG
@@ -28,3 +29,4 @@
 #    include <assert.h>
 #  endif
 #endif
+#pragma GCC visibility pop

From a2fda258b0ed82535f1969f9b0c8407ccafc806d Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Wed, 19 Jul 2023 15:36:59 -0400
Subject: [PATCH 32/41] Fix memory corruption if task is launched inside
 finalizer (#50597)

In #48919, the tid selection logic inside `enq_task` gained a
`!GC.in_finalizer()` condition. However, this made it possible for
`workqueue_at` to be reached with `tid==0`, which would attempt and
out-of-bounds write under `@inbounds`, corrupting memory. This was not
caught in the test suite despite `--check-bounds=yes`, because our
`--check-bounds=yes` is currently best effort. That would be fixed by
#50239, which exposed this bug. This PR attempts to
fix this by marking any tasks launched inside a finalizer as not sticky.
Finalizers don't have any thread they run on
semantically, so i don't think there's a meaningful sense in which tasks
launched inside finalizers could be sticky.

(cherry picked from commit bd8350b3475b0a7c6feace151ebe2752820efa8a)
---
 base/task.jl | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/base/task.jl b/base/task.jl
index f7a82b9c42ab9..5a1b37d4252a8 100644
--- a/base/task.jl
+++ b/base/task.jl
@@ -774,17 +774,25 @@ function enq_work(t::Task)
     # Sticky tasks go into their thread's work queue.
     if t.sticky
         tid = Threads.threadid(t)
-        if tid == 0 && !GC.in_finalizer()
+        if tid == 0
             # The task is not yet stuck to a thread. Stick it to the current
             # thread and do the same to the parent task (the current task) so
             # that the tasks are correctly co-scheduled (issue #41324).
             # XXX: Ideally we would be able to unset this.
-            tid = Threads.threadid()
-            ccall(:jl_set_task_tid, Cint, (Any, Cint), t, tid-1)
-            current_task().sticky = true
+            if GC.in_finalizer()
+                # The task was launched in a finalizer. There is no thread to sticky it
+                # to, so just allow it to run anywhere as if it had been non-sticky.
+                t.sticky = false
+                @goto not_sticky
+            else
+                tid = Threads.threadid()
+                ccall(:jl_set_task_tid, Cint, (Any, Cint), t, tid-1)
+                current_task().sticky = true
+            end
         end
         push!(workqueue_for(tid), t)
     else
+        @label not_sticky
         tp = Threads.threadpool(t)
         if Threads.threadpoolsize(tp) == 1
             # There's only one thread in the task's assigned thread pool;

From a4ba96974fc956f99d9653a2fd752a972faea9ee Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Tue, 18 Jul 2023 19:29:48 +0000
Subject: [PATCH 33/41] build: fix various makefile bugs

Trying for cross-compile and disabling CSL and realized both of those
configurations were broken now.

(cherry picked from commit 9dc13806c28426a0fb32c99ce56451c537b98378)
---
 Make.inc           | 6 +++---
 deps/csl.mk        | 8 ++++----
 deps/sanitizers.mk | 4 ++--
 3 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/Make.inc b/Make.inc
index 96064cb7eac15..04650e68b643e 100644
--- a/Make.inc
+++ b/Make.inc
@@ -603,15 +603,15 @@ endif
 
 ifeq ($(OS),WINNT)
 define versioned_libname
-$$(if $(2),$(1)-$(2).$(SHLIB_EXT),$(1).$(SHLIB_EXT))
+$(if $(2),$(1)-$(2).$(SHLIB_EXT),$(1).$(SHLIB_EXT))
 endef
 else ifeq ($(OS),Darwin)
 define versioned_libname
-$$(if $(2),$(1).$(2).$(SHLIB_EXT),$(1).$(SHLIB_EXT))
+$(if $(2),$(1).$(2).$(SHLIB_EXT),$(1).$(SHLIB_EXT))
 endef
 else
 define versioned_libname
-$$(if $(2),$(1).$(SHLIB_EXT).$(2),$(1).$(SHLIB_EXT))
+$(if $(2),$(1).$(SHLIB_EXT).$(2),$(1).$(SHLIB_EXT))
 endef
 endif
 
diff --git a/deps/csl.mk b/deps/csl.mk
index 457e276c66709..37956ba5c3505 100644
--- a/deps/csl.mk
+++ b/deps/csl.mk
@@ -32,8 +32,8 @@ ifeq ($(USE_SYSTEM_CSL),1)
 USE_BINARYBUILDER_CSL ?= 0
 else
 # If it's not, see if we should disable it due to `libstdc++` being newer:
-LIBSTDCXX_PATH := $(eval $(call pathsearch,libstdc++,$(STD_LIB_PATH)))
-ifneq (,$(and $(LIBSTDCXX_PATH),$(shell objdump -p $(LIBSTDCXX_PATH) | grep $(CSL_NEXT_GLIBCXX_VERSION))))
+LIBSTDCXX_PATH := $(call pathsearch,$(call versioned_libname,libstdc++,6),$(STD_LIB_PATH))
+ifneq (,$(and $(LIBSTDCXX_PATH),$(shell objdump -p '$(LIBSTDCXX_PATH)' | grep '$(CSL_NEXT_GLIBCXX_VERSION)')))
 # Found `libstdc++`, grepped it for strings and found a `GLIBCXX` symbol
 # that is newer that whatever we have in CSL.  Default to not using BB.
 USE_BINARYBUILDER_CSL ?= 0
@@ -50,8 +50,8 @@ ifeq ($(USE_BINARYBUILDER_CSL),0)
 define copy_csl
 install-csl: | $$(build_shlibdir) $$(build_shlibdir)/$(1)
 $$(build_shlibdir)/$(1): | $$(build_shlibdir)
-	-@SRC_LIB=$$(call pathsearch,$(1),$$(STD_LIB_PATH)); \
-	[ -n "$$$${SRC_LIB}" ] && cp $$$${SRC_LIB} $$(build_shlibdir)
+	-@SRC_LIB='$$(call pathsearch,$(1),$$(STD_LIB_PATH))'; \
+	[ -n "$$$${SRC_LIB}" ] && cp "$$$${SRC_LIB}" '$$(build_shlibdir)'
 endef
 
 # libgfortran has multiple names; we're just going to copy any version we can find
diff --git a/deps/sanitizers.mk b/deps/sanitizers.mk
index 81db75a4ee63e..1a272321c05fa 100644
--- a/deps/sanitizers.mk
+++ b/deps/sanitizers.mk
@@ -6,12 +6,12 @@ SANITIZER_LIB_PATH := $(dir $(shell LANG=C $(CC) -print-file-name=libasan.so))
 endif
 
 # Given a colon-separated list of paths in $(2), find the location of the library given in $(1)
-define pathsearch
+define pathsearch_all
 $(wildcard $(addsuffix /$(1),$(subst :, ,$(2))))
 endef
 
 define copy_sanitizer_lib
-install-sanitizers: $$(addprefix $$(build_libdir)/, $$(notdir $$(call pathsearch,$(1),$$(SANITIZER_LIB_PATH)))) | $$(build_shlibdir)
+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 $$< $$@
 endef

From 85301f922398f574156904fa15a69cac1ceb5580 Mon Sep 17 00:00:00 2001
From: Diogo Netto <61364108+d-netto@users.noreply.github.com>
Date: Fri, 21 Jul 2023 21:55:32 -0300
Subject: [PATCH 34/41] gc: faster invalid object lookup in conservative GC
 (#50599)

Optimizes invalid object lookup in conservative GC by just looking at the
page metadata and GC bits.

(cherry picked from commit c82656dac05c5802b6a10dce4227246f280bf055)
---
 src/gc.c | 15 ++++-----------
 1 file changed, 4 insertions(+), 11 deletions(-)

diff --git a/src/gc.c b/src/gc.c
index 732684db332ed..0be48081d5687 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -4067,18 +4067,11 @@ JL_DLLEXPORT jl_value_t *jl_gc_internal_obj_base_ptr(void *p)
         // before the freelist pointer was either live during the last
         // sweep or has been allocated since.
         if (gc_page_data(cell) == gc_page_data(pool->freelist)
-            && (char *)cell < (char *)pool->freelist) {
+            && (char *)cell < (char *)pool->freelist)
             goto valid_object;
-        }
-        else {
-            jl_taggedvalue_t *v = pool->freelist;
-            while (v != NULL) {
-                if (v == cell) {
-                    return NULL;
-                }
-                v = v->next;
-            }
-        }
+        // already skipped marked or old objects above, so here
+        // the age bits are 0, thus the object is on the freelist
+        return NULL;
         // Not a freelist entry, therefore a valid object.
     valid_object:
         // We have to treat objects with type `jl_buff_tag` differently,

From 77c8fdc345f5e08b9df60f7a81f25a045b143948 Mon Sep 17 00:00:00 2001
From: DilumAluthgeBot <43731525+DilumAluthgeBot@users.noreply.github.com>
Date: Sat, 22 Jul 2023 11:53:24 -0400
Subject: [PATCH 35/41] =?UTF-8?q?=F0=9F=A4=96=20[master]=20Bump=20the=20Sp?=
 =?UTF-8?q?arseArrays=20stdlib=20from=20b4b0e72=20to=2099c99b4=20(#50634)?=
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: b4b0e72
New commit: 99c99b4
Julia version: 1.11.0-DEV
SparseArrays version: 1.10.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/b4b0e721ada6e8cf5f6391aff4db307be69b0401...99c99b4521eb19a7973643d1aa4d7b1e4d50a6db

```
$ git log --oneline b4b0e72..99c99b4
99c99b4 Specialize 3-arg `dot` for sparse self-adjoint matrices (#398)
cb10c1e use unwrapping mechanism for triangular matrices (#396)
b3872c8 added warning for iterating while mutating a sparse matrix (#415)
f8f0f40 bring coverage of fixed SparseMatrixCSC to 100% (#392)
0eb9c04 fix typos (#414)
```

Co-authored-by: Dilum Aluthge <dilum@aluthge.com>
(cherry picked from commit 6691a755c3a5a9941c16df03142fed98f81eb1af)
---
 .../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-99c99b4521eb19a7973643d1aa4d7b1e4d50a6db.tar.gz/md5
 create mode 100644 deps/checksums/SparseArrays-99c99b4521eb19a7973643d1aa4d7b1e4d50a6db.tar.gz/sha512
 delete mode 100644 deps/checksums/SparseArrays-b4b0e721ada6e8cf5f6391aff4db307be69b0401.tar.gz/md5
 delete mode 100644 deps/checksums/SparseArrays-b4b0e721ada6e8cf5f6391aff4db307be69b0401.tar.gz/sha512

diff --git a/deps/checksums/SparseArrays-99c99b4521eb19a7973643d1aa4d7b1e4d50a6db.tar.gz/md5 b/deps/checksums/SparseArrays-99c99b4521eb19a7973643d1aa4d7b1e4d50a6db.tar.gz/md5
new file mode 100644
index 0000000000000..6509fe3ef2766
--- /dev/null
+++ b/deps/checksums/SparseArrays-99c99b4521eb19a7973643d1aa4d7b1e4d50a6db.tar.gz/md5
@@ -0,0 +1 @@
+b2ddca51d8d39c2869555229575451f2
diff --git a/deps/checksums/SparseArrays-99c99b4521eb19a7973643d1aa4d7b1e4d50a6db.tar.gz/sha512 b/deps/checksums/SparseArrays-99c99b4521eb19a7973643d1aa4d7b1e4d50a6db.tar.gz/sha512
new file mode 100644
index 0000000000000..2855286b87ab3
--- /dev/null
+++ b/deps/checksums/SparseArrays-99c99b4521eb19a7973643d1aa4d7b1e4d50a6db.tar.gz/sha512
@@ -0,0 +1 @@
+cff167088056690a7c7453326bc1ad0ca0fcff9ffda85ebfd943ebad9684fc8134b0cda18dd70d8550de35493c6d9579b2fb51090b1c9718fa4290008c6d5f3f
diff --git a/deps/checksums/SparseArrays-b4b0e721ada6e8cf5f6391aff4db307be69b0401.tar.gz/md5 b/deps/checksums/SparseArrays-b4b0e721ada6e8cf5f6391aff4db307be69b0401.tar.gz/md5
deleted file mode 100644
index 55bc533861fc0..0000000000000
--- a/deps/checksums/SparseArrays-b4b0e721ada6e8cf5f6391aff4db307be69b0401.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-e59c1c57b97e17a73eba758d65022bd7
diff --git a/deps/checksums/SparseArrays-b4b0e721ada6e8cf5f6391aff4db307be69b0401.tar.gz/sha512 b/deps/checksums/SparseArrays-b4b0e721ada6e8cf5f6391aff4db307be69b0401.tar.gz/sha512
deleted file mode 100644
index 2213bfe87ccfc..0000000000000
--- a/deps/checksums/SparseArrays-b4b0e721ada6e8cf5f6391aff4db307be69b0401.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-ad88ebe77aaf1580e6d7ee7649ac5b812a23b9d9bf947f26babe9dd79902f6da11aa69bf63f22f67f6eae92a4c6e665cc3b950bb7c648c623e9cb4b9cb4daac4
diff --git a/stdlib/SparseArrays.version b/stdlib/SparseArrays.version
index 4290a1d2fc4ca..295400bbd3b57 100644
--- a/stdlib/SparseArrays.version
+++ b/stdlib/SparseArrays.version
@@ -1,4 +1,4 @@
 SPARSEARRAYS_BRANCH = main
-SPARSEARRAYS_SHA1 = b4b0e721ada6e8cf5f6391aff4db307be69b0401
+SPARSEARRAYS_SHA1 = 99c99b4521eb19a7973643d1aa4d7b1e4d50a6db
 SPARSEARRAYS_GIT_URL := https://github.com/JuliaSparse/SparseArrays.jl.git
 SPARSEARRAYS_TAR_URL = https://api.github.com/repos/JuliaSparse/SparseArrays.jl/tarball/$1

From b21a343ce600112c2bcbc8210110b4cf69416dce Mon Sep 17 00:00:00 2001
From: Tim Besard <tim.besard@gmail.com>
Date: Sun, 23 Jul 2023 10:28:29 -0400
Subject: [PATCH 36/41] Backport LLVM patches to fix various issues. (#50639)

-
https://github.com/llvm/llvm-project/commit/af39acda8873cc75db116e326588447f018a99d9
closing https://github.com/JuliaLang/julia/issues/50448
- https://reviews.llvm.org/D139078 closing
https://github.com/JuliaLang/julia/issues/49907

(cherry picked from commit 092231cd50d673057e112feb6f5f859afaf23035)
---
 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 +-
 test/fastmath.jl                |   5 +
 10 files changed, 449 insertions(+), 444 deletions(-)

diff --git a/deps/checksums/clang b/deps/checksums/clang
index c16dd849e6fc5..0096189e2e278 100644
--- a/deps/checksums/clang
+++ b/deps/checksums/clang
@@ -1,108 +1,108 @@
-Clang.v15.0.7+5.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/5dce383804bd3d404b8a1936c12ba457
-Clang.v15.0.7+5.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/5661a1cb2044ded03566c9316978595d692667fbc4e951feca658f9986a8557196557b05ccddf1b00b818aac0893696c3bbbf63a35dc9ed7df146b4488529f6a
-Clang.v15.0.7+5.aarch64-apple-darwin-llvm_version+15.tar.gz/md5/549cbc6fa28ebee446e99701aded16e8
-Clang.v15.0.7+5.aarch64-apple-darwin-llvm_version+15.tar.gz/sha512/55eea0b514aa2e43ad2f373ad25ea4fad5219ff1cd8d5b639914c218a0a454ae9b27b8d022ae73771d8ec89fa329f5bfde538817653cc59e569b600148d56842
-Clang.v15.0.7+5.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/ac3cd40e47702f306bc42d6be5826029
-Clang.v15.0.7+5.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/73b217caa53702bc6fbbb3286241b7a20c111358cb9436283e9f7f9fec90436d5b54cb4c332afb7e447867a40ba46c9e3b93464acefbca7c0bb6191001525cbf
-Clang.v15.0.7+5.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/b1a656501493c15b98442bde584a34d7
-Clang.v15.0.7+5.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/f424254cc887301d4d5b04fa71e2c7da6e4d561725d5b06278925e05be1c62a74769f19c37b431c2e2d73e7e5129acff07ac54a0b7fd381821aece27f260c116
-Clang.v15.0.7+5.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/969170b1a791e89a0094154f34023e86
-Clang.v15.0.7+5.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/d6ae356c9b1b80cbc5cea4eb8632b77ab3ce0d060b103cec4a5f1c73feaaf60688c2253034b2a6e132273fe04c803de93f415cbe2ef40cf1d6f6a30dcfa03af3
-Clang.v15.0.7+5.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/22d599b774af41dcaa54481cc6325b1c
-Clang.v15.0.7+5.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/b0f257d45f1a920f46b18049b762b5a3cefdf8683c4dce46f48ce2993e6a622dbdfaaa6cc9a9cda8a7f047094a6f804091d1ba6c83e26cefc38fbd1ca5c0a536
-Clang.v15.0.7+5.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/f2f5064217c14700f0f933b704fff233
-Clang.v15.0.7+5.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/2284978d8cfe22aa49b1f3b161c75cb0c9d43f84674ba58a1335edf818b91c6ea1684a9c3580f2e1918fdc050a624c698a4e87dc163e9076b9d6c0023c989d7a
-Clang.v15.0.7+5.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/eafd72ec24ec81d42cb044e4e4d638dc
-Clang.v15.0.7+5.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/bbfc6c9179fc43a1db0ad82fc8c1fcc8ec8ce94d5c32b38cd1f88490dedc67953283995c0dd4db7262a9206431135cf2671c6ecc6580da65ba8ff4ec0323ab64
-Clang.v15.0.7+5.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/0432eb21283647995e35bd0d486148ab
-Clang.v15.0.7+5.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/561beaf45770c06b35bc1626e93a0cd89874026a8afa22017b40eb1e6ba306b05305619d42a4a2145c576b1dcc77ade80cd0bf0e0237761f3517f4db402f9b74
-Clang.v15.0.7+5.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/653b9b87f2573818d66992f969f7811e
-Clang.v15.0.7+5.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/517df570b40b51a4f4cbcecbdaacdf0b592fce66ec328139d95eaf8b63c89a1adb41a9cfe4982f5bc032fb29a6b967dc1b16b0eced98cd78756ced36ff2257d8
-Clang.v15.0.7+5.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/4b1a5cf46925575bbc6765f3336e1cc8
-Clang.v15.0.7+5.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/7afb23aa5ce823b1f2371e038faf311e8e21c3843cc50a0b1473038cd746fcdc77dede67130631bfaee778c3d42ac1eaa23ec664a82f43e2ad406962f3019479
-Clang.v15.0.7+5.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/5a6200aef0e6660bb156ecf3e53cc3c8
-Clang.v15.0.7+5.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/0dc564fe753fbccfa03ac94e19828ea5ba2b8b74e7adbe7f501ac8b11d1ed8fd85a65572dcdf957018bfa1be3a6babadb1ec3937966347fe49fb38596a4b1728
-Clang.v15.0.7+5.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/ad693e5cf8f2583c3311a39c095b0bf8
-Clang.v15.0.7+5.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/b4e1120c960bd69f2643f185607bb2139095fa7a2f943fffec65ccad9422f2bd801131185cbeea1b75298c64cbf109fe28bae54c1b9917fe1ce8b2248d623668
-Clang.v15.0.7+5.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/c04cd594e25324c42d97739d72e772e1
-Clang.v15.0.7+5.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/5aeeedbc3f0f8327f7760abe3eb6fda368353a7b429e31ff47a7bf42d612d070cc86f0e97031ca0c2fa9f9f448757d59b2652d89bb05b27fd380f2116a5beb6b
-Clang.v15.0.7+5.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/d706ad9062539a37df1e5cedc084086a
-Clang.v15.0.7+5.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/4862bbe0c71fe0e8cfddade0f881637ae5f58263208e1154f2284884ddf4ad43d76d98bde57904829f2218db21e4fb6ac038e231b682455fa22deeabe65f1336
-Clang.v15.0.7+5.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/6cc35754a4378902f9f126139bf299a5
-Clang.v15.0.7+5.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/4256e9c3f58dfc896d56eeccd7495601ec585e208857de14f91e2d95295a4d03009149f49254be40b27affd5a2250323c6d0744e1ddfbd5fb924fdedc8a993d6
-Clang.v15.0.7+5.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/128bb901686224fb6d32c9689c03cc21
-Clang.v15.0.7+5.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/b7048ff3d8a3b3e3cddc49b2cd9fbda8ad308fe10e932e8d90000e76c12059547342a1132149254628077d0efc36b34479688b3e9f32e7364301e85a18304cf8
-Clang.v15.0.7+5.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/d860412ac46bdeef203a578f0bfc5b05
-Clang.v15.0.7+5.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/497fa51af138b3c645d5017165aea6d33410262d2ce69e322b259b34fbdcf52a131541dbac66fae8b9a9027b70771199f9a76869721bf18760065ca7cb3b5364
-Clang.v15.0.7+5.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/6fb13f1cc2aec210298c3045f8a7fd94
-Clang.v15.0.7+5.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/085c94f43fb46ecc8cadfed5c5d91978c9ddb9d647eea6e82ff0a548eec53dbddc77721faaa8c43ab5b0674f83fef7aa3b34ba0dc273feabdbb8cb95bf5534ee
-Clang.v15.0.7+5.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/63d765b268e792df2aa92f3689de23de
-Clang.v15.0.7+5.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/32b2397bb4b627f0ad9b00838e30c965feca902e417117d0884244a2be6a50e0d4d40e55a27a87616e33819967455f90ae0a4319c2eefefd49b82e9041835444
-Clang.v15.0.7+5.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/c00e93211a1e470f1b00a53e776a9e3c
-Clang.v15.0.7+5.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/6621b3ab12302657ef2441482e8bc6335535964fda472ab8378221e4a9cc0813968589f457e1af66141821cdedbf8eff3080c20105eec810742e5539fc329fcf
-Clang.v15.0.7+5.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/254fdeddad203954ec0531875cecec8c
-Clang.v15.0.7+5.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/84a19469231a9204a553abc58073e423173ff828445634501a61837c0e249ed003f9051fcf1da4eb16201f80d755e7bb4b7513536c749eb1e7ea78c7ded59945
-Clang.v15.0.7+5.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/0475a3e401b59e1a34dcbd9d9b980823
-Clang.v15.0.7+5.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/e0c9e1e18cc4f7106effaeb04e0e6f41fe8ad872d67d3d0da928ce36d1bce6be3d5231d149b2d404b3a4b99900b50d280ac6f7dd8965d30c4dcd3913590144a6
-Clang.v15.0.7+5.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/08c9e802640582af0b79bc04702c9771
-Clang.v15.0.7+5.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/d4f413bbb5d5c3ae01cea2b87ef4e46816023fcf4373f00fca13f2edc6278eac651718feea3f8c7d04d3ef82360417dd93b6c7163d54ecd79a3811a0ed588054
-Clang.v15.0.7+5.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/e7c253db924ea5cb5098be57029e009f
-Clang.v15.0.7+5.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/373884c492e5862aaff27f5782ba44e202e581e4faeb2cffe14bd696a590c0bc72459fccf3342aadbf189282af0c43efe3db113caa47c27c3ea556f0b3313e7e
-Clang.v15.0.7+5.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/9c1867e316ac258d9199b389ea053d2d
-Clang.v15.0.7+5.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/9537f285d2a06b8c86ff21aab9daad1ba7e71bcfac55d780c693da8cc250707011ee22ed021e387422543b1e2abbc34de1a7fe49175a27a9c11e43b00549f1be
-Clang.v15.0.7+5.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/f9a13a80efacf45f49d6d7591d2cc3ea
-Clang.v15.0.7+5.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/c7edc55c4f76ae086080ba639d83793738884b9385618c52b30f5c3fadb0ed2a31bbe95ab80c5eee8504ec6301d73fc7318a8c0f877ba8b5f51170de51179d9a
-Clang.v15.0.7+5.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/c9911680ea55b36c4b9f59cfda2a8e33
-Clang.v15.0.7+5.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/9c3722bd402627a4f51b4c98c8712a85031aa79380fe38be0db9df13a5cfabe428fcc7d5d5cf804ac4387d738cad1796bb3f341ebdcf4726ea7f699c6de586e9
-Clang.v15.0.7+5.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/db82d62c163f69038364189a60b18d09
-Clang.v15.0.7+5.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/5dc415426bd99dc2d7b5fc4fe3f2bb1aabc8961fc2b03a2bc14562f330b273c4d1942d7ea5f05b38c76ee753b440cc4f92015a25f9de7980aa3b1d52f7d0f2bb
-Clang.v15.0.7+5.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/67b7194b31f68db8ffcf5ec250948740
-Clang.v15.0.7+5.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/a032c2ae911b6318ab23950ac74dc95f2c8bf815196be62e410b20cd2e271c4154f916388d119ca91c77e07853ba2c56bd5e75a4ce6742d2a7bbd9d3e61853ea
-Clang.v15.0.7+5.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/50b4fa021c1c9b6bdb29eae63ea22103
-Clang.v15.0.7+5.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/40b377df590521e5291c3f2f9daa8d60863c03253b07d0e537288324819a909ab3466b710b10b1a92ccd6f3566702c515d808f03e6d9fe9d01617b9a836bb63f
-Clang.v15.0.7+5.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/d2da27ebc23793c107cb03e176f02d6e
-Clang.v15.0.7+5.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/3ed297cfd3c1ec03cbff10d7b54f9f4a374a9cf8c699287f179ebd5fa000dd525fdbed3c31b59a8ae32ef1c56115c3a84640d776f01c8a92bfae979c332043f5
-Clang.v15.0.7+5.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/aefacc80a5f704aa7498b35dfc2441e6
-Clang.v15.0.7+5.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/76c7fd64fc4323ca442fb0aa30b236355b26328f897ea8cf3e3be029246574d150a9790ae1c45b289e4fc3050fdacc20b6d57b588a707f6d0750e6da91815edf
-Clang.v15.0.7+5.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/59048d333a8a261d079673828c174d96
-Clang.v15.0.7+5.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/bcd0c3c5e04cea24383fc2472f6190e48f8738fb7fa625ad700d1997f8aa81c9b6909af0fc38a2287b80756fbfd01300f3388c19c8df791d78ed913d8d59dee1
-Clang.v15.0.7+5.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/bb4007dc5b0c0d545f457bdf35e868ee
-Clang.v15.0.7+5.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/2f686bdd0bbcc62aaf9e20d3804c83291ad7c41a0a174516d7a83dee7f969f7d50f19f70c0f35901a3eaa8d54fe83204d832a901586feb9eb8e141631c411b3b
-Clang.v15.0.7+5.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/08f088ab3498a4f7645393f43098583d
-Clang.v15.0.7+5.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/faf62bba3a282f218ea569d3064d6c0cefde9232d055fc3a08c994fe424f2b60dd9bbf1655f6ca101da701e3d05bd813695d6a66628ec2b6b4d11b89f773f0e4
-Clang.v15.0.7+5.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/bb8f05da1e35ab358a96265f68b37f57
-Clang.v15.0.7+5.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/30e3789ccca1fdc5eecaeb25345c30bc4f752cd41b8725c5279654d9b3f500d6e8693c6d1dda8b3167fcce15443682994d66922a17986419eb48bb09970f02e0
-Clang.v15.0.7+5.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/ea9fdfb7c8d1a9c973ea953d4e057f0d
-Clang.v15.0.7+5.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/5e5d9298a12e65a7e4d401a0e404eb172c96e70fa906096f549e7eda5dbfb294189e4f3526246f28f71ba3bcf35d1bf790f05522150c5877bf8f186d8c503795
-Clang.v15.0.7+5.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/053334d0c5aabaccc81f22c1a371c9a6
-Clang.v15.0.7+5.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/aa8daa99a4b52985d80e57d175b6fc4489058ed84f06fb2fd67710a873d5333ee77b64ed0620df099ed5617792fb3eab23d9cedf3ab3c79f4eb6f04ad1fd9588
-Clang.v15.0.7+5.x86_64-apple-darwin-llvm_version+15.tar.gz/md5/b80918f03dcdfc5b5f1e8afa90dd4e88
-Clang.v15.0.7+5.x86_64-apple-darwin-llvm_version+15.tar.gz/sha512/c0397541e06878535b41ba7479b603699d78f1ea3345d9a1146a0e7d17f42078e8365dc71a117981b2d2b25f35a40aeb707ff9ee8a2145303f3cb6567e82bd54
-Clang.v15.0.7+5.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/78b9e190d5cb7e6fb172814eda2996f7
-Clang.v15.0.7+5.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/2c9a764ba2427faa8e67285205dd1b8c211665046c9a4a19aea02de46d02a6d4287467bacd1260b7996b2b85d3e571e750d92f02c21b180abe37709ee9da78c1
-Clang.v15.0.7+5.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/ba6dcd205dbd7c0301855f2a892c6467
-Clang.v15.0.7+5.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/9a98c10943a8abfbe92b151f184370d21a10ce72afb22f131bd0522672c65875868357f60650122e1a2cc91254adceaf8044de4533aea08c4df400ded8c01669
-Clang.v15.0.7+5.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/ce62f8e67b89c612eea35f4ba0e09d45
-Clang.v15.0.7+5.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/9c3afaf0dd338abed0631b81d5f6c197b5dff6aae637996f5bc2f85f2f7dbf64a7a4bdc07dee9ab72abada5be576bb0466550280a9ee9093946a469a2b6af648
-Clang.v15.0.7+5.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/543ebeb138123ce190e74cf0ad17d43f
-Clang.v15.0.7+5.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/aff131b5d0ed372557e3195e15701543ec32db05d5fc18117c4aee789a5cb967706d28b2dc53588bc7566f3a4498fd9e2293518ff28387466464ee07c10e9fff
-Clang.v15.0.7+5.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/58617f16466bcb1b56b204dde697cd89
-Clang.v15.0.7+5.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/bdc0c52168beabc0552ee941246b1d4506fec50913030965b374f4cedd67d6fd2b5746f04505aa5bbd4e6d61c5f684dd22c3b207e364578fd8538aef8efe0b14
-Clang.v15.0.7+5.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/aa6f0d9a455f5f0109433b9cfaa8f009
-Clang.v15.0.7+5.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/b267bd6291fc5830ffee075af00fed9a37177141b0cdcaa8ffd602e6a8bfc58e191408c3a6a12c0fb3ea7a5d825adf1ef99122399e8246e0312b4cd056d49a2f
-Clang.v15.0.7+5.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/ee2d7c4dc5c95e46c6d46c4fff112e9a
-Clang.v15.0.7+5.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/cd11acb2dccd2ac45a53fc48ee6a58299b5e54e80a5b9747c680e9b068381bf87cd388ee75cb0a51ccb1162ee8af03acd4c3f730a5f5a3ed5f443dd24ee91cde
-Clang.v15.0.7+5.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/a5c16a8832f5c28346912f610932ecb4
-Clang.v15.0.7+5.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/91b244ccd569597fe42ec45e5a62f6de0ab2c4da048b8b3ed191bbdde0a8ba5a710054d9f40c31a405a6c494a25c7546748870d1170d76e2d3b22dbb0c618e87
-Clang.v15.0.7+5.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/md5/2d789f91744aebb0deed9b91202c1abf
-Clang.v15.0.7+5.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/sha512/fb991942325fcbfa1ad4903db43e81fcfeda5d007ee664d96a0e0d2ee5f04b5767d6ad5d37e0273f5af626efbf1c6fde84d54536b74cb17433d29b6772bcf7bc
-Clang.v15.0.7+5.x86_64-unknown-freebsd-llvm_version+15.tar.gz/md5/ab8fae829b5822e9123fc3d763d327e1
-Clang.v15.0.7+5.x86_64-unknown-freebsd-llvm_version+15.tar.gz/sha512/1b24b03f6a81fba7400bdaa57899e9cdffd6da7e476832870460a12ab6188662c15a3cadd80ccd7dc0790834aa76ba0df098b400c87fd067eaa9f9fec0b053be
-Clang.v15.0.7+5.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/d5638f87a6ac840d571a3973e89316cf
-Clang.v15.0.7+5.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/0f07e9e8dd75691ee73ab0e78a29047596a543c5886a137a7503c916ee6792cf7d6a7f279dbd864a2ad36d36aac422555d408381e3781ec004bcde5525abeb68
-Clang.v15.0.7+5.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/e777625c3c7efe2dcb029e74ac7d1ba7
-Clang.v15.0.7+5.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/25e0a48a4d8a2ad7f5f5adb7c30429655ff496e6b5a224fc5707f092233239d4c3f4cc17432de12815e546bb595caf2a70b18ff208a53b9f0236accbd83acda3
-Clang.v15.0.7+5.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/22e03dc887f6e425f98cd66e0859ab2f
-Clang.v15.0.7+5.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/ef20886b841ba8b749ffb0c5780a9dc25d5f563ef726b1026ee77607e0572c45b8eb3470e252f882e2c4c23a2159d88ee83d31aae5081c6e4f4c37a61a7875c1
-Clang.v15.0.7+5.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/5d8f1390ff66b6b357768b1994a43d1c
-Clang.v15.0.7+5.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/5fd2fc0cf888d95c38531d236564109b284f20faed222d1feeab2beae68662073c9c59baee310e2bd67908f267416cded7b75f73e28969e2a16d2fcea0b03854
+Clang.v15.0.7+7.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/3994ef8cee2fe488709909f5fffdc091
+Clang.v15.0.7+7.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/0713994930b87768dbddeaf5ce5143380e83bfdf3e0e10aa1ba0337fa0ccfc3c84fa05786cccc2b2461d0bf3bf7dee45e18b4f7146c62ae624705f4d3e43df1e
+Clang.v15.0.7+7.aarch64-apple-darwin-llvm_version+15.tar.gz/md5/dd097ca34e16abfcee18ec6b955f0d3b
+Clang.v15.0.7+7.aarch64-apple-darwin-llvm_version+15.tar.gz/sha512/446f31dbca35a307faec0a779737129c7878ce8c879637265120114f4c68365a6593e1f692c76ff160f5b264a0bb0e9b9f157315ee138ddebdcda1e6e9d3c030
+Clang.v15.0.7+7.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/96a5a51c74d4d74ce9a5f7701f7da325
+Clang.v15.0.7+7.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/d27e8931b89aaea97bf10a7bb9d9608a14537e352bbfdb496f0ef9537599f47ce11e519f77912a6befe96189a26c423a8359b1543b39558ec9648a82196c9057
+Clang.v15.0.7+7.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/2bf9499f0016a6d3f192e9b982587fdc
+Clang.v15.0.7+7.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/956cc2c49b49a0d56575c8192e8bc8a3378d484ffafb3fc78f2f8d4331f1070a6fa8111c6bcd63d579a0e54546a3d5134a3c760c609a962e2a586d7b0d48646c
+Clang.v15.0.7+7.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/28ea22de73f4c555edeeb4ff22ce6099
+Clang.v15.0.7+7.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/88491ec5f0c51e3a6b4b2b6877e9e8437f8b3145a22f8dfb05269f9ddf72c1b8eca496b650ce2e9a26101ad48d2e79d01b4b4a48883fb547d4445b24ab79bfd5
+Clang.v15.0.7+7.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/9058d021eb893fb11313a04359d1d2b0
+Clang.v15.0.7+7.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/5fd93a2278b3d3c6f6a1836722b97ccd099f17a36da900b8bd54f0b399bc9ee42e847bc094058c3f3ce77dfc6950b5cef9b4571f5941857280a370af16c8b7b3
+Clang.v15.0.7+7.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/8ac220c9570fa66c2f13d9247dcfb324
+Clang.v15.0.7+7.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/977077fd338912c2fdbb88f4bcf1591b6b4f648d6e7c9ba2783b331eb67da2e6b9b29f85446500f6dfb15c9e05af8fe9128dbf3e77dfa69bd597999873769e8d
+Clang.v15.0.7+7.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/f017a86ee8803f2099b04ecf254e8157
+Clang.v15.0.7+7.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/c773d0c07234b03c71a1c2862f373f76d4c898fdbad35342c2e687a2afadaa220daad759afa5f88aa7eaab3d0d05f1e8eefcfd374bc1c92ddf638d42d20b74fa
+Clang.v15.0.7+7.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/80af25bf64203daaccc72f2274b60681
+Clang.v15.0.7+7.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/913f8ee4c7f9618227673db0aad7e5e98f0fccb8a1faa84778ec84ab10ee8fe4d59a8115582420459de67b8667f3f4681bde59dab6dfa70ddeb8ff8b7fd1add2
+Clang.v15.0.7+7.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/5b79fba21be10d03476c52ad0888d562
+Clang.v15.0.7+7.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/075e074a0f460be27fddd32069dcf4ee48aacbdf480ea74356692b3d98808868a18166ae5e689b17faa6b0ae1f1453bb63d98ed119afd3f44a8e662fa602a57e
+Clang.v15.0.7+7.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/90a9224695634cc70cc39b603cc8bc57
+Clang.v15.0.7+7.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/c1e388b838723b5251e6bf068a1790f83ccfe618be2e138b397d0a40c4f85f717bf01e8a46bbab48a91f182caef8e3fc291ec71a56df95fa60446a8858ac904b
+Clang.v15.0.7+7.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/6f2ec0e8aaaeb7c9e0c1d826010886ba
+Clang.v15.0.7+7.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/eb33e93ff5f3e32051c08c0aa42f1cc691dc364683ac484bb292f190911c879226282cea758224c9fea1bfcb934e4abbf4edd07666d9a2dee63d0ba40c2b3b47
+Clang.v15.0.7+7.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/2e8b81ef8017987c5ace824d524545cb
+Clang.v15.0.7+7.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/76d1cfba99747038542946680dad02d9deb4fb6dafde6def13e95c393da5d5f5f2aa30889377c6f3a869963075b9181b3d7652016202767768e880f2fdea827d
+Clang.v15.0.7+7.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/7556ca721d4e90e64a266c4b59fefc48
+Clang.v15.0.7+7.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/8df1651aaa87364fe47da4fc993551a9f9ba575ca88c749b92d6586390e19c8b059c20081e4b76426b23cc1140d1bd38c216855d968f3dc01505e29dc5760367
+Clang.v15.0.7+7.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/fd294a76698157d71a3a64f4f4e442e5
+Clang.v15.0.7+7.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/71466cd9d0b46686af10e124bb026e02af240b5ad5f3844fa5c0bb152ee334a56d41e5c82c8b2e3778ea409f5dbc1074afe5a8121fcb157745420a2fcc3465f3
+Clang.v15.0.7+7.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/a2ad561f1a41ed993fc2edebbe1a6b3b
+Clang.v15.0.7+7.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/51ed85190a1bdf89d0f5fe361381b0e0b773be05f510ac7b77747948f49dea49807d3d46cb3e948d22785884b8b92dcbf36d202087d2c2628fce6c73c6cd9789
+Clang.v15.0.7+7.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/98829294d5c6327582a8f9b1d7232083
+Clang.v15.0.7+7.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/d570b28e6a11d02467075e82931f8529671acd5e61992f462729d690810953535be31dcfe6fbdb3add0e00799809bf3afb529d227820c7f176e6193c24da7853
+Clang.v15.0.7+7.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/bd173830434f85d17e4857b7ffdb2dd1
+Clang.v15.0.7+7.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/ff66a8b1085d67521aa58f766b7bfad2c19ec89add9a67be2c5984a7a5ff5aacf60d54e0448ce70ca80d9a7d972624b9a2be530f767c87ed6839f709a482a7aa
+Clang.v15.0.7+7.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/34b020d23cd5b34ae47b2b0473822f14
+Clang.v15.0.7+7.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/250d55dfb02be3cfc4eeca0da386590d9fb0b9d6759360732b72b8663f4a3c843cd9e23ea08b8d272945fa64230e57f9a5bcdc4399dda2db54e51961e7c9f3e6
+Clang.v15.0.7+7.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/b3c76e91d6b43c7794b6ddb9d300d8f4
+Clang.v15.0.7+7.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/efbbcf2cfff1918e58fd850d99eec1e28cdaa11730b722a416e5da233a8fd0be685259052d5e9adf32c2c2364a4f96540a0175a44b8dc8d6ec872ef12394b9f2
+Clang.v15.0.7+7.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/81ae8ac294b1656b188dc437a7de6b10
+Clang.v15.0.7+7.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/1eac2968698b759bba3467205843183ed7279f24ae06f2d47b1cd4965c115d0b9f578ff7e0a6006883a462ad97c1829f3d706767de77a05d159bafa183064f84
+Clang.v15.0.7+7.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/581efd97263d337031ee761326320489
+Clang.v15.0.7+7.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/ae28a7743146eba68831e0f1929f87596117ebf64d9284585c1909ed1b78a60e102618e4232b37017543351208e0d1183d81e0bbf737c7930bd35dd146c9a2bb
+Clang.v15.0.7+7.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/34342cc1e94435ddac6ffc7ec89471f9
+Clang.v15.0.7+7.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/2e06c7a4b79a45d2139cadc3c10c4dbc086e6cf20b5f2ce90b50aad9bab6ffa4b55eef3dc9e40b495329a2a1eb9d0948b29a4495dc8a3cd56ce500087b9e63c6
+Clang.v15.0.7+7.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/de880e4c673351c777509ccfdc0a2579
+Clang.v15.0.7+7.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/e1becf694f1edbce097eaff7349c8a2ca8a1dda265c01a40549acf0dbcbbdf3c23d515236b114e6ec124f85e6bde380850ba72029de37cd36d59789936a21e83
+Clang.v15.0.7+7.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/93a4565b236d905021ab84b0a6c9fd34
+Clang.v15.0.7+7.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/d7c5b5e6fb627c2e19c72e42dcbcd8de9784dee522057d9fcdb03b0bba127de5517d72da8ca120c3cafabcfe6ac016526a7fbc090258119f5f6252d26d2c0c17
+Clang.v15.0.7+7.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/31d9e5992d969548f67b9478abfb1575
+Clang.v15.0.7+7.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/28ed4cdf1a289ece1defb2d4f19cb03ad07963f8e9df62073fbde3adaf943e78085a6f2d03b6cbd3f00f10f61a3499f964e104c2c1ee73167965b84be0bca901
+Clang.v15.0.7+7.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/8b6ffb09acc5d80408362b2705629db4
+Clang.v15.0.7+7.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/d69bd543be8848c9349014f216af7ff1cb32401cf1b0a060a3687259cb56518933f65ac8ce24eca74e2bfc79a1900bc638ed1428e7823672d088efee8aa70387
+Clang.v15.0.7+7.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/6dc4752e4987fbf9afc49b0a5a0b62f4
+Clang.v15.0.7+7.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/7617ac0ad1496549f6a38d33414cbbd74b72dbb54758f24ffc88a42226cfb607babba73b7e33d9558bff2d208bac3ee8f3b2594990d5e5fda49819eff3ad0d05
+Clang.v15.0.7+7.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/47cccd1ef2565df7196afe4da7659380
+Clang.v15.0.7+7.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/9d25f2d0634e2b4f5b8d9e4fb57c65c7d5956cadc24bbdb67a62095f2e6378aba3a8f16a0bc3aea6656c97aa035b3179645e352ff1a0b01cb89a773e9edc0b89
+Clang.v15.0.7+7.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/4e3fdf880b91a5fdbdcdff34386ee8de
+Clang.v15.0.7+7.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/b02b3a7db9796d45d9d1bf1fc95495c71f6575a70ebf7f4d9d249bf117eb8bdbaa100b2d4e867f82da1b9f9d13ae0d7f68097d1b085b0b6f3826ed21723cc709
+Clang.v15.0.7+7.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/859e942a9b7d0ee2fb626552e87586ad
+Clang.v15.0.7+7.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/23f4ecd6a2b4967d41a7a7ee18d3930b4c5e9dd4894a75c2f85e59be0c66bc0fccc7931e051258f36290affd64b6fa37b925ed53a68a0d0cb937a66a6ebfd263
+Clang.v15.0.7+7.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/f1c4a569ea5705e9eb5c1807f4053c4a
+Clang.v15.0.7+7.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/73cbb461b39b25b9af334487cea4f16ede9d82ea615671a72d9cce28f9069c3f872f8caa85a3ca61d75919424cd03259a9ac7cbc6c245e1aee2f9afbeef37d7a
+Clang.v15.0.7+7.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/d350e088544d652bba6e8d7ee787fc5c
+Clang.v15.0.7+7.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/a2123559d0be8875dff1336127eee38fb38e1c65cc06ce3c37785b81bd78c0c3a07bdadbb9e1eb700eb93845fe82198ab900a9d4568fa243a39109ec5c3eed54
+Clang.v15.0.7+7.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/70d920b3d62965a011b1884924b549c8
+Clang.v15.0.7+7.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/4937846f3a0c1a2c1ff086e761a30d3cf8dd06b010e77e4d39264d86c3819526cc74f276d0bf2901d47244b07a4e3ae21d9a213e2ae23fb7f95aec4568e6298e
+Clang.v15.0.7+7.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/7b0878064a5f8ba1953f5e76c4b63c18
+Clang.v15.0.7+7.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/542f057b2c3d6e829f34a615d7c9c021d793ce3723512b70f7e140640175b237a9669bd9f24563eede1dc5e25e37fa8910b1769ed344af9ea4d21bebc6638801
+Clang.v15.0.7+7.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/e797f5d917b08bdae66fdcab4f8367b5
+Clang.v15.0.7+7.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/40a379b2de5eafa8f202b258b8620bf82fb3eae384337120149ae17c7affa7e166a6b4fb77fb4ce94808c152efdf270ec22f03a2ca57aee27799ccc3c684b88c
+Clang.v15.0.7+7.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/1fb0bda6cad1591b1b40752efaa1f198
+Clang.v15.0.7+7.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/0ff8a3d9fc53e5733b9ea9ea30a4c0023fc926704d2dc747a1802343e5c45f6cabed9fd3207cb146218bf8f71b4de79d708c3f169fa13e3eb35dde591509d84a
+Clang.v15.0.7+7.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/7e2922fc9c5e3f93b73af4b2f8502f7b
+Clang.v15.0.7+7.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/b7656c67cbe9d6cfcd0837a4646819d9dcad83ab0907a570f8e66894f2650cbaa43c78796435b16bf28878b39e1c9254772b5aaa996f6a5629159c7c63caf26b
+Clang.v15.0.7+7.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/828fba3b956b5ae3c53337d7925001c7
+Clang.v15.0.7+7.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/f251d08399c3781c4441cb598ad5d32434db5fc235f023c0c99356cdec94b0806fb46302c431af1944536a124640747577ceb5daf8cc96a9c5fe696ba5faed29
+Clang.v15.0.7+7.x86_64-apple-darwin-llvm_version+15.tar.gz/md5/4b93518a7c69cc83568468089ea98376
+Clang.v15.0.7+7.x86_64-apple-darwin-llvm_version+15.tar.gz/sha512/0a7a0a2717e87ca6b2b8d50f5ae123c6ea86391ff6bfd19937b3beef599ef0e5d64cc21ea542ee5cc30f6b6d2951cf99c3448eba86aebe567a51a540d2aae794
+Clang.v15.0.7+7.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/9ccb6fc99b35c72b6e566f3d2336c686
+Clang.v15.0.7+7.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/af926692bcca26ea35450bb2794b94f6694ffbffbf54342f403dc47270e983ee697c06dbaefc143ecd0954100736586838987f51f8259e160b0ca06688514889
+Clang.v15.0.7+7.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/ce36f48d88d7dad1aef44c11b30aebf8
+Clang.v15.0.7+7.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/fbbf65977c5924830ff4c1c2c6d824a3635d09d4ee9304888030b8eca1bd7c06d8c053521068f663df932379cb3b7f0772589f7cca56156dd7053e6722d29953
+Clang.v15.0.7+7.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/2b68c2057aeca1564106dab565fe876b
+Clang.v15.0.7+7.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/64c8be7c227fa52c9d90353d5ab72c179c8974b0bc048d6f5793d0ac08110b98c54e2e3f65416986b7049904cf86b5a865cf3de4423d7b0906b4e85a0dcacd21
+Clang.v15.0.7+7.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/04a0a842bc490c440ec65927c285059f
+Clang.v15.0.7+7.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/82dc5eba9a795fe8d0e5c660aad1d902cde8c304ddfeb794d55a7b8decc97d27b648f658bb749b3bc25d2d50771febb0b481198459fc739c1d6944542c2b64f0
+Clang.v15.0.7+7.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/1742d997df9bc95ddc7791e0f3ba49c8
+Clang.v15.0.7+7.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/5187a9fddf31ea260d6d46f613d96c79b3c77bb8c7dd2752bc8d7becb7b7210a3d9ce195b2f03d466760bb4e52dee0beda22f238097e1472dbed04170b14e2c4
+Clang.v15.0.7+7.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/79e68396face36fc162ab27b99714b34
+Clang.v15.0.7+7.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/80f22d1bca302debb3e01213da099e5378eb3c1ff8684dbc8efca9145a27d1542a9a065e328c76148465dbb42268dad028004f38215289bbd862fc2cb12abf81
+Clang.v15.0.7+7.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/e2f7246f9e8ebd73e21186f18985755d
+Clang.v15.0.7+7.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/6dcaa68abe3abff6f3e288aa34ce3591a8e92d933187715cb9bc7362947fefeba3ce1b3629efdcdcb1fa3be111f7614a10b4f0b73f3ed54f46d6d9791612305e
+Clang.v15.0.7+7.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/15a21dc979f82c71a2d743f76a539c5d
+Clang.v15.0.7+7.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/684b9d596c4e0c4567841cc913ba91671030765edea4642c1883d87c12ddc2a2e4ec82931b2024a66e37c48820aeedd1fc41982930396cf657596d8d3970bf09
+Clang.v15.0.7+7.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/md5/82d172f6be5b1ae34fb92f85f962b9d5
+Clang.v15.0.7+7.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/sha512/62c39f038d7a616986314ec3da0ebc59cbed5a6cbac73becfae5a037e734922f4ab59e45a25c8c31242660fe4409023a1191c7311d0af1303d6170ec87d97413
+Clang.v15.0.7+7.x86_64-unknown-freebsd-llvm_version+15.tar.gz/md5/89c040d2773aa3f40fc1b0965d19b201
+Clang.v15.0.7+7.x86_64-unknown-freebsd-llvm_version+15.tar.gz/sha512/adb704fc2545d766da18766b2e3b6353f9865dac7e46a54e5d83b6886ca5ba8a091a8ceed86fe12bbfc0b3dc12b990dcf1389ba8d27ffe1bf8291c9855ca69b0
+Clang.v15.0.7+7.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/73b289f442e377a149e9e2e371fb0870
+Clang.v15.0.7+7.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/636e50ba832e753d35aaf102cb1d33cfb29004150f4d8ed5fae2a07264b70c39491447cb376700d842fb9a2f6882156eba58e84d58021ca6a47a7e850823fa59
+Clang.v15.0.7+7.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/9e81b9b49067f19c827c2e2b3386aca0
+Clang.v15.0.7+7.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/45cea529842d1bb142db1b0f5162442cc8ce1c9a26e225a431326d362a239532679a57b2fa875e70ba9679451d975415930c0c7223bbcbca4a933334b12eb6f7
+Clang.v15.0.7+7.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/d73d05082cbe59d44cae0143822f8f5b
+Clang.v15.0.7+7.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/6b497147e1bc458296aef639f0cb2c4e9a0ce9b452f970cf3d5f789c81884c41371a28d0608158aba7e1a328ea94334b4e7646ad32dffa915df9492fbfdc9bb5
+Clang.v15.0.7+7.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/a2ea302b51f0bcdc648cc328fb263290
+Clang.v15.0.7+7.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/5f04342029064f71b698a865d5fd4e407caed9751c443a4ed94ab195980ab14f9477a40cb4b914e9ff090d2067694104bc4bcd1b927cb2c07c268e5da142ccf0
diff --git a/deps/checksums/lld b/deps/checksums/lld
index 1b238fdbd1a96..2459825b43df3 100644
--- a/deps/checksums/lld
+++ b/deps/checksums/lld
@@ -1,108 +1,108 @@
-LLD.v15.0.7+5.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/0edc0983135da9e37b18fa3fe6d56237
-LLD.v15.0.7+5.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/2adbb4eb76e72be28951c96140070b6d16c5144f689631d51b56365549a5d38535c1dbb5e351a6bdac4648ba52da02297591874193b1c16e7078060c99d23f04
-LLD.v15.0.7+5.aarch64-apple-darwin-llvm_version+15.tar.gz/md5/59b06fca083f1a5e9bf9517ae4f6a4d6
-LLD.v15.0.7+5.aarch64-apple-darwin-llvm_version+15.tar.gz/sha512/7f1dc641df9288dfcd887239b86e7fe2871220b9d7f877b24b3197ab73d2176c4533decbea427b09e8f70ddc6c7570d31f5682eaed7215193e95f323769276a8
-LLD.v15.0.7+5.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/c97e607a661b9ff571eba4238ec649dd
-LLD.v15.0.7+5.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/7c7add8a0fac379b580a19a02966adca4932bd4573ba0111262544c0d935fc121c5aadaeadc97f9564331202b08c7366ceb170bb2b318db3425c157772d283ea
-LLD.v15.0.7+5.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/d55ebbd25b97a4e4628fad1e04782056
-LLD.v15.0.7+5.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/681729b4d10d8f66b0cdb89ca4500ee8a417561cc886608d06af0809d946bdf7cf5c6bda2b6d5d577bae3a15dc347568a3d7d7428568f86ca61327041026fbd2
-LLD.v15.0.7+5.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/78b06e5a351e6eab372ae29d393ffdcf
-LLD.v15.0.7+5.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/37a8b5fa3491ec8ae74da88e81a0c229d38166acbb46ff3f5a819034c40fa59ca2ebf4c0ed58e615baf7bf7da789ba86114738252501cfbd842be95cc2104dd4
-LLD.v15.0.7+5.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/7ba5b76c83d746a3c62354bf753db697
-LLD.v15.0.7+5.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/1fa403c8923487e2d6a8e8c1d86c2ea955ed32bcde2328cb1167a315cdcf704af896505e9c44b750ffca9e3ae66e805f60831136eb79fe1c6d58eaf81a78b1a4
-LLD.v15.0.7+5.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/f052208026a0fd5120ea838843b244ac
-LLD.v15.0.7+5.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/fd9ff2d5836300bcf76e4aeefb1e57860b3203fab0c32e668dce3e636dc362876d0fba1f2c23bf55a342ac17294c73e839a8eaf065d64d4397582dc212b8b9f4
-LLD.v15.0.7+5.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/4d1077835df0f592a168c140ffe6299e
-LLD.v15.0.7+5.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/8dfd44113b817f607bc38ac1b4ffb192be340c826b9bc8f9d41e92e0f0333d8fc4227f93aaed16a4b9e94a5ec8b79628f2d3a73fb644684a595921f36ccfbeb8
-LLD.v15.0.7+5.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/0f31939f4ff00c572eb392b6e70aab38
-LLD.v15.0.7+5.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/581441087ad4869cfdba13808b2d6adaf929ea1b38ce96c357f276d77c3e63439f8edbb822c8f41770cb61fc08837d7eed2466d187683bc44f2cb3c553e2e60e
-LLD.v15.0.7+5.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/ca767173044b5a19a86c6a890dda3b05
-LLD.v15.0.7+5.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/0577785079039b534fd736ea7a51d9b5176693d81e0bcda4fccd760d7c1218042999b6a38b973a903c0ef68e57dfb3b86e9e2f9e307dbaf603997a853f34eed3
-LLD.v15.0.7+5.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/89bb950f17a5b792a6e60ef98450a6b4
-LLD.v15.0.7+5.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/54bb68159743cd14ac0fce7f218a66ff6bf29e626df8dbdbd6e8581699d9b1d357a3c10d86c6822bde7299c14728bc55480f91cefd041d1de61cc179ed347b9a
-LLD.v15.0.7+5.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/735e4dda5f8cc06934f6bda59eab21d6
-LLD.v15.0.7+5.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/a9b91beed959804b9e121fee786f28808a7670fc5d2728688cca1c7e0fe56e82e47d95712e38fdfc42e02030896843c4b3df9928eb34c2aca9ac02262427c76c
-LLD.v15.0.7+5.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/30a95179bef252aaca41984daa54c680
-LLD.v15.0.7+5.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/0302db3c04396a30d1f6ab8d8d585bbe3a9e70342f068747ddb875b024c173bb9bb34518da7e76a10d3a325dfd741118f36f67fb83251bdb8a9901c4799ad79f
-LLD.v15.0.7+5.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/4386c746c5d9b1408dbe7df04bc6a08d
-LLD.v15.0.7+5.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/d71c6ebf5d3eb42368ab336cf8520afcd05470308ea117fe95797171e5c573948412ce777f62cbd45ee99ffa59cc769c276a60393a22fecffbeaf8b77b50ea35
-LLD.v15.0.7+5.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/49287977de61b100979355e458c8970c
-LLD.v15.0.7+5.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/85ed3b2c7d2478a307a393a2003e694fc3097cc6812143abb3cbdd73a7d36bcb6f06a7d341ea639b9849f714c2d8f418a8b96035ed1c19a3957b42d005c0427a
-LLD.v15.0.7+5.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/80a97341c9537b8a58c7df23f86d5cf4
-LLD.v15.0.7+5.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/5774b246ae820de4230a1f4f65bd683145dad5cbc4d326fd75649e06e773c74c2cffd48108a79ee0cc93175786450b6d50f7ac532e6f68961c18fe6119ef94f5
-LLD.v15.0.7+5.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/6f84d6858aecdfd95726a37c9b6a0e0f
-LLD.v15.0.7+5.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/2cdac9a810c777ec6d85093926292c75e4287f83b7224246f6fa248e3874a2078c46377cd5ccb0f36a5e25b139691f1111d705079e89ea4215c9bc8659414094
-LLD.v15.0.7+5.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/d40f0956cc36aa7846630755a672a91c
-LLD.v15.0.7+5.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/01368311a0ecfbe3f23514115f0bce7ce816c878815d937f3fa067b9daab07da0c02f520a96ad793212e5056bfb6294dd0129dae75f274dfeb48191e504c5322
-LLD.v15.0.7+5.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/689120b8091b9da8cc9528c96f5c5df2
-LLD.v15.0.7+5.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/ab78810af7d77116a4973b5825d5090133218cf08d5d77be14f83e028821e83493a112adf71094cc208f74cf4deabda63d7fff98866cc0304793aec9b27b7222
-LLD.v15.0.7+5.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/5627ccf1677c48b7ef8ac9e5faac1d20
-LLD.v15.0.7+5.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/454d2636cd72974c79c2d907e56e3c69c30c3fff78b199591c9ebe4f14d04c40c4bd7331f8dc2c957c37e214da8d28ef3a47ed8d3dd4ca9d480d52bab3429b39
-LLD.v15.0.7+5.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/8f50e5f684c41845308c123f8e45a0d5
-LLD.v15.0.7+5.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/21baf8a00fa65473ff6cf7ef2974ef88cd5b0eadd06ff85598de10d09425074297bcff3472ef001047a5440065a2de2fc6b1eefe3a32c7c1b3e3261165dc063c
-LLD.v15.0.7+5.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/c2e0a5f58e38a9acf2c3914177ceb827
-LLD.v15.0.7+5.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/2a1653d171a2ff08bde55c53973e62955fe9d9629388ae014a645d3199d8f4bcf0fb923d06812ccd62e224032b261c8ebed56ebebed750acbc87671203d7aee5
-LLD.v15.0.7+5.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/fa3959aa413a2b707d8831edd2bd7867
-LLD.v15.0.7+5.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/8b74fef916a72c2f4933c21d3344410c7e03e64265a44dd62cf2ef2ac0feeafeb2b443eafa5dad3d3d0028be96b9424ff67b16391f1b3a2185826de68921adab
-LLD.v15.0.7+5.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/b0751bf7eba4f7f7a28dc22993eac9cc
-LLD.v15.0.7+5.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/7510f7349b06365e9cd260229e7b8c84da26bac072c5fe9a4e59484d82a0753d4ecf1066ffe41343f881a682590dc9ee4ef4a49cd83dba45c21b8d76dfb80f67
-LLD.v15.0.7+5.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/5abfe9e960bab4c8a44f41aaccaf936b
-LLD.v15.0.7+5.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/efda0e0a35e2774af2f2df53f89d61f146a5730086d40865d448b009c833934b23ea4b296c3dc3f2039527b72ef40493fdee6f7c630484f64cec2d1aebf4a4c1
-LLD.v15.0.7+5.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/bfe87378e965050b1b20e993c8b13a53
-LLD.v15.0.7+5.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/ef2fd5e81f349673417bffd68c4122a87c09caed3f6f8f0235bc70b75deca7363cad68276aa708fb9ad8f7edd249d49f78d9f5fe7b226b62e8604c7bd3d4b9cc
-LLD.v15.0.7+5.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/4ee16f57d7dc060007250e17ffd55817
-LLD.v15.0.7+5.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/27fd3a21bac676feb2c2c2363c027cf12988c70d889174e52c6bc1fcb4a93241f4bae85d5750ceba5fa971611700a9d15e3e02803cc14382cf6a1ab2918b719c
-LLD.v15.0.7+5.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/06699da5617371442b0539203152405d
-LLD.v15.0.7+5.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/83ba6300d5669b52c1913440598a2577106ea73e0b83549a5b3b0f081a94b6b8ca9fc05687d2be4b60c2d6a524bafd43b839082f0eee58b4685758061b229fde
-LLD.v15.0.7+5.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/a051688aa3a6383b4be4faa4f4aee985
-LLD.v15.0.7+5.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/2059c6ac6579c4720e7167cd547b679a9c1a27a2c68174ed543be935ee23122234b3f2a4555de0abab3a982aba73d1751db336f3e28005ce8e4659d61f9269aa
-LLD.v15.0.7+5.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/600baa66310cf348ef3b4351ada014f4
-LLD.v15.0.7+5.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/52b4718993d8abdca8ab701e86022367655d7927dabb8f3a8e41e43dbc90a9af78caf8abd37907a79b0f05017b6f0ef72314a187dab5bdac8ef7996e74c96e2d
-LLD.v15.0.7+5.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/4bc599fc07e9c7c717355802c1538a6b
-LLD.v15.0.7+5.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/4521e40cf6cca31cc9ec8ad974c6eb922632d8ad0d5008c951e23b7ec193a71dba5f3bc2dadcfe47e2ca29395646293c6559bd88ac286c5d31d5c4521756177d
-LLD.v15.0.7+5.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/462b9c453405768c2d93535fc83308b8
-LLD.v15.0.7+5.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/39dee4d4a0073a8dc4ea63d43bc9a357bcf8e26e3c5c17f1441fa72145f5a4ff6a53e0aae6de687b8fcbace40207ba06e61cb8452c9bfff7882ab48e9f9f5ff0
-LLD.v15.0.7+5.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/8b12a4f5db80b925785f42a97e6489f0
-LLD.v15.0.7+5.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/797d12888668712658fce85ff842d812a255fa4633bf4e78b21488867518a1fc2de746885e2fca1055595ae476670790239a714797f2322ca04027afbf27330f
-LLD.v15.0.7+5.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/acb8716cf94f654078c7dce4a140f71c
-LLD.v15.0.7+5.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/cf64ae04ae3e55575d5781ad30212b1c0ec734f81b42e3c26da8766bde7c47b6a9512515997afd15f9eeef2ee326c7aa589ee1b557c45b4ef955a8afc72fd759
-LLD.v15.0.7+5.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/331d844c447f564171345009764321a1
-LLD.v15.0.7+5.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/978349a74fc5498408a5318c87ec6d25c01268b9d21fb85e6bb601243ad0d33be8501b181d1f9ab7663433a740912f5bcb7160caf1011b1a2c84fdd51e0fce78
-LLD.v15.0.7+5.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/8595a49c49e851973fffae7c4062911d
-LLD.v15.0.7+5.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/f707e514843a206b53f380c7bd8d4d8203cc62219344c1234416462dc1cb3d3f8a7452ddfd0f07178d43dfb193b4402a018cc465dc76b43b687fd20fa1ea5222
-LLD.v15.0.7+5.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/5b4463e81c156dabe3d182c42eb647e1
-LLD.v15.0.7+5.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/995db577d4a78d62cfcfca3f1fafb333ff26548b41d8aa8d763e4705dcdfe8005e2f68873faba4040599a6d15821a523261d0451d75fdf6e1c5224e8e777a71e
-LLD.v15.0.7+5.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/d2f9f08cc952c0639f7ef1073c8630d6
-LLD.v15.0.7+5.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/b1cab7b813fe0f7c26c55261e8561295cbdf1e812db3844b87605fb527d09855f2bef4a40ddb0a7cd354c7cbb626293d4d4012f33acc242f9af4abe1dbbbeeb7
-LLD.v15.0.7+5.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/e82e3b67a073cfa6b019bf5604eabf2a
-LLD.v15.0.7+5.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/9bb18adf78afa9dfa0054e6511f5750a9e2fa9138aeb1bd83f7a51d37d031e2f3c151463ea8f682dc7130cb98fafae0b84c60d3befe27f9d0d3dc3334ef82420
-LLD.v15.0.7+5.x86_64-apple-darwin-llvm_version+15.tar.gz/md5/56da3cbe81ddff089ccf6b6392a9396c
-LLD.v15.0.7+5.x86_64-apple-darwin-llvm_version+15.tar.gz/sha512/2af483a1761022dcad414fa7cec7fb5c6fd54be28185e49539f4824cb0b6acdc1cfa5c78de31268dbdc444201936c5a6d2e04f39ef6f0b9fb184985ba4e3daa2
-LLD.v15.0.7+5.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/15cbf5eaf89c7b834ee19629387515a5
-LLD.v15.0.7+5.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/75ce7c398bdfd57af2c09dfc946b024d5a72e90575ed92f28e015e620ca89e421dfc9a391f4a78277c3e06c38dd696d572c5601a2b1866e521dbc2fc5a60da56
-LLD.v15.0.7+5.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/b895da29b6082cdff6f0324179352fdf
-LLD.v15.0.7+5.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/e89a97dfd6c345158e3e12cdf97d33c22f849e5438401cf5a3670c0d1cf0252ca03e4c52475a42c3e6c2b2d689c2f53fc5cb7c925a23167ac51fa1a5e01e3d7f
-LLD.v15.0.7+5.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/7edda2d8c2eaadec2d262ded2456934a
-LLD.v15.0.7+5.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/0b1d60840d638c0b0269b901a3f5198e18e244da338aef2fb49b474b3601d44a2b4dec13e258909985e363ef8a8749838b01dd195e05a266ca36e6d9f274ef17
-LLD.v15.0.7+5.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/e26138e3491a053ea9a998dd00ad728b
-LLD.v15.0.7+5.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/1215861fa52b1ee21196bbce0e99912b25f887f5734e0c2628ac78c1af5fdf57c4d7cf099cddcd7031a26c60cf141aeea66a0147428008cb485c207e90801835
-LLD.v15.0.7+5.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/a1e786ac775517b8b483bbe3f6571d37
-LLD.v15.0.7+5.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/3937f156fc2fb8eecb13444c71f380753c16b08f29124228808c91ea4258ee2195219c4a9b601d4468cc24bd584403c16175518a620bd94a7dadff868b3771d7
-LLD.v15.0.7+5.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/976d840de14ef6ee2c0a538197fe8f10
-LLD.v15.0.7+5.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/7f58f975dc3d69f502537aca79509bbc3c4f5da2ff8ddb1c7e27180a6bb2123713eb42da61cfabd7a48a31fc464fd74554b34935dfdb3ec095d14ff443f514f3
-LLD.v15.0.7+5.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/ab0295ba327cfa6b9a252b0e7a4b50a5
-LLD.v15.0.7+5.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/7c750916d4157ba0a37cd1277a0f8faf32123dfc626ea76f848a7c567fd889a7801f8402a307c190ab34fc21b156f2a23967abc9972fc103e5847a200ffc7305
-LLD.v15.0.7+5.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/6827f38ed653f33953ff7ae510a517d5
-LLD.v15.0.7+5.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/f01c655f6433ec6808b62872b8fb4c5a2d8e187643c11f0b4f5c06e2302e462353b516f431c1e26ee60b579c0f8c8c6385f018db3011c619745a39f9ef263436
-LLD.v15.0.7+5.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/md5/385cd2715d29de3e85a3ac10bcbc88d8
-LLD.v15.0.7+5.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/sha512/5c90e8e583176ed9dd563f794073bb344283284a10e303834b6c5a9b71369f50dfbcbac61400ff70f34f3065279c848dc29086309ad38774e50eca3fdd5f9799
-LLD.v15.0.7+5.x86_64-unknown-freebsd-llvm_version+15.tar.gz/md5/241978345735e3b57a88918693c0c0db
-LLD.v15.0.7+5.x86_64-unknown-freebsd-llvm_version+15.tar.gz/sha512/916c6a4540ce9a2b2574d92c3aed42171f9e49f776ab97d3e5be84df832d463b7e542529c3ae81e4d6a31d5789d55b96f9559f48c0e4c8be36d70e3ff6f4292f
-LLD.v15.0.7+5.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/a4f16e809240c1837b90d28930e3f711
-LLD.v15.0.7+5.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/983201793e0f9e6416bcea23b4a70a5a1a36fbdd72bed2cc60ec267eee441aa3d9c850b4aa3da6a232f3de451089754138ecd5411e5431f632e48c1993513ef9
-LLD.v15.0.7+5.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/70f47c2be55741f754ffe89e4749dafa
-LLD.v15.0.7+5.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/f2dcf4f6ce888801e8a14875909f78b46d8ed853a7063a185356c7f21e42e15323d847d9a9d4b020481a7fcec9539d979e4c7f2b083ac1c1bf75a275a200562b
-LLD.v15.0.7+5.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/becf7c6cc39a98cb722899c94b32ca34
-LLD.v15.0.7+5.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/84818621307779e27cc149afbf958653049e47a62ca44ff78552878114c2fb0f7c40cc83722394ee8d880a6ddfdec79012235a6ed20bbfd1e5d9e83ed0a0199b
-LLD.v15.0.7+5.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/0117c05f8dabf41c4628532d59cccd3b
-LLD.v15.0.7+5.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/b276dff2c54fdb6403a461ecf5435978e2cf9c9273934edcf3a31e7f640ecccf37de672f6b0b3f296ddb6a7059b0d95ca6c5bf62d62ca545cc62a69ebb84b8ce
+LLD.v15.0.7+7.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/0edc0983135da9e37b18fa3fe6d56237
+LLD.v15.0.7+7.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/2adbb4eb76e72be28951c96140070b6d16c5144f689631d51b56365549a5d38535c1dbb5e351a6bdac4648ba52da02297591874193b1c16e7078060c99d23f04
+LLD.v15.0.7+7.aarch64-apple-darwin-llvm_version+15.tar.gz/md5/59b06fca083f1a5e9bf9517ae4f6a4d6
+LLD.v15.0.7+7.aarch64-apple-darwin-llvm_version+15.tar.gz/sha512/7f1dc641df9288dfcd887239b86e7fe2871220b9d7f877b24b3197ab73d2176c4533decbea427b09e8f70ddc6c7570d31f5682eaed7215193e95f323769276a8
+LLD.v15.0.7+7.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/c97e607a661b9ff571eba4238ec649dd
+LLD.v15.0.7+7.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/7c7add8a0fac379b580a19a02966adca4932bd4573ba0111262544c0d935fc121c5aadaeadc97f9564331202b08c7366ceb170bb2b318db3425c157772d283ea
+LLD.v15.0.7+7.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/d55ebbd25b97a4e4628fad1e04782056
+LLD.v15.0.7+7.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/681729b4d10d8f66b0cdb89ca4500ee8a417561cc886608d06af0809d946bdf7cf5c6bda2b6d5d577bae3a15dc347568a3d7d7428568f86ca61327041026fbd2
+LLD.v15.0.7+7.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/78b06e5a351e6eab372ae29d393ffdcf
+LLD.v15.0.7+7.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/37a8b5fa3491ec8ae74da88e81a0c229d38166acbb46ff3f5a819034c40fa59ca2ebf4c0ed58e615baf7bf7da789ba86114738252501cfbd842be95cc2104dd4
+LLD.v15.0.7+7.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/7ba5b76c83d746a3c62354bf753db697
+LLD.v15.0.7+7.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/1fa403c8923487e2d6a8e8c1d86c2ea955ed32bcde2328cb1167a315cdcf704af896505e9c44b750ffca9e3ae66e805f60831136eb79fe1c6d58eaf81a78b1a4
+LLD.v15.0.7+7.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/f052208026a0fd5120ea838843b244ac
+LLD.v15.0.7+7.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/fd9ff2d5836300bcf76e4aeefb1e57860b3203fab0c32e668dce3e636dc362876d0fba1f2c23bf55a342ac17294c73e839a8eaf065d64d4397582dc212b8b9f4
+LLD.v15.0.7+7.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/4d1077835df0f592a168c140ffe6299e
+LLD.v15.0.7+7.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/8dfd44113b817f607bc38ac1b4ffb192be340c826b9bc8f9d41e92e0f0333d8fc4227f93aaed16a4b9e94a5ec8b79628f2d3a73fb644684a595921f36ccfbeb8
+LLD.v15.0.7+7.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/0f31939f4ff00c572eb392b6e70aab38
+LLD.v15.0.7+7.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/581441087ad4869cfdba13808b2d6adaf929ea1b38ce96c357f276d77c3e63439f8edbb822c8f41770cb61fc08837d7eed2466d187683bc44f2cb3c553e2e60e
+LLD.v15.0.7+7.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/ca767173044b5a19a86c6a890dda3b05
+LLD.v15.0.7+7.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/0577785079039b534fd736ea7a51d9b5176693d81e0bcda4fccd760d7c1218042999b6a38b973a903c0ef68e57dfb3b86e9e2f9e307dbaf603997a853f34eed3
+LLD.v15.0.7+7.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/89bb950f17a5b792a6e60ef98450a6b4
+LLD.v15.0.7+7.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/54bb68159743cd14ac0fce7f218a66ff6bf29e626df8dbdbd6e8581699d9b1d357a3c10d86c6822bde7299c14728bc55480f91cefd041d1de61cc179ed347b9a
+LLD.v15.0.7+7.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/735e4dda5f8cc06934f6bda59eab21d6
+LLD.v15.0.7+7.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/a9b91beed959804b9e121fee786f28808a7670fc5d2728688cca1c7e0fe56e82e47d95712e38fdfc42e02030896843c4b3df9928eb34c2aca9ac02262427c76c
+LLD.v15.0.7+7.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/30a95179bef252aaca41984daa54c680
+LLD.v15.0.7+7.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/0302db3c04396a30d1f6ab8d8d585bbe3a9e70342f068747ddb875b024c173bb9bb34518da7e76a10d3a325dfd741118f36f67fb83251bdb8a9901c4799ad79f
+LLD.v15.0.7+7.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/4386c746c5d9b1408dbe7df04bc6a08d
+LLD.v15.0.7+7.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/d71c6ebf5d3eb42368ab336cf8520afcd05470308ea117fe95797171e5c573948412ce777f62cbd45ee99ffa59cc769c276a60393a22fecffbeaf8b77b50ea35
+LLD.v15.0.7+7.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/49287977de61b100979355e458c8970c
+LLD.v15.0.7+7.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/85ed3b2c7d2478a307a393a2003e694fc3097cc6812143abb3cbdd73a7d36bcb6f06a7d341ea639b9849f714c2d8f418a8b96035ed1c19a3957b42d005c0427a
+LLD.v15.0.7+7.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/80a97341c9537b8a58c7df23f86d5cf4
+LLD.v15.0.7+7.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/5774b246ae820de4230a1f4f65bd683145dad5cbc4d326fd75649e06e773c74c2cffd48108a79ee0cc93175786450b6d50f7ac532e6f68961c18fe6119ef94f5
+LLD.v15.0.7+7.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/6f84d6858aecdfd95726a37c9b6a0e0f
+LLD.v15.0.7+7.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/2cdac9a810c777ec6d85093926292c75e4287f83b7224246f6fa248e3874a2078c46377cd5ccb0f36a5e25b139691f1111d705079e89ea4215c9bc8659414094
+LLD.v15.0.7+7.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/d40f0956cc36aa7846630755a672a91c
+LLD.v15.0.7+7.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/01368311a0ecfbe3f23514115f0bce7ce816c878815d937f3fa067b9daab07da0c02f520a96ad793212e5056bfb6294dd0129dae75f274dfeb48191e504c5322
+LLD.v15.0.7+7.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/689120b8091b9da8cc9528c96f5c5df2
+LLD.v15.0.7+7.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/ab78810af7d77116a4973b5825d5090133218cf08d5d77be14f83e028821e83493a112adf71094cc208f74cf4deabda63d7fff98866cc0304793aec9b27b7222
+LLD.v15.0.7+7.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/5627ccf1677c48b7ef8ac9e5faac1d20
+LLD.v15.0.7+7.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/454d2636cd72974c79c2d907e56e3c69c30c3fff78b199591c9ebe4f14d04c40c4bd7331f8dc2c957c37e214da8d28ef3a47ed8d3dd4ca9d480d52bab3429b39
+LLD.v15.0.7+7.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/8f50e5f684c41845308c123f8e45a0d5
+LLD.v15.0.7+7.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/21baf8a00fa65473ff6cf7ef2974ef88cd5b0eadd06ff85598de10d09425074297bcff3472ef001047a5440065a2de2fc6b1eefe3a32c7c1b3e3261165dc063c
+LLD.v15.0.7+7.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/c2e0a5f58e38a9acf2c3914177ceb827
+LLD.v15.0.7+7.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/2a1653d171a2ff08bde55c53973e62955fe9d9629388ae014a645d3199d8f4bcf0fb923d06812ccd62e224032b261c8ebed56ebebed750acbc87671203d7aee5
+LLD.v15.0.7+7.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/fa3959aa413a2b707d8831edd2bd7867
+LLD.v15.0.7+7.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/8b74fef916a72c2f4933c21d3344410c7e03e64265a44dd62cf2ef2ac0feeafeb2b443eafa5dad3d3d0028be96b9424ff67b16391f1b3a2185826de68921adab
+LLD.v15.0.7+7.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/b0751bf7eba4f7f7a28dc22993eac9cc
+LLD.v15.0.7+7.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/7510f7349b06365e9cd260229e7b8c84da26bac072c5fe9a4e59484d82a0753d4ecf1066ffe41343f881a682590dc9ee4ef4a49cd83dba45c21b8d76dfb80f67
+LLD.v15.0.7+7.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/5abfe9e960bab4c8a44f41aaccaf936b
+LLD.v15.0.7+7.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/efda0e0a35e2774af2f2df53f89d61f146a5730086d40865d448b009c833934b23ea4b296c3dc3f2039527b72ef40493fdee6f7c630484f64cec2d1aebf4a4c1
+LLD.v15.0.7+7.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/bfe87378e965050b1b20e993c8b13a53
+LLD.v15.0.7+7.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/ef2fd5e81f349673417bffd68c4122a87c09caed3f6f8f0235bc70b75deca7363cad68276aa708fb9ad8f7edd249d49f78d9f5fe7b226b62e8604c7bd3d4b9cc
+LLD.v15.0.7+7.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/4ee16f57d7dc060007250e17ffd55817
+LLD.v15.0.7+7.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/27fd3a21bac676feb2c2c2363c027cf12988c70d889174e52c6bc1fcb4a93241f4bae85d5750ceba5fa971611700a9d15e3e02803cc14382cf6a1ab2918b719c
+LLD.v15.0.7+7.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/06699da5617371442b0539203152405d
+LLD.v15.0.7+7.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/83ba6300d5669b52c1913440598a2577106ea73e0b83549a5b3b0f081a94b6b8ca9fc05687d2be4b60c2d6a524bafd43b839082f0eee58b4685758061b229fde
+LLD.v15.0.7+7.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/a051688aa3a6383b4be4faa4f4aee985
+LLD.v15.0.7+7.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/2059c6ac6579c4720e7167cd547b679a9c1a27a2c68174ed543be935ee23122234b3f2a4555de0abab3a982aba73d1751db336f3e28005ce8e4659d61f9269aa
+LLD.v15.0.7+7.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/600baa66310cf348ef3b4351ada014f4
+LLD.v15.0.7+7.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/52b4718993d8abdca8ab701e86022367655d7927dabb8f3a8e41e43dbc90a9af78caf8abd37907a79b0f05017b6f0ef72314a187dab5bdac8ef7996e74c96e2d
+LLD.v15.0.7+7.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/e1e12162e5c63141dd95fca83cf1be64
+LLD.v15.0.7+7.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/ce21d1cfa4af89fee1cb13587e15d355f179d38a4a9b4ffb9f357d46fe9b7fed4a5cad801ddf75d66b71d77170427609a51144450f83c8dd59af5c02fb0a9017
+LLD.v15.0.7+7.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/932639f712fb881f621e5bb369921132
+LLD.v15.0.7+7.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/86426de75c4fd1e1d56e1bee08bb6447be0c7417f8492639158f436caa5794862dd3b2981f26f1828852f35806dd2177fbdaacbee67ea849e8de597948b276b9
+LLD.v15.0.7+7.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/2ff9f42465eb6e845ed6b7567b9d14d8
+LLD.v15.0.7+7.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/a19b985b28a642b9a40ef25d02d4e94608b7e5c9925db5202e9d34ca8258e0b02d758de5bbeed63f958602f7fb59b70c4f32434a59008af3f0dd1b757a20e2bf
+LLD.v15.0.7+7.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/6de812afa415af04eb9d806adbd4b2ed
+LLD.v15.0.7+7.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/c6799fb148f8b019d0b05fa707d58ac7f449347290fc3f47458cb84e0bef704fd179e6d29d2efdeb0c35e4ee799284f5850b1ec5c04ccfad45b38e058e449554
+LLD.v15.0.7+7.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/331d844c447f564171345009764321a1
+LLD.v15.0.7+7.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/978349a74fc5498408a5318c87ec6d25c01268b9d21fb85e6bb601243ad0d33be8501b181d1f9ab7663433a740912f5bcb7160caf1011b1a2c84fdd51e0fce78
+LLD.v15.0.7+7.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/8595a49c49e851973fffae7c4062911d
+LLD.v15.0.7+7.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/f707e514843a206b53f380c7bd8d4d8203cc62219344c1234416462dc1cb3d3f8a7452ddfd0f07178d43dfb193b4402a018cc465dc76b43b687fd20fa1ea5222
+LLD.v15.0.7+7.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/5b4463e81c156dabe3d182c42eb647e1
+LLD.v15.0.7+7.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/995db577d4a78d62cfcfca3f1fafb333ff26548b41d8aa8d763e4705dcdfe8005e2f68873faba4040599a6d15821a523261d0451d75fdf6e1c5224e8e777a71e
+LLD.v15.0.7+7.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/d2f9f08cc952c0639f7ef1073c8630d6
+LLD.v15.0.7+7.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/b1cab7b813fe0f7c26c55261e8561295cbdf1e812db3844b87605fb527d09855f2bef4a40ddb0a7cd354c7cbb626293d4d4012f33acc242f9af4abe1dbbbeeb7
+LLD.v15.0.7+7.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/e82e3b67a073cfa6b019bf5604eabf2a
+LLD.v15.0.7+7.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/9bb18adf78afa9dfa0054e6511f5750a9e2fa9138aeb1bd83f7a51d37d031e2f3c151463ea8f682dc7130cb98fafae0b84c60d3befe27f9d0d3dc3334ef82420
+LLD.v15.0.7+7.x86_64-apple-darwin-llvm_version+15.tar.gz/md5/56da3cbe81ddff089ccf6b6392a9396c
+LLD.v15.0.7+7.x86_64-apple-darwin-llvm_version+15.tar.gz/sha512/2af483a1761022dcad414fa7cec7fb5c6fd54be28185e49539f4824cb0b6acdc1cfa5c78de31268dbdc444201936c5a6d2e04f39ef6f0b9fb184985ba4e3daa2
+LLD.v15.0.7+7.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/15cbf5eaf89c7b834ee19629387515a5
+LLD.v15.0.7+7.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/75ce7c398bdfd57af2c09dfc946b024d5a72e90575ed92f28e015e620ca89e421dfc9a391f4a78277c3e06c38dd696d572c5601a2b1866e521dbc2fc5a60da56
+LLD.v15.0.7+7.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/b895da29b6082cdff6f0324179352fdf
+LLD.v15.0.7+7.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/e89a97dfd6c345158e3e12cdf97d33c22f849e5438401cf5a3670c0d1cf0252ca03e4c52475a42c3e6c2b2d689c2f53fc5cb7c925a23167ac51fa1a5e01e3d7f
+LLD.v15.0.7+7.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/7edda2d8c2eaadec2d262ded2456934a
+LLD.v15.0.7+7.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/0b1d60840d638c0b0269b901a3f5198e18e244da338aef2fb49b474b3601d44a2b4dec13e258909985e363ef8a8749838b01dd195e05a266ca36e6d9f274ef17
+LLD.v15.0.7+7.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/e26138e3491a053ea9a998dd00ad728b
+LLD.v15.0.7+7.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/1215861fa52b1ee21196bbce0e99912b25f887f5734e0c2628ac78c1af5fdf57c4d7cf099cddcd7031a26c60cf141aeea66a0147428008cb485c207e90801835
+LLD.v15.0.7+7.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/a1e786ac775517b8b483bbe3f6571d37
+LLD.v15.0.7+7.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/3937f156fc2fb8eecb13444c71f380753c16b08f29124228808c91ea4258ee2195219c4a9b601d4468cc24bd584403c16175518a620bd94a7dadff868b3771d7
+LLD.v15.0.7+7.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/976d840de14ef6ee2c0a538197fe8f10
+LLD.v15.0.7+7.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/7f58f975dc3d69f502537aca79509bbc3c4f5da2ff8ddb1c7e27180a6bb2123713eb42da61cfabd7a48a31fc464fd74554b34935dfdb3ec095d14ff443f514f3
+LLD.v15.0.7+7.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/ab0295ba327cfa6b9a252b0e7a4b50a5
+LLD.v15.0.7+7.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/7c750916d4157ba0a37cd1277a0f8faf32123dfc626ea76f848a7c567fd889a7801f8402a307c190ab34fc21b156f2a23967abc9972fc103e5847a200ffc7305
+LLD.v15.0.7+7.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/6827f38ed653f33953ff7ae510a517d5
+LLD.v15.0.7+7.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/f01c655f6433ec6808b62872b8fb4c5a2d8e187643c11f0b4f5c06e2302e462353b516f431c1e26ee60b579c0f8c8c6385f018db3011c619745a39f9ef263436
+LLD.v15.0.7+7.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/md5/d444e6188476c8b7bb6026aac6ea0a1f
+LLD.v15.0.7+7.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/sha512/69510929896bcfdc4377b180ed206617f96e1fa13fe9f8ccb18d78958c3f9f951a2ff8ada9d1217a02407819caed5308d91bf8fd72434ba347f548c9ba000a5e
+LLD.v15.0.7+7.x86_64-unknown-freebsd-llvm_version+15.tar.gz/md5/728e79f334e5151fe5595711763baca7
+LLD.v15.0.7+7.x86_64-unknown-freebsd-llvm_version+15.tar.gz/sha512/2501a5cae4e61302e44f06fb7d38d15a776d750c6e99c30f89e1464e836a29c735d40972d48d19f1b38aac3f487cfb532d71ce9db2df8bfddd03d1fea5f3750a
+LLD.v15.0.7+7.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/12329ff896ea6018df464e0d97154f74
+LLD.v15.0.7+7.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/f44e3e2c8b27b8c3a8f5c90d58a286e29b5ba6d05fabcd891749fee57b441c3ea846103116fe02e2d7f754e77e8ebd97198a180bd855fc8009e9e285a28435ba
+LLD.v15.0.7+7.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/0771c767ba9babc3961102d8dbb0087b
+LLD.v15.0.7+7.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/6ddf5174189f06a7cfa0be0e14f73e593786e02be51ed1e5576dfdf2f66149e68e0162a9fc23bafd5f1c2b445861734799cb0316a6762acc2c303bff417df3f5
+LLD.v15.0.7+7.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/bbb2c448fef481ce9ee96d311323bf7e
+LLD.v15.0.7+7.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/9f6fde5aa099e2eef3aabdb6a67f5664f0c3bcfd5b3bcb955565d26334f49acf1b976458b44867ce2d7aa0238370bdb9e98cfef30311177c059036b1c51d6109
+LLD.v15.0.7+7.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/e1b7c87717936fe073638b22892fd380
+LLD.v15.0.7+7.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/96bf89bd3edf2225a704ba54675af2c172a469adda9f2700a091af63168b46da7bf13499fccd7a4bede8ec6f9c6da14c42f69df9c1f2ff3b3a9b1ec9801f2eff
diff --git a/deps/checksums/llvm b/deps/checksums/llvm
index 6380397ffb84f..02de35bbaa43a 100644
--- a/deps/checksums/llvm
+++ b/deps/checksums/llvm
@@ -1,111 +1,111 @@
-LLVM.v15.0.7+5.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/f18fa63ec97c79f3773af2bba51f69c6
-LLVM.v15.0.7+5.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/4ee1c3e746177296fbe976976c58b6ca09dec22943ac1e63008aeed94f46619e4e60d8278566e74f4912fa9d3aa21c8b03ae2bee360db54c7dcdfa2381469148
-LLVM.v15.0.7+5.aarch64-apple-darwin-llvm_version+15.tar.gz/md5/f482e543971546cd59d946cc33d79d5a
-LLVM.v15.0.7+5.aarch64-apple-darwin-llvm_version+15.tar.gz/sha512/d026b746f419e9bcc04daea60b1e66e26d4132e7a551b0f14c95ea95dc9a0f4e645110d8cd5b91b92bce7775ababb715747a2e4a09c0920787e2f25ef1bfbf19
-LLVM.v15.0.7+5.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/5d12f50225285b180274cc89c21e7c44
-LLVM.v15.0.7+5.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/3947f0d909444716a29c26a0645288e0f02ab19e6fa6ac0104c5ffc9659f01337198a5914beca2ccea7c98c9aeb12fc537891d440766054c0b9d3bbc40e24165
-LLVM.v15.0.7+5.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/e555476d3324996897cb0845ca22312b
-LLVM.v15.0.7+5.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/a809d8c455d6f72c2bfc2517ab375d6ce329880ae33c5c1bf575dfd599d6132e38df35fac4300a0e72726ca33ae1db69ae67f5fb03d5c617eb34f7ad20f09b8d
-LLVM.v15.0.7+5.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/6432ac27166a0ebb550c7b000c27e2da
-LLVM.v15.0.7+5.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/be6440412d46252292e6d907f04193ed3f438b06419d0fb8b067a7cd89e5cd2dd9143af4605de9a2a697ec2745efbdaf6021d065346041fec3b86051de42a26b
-LLVM.v15.0.7+5.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/0bfd05e6bd23c92b73751a86826b288e
-LLVM.v15.0.7+5.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/68c08b2624bd0d38c7cfaa8b61b7e1ed70c7a106dda814f146a3f5796cbd42f476ef19f726d3ce368d89e624c7a3fa7f07829c171d79581f3cf565dba28c27de
-LLVM.v15.0.7+5.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/53a9db6445352b44717f7e0f81d896b2
-LLVM.v15.0.7+5.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/ae34208c128f1d4468d8a25b060bd1904f36a73dd0029606394061843f90aa26f9c3071e8281e76dbc10fcfd103f04602fde370a0cb04d435fe2f7a230989cb2
-LLVM.v15.0.7+5.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/f7320272ec2f3cc86a742a8ce3b4cec2
-LLVM.v15.0.7+5.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/612f03f49b04fce2a21e3e0242c3ae591ccdf6398e31aaa63956c40fb805d4a060da8acd6e5ca1d1c0a7b1f994105ad74b1acf78490e31a149368c8a9c96c026
-LLVM.v15.0.7+5.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/db7b7a03c047a6aa7b599cafbf6023c0
-LLVM.v15.0.7+5.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/05474495e73c56a8bf8a2459e705198a6c6e32df5b83ab153f1080a763d2f7d79dbe014592e12f0f3063b30bb0641dcfbf4f161ed988c777c8955ce9bdb89cbe
-LLVM.v15.0.7+5.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/88255189a80045bb410da1eee3c277e2
-LLVM.v15.0.7+5.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/b944ed004867d6bcf48dbc089d6ee5904318d6a2ab3a7dac3c802cb7646d4df21950a6e4bcd5bc57bbea872f99f39ef9e174dde8dfa4f5518f23a1fa0e8cf959
-LLVM.v15.0.7+5.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/a25160098b55d2ec00cde15d088343f9
-LLVM.v15.0.7+5.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/2e84a0b52a4852a69155aa4cdf33366b863caba7ced42db573e401a64c0fd2acd1d27446a3ad0ff94740a5fc4c579e745802bc32f925bb505177afdc64fb85eb
-LLVM.v15.0.7+5.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/10b225be9d25681a36fbffdb5f3e315f
-LLVM.v15.0.7+5.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/6c38d87c8aa321fa08ff9880bb27cedda1806bf6aece891f08f757e6276dd37e450a899c4fca587bb693f683f9ad0d85f388e7c4ec4a76c96e73f0f26ff6766a
-LLVM.v15.0.7+5.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/320b77cc43b91549ae0e6b538ff53f7b
-LLVM.v15.0.7+5.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/6b297c643530c06be5ef1d8dc2fd47abbfaa3a7862ba42ee9e4cff1361e54aa7ce77d4d9d7f5d2db38a3c780cd38a472eba1308e1f50aba74d3de3bf188fe91a
-LLVM.v15.0.7+5.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/c3e0fe843bfcbe0c03a563bd40a16f0d
-LLVM.v15.0.7+5.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/b62c3d8867594e34b1eb0c16f1db609c4b43146deceeabc23d4ee9af2046d8b2ae1a8566e2613a69691646d1991017f0a7d37ba8636a395d471f8f385a478479
-LLVM.v15.0.7+5.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/be03ae93d0825f335411a4039905052a
-LLVM.v15.0.7+5.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/9e0159681e8ecfe477d3099314ccf2986eb2a8325cee274b6ab35e04ee9e89ea61356e5082d9adab6c41b8be98d0171e41642afca283ec59ed91267e66223c6e
-LLVM.v15.0.7+5.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/9e244718d094dd6b2cdc50be77a284af
-LLVM.v15.0.7+5.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/705668d6b44bc754fff8f28246d8359773f29888c1f6ead6a5f1e10386c88572de27d4d47b8a1bb160211c07fcde2667833615c31ae445d1929229d981e36e3c
-LLVM.v15.0.7+5.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/12162558c4c89913f0486f3a4c969c8f
-LLVM.v15.0.7+5.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/dc6a48cdc9a04b3f0938784d5d40d0b453bf438881895c78a0cad9ebd83090cd9f1d12fc00df6538d053b2943a590a3217a8309aa0912fb3615d728280979276
-LLVM.v15.0.7+5.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/e5012844af1fd76d6cf92ff0921a9f24
-LLVM.v15.0.7+5.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/436ace73907097593bd060ff5674db2e36f7a6e4081033b078554b76244ba0d2caea30dd94a49fb62c96f2a1c3e1f190de440bd2bb9242c1206f4794b65b30a8
-LLVM.v15.0.7+5.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/9ee929acc7c52d18a7c42808761ae233
-LLVM.v15.0.7+5.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/12f07258d295245f2b53414d0df0144c547c60b090354b5548f50bb704a82e1623e55ad353eec233407f1840a50d423d1404fc3e7b87f2386863189e7f886813
-LLVM.v15.0.7+5.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/c94a2e1f4bc031a7c663111babb0f8fd
-LLVM.v15.0.7+5.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/4c82406d8df72312798d95ac0d038b38eb332b4f4f8a586bca7103bdbf7759365daccb6f3bdef9a9c74a06d04a12e96c01ac9fd03aa38f3c586a7ef3c7ec7e8c
-LLVM.v15.0.7+5.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/e038b8feabb2e60b866756a8dc7a5947
-LLVM.v15.0.7+5.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/c3e03bff11db87c7f131dbf7163b414cac91556795e4c5c340bec52409c39f7e91c26cb34a6339c10610d0906f57a209d36f6cfd458b26d24ffca9a43d259f5a
-LLVM.v15.0.7+5.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/b3bf4ff216946ad38ac6be230e0865e6
-LLVM.v15.0.7+5.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/0daba831dda378b2add9607fdc0d32046c0390a0a63758a6cdd9c0b90f660559cad0e71c5ee0b1c4264f3427e523a8c615bb87ebdfb63a65b983acfcb8df43e1
-LLVM.v15.0.7+5.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/33a3c56ab597e6f2c2863842f0103e53
-LLVM.v15.0.7+5.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/fb15d07a66b1f56b73625ead591f90b57a843cd9cb140e5158159a5f7c9249437678c61d0e19a11a65a536776dad37abd6be34ee0ec5dec7c0736079a0fcc7e6
-LLVM.v15.0.7+5.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/7488ef289e45e6c44753a42dc51aad7c
-LLVM.v15.0.7+5.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/6ecd62f0756a1941c8df92605a7edf9fc2e70957f39ae407e5b1b49977301ac6e82d55bcb856668135c27f1a75d156f3dfe7a27c47c6a3594c2c9f032af8ef19
-LLVM.v15.0.7+5.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/5a286dd05b936c0a3ab61722531ef5ee
-LLVM.v15.0.7+5.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/80016717959246708eec8588fd6bb5cb4894bf05c2d78cd1641e31cb43f38c0fda866283dabf1d999c77d030b70b89363e2346bd9b9310a2999623e47b2e4e7f
-LLVM.v15.0.7+5.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/b62420d31c65fd8720427900b72f9aa4
-LLVM.v15.0.7+5.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/f63f62a667f6f2c6ea76db2b142d58cad3165a426fd420348f0831d447a9eacfda5ec9c006e05f60c1f2804e8b25e87369e754a0bace28257035a63a1ea23a76
-LLVM.v15.0.7+5.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/ea922c8edae65c855e40f6ff924c35d7
-LLVM.v15.0.7+5.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/d83a3737058da3c2427c061cac83ad910c43368e47bd1f9ff86c21ef0b40669946b128bd1063a8fcb081563ecf606d70a783a0747ec951c3443077b3ec8e93f8
-LLVM.v15.0.7+5.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/7a20fc23311317b85127fa033cb69059
-LLVM.v15.0.7+5.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/36d51f84dcb3c76556b6ee677a4f0fde1610df30a7030d1799fe9681c27e04faf1ecb4b5731db9a58060879076c037e3e5bab65faecc527296b439743bdd7d86
-LLVM.v15.0.7+5.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/bf6859a7e73fb51bf91e2c7ce5b879e9
-LLVM.v15.0.7+5.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/39aa6b1e2923aa572458cba58a328bf6ac0efd5f11974e04343d65cbb56fc5804066f7cedb1e9c58252313f94ee0487d6855a1714adebb3b71fd6c783a01018b
-LLVM.v15.0.7+5.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/10c32deaee824ed7a19dca9055a138ae
-LLVM.v15.0.7+5.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/b9b14c9ddc2b0b07c07a53bbd3b711737d1a7d71626d3c34812bc3862145865205e5da07b052e119aeaf54fb97968b27e86450d768312623a7a87c6b8179d872
-LLVM.v15.0.7+5.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/caa574701f180bf4dc323ecb441fa53d
-LLVM.v15.0.7+5.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/1c97d2311111f4411c3eedc6f1338a8c899932e7fc3490a03c0c9b2bc4c9a52d5797c50339ec7105d60edca951fc57c6f11bc7198c8e1c96334147d2b2dc670c
-LLVM.v15.0.7+5.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/f46c39e2f848fb5fbc9f1eed7fa695af
-LLVM.v15.0.7+5.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/ed5bfd8057b2d6d543c4a11f0c1c6502dc7aafd07d0c5a96ca2b1d0c5194093f20f995ee38a4a25cc0291b31c682c6dcee460f9fb657b90be5afd43258ce4c43
-LLVM.v15.0.7+5.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/06533f3ac22a8a9be2501b6708821806
-LLVM.v15.0.7+5.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/5284308b46ab1d8ed896e0425fae4288f87a640707c8cd5f298520cb19cea8d6311b0e6d21d5ed016f6d87f47b93d92d371abfe9bf1810b357972b7c9b437811
-LLVM.v15.0.7+5.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/f75c2acc329a9ee041ff2c81aa93b4ed
-LLVM.v15.0.7+5.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/6ec83776bac9e2cf2cbf3f890412a940c9507ba06eb50b6a05148c9c336775168cd5b6ec4aa1aa148703e6724c414830e54c3ae075e4d3649280ada705ce9816
-LLVM.v15.0.7+5.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/7e2ea1a3e9c61976b446cbceadf33193
-LLVM.v15.0.7+5.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/b21830528362115476cec7f32b11f3c1541a5779027c824882fdc00b248ea0f0ca8d08ebd86b938c10fc80a7f7930d86e2cd4482fdce33822613128eb250884c
-LLVM.v15.0.7+5.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/d77b1c5ec7cb8bd02ccd24347e2e620a
-LLVM.v15.0.7+5.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/84ddacf1c222bb5d895939ba4aab80dc6b5c5c596a36fcc2869a87d639d006a156750f04d268b6c10b47d286cf3bb5e8c20804174fc93881383f2512833ad7cc
-LLVM.v15.0.7+5.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/26f634aff16b5c8cff48b0183f3f8ddd
-LLVM.v15.0.7+5.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/cc3619c9c8adf322bb334a6b2c9de1ad088a17f117bcb9aae5b51a4f7613a50391c3478b7f892e9dcdb802067de69b098ba7d61edc9979b8f960028af0fa172b
-LLVM.v15.0.7+5.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/891a1f113e7f3f8dfa56f5f28e1c8176
-LLVM.v15.0.7+5.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/9b6a4a26c8f83764f892f7caf5f09a5453ab6e89c742ae4cb1e831a0711104d131d8fe0d9a8cbdd384b2d881edb3d9026af804f47f5f79d62da1d51dad4ec0e0
-LLVM.v15.0.7+5.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/7dbc009fb3ef6ba400baaafa733afb54
-LLVM.v15.0.7+5.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/c279c4be6a5e131b567625173b33e1f51a56c53eb0740895c1afc8b6824a00d4331df76bae9960c2143f7bfc2a9758dcbc7898fb49ef4aab56df6bba7030d636
-LLVM.v15.0.7+5.x86_64-apple-darwin-llvm_version+15.tar.gz/md5/007fdc357a995d68a01fb45d52a92da9
-LLVM.v15.0.7+5.x86_64-apple-darwin-llvm_version+15.tar.gz/sha512/2bf2752f654db140822f4ed74494bcdddb85f4040ae24a753ed9c77efa29d2f50397719fa20de031325823004a66ddc1c00c9624887289c8020d6627ffd21f5a
-LLVM.v15.0.7+5.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/fb17aeedc48fb6a24f0aa2d078ceb2f3
-LLVM.v15.0.7+5.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/bd622d2472f85ac5b0cb255a929413ae3b30ee06ec7204148072dc1f9da7bf451b07960f4905a66d2673db9926797e4bc33b262cff656e7bf4cbcfd132b49868
-LLVM.v15.0.7+5.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/eceea244f8fdaf61c6addac8b8f57319
-LLVM.v15.0.7+5.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/44ab4a30ff65685a121dc54c2de55de441fad95b02f54cb359ad44fb298adbf48fd7651ce871fecb40b08d95e1ca701ad4c857f975a37a5e5a42280dab6fc670
-LLVM.v15.0.7+5.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/b09f19c4940f6fa12ea8b5076501e297
-LLVM.v15.0.7+5.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/a52da2ace1f0f2ce0090a582a267fcba526c86a88be3d8e55020ea07e00a1cbb0323f8b8b0205c9417982774fcc05d667b8330f7676dd40c869f374130dcc50c
-LLVM.v15.0.7+5.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/a365e7fd610b6f6ad2dda2d94a141b4b
-LLVM.v15.0.7+5.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/5242fa37a93dfd99720f9c4966b4f9ac164987cb8de136c01b3474860c6229538e73db7727a6c7c832f651ce7ccb97dba0082cd66da2fe812dbc8ecd44fe2cf8
-LLVM.v15.0.7+5.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/6645a6254d82bf854e50e47d671b192e
-LLVM.v15.0.7+5.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/d330eb15c34e13cad0eeb046e2e27f10eaefcf1d6cb68bc4d55668b55e3c00cfa07bccfb4292647a737ffc69bdf4070cf5a8bb1cb7f6319a1caf0faddde7aafe
-LLVM.v15.0.7+5.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/4073ae0cc33b7f803644a272cd0730d2
-LLVM.v15.0.7+5.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/2ea897e3ed3688e2ae45918db51c5a1273afabf46d01a6a27739ac951803645861c549fd438b48dcda05294a4d87b6c39778d42e916301277a0bfc1d9ce53979
-LLVM.v15.0.7+5.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/e223954ddf9e11830cbab24e4ed435c9
-LLVM.v15.0.7+5.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/fb88bfc543ccae5cc9ef737e81757a8f7f61d1a2816501d569456fa62bd8ce30ae57b837ed32dd6d2a7c55fdc26c2c1b1a9965968f784eb3c01680f25ee5bd8e
-LLVM.v15.0.7+5.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/356d2f3008be6e04843a278d182834ff
-LLVM.v15.0.7+5.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/ae5b30925cce41593a34cf2e76b606e978c352f2bc915d8869b01600c8a81547ad392fc900766db2ade06355c2d95aa473bd51dd3d45f6bf20289d9cdfbb126a
-LLVM.v15.0.7+5.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/md5/c31804464c51d1967e73f491948e2763
-LLVM.v15.0.7+5.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/sha512/84ab795067bbe71390f15b2d700ff9e0c4fc124c3d111bdd141643242cf6dd7d3317a92d9c97ef5129ef089cfa3d703abc2b12c6a9d2287c90a9ad58a4de8478
-LLVM.v15.0.7+5.x86_64-unknown-freebsd-llvm_version+15.tar.gz/md5/9f205efa80dbc9d43560830c668659b9
-LLVM.v15.0.7+5.x86_64-unknown-freebsd-llvm_version+15.tar.gz/sha512/54548970bc7b3988142c1a5c2be36f877c4d2cbdb3a58dba71acd7bb32b20cab2ab12c82619abeb6b3bde9a95fb66942e08104df0fb0f59d2ead7eda957b783d
-LLVM.v15.0.7+5.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/ab175b04b9c8dc73f2c06c06bd9d6915
-LLVM.v15.0.7+5.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/c28bb2033ce2fe182f6a5a29e34a6ce4cdd22e994245f7122c4efb39cedd491c9d4343d8ba2aa8062eac156ad36d9f54605e6832feadce3c6e9f66e9ed7c760f
-LLVM.v15.0.7+5.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/7e4dedc77bdcd6853d613d8b0e3e9af0
-LLVM.v15.0.7+5.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/e09c451cf018548bb388f9a0b419496a6c6540cdf1e204be391391b3a5645c2198562c2f995c3ae30f775c786e9e59e8b93c0fbb5d00fc9ebf1529dbca9c568a
-LLVM.v15.0.7+5.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/0835b50b6cd53b4d1fd894f27b3e072a
-LLVM.v15.0.7+5.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/8d228561f66feaaa96cf0af71421032f6c241e8a8ce3b8352771072d7bdd972e1b6270e15b0a4f5f4b76764cbd65ec371626cabe8607294041679fe9b6bac5f4
-LLVM.v15.0.7+5.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/bb61fbd156bb0a70184f6f425ba770a5
-LLVM.v15.0.7+5.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/ec310cab20f39facaa6c0b3a8badded0e4ffbd7bbc1fea6b3e67717046bfe6932a94cf562d3e35dba5052d5cfe62c540c6a38477452e535da52e650fe5dd4d6c
+LLVM.v15.0.7+7.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/8b23ac6a55ad8a8a911af1cd2be84f7c
+LLVM.v15.0.7+7.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/60df009ecef6b7d435fc198dd477e9198e1f96d89b3c583b06af5b6b938b9f4d545f75f09d0daee93f94448f6fef36ca2e0b541e1179280e6d918b02c619291f
+LLVM.v15.0.7+7.aarch64-apple-darwin-llvm_version+15.tar.gz/md5/649c61e6bb2ddc619d2f967d923a62d6
+LLVM.v15.0.7+7.aarch64-apple-darwin-llvm_version+15.tar.gz/sha512/864910013f659f473def2a5df78adf5c13f6f84f400d3b87c5660ef51a97c86520a73cc6072db2ed739f3e7e3e2d326f34634bc9ab432edbab59baaf2085f4bf
+LLVM.v15.0.7+7.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/2bae4d31c56385e73f3cf667e5cb5582
+LLVM.v15.0.7+7.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/27f8479a639434329fc5e67326df2c22aacee61237cb1eb1bf9938a58b1dcf883ea0476a066dd284047388a42a3b676c37b2c800f97feab694edf091aa10a8b7
+LLVM.v15.0.7+7.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/040485a871ce0036fb19f3e9ab9ed1f6
+LLVM.v15.0.7+7.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/0472ab3fb75efe1b67ba8c34cd9b36377ef9206506f741ea9a6289d3dad4ba4d0560578661bf9e433b51c03c77a9de5ed23df37e160a9225bcb50c27e5431e76
+LLVM.v15.0.7+7.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/12f54c1888f00373ea1e8fcafffbc313
+LLVM.v15.0.7+7.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/fc246d39c1711cc041b014a77e8b0c9fbbdf86c92a1c027e35a152d18bf6cc72d8b059c65457851ce240a5c745ebd39934ed6ce6f553d408ec8ad4078135c746
+LLVM.v15.0.7+7.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/7065ccae75d0e16876aec6d96de41409
+LLVM.v15.0.7+7.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/1c0bdce88797baca3188be7927d7694861bc491b4ad7970e485332ecf36b28e121a57e3a4ffbe83f6919f00da66d04d7809c589b8f9bf4b9940b15cc5c1590e0
+LLVM.v15.0.7+7.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/708f78fb147a1a5455b1f0e27e0a8946
+LLVM.v15.0.7+7.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/f7aa0dab1f2b0a7dc5324ef1ed9969e31334245938f2954425eaea2c034072d844a3c9eed8b522bf1794a22d822117d6beff6c23872c875dcbcdd7cc719a6d61
+LLVM.v15.0.7+7.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/eaf4c42566b3ffbd6c3fa3fdab126d0a
+LLVM.v15.0.7+7.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/7d60771a1795fe328c8f5fb534580d34016f6dcd85c268e94d6ed8af7e68fc74e3bb25ed8262bef4100b9341dea180a2961d1705e453d37dc5d6a01ff9b00ae8
+LLVM.v15.0.7+7.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/f4ed6360b1e46be18392900cf5e6e413
+LLVM.v15.0.7+7.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/0dbc3f7954ef085bff00cf1a7d18bf338bd76f67ab98d972a486942ade7f11a6c9761a4605ae653402d867c543a065d6c238bd6a375852544e89eb9f9cc6c335
+LLVM.v15.0.7+7.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/b8cfc0edd85f79fe0ee22b84b9271d62
+LLVM.v15.0.7+7.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/8f8b5111223d433bbbb7ec48df5436ee5a4c21c4cd57fab1b6a4121d72230251998035c9d62993d442af279e3d393afa2df1c161af2762420ec149ee16f01833
+LLVM.v15.0.7+7.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/5cff8a24ca2d1da58ea709d34c33decd
+LLVM.v15.0.7+7.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/2c20fef573744dacafc6333687be408b474c9773c558fe08ff1702d1957aac3bc99dd9998866651bf9af7473214d1be236273725501cf9f5c38d1807f1605456
+LLVM.v15.0.7+7.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/2721d242b457748e3f8301b085282c3c
+LLVM.v15.0.7+7.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/8a73828ebd84e683f9a043007bba955ca85deec608d9602fe29ef18fc999b4959bc8e87c865bcd060adb8b4c15f8cb04113027b37c3b4e075cc8c7946831a52d
+LLVM.v15.0.7+7.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/8c8171ed600e466b022a96956fb93e69
+LLVM.v15.0.7+7.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/48798715ab9866528d55b0c75a9aa6a87e03b771c3a29b0f3d88bc8d89845ee8f39ddeb6232a0337eb1491092322fb7617e5ebef1e55c0bc4c46f05ed115a0f8
+LLVM.v15.0.7+7.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/8343d87440928bdc76f0209eb905fac6
+LLVM.v15.0.7+7.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/e20a0fb7e3cff62832ba840782b84c12ce8ac38cbcd0eff82dbc6a6ab5cd58c59cb760f5b85e4e60dec63aa274e8e43035c5e1fa5e77639d607971690487b3a4
+LLVM.v15.0.7+7.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/f6a415de133867e9045c5821ae2bb286
+LLVM.v15.0.7+7.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/acd4c6a31f998f506c747f3d8d4ddae393f6a58a282a928913d4eab850147e485e99fc953d4847d00555a1bde295255eed530e4dcf1dbd46e62d2c0a4df9c4c3
+LLVM.v15.0.7+7.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/4164c3a46ea05eeda4c471b290b9c782
+LLVM.v15.0.7+7.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/c19df17b57f67d2dd281f1939462250aca5b6cfd99598b0dd45eb76ba46f4b02c4e3ccc8e09ca57843c12de822a94df88d5593a34b401050f148452986094ec2
+LLVM.v15.0.7+7.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/1d3bd6f4770fba34a9f1b14a3871665c
+LLVM.v15.0.7+7.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/686a8be7a96e37b91d70bd06259a8a61b6e8d2fbb3b28d9252b987b7ed58ae476a4cb1b773b143d41dc6de23a7b969cedf35c9b8070052a7b9882503379d4f6f
+LLVM.v15.0.7+7.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/3783a3c99a4c8c27ae367e5bb717cf3a
+LLVM.v15.0.7+7.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/34bc40f96d054487022879477eb826ce769b507c90de9c481107f582a1c995a9af9172d1d017eb30e6a9875f68877c26b76fd3ec48a4338c9e5608d970d012f5
+LLVM.v15.0.7+7.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/b6d3fd4b5460fb336ccf71ed4f27112c
+LLVM.v15.0.7+7.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/9558ed5556c8c0ef5f3882f76bf4f4f5ba8bb642eecd3a6f9f7d4ad82c0d9a15038e8fda0e613eb614b747ef045e3bdb1cc3cad6a674627e9f54e56abac67daf
+LLVM.v15.0.7+7.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/37ef614a98b59a8100ead9a5a0b3a369
+LLVM.v15.0.7+7.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/02f99b72dd23aeaeb5326c555e26f2090c311c8b111e3b203235ac503faa3d8499afda2e3541d0744dbbd8b6451c50d377b09ff7dfe37d3934b931e31b643640
+LLVM.v15.0.7+7.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/f0b6cfc6d392e597e305a77985949bbe
+LLVM.v15.0.7+7.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/9e2487984369a573e000b92899888ec845cb76dc20aaf200eaa1f52dbaedc8311c4161f3c9febce47b077be86aa8780c6d9c550f508c6b4949d76d236ecefcea
+LLVM.v15.0.7+7.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/a369c3db68953d38d71d2e342ebb72d4
+LLVM.v15.0.7+7.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/e0a4f18dd056578b690903dddc971aa91f91b194758a4ec69422f4834dd1c85224bdfd2b95d6f801cd4d23aa26c09a104452266ba8d61b5f1a429b57b2f597b4
+LLVM.v15.0.7+7.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/ab49be8073da48f3a353346fd6d9a833
+LLVM.v15.0.7+7.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/3f0a76b3940a918bf8206529a15d538db59e4c419cdeb4af0f338d343912d5708bf89ff89435a95b7ea42d3d36a83616a2f45bd21e1e8e4a067df5be22898ba8
+LLVM.v15.0.7+7.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/493df42ef5cae32a099ca7ee2c2dfb1d
+LLVM.v15.0.7+7.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/ac27639cd6273f6dd38bad0db9bba82f1dd299d9260c6877cc4b876d4f82fd518c758aeeea58b389e790eb7e212d0976fd1af1741e7854e8c287c4a381c5f0dd
+LLVM.v15.0.7+7.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/529256ff2095f50c1c57356819122ed5
+LLVM.v15.0.7+7.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/3922fb3a3419ee319392c68124550824e6644e7a638d39ac2831b6595c1e1fdce6934eaadb74415dc81f6ab349714e5443f746a61c0d8927c78b51987dc95a32
+LLVM.v15.0.7+7.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/82216b18dcc9148c3cdc00bdaed163f2
+LLVM.v15.0.7+7.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/c212134793544ba37247842c733b540055bb987b0854194d038f90dabbdf9ab5df6ca1e64c7e85d8071263d0b8f1d2feb99ac9d842b731551aa58ee2be2618ea
+LLVM.v15.0.7+7.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/465288c493241318c5947f756319d2ae
+LLVM.v15.0.7+7.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/4ef949ced9cf6c9f30c56388a8e53eb67c528e0635bb3c00d1dd204c8b8f74e72a6bc2104745dcfecf7c653ce1499d86c3a7acac98b565546b3826230710b92d
+LLVM.v15.0.7+7.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/0437433a85900470209cde06ee185e9f
+LLVM.v15.0.7+7.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/efa646ae330dcb5d4dc40a8e91a51248b55811d090111deddd415e22d8d7f26009dd4a124756dcdb9df4d83804f11576b786758692a5e82ceaefc88de3b9b00d
+LLVM.v15.0.7+7.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/895eedc69041096b1643f66976f2a51b
+LLVM.v15.0.7+7.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/dab5fcbd7e48e60c7d16031930e954a83a87e705ac72cba3f660bd569fa8b6a05d7ddf2551eb8e5f163d385c31ce197ca519e47e6ccf85982c6ae7072c6a301d
+LLVM.v15.0.7+7.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/083c0b15d8747cedfd617a9127792ca6
+LLVM.v15.0.7+7.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/427d8caba92e5bc3f88b9f33ca951fdb01dd6ce94bd852af61cd94f3476c35e82f9c387989c5847af8ae65d5e9ddfb6efc4afdcb57320bac1115b3ef23e9563b
+LLVM.v15.0.7+7.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/d66a108fbedcb078aa8c81b70688d5b8
+LLVM.v15.0.7+7.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/521d7008bee38328649657c4235c82f431639aac21f68aec9edcc4859958ea608c9f8dea537d63df3f41c9160f4eae18f2943518f6a71e83e3fb41ce0ec94c26
+LLVM.v15.0.7+7.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/3ca9fa624a36b101a1147890359c0920
+LLVM.v15.0.7+7.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/7cf691b77e252e11aa56b2d568ad5b2dcb131b1f2e685a6e77bd3a5b9a51c30aa2e654b8d4ef732f5c8bd5f9e4379846d4a002377760f3eda49264c958df9ddf
+LLVM.v15.0.7+7.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/a946f58fbf446c1605758b92b85b8798
+LLVM.v15.0.7+7.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/23b7e5b42611d7bce50bdc36326557807bd343e50a7cc8ddd7517a8b7807793bbdab2de0042e7dc413cdb7ee2ef565692844547cbd281341398265c8232fd61a
+LLVM.v15.0.7+7.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/daa0bc251d8f712d09544cd60ab5690b
+LLVM.v15.0.7+7.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/d86b55eb775a5f0e1eddb412e2ac4afe818b1ba0a40b96e764ab3c7f3324a31b45a0f23051903fe84a5020f3ce1bdb42130c21dffd1f6277e6c2f5db840cc50d
+LLVM.v15.0.7+7.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/ff278e2aa1a91a9bd6dc0d240ce23e3b
+LLVM.v15.0.7+7.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/5903a1cb350391f7e15ad81ed9c0690b43e267c5b061e011c61badbf324be544287869fbb4c2d68415c4621ecc37cc798762cbde34ccb64194547d63cb3a980b
+LLVM.v15.0.7+7.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/a02b1dea41d86fd28411798b535f7674
+LLVM.v15.0.7+7.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/7b6c94d8e60985206a7e6faefaca1dfab04a1a1378e8b52cd981726f6b6558caba23b716d44824fdb9fb54c16ec478e8de4296db9b2ef0be67680784ed26831c
+LLVM.v15.0.7+7.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/1d1f3db1b9a23c5948a5b982b46e5de6
+LLVM.v15.0.7+7.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/d741dcb76c3a143fe3b000999a627ba4a3abd36d738028e739e96c861be661cd1de12f5c7ee7e03826b1109aea11e80371d18865fb5332d1834f4dcf0ceca245
+LLVM.v15.0.7+7.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/3ed7af8b8e34820a83a8459edeb3843d
+LLVM.v15.0.7+7.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/eaab7e410cb433f2b83e6b38671a6e7489556865cc7007ce1588c8fcb0421c64dda480be231f96b30ce6fa75c2d9e99fbdb2a6293fa108ed9bc0599d2ca2ca63
+LLVM.v15.0.7+7.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/88003e4d20bce7d175d8e4db003e0eeb
+LLVM.v15.0.7+7.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/aed46b6b3aacf7ef373f9812da24edaf71ff1a382299e5f15eaffec605bb308fb3732846b9dde6d3afdeaa010de61773ba0e725d41e3b160fab37d2d0cf389cd
+LLVM.v15.0.7+7.x86_64-apple-darwin-llvm_version+15.tar.gz/md5/ef75e04e4946bb58091eb1a57b08ace2
+LLVM.v15.0.7+7.x86_64-apple-darwin-llvm_version+15.tar.gz/sha512/7e6ff0a8d511f19eb868d61fa50ff8c0014da4ea50ad960603f0851a6c09a693a66baea4563af6cdcf2f2fcd018bf2456a9e9479b9278c656ef64f0a08aa11ae
+LLVM.v15.0.7+7.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/95a8b1fe9135120ee5fba2441ad16f2c
+LLVM.v15.0.7+7.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/167dcff24d6144a4e211ee473b389d5fb4daa51d4ddbd98655456d3bee6c00554b91580a627ca5355e5c2d38a9a326f13c13454de64c0cc32a1f214a52b21400
+LLVM.v15.0.7+7.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/ba2fd64dcb09926f754fdde94ec5cde1
+LLVM.v15.0.7+7.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/fac4e6ab8875aa94cf6cf2065d718403b733954c18b0f5dee11148b70ecafabd92ff23155224ba5628c743fe963ee82a376ba9025f8ec8ca199a66412855ecd2
+LLVM.v15.0.7+7.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/f80738de98ca42cfc8c4ef141ec7cf0c
+LLVM.v15.0.7+7.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/ddf7670f555db3916933ea202672c7ffb51d254422af801ae928fa3618b3b7db1f7513710576dabd52f219cb2791e19803b5a4f3470f7ea05f71b0b04b03aaf4
+LLVM.v15.0.7+7.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/a502a8057b19bebe8aac1c42d9cda20f
+LLVM.v15.0.7+7.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/6e20328737c46fae6204cca68b16fa72e55c4b00fbaf8470b4847a869741fc0e2cef0da2ed9507fc4980678500dffbd42ccfe9f173321dee633bb0cf5adbe57e
+LLVM.v15.0.7+7.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/3b06471de330c6f4a53012711c7c9d72
+LLVM.v15.0.7+7.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/c19a9a2d8e4d3bca25a1568b0fdc01653b0b467dadc68967c4ab88512b4b78cab2e829fcfcd3d1e7139ad5bc3fab62dfdfd50be57f0d0099de383d820dafd306
+LLVM.v15.0.7+7.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/06a632eb722009eb4bbd49689b49a8a8
+LLVM.v15.0.7+7.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/67969cd09ab313b395cdf9f614dffeeda1ab72b2fa9e68057bc8dae9bad36d39443569b91ad88bbab9a6309a8084e09d40dff76d5d4bd261a1553afd5c3dd6c8
+LLVM.v15.0.7+7.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/bc000f09920a305fea5b32cf2d1bebd4
+LLVM.v15.0.7+7.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/580a3b12d7620d4c3148f988125d081b3fc76defb0e78702286806e08dcecf2b9c41ad8071334ff1e4e9ee4155d8949d07c57e8470109c01acecd2b37a07083b
+LLVM.v15.0.7+7.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/6cd4cf2922f69efe968637d240bcfd62
+LLVM.v15.0.7+7.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/7a23f48faf2c4e85247c684bc43239a21ea0732c980b4d46b50df27857f143cdfc081bca867a5692b086d32ff9031a230d496c0231d3ccb5fe3f48beb6ad480e
+LLVM.v15.0.7+7.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/md5/e7c54d9144ba36f697cd9be10e8e59cd
+LLVM.v15.0.7+7.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/sha512/bd96434dd2a79b335bd7169222bf5bd78fdc00eeb7ef2f364bb5ec71071d68846a0ba6b51d5b182522e6ff577d8e3d7ca3c014962cbc04ef5a04a7157887cd6d
+LLVM.v15.0.7+7.x86_64-unknown-freebsd-llvm_version+15.tar.gz/md5/22005a7066939bef459f0fa7ad8508a4
+LLVM.v15.0.7+7.x86_64-unknown-freebsd-llvm_version+15.tar.gz/sha512/2742a12f8a9054d6aa70fa823d2cae8126fc7a591849259e92b87b2e6b90ad7d21ffd855d34e08999600a5e2b591492502788d2ebd0a2564325ecc1860607b50
+LLVM.v15.0.7+7.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/76c1ef843acb9d29acf6c804ae9cbe1c
+LLVM.v15.0.7+7.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/7b25d5e6df47850c2c959b4e0d29db67582c3e0bbf102eaaad848f42787f421839cba1ed66a35ac99e106384a49e0474cdc7d7298569f95ff11df5f422554bf3
+LLVM.v15.0.7+7.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/d5358364b37f1bba07d2b22e16e76e71
+LLVM.v15.0.7+7.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/e2115a60b5fa74093b4d62a7397d7905d3cc89afc1051a3bee035925c6d5c06e2b4d16f7d86bdd2cc7519a506630697c6ad329841e7f8ced2992e7e969855fc1
+LLVM.v15.0.7+7.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/37702697b8cfbe73ce7f355d0eec9ef9
+LLVM.v15.0.7+7.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/bae316dae5e3bc2428c8b316155a8e02f9558580e65c1a8ca975bd10bda7170d1fe8584d0917e4af2f698362e18084cea8e0cbbe46707af3d3f07d0bf9a799de
+LLVM.v15.0.7+7.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/b0ba5f21e0724c66ab4e0afd40ffc630
+LLVM.v15.0.7+7.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/d25fd0015b67072fe2e57813a2250848ec8b86ba71443e294dc11e42e1b15148eed3c388cb242fa154c10ecb2bf6fb6b48272484a45e3337064fce4fad685b54
 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+5.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/c1bfb47e9a53cc612fe98505788e1838
-libLLVM.v15.0.7+5.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/f16c9f1faa3e959d486fbb109add976c2a2018597a0b053ac3168abad074ff9c2b23874f8969f0a71c6551c8092082938bcc35ad846913a0a9965dd27d6dc876
-libLLVM.v15.0.7+5.aarch64-apple-darwin-llvm_version+15.tar.gz/md5/cbe0859ffa50e2de82b8fe86c2540f6f
-libLLVM.v15.0.7+5.aarch64-apple-darwin-llvm_version+15.tar.gz/sha512/e864e7d62eb3b62066fe14210c43b79dfab704f04381ba29fcfc2a2e2b839e8db2ad3f61bb257b64cb6a546cc45e95195089e8b734425d9d4afa3168211f6762
-libLLVM.v15.0.7+5.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/352f8869f53096a566b387b885a74918
-libLLVM.v15.0.7+5.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/67dc69f8b327791ab77d4082208653ca74ce2cc750d9cba833cadf4d0f311dba73dbc951d0ce088a66b06321f7addda34bd5705a6c38d4d901b5813b2d1bd37b
-libLLVM.v15.0.7+5.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/220916b081fea2190e372df195daf13f
-libLLVM.v15.0.7+5.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/28bc05009335d61bfec33f24c89e67412f13760de72ea9acf7a12b2abf6d89cc3f3067fddb4ce598031b054b33efcf6773b4057d5adad830ab15c88fdbe56955
-libLLVM.v15.0.7+5.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/2774e9f2922e087d06e0976076d3ecf3
-libLLVM.v15.0.7+5.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/2aacbce77120fa9d24fd4026220e610b70c08b36175dee70f718f4d023b0ced9f8ae9dd2d58e35b61db7ca77ae337ed6f2da6a0de70296b4160a3f8e99ecdf67
-libLLVM.v15.0.7+5.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/63801b5fa51c2e75abd4b46f4ab1046c
-libLLVM.v15.0.7+5.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/eec9642a9c000d1aa3d298382a5b7c66caa81714665c7a405b416818f2e7a0cf1bedb81bc2a650452424391fe57061c33c2559abfc55bbac9b58e19d82131d5d
-libLLVM.v15.0.7+5.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/b3b3975a9a00b0292b9ba4b7fdf5e757
-libLLVM.v15.0.7+5.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/c886fff05f76053682a906dd94c6674f072206f37781b1025ec8a977eb952e0aeefcf20d76a3411e54782a6425667ee3a373f0a48d5a486fd4f37c02b0ecef78
-libLLVM.v15.0.7+5.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/88cf748f1a8086f949cb6217fcdd40b7
-libLLVM.v15.0.7+5.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/4e3d3cef71062b002406afb923f3d16508206662c3835242bf522cc7c881ea236695cee6add1b1f85a0b2708510dab2b59eafe004e67ee1d87a5970602a9d942
-libLLVM.v15.0.7+5.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/dae6e06bf26505fff786d0187cc5f90c
-libLLVM.v15.0.7+5.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/ed76e52223f84dd8c1ad7190341b167928493c2c617968aa17266c274527d18348865d9289cb82dd1c0d12240220750ac31e6c1354ddd9bc5ec2e226f360ba87
-libLLVM.v15.0.7+5.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/1bdae6507ca26b09a81c3b5b89f17908
-libLLVM.v15.0.7+5.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/b2704c0ef478467eb0fa21c7b436d6efc9602e8723bcf194dfcf6b3ac33d316b79de66c0c1c291e92f45f5bb09b6ab579a45782fa1ba3c03192177aaad6c29e1
-libLLVM.v15.0.7+5.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/8906c5b197baec7fc795256b92ca0a75
-libLLVM.v15.0.7+5.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/b79ec5ef4e59b0016784d31e51a94c9b292d19c36d66eadcfb3be6579244048b2650206836b4e017a63d84d8a0c72cd487f22ea08fd92f5b5ab4cb46d218e1a0
-libLLVM.v15.0.7+5.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/bd81f6f43b54364bef1e6486c17e3dea
-libLLVM.v15.0.7+5.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/892e4478e672fed55d63bfbf20a959b488e1cfafa332e2f1743cb519594526b5e0f2167b67636714dec6f43c76dcc0eb0bb2775eb43e4d898e63a0d1e78e9c94
-libLLVM.v15.0.7+5.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/6437ac1aa63c9b83c72238f4b0eaca00
-libLLVM.v15.0.7+5.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/f5e2bdb0af587e5cd55a5a2f16bf551c0e0fbadd2d9232fd5d3b2b38cdfaa80920d25903af5d79cb52a45a703a5bc07e550ca07163628cd1a79d3b3dda0d05d1
-libLLVM.v15.0.7+5.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/5616fc6e683ab133ed751d60164ca894
-libLLVM.v15.0.7+5.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/40944ea809c3f4000038b7b26e6297a5ce9d2710995c57b4e0751e74dcbeed9c00b1d89d0c75bf0f0d9094fd4811f5c5ca0cc5b83f54cbe20c1b2db85de44d72
-libLLVM.v15.0.7+5.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/dcdb815f425a6ec2aca7f29f601a73b5
-libLLVM.v15.0.7+5.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/3619419dbc81807db63e5c7bd7b237a6355ec60d2aada9bf26c1d38f10b4cb87a3cb3fc9a81e7f695ed7a195d2c3c214cd9bf96d3ccca68422898be323797fb1
-libLLVM.v15.0.7+5.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/ab2250406d3a69d68755b77b79b61f53
-libLLVM.v15.0.7+5.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/f5eaf02c7d19689a9cff2410269daccc00a075abde9287b025de3aff1d5b539b43001d1f2120f88c4c149af27eaf0caedb2942ae029550cc822e6af103b32960
-libLLVM.v15.0.7+5.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/77576af5b13b2916dae4e7e24760afec
-libLLVM.v15.0.7+5.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/1b3708202ccebd47aecca5a7c6396799ef14c4235b0904d23d6b6b4fdd91fb6b13a1627f65211ee0283a15d96b8a68cfc962d7aa2ddf75c08f2670a767c6cfa8
-libLLVM.v15.0.7+5.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/81277b7fde4cf08293f8ca956417fe05
-libLLVM.v15.0.7+5.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/72caccf9933e1790bdb0b6f6dc1ec5da6a84a5fc06336e29f2928142f3182261afd39477be913427d65655c40ddbda5ec5042c360bc49383e88c871db19b018b
-libLLVM.v15.0.7+5.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/d326fe9ccfbbf179571fdcd684bb7b80
-libLLVM.v15.0.7+5.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/a34550dcbb416f79648a5c4306775f1aca041c4e8e3b269e94f960ec0925d5b7cca0ed1934b2b63b9f4437d304d658adc6c0d3e0169c629d50d7c0b5051dbb04
-libLLVM.v15.0.7+5.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/5ced197907e87c470e5cc1ab08a7eedf
-libLLVM.v15.0.7+5.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/b57810b718bbfb1ec48415ec3e727388bb647fa3768ee191d81fbb16248edbde9332086d445ff57ad53e9d62fb9c8fb1f8be176649350f5eb57c744404c63cb9
-libLLVM.v15.0.7+5.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/4d5133f794e0b53d563ccfc10ca42e98
-libLLVM.v15.0.7+5.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/9fc7bbb8dee022304c4aedb930318db04345987bb7ec9b78c3d488a5616680738ca2b9a9087f60b7d6cc68650234295d18c6cee4a45d1956d2240791993fe45a
-libLLVM.v15.0.7+5.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/e5c8eae08bd2defe76e0985687d6f057
-libLLVM.v15.0.7+5.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/d632971cd93131b90d5a26fdcd8a262f2042a2dd59a09c82a8523558f2b292f9a3f285b0a6276f0e6b255f34d855736c0bfb9f426488c5929f2abf6c0b921b73
-libLLVM.v15.0.7+5.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/f0fb4b9b0257e0ead2e5aeafebb64214
-libLLVM.v15.0.7+5.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/1993c7d6ceb7efd93f2eb21379c046073b7d9d2460d6eab5aca26cae94bcbe07658780a2f6382a052e4d64813614078b5e582a933a0bc9a5d64d8388df98ce69
-libLLVM.v15.0.7+5.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/e236983a6c801d33ead6f60140cf1ddd
-libLLVM.v15.0.7+5.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/c6b44cd0d9139e0b1d47c8b17e9035099a6b360f873a2fc5c6e84c1c97dd455510f4f4262c746b47910703158fe0ceba0d19b8e6a61117d9723346f4c3e89004
-libLLVM.v15.0.7+5.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/c3ad2f3774b9b7651078fa3b2dfbe7ff
-libLLVM.v15.0.7+5.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/009561d4fecd65e35960843670048b79e70495c2cfc80a7c80614f253bea7ca46d8278d338bdf7719229fa7eb9f02299bf8bc39ace683b862ad005cfebcca0e7
-libLLVM.v15.0.7+5.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/6f8d226436a2822eb7e0f25d1073925c
-libLLVM.v15.0.7+5.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/b63a32b1eb4a8af210f6a9511bcc4c90ad39091a6b2c50431253f4fe5e1ab304b68f79e71fe55e173449ebc96a3395dd1ee55a9a8cdd289950b609a5bec8e722
-libLLVM.v15.0.7+5.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/a618c88b200fa25434e969a168b93a15
-libLLVM.v15.0.7+5.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/940d6b61162bdd2d9ab5c264c9ba71789638fec646e62b9204e9304c8244d10c8a5ea3603c84bff76c5471e7f3184a21e4d1760bfe05deec80c8126a7207db04
-libLLVM.v15.0.7+5.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/8a4e4c69ff51c941244d0765947dfaba
-libLLVM.v15.0.7+5.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/287e59ff6e8e81e1650796da7a01be568b9ef024eef0505eaa34cdaf4cfd8d798596e9396e48fafa39acab5e70c3a41129917e8ec7d625f9acb896bc4e9e7b5e
-libLLVM.v15.0.7+5.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/3f131f5c0e11db8de1e0268708ff17c4
-libLLVM.v15.0.7+5.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/04d1371a970694c234880ccd826f6a75615793867a3ba1fdce683a844cac3c9d33a58d34163bf2141624dde71f3af0e3582effbfce679ad2134894f86ac3ce98
-libLLVM.v15.0.7+5.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/8636def624785ea4b99d12c0d65bc0c3
-libLLVM.v15.0.7+5.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/b8ae5cc249664d32a8dbc26a2bf180a782f51ba69126d099bb239ee94afdca7b8492a7458971cc91aef0ca55a1ca38d3bf3c8716234ded81319a2ad5ac082732
-libLLVM.v15.0.7+5.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/bedb9f6540966fc382de1a4544ce8c9c
-libLLVM.v15.0.7+5.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/527ad792c220e491fcfb46de81b9b15cf4f6a1d50cfe4435296e0f94ae4d8e53165b6f634f85e95a8c7369a1e7b3788d1683fa77b843f56dfb1264313f80dae1
-libLLVM.v15.0.7+5.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/62051888207139e47c9a0694cf4de5c6
-libLLVM.v15.0.7+5.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/034e4e272d09ae8f573d3a7e591f93dc551651c7a32e2b8923fcd7fcf36be5bb491530f4673cb9bf39a54c1527cc3e3ecab64c79e3fd7075209fd81f32f7f4f9
-libLLVM.v15.0.7+5.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/8543a076a97e6c72e7c514021ca5f121
-libLLVM.v15.0.7+5.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/fc11ac25945adee135ebc523fe3908bcd5c5a7aa4c2a405e3dba61e0fb59502e5aef3cf4982502da7f7ee1974bcee8354ac675e0e0182f9319ea20c299813a1f
-libLLVM.v15.0.7+5.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/6247a9f59f87a2b923aacdc0a7c128ca
-libLLVM.v15.0.7+5.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/f13adadc653d2f8442c8ee4ecca9563d6cad5f958abf2893d8a3eda331d9ed8c33cd4a52bb721be811dec66b3b5566f038bfebbcfea620bf0094c305cd3aef0f
-libLLVM.v15.0.7+5.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/873155e60b133d597cf8c40169c5745e
-libLLVM.v15.0.7+5.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/a000e1fe4698d5c19bf85b048bcf76cdffea191ee281b44ffbd83230de5dd93c9efb564a51da082df070f2358d6dce423bf0d6023836217c5b34d563844d977e
-libLLVM.v15.0.7+5.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/17467f361317ad56762b7e455d869724
-libLLVM.v15.0.7+5.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/62a8d601c8db178cbdaa57a23a26cd65a8f3855be40ba2966b445afc9ee223db2ed6c2fc344ea98ff129d8917c14f34ed93158633521780d52763fc4a4f2a799
-libLLVM.v15.0.7+5.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/2c094ecef656dc6c9317038b0c5a47cc
-libLLVM.v15.0.7+5.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/af5972750be3de00df275a0f03c9c8a3b487a040f9bd29356457bc18661ffba9b3aa909849b24ae1c518fd2975a9b687c33353ba927f8713796a6c8eefa6e509
-libLLVM.v15.0.7+5.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/c10497e3f473e80e309d4c6102fc194d
-libLLVM.v15.0.7+5.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/2349230301cbebe8c7a7d7054bb4e60d991e1798dbb8bc6b8cf73350738e7058a9eb3c1067ce7d3ece1780e360080d00dd4777359742aff924d2db5c463f2a8b
-libLLVM.v15.0.7+5.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/15c99e56a9e8ed664deb2d6aedeb7ea0
-libLLVM.v15.0.7+5.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/c7d3d6d33f0fc0cad0394c02662bed2dd7d5389a6aa21027d7ebee124c3c9f5910316c44bd4485f1d45c6bb9fe12775c697a176602809bb52c8d3cfadf4f2737
-libLLVM.v15.0.7+5.x86_64-apple-darwin-llvm_version+15.tar.gz/md5/b8d748a34a381d085c962549612a212f
-libLLVM.v15.0.7+5.x86_64-apple-darwin-llvm_version+15.tar.gz/sha512/02afa1db42ff68a3ea0443ab539a7c613e5acb6170f7849cce1d36969ddad36e7546427bc55cd289df46a5fd8e83477b70941b8fd9aba0717dd861c84473da49
-libLLVM.v15.0.7+5.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/12f825c1c1586a8f7c9ce56e243b6bbf
-libLLVM.v15.0.7+5.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/f6c9cb33f129f1ff95800c0c88152d27e6de3fd78e01b29d75a80df9fdd8d95de70003dee0df3868215009cf434006223b488c64d6eb240f1e18799f529e980d
-libLLVM.v15.0.7+5.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/19d05d46cd97714abd23b668693afe4e
-libLLVM.v15.0.7+5.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/deb786016835fb34967e474235b1ca9c2e9f0258c88394979c41654fc4487ef83ac622f1e049aed5d83da8738b8f1079b3dbc67ca788f6c68b432d7007b850e7
-libLLVM.v15.0.7+5.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/0fee1aea27ac30304228af1f398dbf14
-libLLVM.v15.0.7+5.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/e14eb6fad8ef734efd5dae610cc1906901b389c7557853e7fad27c4cbf6c06614996bdd5840ee3640b9fcd8a870ea058c212bc978b6b869f4594cd8b06b42ca7
-libLLVM.v15.0.7+5.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/dc14c7faeadb0c42f4e9cffcae8c7684
-libLLVM.v15.0.7+5.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/10ef07d1e1fe3bcf8bc52da169156ad10de7b3bd54f16bf1d694bd243bc4c86b4244643f1a71fec94b024ffa2e605141eec9b10e6e65dce5d96aee2b454fdb6a
-libLLVM.v15.0.7+5.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/ee90487acb75a33b77f24fdb075402f9
-libLLVM.v15.0.7+5.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/6bc8605021dbb23aa71636318468a1f81f8dbf7308d637f551132700634fea208d24608c4afb28a9609a7a866302597f684d204f718fd8cae10a616abc1b7b0a
-libLLVM.v15.0.7+5.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/2c96c511ef55496a1044f63d4fdb096e
-libLLVM.v15.0.7+5.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/564202d6cd321b8b058124c4623bfa7d7310a5020140f194bfecd44a25490ff9590e661bbb838b1af4f7e40fc15f88363a1510d8f7a2138f8ccc52ad76700506
-libLLVM.v15.0.7+5.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/555ea3150d5eeeec54b1d463380447cf
-libLLVM.v15.0.7+5.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/9da05a39e8d4d9cffffe85bc2717e105a47137682ede9cbbd2f216065ebdbb6624b68a2e120a1b87247838276cd8a501c83aec63c91673229bde8d207f651f4c
-libLLVM.v15.0.7+5.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/a1f6daa0703ddcbc87b8f9d17c9ad54a
-libLLVM.v15.0.7+5.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/e803ba34861b600b350bc99484adb619bd75a82162633e8d80f1456a908d42d95842f194a6752fa43e683c26356592fb94b64f7823b64edc922aca154d970288
-libLLVM.v15.0.7+5.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/md5/364b73f29c1df14d8b942183cb113dd2
-libLLVM.v15.0.7+5.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/sha512/c4966e3607314acbace4b31dc095b81770ac3414ac1bddb43084443191b92b2b96f6702177dec76b70be12f7a3af4797c9692cf872ea7eaf60569dc7fdd92ee4
-libLLVM.v15.0.7+5.x86_64-unknown-freebsd-llvm_version+15.tar.gz/md5/d4aea085c08951e0facaa553b3c22a91
-libLLVM.v15.0.7+5.x86_64-unknown-freebsd-llvm_version+15.tar.gz/sha512/cc5cc36d50a342b5692144905ae52676fe9ff19054245152e3fff02276250604009881325cb5ef063f274b51cb2b45dcc88db0a929f6244d81cad1f241bd0c64
-libLLVM.v15.0.7+5.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/5cdf36e1300bbc9b032bebe5cba7bd6a
-libLLVM.v15.0.7+5.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/c732ba652aaf7a5f6aa8cd2f39088d83b78d2fe3121c4e2415bdc935b0a3ccdff7f028d3ef50f0b5f7bccff54f1fb5acbf970fc28301510d09b3f3847556c613
-libLLVM.v15.0.7+5.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/c5b335f634ec9e663a7c5d54dfeb1967
-libLLVM.v15.0.7+5.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/51c7b1ceb0e235d9d7db9727eb7744cbd8b2e51e189c58bfa6d3b65bc4b6e7a8224e8b7b57eeeefce01c7f65a4df48da97a975dec61fb000d83d23d15737728d
-libLLVM.v15.0.7+5.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/822be345af871cd1d5e595b2a83bedf3
-libLLVM.v15.0.7+5.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/fda0ff71c7a26e783436da214acc22842fe73df1f9d1d526955f4acd0794c3afa8722df8e4c9671b11948fd96e4c079fe525c9bf3e38b5119a79793a22baf16c
-libLLVM.v15.0.7+5.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/1201b56c0dea9d1fd2a5ceb4d62f78a9
-libLLVM.v15.0.7+5.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/550c041f495a2d2439e6c4abcd4db6da06702d32046f6574f6a595fceea467ebf896635bc70d9c3e41c99b42404c87d98e3cd76a34b0f959d21284e3e4f15941
-llvm-julia-15.0.7-5.tar.gz/md5/1ffb5b00586262196d24dcc7baa4a4c0
-llvm-julia-15.0.7-5.tar.gz/sha512/5b5c93b4359cee649974bbdb5c3c191cff5ce5c3862e7cce00e2e35dd0627bf50e0aee454e67ea0fadd21c36065b7c1cae6e77abdd512fab70b71899d369cfac
+libLLVM.v15.0.7+7.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/6f46148833fa386b55dd92e946561c85
+libLLVM.v15.0.7+7.aarch64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/ea1912f9a75c07374bc9c22c7b8b4321a0700f4ea196d29169e14a648a30d164897215ef4c4c6478810e5c5cdc76b1f2937fec4e6b0bb3e4f579bae06a219d0e
+libLLVM.v15.0.7+7.aarch64-apple-darwin-llvm_version+15.tar.gz/md5/0f2558df8ed485a93837e790bc646018
+libLLVM.v15.0.7+7.aarch64-apple-darwin-llvm_version+15.tar.gz/sha512/e7f962c4dd9675b6abec6129e7fa460ba3ba4bbe9eead4f9327a1db5fc9c64651d7424f9439ef396f0546f8e232bdc34eb625df0fa36bdfaed0e6b7af4dd0070
+libLLVM.v15.0.7+7.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/3317b67ebfb01c8d3dcb17c04d0f5ee5
+libLLVM.v15.0.7+7.aarch64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/383ec73210e00b02b3fe3f247bfe81a8c81668d3faf59c0ba9b0f032c41603807cb65808f28fc8a91dcf7cf72f3f5fa3bc68277bcb17cd35ec758ba3dd8ec857
+libLLVM.v15.0.7+7.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/f49e5ae9b0eb96cddeb3d68bec320d7b
+libLLVM.v15.0.7+7.aarch64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/e2cf6ef242479bc781f6ea70d7123b087370bad917c8f398757ba32d9446ef3b8c3d3b813be2c1ad3a8945dce1464551b57d3bc40a2e063199dfe555ad697dc8
+libLLVM.v15.0.7+7.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/e8eb2e0bc1b0693fbdf01c9dbe0e0170
+libLLVM.v15.0.7+7.aarch64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/245a157bd6b49ece87075d6250315f419506262c43ad6c5c76340d60ca1eedb00dab77c6588b91bb5cd8033e7ed1d97c21d801f8359486c9c350ded3bfae7642
+libLLVM.v15.0.7+7.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/60dea992b59646da2d719185f32f4a7e
+libLLVM.v15.0.7+7.aarch64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/7fcd64e51c87de8683923460d4596e406c5775d2ec6b7f4111bcb0689692dee09584622ecfae17ce91d1632f03a37cc9d43696190a5b92e916f4b8d4d0a50003
+libLLVM.v15.0.7+7.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/86385feda64011d17952300a29a28a46
+libLLVM.v15.0.7+7.aarch64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/2cf9f4934932b39a4a0195eab39f28c718c7cb5b830a425bddeb2f0a643fe6a74c7754483324f57e876ca8b92b5cfa1aaca802a44dc9ebcde86d8875c0493952
+libLLVM.v15.0.7+7.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/72cd1154871445247a6af96536ae1b51
+libLLVM.v15.0.7+7.aarch64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/b35740ff38e77c2b718f151e3ef55831bb4145d164c9c74bb78b7cce94693a6accb39cc747c67171cc43c72fff6cc72b3a19ba73e4dc8cf127ffe61f640ceac0
+libLLVM.v15.0.7+7.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/8dd9a908e0d94695352762d87bb5cfd4
+libLLVM.v15.0.7+7.aarch64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/3d9fbede7af089548bca9348c5ad13f146386ee4e2391223b4f9d299f9a52f7062dc758ab098805e481f434a5057ed37cb031d48de7fc3eb3137699f5540587e
+libLLVM.v15.0.7+7.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/f55864a3ee48940270502c637412dd58
+libLLVM.v15.0.7+7.aarch64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/c52bca8cb48cee54ad86bb86696f489d6a6d471238e49affb9af70b0e88ec6a4af57391a72f88fbea31f7c597a066d57978b1d3ea63a29cfae559457c66f6e06
+libLLVM.v15.0.7+7.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/20d1d88a807f96b469032e5c932c0696
+libLLVM.v15.0.7+7.armv6l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/d6cdc9746c81c504faa968638ea9d7fd9ded72ad0abdcf6c5adb8bcd127126d35506c2b6b3bedb977736a76318edb5c899ba555ff1d05df21f797a8f9a4e5122
+libLLVM.v15.0.7+7.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/b4d7d4ebce4c7bbe3ac11cca0017a67a
+libLLVM.v15.0.7+7.armv6l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/bb388db416d805ef5fbdbf4d2210d4b2188d6eae2c864692cfb1da7ba89de772423667e4648889db7cf43d9127aa13f77981d0b99ef321ff3f09faf7fd4b8bb9
+libLLVM.v15.0.7+7.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/b9382496b307f7e72fb12d394eef4e39
+libLLVM.v15.0.7+7.armv6l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/122a5f8daf1240c5d7b4f1926292311a3d287c4461516ee3321d1657ff3c9ca5caff54a1298f0d2a2b4c19627a57d626a4fb4455921862d87fe5897d672bdfae
+libLLVM.v15.0.7+7.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/bd564398619c3338e509e2f9ef7d7ba0
+libLLVM.v15.0.7+7.armv6l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/a54812732e95604031ef1fb420057ed40b909e211a68d5a533be617556c7c41e4022dea35fc6b8c81d8cb1227e4086d46b345cfcb6022dad9efc456ed85d7825
+libLLVM.v15.0.7+7.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/39daf88d35f518325138f8562dec70dd
+libLLVM.v15.0.7+7.armv6l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/2b2fd30a04cbdcffa57d12ea2785e3016456fbf1dfe99b74a1628ce213bdc28d65f8c6937175c700c0df4f5f8f1c257ef71f27d1d5cca2c5efe5598c893d5011
+libLLVM.v15.0.7+7.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/af88ec70f786750081d2948b6b9fd0ba
+libLLVM.v15.0.7+7.armv6l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/f2a6bf3d74ddd06115d4791bd7ed833fc9ff1c24c0a317d7756d181f7cc59d21da73e085abb7ab0b46a12b0cbe4656df0e9e509b057cdf7d3d0cae2304f6b39c
+libLLVM.v15.0.7+7.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/5dfdae75a373ef890d7e6c004cb16b2d
+libLLVM.v15.0.7+7.armv6l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/3993609a2199c78cc12f430f76c2c3b58b0d6f208271bc474e3869d9f505fadfa61e1c2c5774ca5190c7886cad68507fff9a0f6d11641106507fc4b5e3bc8a41
+libLLVM.v15.0.7+7.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/e426a70337cf4e38ba22f64c9adbabd0
+libLLVM.v15.0.7+7.armv6l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/c5ac86c22d016adf70e77970ae976a5081a85ebe1943a46fcb93be53f85f82e4aaa724e41b450306d0cf50dc4eb64367059737b6c828eab554f6166774201310
+libLLVM.v15.0.7+7.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/523077c1c0fedd6d5e62536e933b2c8a
+libLLVM.v15.0.7+7.armv7l-linux-gnueabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/246df1e0d1a038ea2cb77a9678ed0e13f568ca35bc2c751547b9e871163c0dd7e18ea321c88eb6c9b2ccce9ec4347c29c69e5cbc41dbbd43d23d7a658ca5fc15
+libLLVM.v15.0.7+7.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/md5/23aa72bc1511ff8f4c09a2bdf70085a7
+libLLVM.v15.0.7+7.armv7l-linux-gnueabihf-cxx03-llvm_version+15.tar.gz/sha512/4d1d46652e98e75925478a86bc3b2e613ce54d3e99cbd75fecc637dab70a72187c36a979e2124592cb764d867c39555c013497fc3438103aa320fb7e45247254
+libLLVM.v15.0.7+7.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/ba162cc558297ef830f94323e351aae0
+libLLVM.v15.0.7+7.armv7l-linux-gnueabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/f98f1c74f5fb3a1e8936692c0b9c57fb8da1ae8fcbe187e019d61ff6691cbcdb03e7f53b5254bd219856bc3dc4408cb29926744f6086a13c3a32e66c1a79f422
+libLLVM.v15.0.7+7.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/md5/9b364f0c1f2bf550d5908407120ab68a
+libLLVM.v15.0.7+7.armv7l-linux-gnueabihf-cxx11-llvm_version+15.tar.gz/sha512/c7bb0a90cb24352926c6a0d3599490db75f84e907697f48d1ac099767f4d3480e94a6e19995bd16d2c26c7cac1309bb579f71208899ce83aa617ec06cea2847f
+libLLVM.v15.0.7+7.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/md5/06ff2d8850863f47c6d7391d9bdc4cd9
+libLLVM.v15.0.7+7.armv7l-linux-musleabihf-cxx03-llvm_version+15.asserts.tar.gz/sha512/6d03c53673b072ba1936124b681219ca474f7d269dbeb3c0278ea88aeba5949a5af5388f3776f9bf5c1f05fef81922c9720d16fbb57737bd9b83925206f46cf1
+libLLVM.v15.0.7+7.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/md5/7d37c75e75b9fa3e5db8cc2422a65b90
+libLLVM.v15.0.7+7.armv7l-linux-musleabihf-cxx03-llvm_version+15.tar.gz/sha512/ffdb947940a033a01d0568f25018c125a743f3c71ce46565965ddbad52bd88596092190070c827aa6f7e70e22338e5d5162dfcb008deb80734f59d35437b41ed
+libLLVM.v15.0.7+7.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/md5/c31df5def85016f499c1a7daedf006ef
+libLLVM.v15.0.7+7.armv7l-linux-musleabihf-cxx11-llvm_version+15.asserts.tar.gz/sha512/d1b7220c0037450ec6efc4a2119c4dc4b9c48a20281c60b923f33bd80a9d146a69270983fe15cd8623ccfbac6c4bc4f4df3b44ad36cbcf86da8086f932e4da4d
+libLLVM.v15.0.7+7.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/md5/a178f55baca2221e71a0badc79b49bd2
+libLLVM.v15.0.7+7.armv7l-linux-musleabihf-cxx11-llvm_version+15.tar.gz/sha512/d613e2744c59b845b8893eba4a4579750d9dd4bf4375837aadd963f051475dcbf074d254dc8eacec2f4b2f77a9c1cca68f88b7948df8065910b1b0752dd2004b
+libLLVM.v15.0.7+7.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/2c5cd46b8a66d959807f4b285f5a221c
+libLLVM.v15.0.7+7.i686-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/43061164687d44c1aa92f11198e218af19e96b1fc6519a2f41a2626302b3089beda58d24040e3220424e718366c761c41a064479411c8c923eea1708b4bb4c77
+libLLVM.v15.0.7+7.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/1a0850a7e8c88088a6c26a50cd746396
+libLLVM.v15.0.7+7.i686-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/57bb6a55f7b84488d72195e1420826e94f082541fdaa0f981da1abcd8b1fb4f0a12f1398d786abd51943c6920513914e9476a05c7477b2e003e30a068304f0ae
+libLLVM.v15.0.7+7.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/538b7f590bfe5145c39c06aed74c845f
+libLLVM.v15.0.7+7.i686-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/98e59c9a2354f4881b61bc23ebc34c2f70e6394a54cbc6735a56f59688e248db85b8a674e1e4a2a60bb8802f23213767c17985c44eb530743132d3366b0ed2ce
+libLLVM.v15.0.7+7.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/854ce5a05f524762390216637048a2c5
+libLLVM.v15.0.7+7.i686-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/028714472e5e5ae01b667f1058dc704b051030c8c95ef4816aae1118aea6442f44d824e48c13cf4111f81ea151a7dd951aad40e4c05208730da4a4f9f4e52c3f
+libLLVM.v15.0.7+7.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/dc6aabdb3fff4b33a9eb75ace7e6615e
+libLLVM.v15.0.7+7.i686-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/457a1f6d28b287033f501247499c4a9871be7db7880b65f34ab615846c06759fcbb9b4643a6692f670d56bb2346311806475fc7bb82a699755ea6410dd999d37
+libLLVM.v15.0.7+7.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/0578542bbde3db752171f9420ce30d74
+libLLVM.v15.0.7+7.i686-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/93a8310e3b5bf85bcc7d1b20ee836805eb087a318bde258d5117babb877689e05d5a0d66e8c00946544b6e07a322c2af5bfd1499927cc325a98fb5b6aefdbed3
+libLLVM.v15.0.7+7.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/c2b7dec7d566c3f110f84a69e781866b
+libLLVM.v15.0.7+7.i686-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/44652389f9aeea2a8ba4e49bf78fa7d11ef3579205f178af844567e8e999917d737e233fe74a31cb3bf9a49847e364824109634e6683b75096b3f45a9fb4150d
+libLLVM.v15.0.7+7.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/1c13dbb8577ad9e7020059a474560286
+libLLVM.v15.0.7+7.i686-w64-mingw32-cxx11-llvm_version+15.tar.gz/sha512/1d3e4a06f3d6ae3afa976713ad8937a51c4e9fd0b544c1e9f8c74ae8579dba29fd8e77eb8acec0873dec8ec58fa91bfa6738212a504769807a758caa1f203b2e
+libLLVM.v15.0.7+7.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/ba4c9eceaa281a177f1f8b878bde35e6
+libLLVM.v15.0.7+7.powerpc64le-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/c0f8fecd3f6e1b342a075630ef0fbcd76d964e9bac08ac5e8a48ab0686c0ab91d327c263e045056a66b93f44346a0624af1687ea36d7f3c41c94d23d33c0d2ef
+libLLVM.v15.0.7+7.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/396cd763186100f920279ea551db8d09
+libLLVM.v15.0.7+7.powerpc64le-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/c79d60d522b4c186b51b7ea50fa8916ec63f64941225d535f8cceb25e3732458291260186684d098776091f8ba235c7c890fc635e8f39ac3c603aeb7c84f0782
+libLLVM.v15.0.7+7.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/8288ec83ada261b340994f5ea62c2efb
+libLLVM.v15.0.7+7.powerpc64le-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/c612e99e655dec48f0c1b2b28d5aa999c3ba8e83f7796a1f2807074ceccdb08a8b6a5e3554eacfc3ba7a99aeeb8c6b28217cdc957937e344a94636920cf288e0
+libLLVM.v15.0.7+7.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/039c44655a46ee04f7de2b184bba432a
+libLLVM.v15.0.7+7.powerpc64le-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/a47b840e221933001b9366aa90b5862f25eced86bead68164b98ac3b095a1a948a9d89a6d2f9e7db2fabf40df4de211b5ff5d7d10fc3572c24470764d14a559e
+libLLVM.v15.0.7+7.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/md5/036be0a300369212fe943134678ba985
+libLLVM.v15.0.7+7.x86_64-apple-darwin-llvm_version+15.asserts.tar.gz/sha512/7dc49931b9775372385a61cd9de441dae567df791c83adcdacd45602e8cb64848895b26e8c53476fe53d86d21a06a00c21623eba4ef71ca97a545bc4fc2c5b18
+libLLVM.v15.0.7+7.x86_64-apple-darwin-llvm_version+15.tar.gz/md5/747b5946945160209c2e5705a0ab0bcd
+libLLVM.v15.0.7+7.x86_64-apple-darwin-llvm_version+15.tar.gz/sha512/da1b2b543c648e322a1d87d2294a0cf87f4ae4c1c5b5708a3de6bfd29ffd589f970fa8f01182017db1743bc53d6726f9118438efef07484c7388ff0b0918c99b
+libLLVM.v15.0.7+7.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/md5/b5eebac2361874017e0908dd2b655953
+libLLVM.v15.0.7+7.x86_64-linux-gnu-cxx03-llvm_version+15.asserts.tar.gz/sha512/b3e1b05afb00e44d1b6b1ce9adc6934e2f2caf1d8bc8d112a7aee5526a39cf77d52b256b888bdc54ac848a98aa2714c6a8beca5603fff62e974595f2c2ce1b25
+libLLVM.v15.0.7+7.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/md5/16864fadbf7366031ec0f5aa69a295ac
+libLLVM.v15.0.7+7.x86_64-linux-gnu-cxx03-llvm_version+15.tar.gz/sha512/2099f8f4167f7a96ad2e9145e2c4e26d201aececd8a34d21c1e21b3865e8c63192cfef6e012863a6920b55d7865143527aba17805412b122f1fa0e2ff304b515
+libLLVM.v15.0.7+7.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/md5/3146935cca2cf625311fda3df6860aef
+libLLVM.v15.0.7+7.x86_64-linux-gnu-cxx11-llvm_version+15.asserts.tar.gz/sha512/745310983881e2839797b3da1f56e4adc115f34ac932215546ee1bbc869baecea1be077b546c9a68dd0fddb89551dea19ff181c691892e572f86ada885da3bfc
+libLLVM.v15.0.7+7.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/md5/7c3ba44af8f1fecd3c370614fda602dd
+libLLVM.v15.0.7+7.x86_64-linux-gnu-cxx11-llvm_version+15.tar.gz/sha512/ddf418ea2dbfbb61ce4c977e0b0ae29137e378458fab37b5fc18db8a7d196663d7012e28161efbaaa75824ad0bd0c16841625349d89c8e3f7738d973e760cd27
+libLLVM.v15.0.7+7.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/md5/b7985ca8dc4eb2b89239ce6e0083db89
+libLLVM.v15.0.7+7.x86_64-linux-musl-cxx03-llvm_version+15.asserts.tar.gz/sha512/babb426085a330434ffca6e55d1b237b780754845e4699621ef581b2cdbd803c0e0a0b3f91693f76848ba2cf1f177b6c342ebbd459d9926d6a4e0b7f4184de18
+libLLVM.v15.0.7+7.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/md5/cc912aceddbfdd5278f302dff233aacc
+libLLVM.v15.0.7+7.x86_64-linux-musl-cxx03-llvm_version+15.tar.gz/sha512/fbdd72353b76cab6c82af9e19e7f2abc7b5e19c634abb66d25cda0276c79e4c75f14eeaa8de6f03197a3b69cab130f0693bc3b17f144bed476a2e14268f2a5cb
+libLLVM.v15.0.7+7.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/md5/e9bc3f99cf16ad7e37b6f8692610c0c5
+libLLVM.v15.0.7+7.x86_64-linux-musl-cxx11-llvm_version+15.asserts.tar.gz/sha512/b7e0b1b1804d3641e8763eb35d08e1f9c9c2bdbcf9d129d1fae5835067d5b6ccda1acf0888b686c5e8a268b14fa455f52451e3cb6909446c9d053d3d1d261fb2
+libLLVM.v15.0.7+7.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/md5/ba454f84baa9f746de63e22714c740f2
+libLLVM.v15.0.7+7.x86_64-linux-musl-cxx11-llvm_version+15.tar.gz/sha512/2b61a1a6693c7899fd9af8630c9eb45b54b6c84519e50828d80a6f7eb88dfb3df6ee4d473f8e30ca11a0e1db2c096711164dc08cc61707277f7beb1902930f43
+libLLVM.v15.0.7+7.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/md5/1ebc12781d75fa94145bb6c7a2ba235e
+libLLVM.v15.0.7+7.x86_64-unknown-freebsd-llvm_version+15.asserts.tar.gz/sha512/43898f026a1f43ef035999654555afe4410425f2b6f56341100115e2a66825843fe93777c10ba052d60562a64a1150095fca4181a1c09f0820baa83736611627
+libLLVM.v15.0.7+7.x86_64-unknown-freebsd-llvm_version+15.tar.gz/md5/7259f7a15909745b0176c7bec2d5bb8e
+libLLVM.v15.0.7+7.x86_64-unknown-freebsd-llvm_version+15.tar.gz/sha512/fcf10dcc6bc0bfd4389859db1ab6a827fcc15368cbd42f1f50a2b7a3e752c4cd2676e65fcd69bf0eb42579293d303d770e06c6d10150ff17d7fdd6fc71d0155f
+libLLVM.v15.0.7+7.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/md5/15ce58ac469ed16d371c103718d12957
+libLLVM.v15.0.7+7.x86_64-w64-mingw32-cxx03-llvm_version+15.asserts.tar.gz/sha512/e671652b802a31311bc36a443b616b3826bbf9a5045cdf2593e055b224401bacc50b1439d13ae6eb7f55376c73c40ea5c972ee4a518777b85d4774a76bd15b10
+libLLVM.v15.0.7+7.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/md5/44e02ae3f143c0cca893332f73962050
+libLLVM.v15.0.7+7.x86_64-w64-mingw32-cxx03-llvm_version+15.tar.gz/sha512/a2b832da758f2d9911db535747d244b4f29b9f7730eca43eceac1fdbde4e262c14d6622f9c0ae38f2429221c5a113d8d59c0bedc243af6810ef1b75063fadb8b
+libLLVM.v15.0.7+7.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/md5/b30e6e6fdc1ade7a4148724facd5c934
+libLLVM.v15.0.7+7.x86_64-w64-mingw32-cxx11-llvm_version+15.asserts.tar.gz/sha512/51d7faebdb7863e6f2c8d97e0a5d119c2115aada5a6189b3b8b2928fdf8b3350f7b6eda67ce4ebe087821fda86ad2cfd0042ef3dc4a37c678e21267e04389541
+libLLVM.v15.0.7+7.x86_64-w64-mingw32-cxx11-llvm_version+15.tar.gz/md5/596a32ac2f4a2e4aedcef09cea7541a6
+libLLVM.v15.0.7+7.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
 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 d291dc8e8f8d8..c33134b5cb0f0 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+5
+CLANG_JLL_VER  := 15.0.7+7
diff --git a/deps/lld.version b/deps/lld.version
index d4b2a664d980c..9dc25700fd088 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+5
+LLD_JLL_VER := 15.0.7+7
diff --git a/deps/llvm-tools.version b/deps/llvm-tools.version
index f2ecd0b33e989..6166718149c66 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+5
-LLVM_TOOLS_ASSERT_JLL_VER := 15.0.7+5
+LLVM_TOOLS_JLL_VER := 15.0.7+7
+LLVM_TOOLS_ASSERT_JLL_VER := 15.0.7+7
diff --git a/deps/llvm.version b/deps/llvm.version
index 4e7969994141e..06473a9ed2960 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+5
+LLVM_ASSERT_JLL_VER := 15.0.7+7
 ## 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-5
+LLVM_BRANCH=julia-15.0.7-7
 # Git ref in `LLVM_GIT_URL` repository
-LLVM_SHA1=julia-15.0.7-5
+LLVM_SHA1=julia-15.0.7-7
 
 ## 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-5
+LLVM_JULIA_REF := JuliaLang:julia-15.0.7-7
diff --git a/stdlib/LLD_jll/Project.toml b/stdlib/LLD_jll/Project.toml
index 90d867ca0f7da..38b89e449e399 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+5"
+version = "15.0.7+7"
 
 [deps]
 Zlib_jll = "83775a58-1f1d-513f-b197-d71354ab007a"
diff --git a/stdlib/libLLVM_jll/Project.toml b/stdlib/libLLVM_jll/Project.toml
index 87519e5a824b0..804fd0f320d5e 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+5"
+version = "15.0.7+7"
 
 [deps]
 Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"
diff --git a/test/fastmath.jl b/test/fastmath.jl
index 21f3ebc1e603f..34744f325ad7f 100644
--- a/test/fastmath.jl
+++ b/test/fastmath.jl
@@ -293,3 +293,8 @@ end
     @test x == [1, 1]
     @test i == 1
 end
+
+@testset "@fastmath-related crash (#49907)" begin
+    x = @fastmath maximum(Float16[1,2,3]; init = Float16(0))
+    @test x == Float16(3)
+end

From e12f065dc217c693539fcce31b16590137c938b0 Mon Sep 17 00:00:00 2001
From: Nicholas Bauer <nicholasbauer@outlook.com>
Date: Sun, 23 Jul 2023 10:39:55 -0400
Subject: [PATCH 37/41] Revert storage of method instance in LineInfoNode
 (#50546)

Due to #50082, reverting the causative portion from #41099, which stored
MethodInstances in LineInfoNodes.

(cherry picked from commit ae798cd6427918e78f2d05c5fcc578085fba920c)
---
 base/compiler/ssair/inlining.jl |  2 +-
 base/compiler/typeinfer.jl      |  2 +-
 test/stacktraces.jl             | 13 ++++++++++---
 3 files changed, 12 insertions(+), 5 deletions(-)

diff --git a/base/compiler/ssair/inlining.jl b/base/compiler/ssair/inlining.jl
index 505a517e1bf98..304a5e78a13e1 100644
--- a/base/compiler/ssair/inlining.jl
+++ b/base/compiler/ssair/inlining.jl
@@ -330,7 +330,7 @@ function ir_inline_linetable!(linetable::Vector{LineInfoNode}, inlinee_ir::IRCod
     # 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, inlinee_def.file, inlinee_def.line, inlined_at))
+    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)
diff --git a/base/compiler/typeinfer.jl b/base/compiler/typeinfer.jl
index 77e1fd02de8d0..92e6b0dd5f666 100644
--- a/base/compiler/typeinfer.jl
+++ b/base/compiler/typeinfer.jl
@@ -1015,7 +1015,7 @@ function typeinf_ext(interp::AbstractInterpreter, mi::MethodInstance)
             tree.slotflags = fill(IR_FLAG_NULL, nargs)
             tree.ssavaluetypes = 1
             tree.codelocs = Int32[1]
-            tree.linetable = LineInfoNode[LineInfoNode(method.module, mi, method.file, method.line, Int32(0))]
+            tree.linetable = LineInfoNode[LineInfoNode(method.module, method.name, method.file, method.line, Int32(0))]
             tree.ssaflags = UInt8[0]
             set_inlineable!(tree, true)
             tree.parent = mi
diff --git a/test/stacktraces.jl b/test/stacktraces.jl
index 590abb90c590f..882114e71d833 100644
--- a/test/stacktraces.jl
+++ b/test/stacktraces.jl
@@ -91,9 +91,16 @@ trace = (try; f(3); catch; stacktrace(catch_backtrace()); end)[1:3]
 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
-    @test frame.linfo.def.module === which(func, (Any,)).module
-    @test frame.linfo.def === which(func, (Any,))
-    @test frame.linfo.specTypes === Tuple{typeof(func), Int}
+    # 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
     # line
     @test frame.file === Symbol(@__FILE__)
     @test !frame.from_c

From def06fe9fbea0657f1b22ec9cad09e4d03bc705f Mon Sep 17 00:00:00 2001
From: pchintalapudi <34727397+pchintalapudi@users.noreply.github.com>
Date: Sun, 23 Jul 2023 17:27:17 +0000
Subject: [PATCH 38/41] Shift DCE pass to optimize imaging mode code better
 (#50631)

(cherry picked from commit e23e1168a27ef60e92307dc076b786421dfb4911)
---
 src/pipeline.cpp | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/pipeline.cpp b/src/pipeline.cpp
index ca5992b6f3135..e5dead97f7195 100644
--- a/src/pipeline.cpp
+++ b/src/pipeline.cpp
@@ -342,9 +342,12 @@ static void buildEarlySimplificationPipeline(ModulePassManager &MPM, PassBuilder
         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) {
-            FPM.addPass(DCEPass());
             FPM.addPass(SROAPass());
         }
         MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));

From f8b0f298e8e6752fc05d30eb789072148d931083 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub.github@gmail.com>
Date: Wed, 19 Jul 2023 01:24:51 +0530
Subject: [PATCH 39/41] isassigned for ranges with BigInt indices (#50587)

This fixes certain possible regressions in `isassigned` for ranges to
restore the 1.9-like behavior.
On v1.9
```julia
julia> r = 1:big(2)^65
1:36893488147419103232

julia> isassigned(r, lastindex(r))
true

julia> isassigned(r, true)
ERROR: ArgumentError: invalid index: true of type Bool
```
On v1.10.0-alpha1
```julia
julia> isassigned(r, lastindex(r))
ERROR: InexactError: Int64(36893488147419103232)

julia> isassigned(r, true) # Bool is converted to Int
true

julia> r[true] # but indexing with Bool doesn't work
ERROR: ArgumentError: invalid index: true of type Bool
```
This PR
```julia
julia> isassigned(r, lastindex(r))
true

julia> isassigned(r, true)
ERROR: ArgumentError: invalid index: true of type Bool
```
This still leaves
```julia
julia> isassigned(collect(1:3), true)
true
```
so that should perhaps be changed as well.

(cherry picked from commit d270a71191372c4fe51306264daa1270b8b43ef1)
---
 base/range.jl  | 5 ++++-
 test/ranges.jl | 9 +++++++++
 2 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/base/range.jl b/base/range.jl
index 6b701d31b0358..bac5c389bd9da 100644
--- a/base/range.jl
+++ b/base/range.jl
@@ -905,7 +905,10 @@ end
 
 ## indexing
 
-isassigned(r::AbstractRange, i::Int) = firstindex(r) <= i <= lastindex(r)
+function isassigned(r::AbstractRange, i::Integer)
+    i isa Bool && throw(ArgumentError("invalid index: $i of type Bool"))
+    firstindex(r) <= i <= lastindex(r)
+end
 
 _in_unit_range(v::UnitRange, val, i::Integer) = i > 0 && val <= v.stop && val >= v.start
 
diff --git a/test/ranges.jl b/test/ranges.jl
index b263e6d4d530d..c9cf9228f091b 100644
--- a/test/ranges.jl
+++ b/test/ranges.jl
@@ -2490,3 +2490,12 @@ function check_ranges(rx, ry)
 end
 @test Core.Compiler.is_foldable(Base.infer_effects(check_ranges, (UnitRange{Int},UnitRange{Int})))
 # TODO JET.@test_opt check_ranges(1:2, 3:4)
+
+@testset "isassigned" begin
+    for (r, val) in ((1:3, 3), (1:big(2)^65, big(2)^65))
+        @test isassigned(r, lastindex(r))
+        # test that the indexing actually succeeds
+        @test r[end] == val
+        @test_throws ArgumentError isassigned(r, true)
+    end
+end

From 75734b3a6f6725d05015a12b9b110ff011cec5f3 Mon Sep 17 00:00:00 2001
From: Oscar Smith <oscardssmith@gmail.com>
Date: Sun, 23 Jul 2023 09:11:50 -0400
Subject: [PATCH 40/41] Page based heap size heuristics (#50144)

This PR implements GC heuristics based on the amount of pages allocated
instead of live objects like was done before.
The heuristic for new heap target is based on
https://dl.acm.org/doi/10.1145/3563323 (in summary it argues that the
heap target should have square root behaviour).
From my testing this fixes
https://github.com/JuliaLang/julia/issues/49545 and
https://github.com/JuliaLang/julia/issues/49761

(cherry picked from commit 32aa29f561a3dcaffad7b2595928a4aa41c51b81)
---
 NEWS.md                   |   1 +
 doc/src/devdocs/gc.md     |  12 +-
 src/gc-debug.c            |  17 ++-
 src/gc-pages.c            |   4 +
 src/gc.c                  | 256 ++++++++++++++++++++++----------------
 src/gc.h                  |  11 +-
 src/jl_exported_funcs.inc |   1 +
 src/julia_threads.h       |   4 +-
 test/testenv.jl           |   9 ++
 9 files changed, 203 insertions(+), 112 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index 81f744158d58e..112b229c3cf7e 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -31,6 +31,7 @@ Language changes
 
 Compiler/Runtime improvements
 -----------------------------
+* Updated GC heuristics to count allocated pages instead of individual objects ([#50144]).
 
 * The `@pure` macro is now deprecated. Use `Base.@assume_effects :foldable` instead ([#48682]).
 * The mark phase of the Garbage Collector is now multi-threaded ([#48600]).
diff --git a/doc/src/devdocs/gc.md b/doc/src/devdocs/gc.md
index c072912e77c3f..942535f426b34 100644
--- a/doc/src/devdocs/gc.md
+++ b/doc/src/devdocs/gc.md
@@ -67,6 +67,12 @@ This scheme eliminates the need of explicitly keeping a flag to indicate a full
 ## Heuristics
 
 GC heuristics tune the GC by changing the size of the allocation interval between garbage collections.
-If a GC was unproductive, then we increase the size of the allocation interval to allow objects more time to die.
-If a GC returns a lot of space we can shrink the interval. The goal is to find a steady state where we are
-allocating just about the same amount as we are collecting.
+
+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/src/gc-debug.c b/src/gc-debug.c
index bab2c5b0fa607..6e1587b17a6d9 100644
--- a/src/gc-debug.c
+++ b/src/gc-debug.c
@@ -1,7 +1,10 @@
 // This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #include "gc.h"
+#include "julia.h"
 #include <inttypes.h>
+#include <stddef.h>
+#include <stdint.h>
 #include <stdio.h>
 
 // re-include assert.h without NDEBUG,
@@ -1216,15 +1219,25 @@ JL_DLLEXPORT void jl_enable_gc_logging(int enable) {
     gc_logging_enabled = enable;
 }
 
-void _report_gc_finished(uint64_t pause, uint64_t freed, int full, int recollect) JL_NOTSAFEPOINT {
+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;
     }
     jl_safe_printf("GC: pause %.2fms. collected %fMB. %s %s\n",
-        pause/1e6, freed/1e6,
+        pause/1e6, freed/(double)(1<<20),
         full ? "full" : "incr",
         recollect ? "recollect" : ""
     );
+
+    jl_safe_printf("Heap stats: bytes_mapped %.2f MB, bytes_resident %.2f MB, heap_size %.2f MB, heap_target %.2f MB, live_bytes %.2f MB\n, Fragmentation %.3f",
+        jl_atomic_load_relaxed(&gc_heap_stats.bytes_mapped)/(double)(1<<20),
+        jl_atomic_load_relaxed(&gc_heap_stats.bytes_resident)/(double)(1<<20),
+        jl_atomic_load_relaxed(&gc_heap_stats.heap_size)/(double)(1<<20),
+        jl_atomic_load_relaxed(&gc_heap_stats.heap_target)/(double)(1<<20),
+        live_bytes/(double)(1<<20),
+        (double)live_bytes/(double)jl_atomic_load_relaxed(&gc_heap_stats.heap_size)
+    );
+    // Should fragmentation use bytes_resident instead of heap_size?
 }
 
 #ifdef __cplusplus
diff --git a/src/gc-pages.c b/src/gc-pages.c
index 682e76611f5d9..8d596f4a815ca 100644
--- a/src/gc-pages.c
+++ b/src/gc-pages.c
@@ -52,6 +52,8 @@ char *jl_gc_try_alloc_pages_(int pg_cnt) JL_NOTSAFEPOINT
         // round data pointer up to the nearest gc_page_data-aligned
         // boundary if mmap didn't already do so.
         mem = (char*)gc_page_data(mem + GC_PAGE_SZ - 1);
+    jl_atomic_fetch_add_relaxed(&gc_heap_stats.bytes_mapped, pages_sz);
+    jl_atomic_fetch_add_relaxed(&gc_heap_stats.bytes_resident, pages_sz);
     return mem;
 }
 
@@ -115,6 +117,7 @@ NOINLINE jl_gc_pagemeta_t *jl_gc_alloc_page(void) JL_NOTSAFEPOINT
     // try to get page from `pool_freed`
     meta = pop_lf_page_metadata_back(&global_page_pool_freed);
     if (meta != NULL) {
+        jl_atomic_fetch_add_relaxed(&gc_heap_stats.bytes_resident, GC_PAGE_SZ);
         gc_alloc_map_set(meta->data, GC_PAGE_ALLOCATED);
         goto exit;
     }
@@ -188,6 +191,7 @@ void jl_gc_free_page(jl_gc_pagemeta_t *pg) JL_NOTSAFEPOINT
     madvise(p, decommit_size, MADV_DONTNEED);
 #endif
     msan_unpoison(p, decommit_size);
+    jl_atomic_fetch_add_relaxed(&gc_heap_stats.bytes_resident, -decommit_size);
 }
 
 #ifdef __cplusplus
diff --git a/src/gc.c b/src/gc.c
index 0be48081d5687..41c0baf492507 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -42,6 +42,8 @@ static jl_gc_callback_list_t *gc_cblist_pre_gc;
 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 { \
@@ -128,6 +130,14 @@ JL_DLLEXPORT void jl_gc_set_cb_notify_external_free(jl_gc_cb_notify_external_fre
         jl_gc_deregister_callback(&gc_cblist_notify_external_free, (jl_gc_cb_func_t)cb);
 }
 
+JL_DLLEXPORT void jl_gc_set_cb_notify_gc_pressure(jl_gc_cb_notify_gc_pressure_t cb, int enable)
+{
+    if (enable)
+        jl_gc_register_callback(&gc_cblist_notify_gc_pressure, (jl_gc_cb_func_t)cb);
+    else
+        jl_gc_deregister_callback(&gc_cblist_notify_gc_pressure, (jl_gc_cb_func_t)cb);
+}
+
 // Protect all access to `finalizer_list_marked` and `to_finalize`.
 // For accessing `ptls->finalizers`, the lock is needed if a thread
 // is going to realloc the buffer (of its own list) or accessing the
@@ -178,6 +188,8 @@ jl_gc_num_t gc_num = {0};
 static size_t last_long_collect_interval;
 int gc_n_threads;
 jl_ptls_t* gc_all_tls_states;
+gc_heapstatus_t gc_heap_stats = {0};
+int next_sweep_full = 0;
 const uint64_t _jl_buff_tag[3] = {0x4eadc0004eadc000ull, 0x4eadc0004eadc000ull, 0x4eadc0004eadc000ull}; // aka 0xHEADER00
 JL_DLLEXPORT uintptr_t jl_get_buff_tag(void)
 {
@@ -665,19 +677,26 @@ static int64_t last_gc_total_bytes = 0;
 #ifdef _P64
 typedef uint64_t memsize_t;
 static const size_t default_collect_interval = 5600 * 1024 * sizeof(void*);
-static const size_t max_collect_interval = 1250000000UL;
 static size_t total_mem;
 // We expose this to the user/ci as jl_gc_set_max_memory
 static memsize_t max_total_memory = (memsize_t) 2 * 1024 * 1024 * 1024 * 1024 * 1024;
 #else
 typedef uint32_t memsize_t;
 static const size_t default_collect_interval = 3200 * 1024 * sizeof(void*);
-static const size_t max_collect_interval =  500000000UL;
 // Work really hard to stay within 2GB
 // Alternative is to risk running out of address space
 // on 32 bit architectures.
-static memsize_t max_total_memory = (memsize_t) 2 * 1024 * 1024 * 1024;
+#define MAX32HEAP 1536 * 1024 * 1024
+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;
+static uint64_t old_heap_size = 0;
+static uint64_t old_alloc_diff = 0;
+static uint64_t old_freed_diff = 0;
+static uint64_t gc_end_time = 0;
+
 
 // global variables for GC stats
 
@@ -730,6 +749,7 @@ static int mark_reset_age = 0;
 static int64_t scanned_bytes; // young bytes scanned while marking
 static int64_t perm_scanned_bytes; // old bytes scanned while marking
 int prev_sweep_full = 1;
+int under_pressure = 0;
 
 // Full collection heuristics
 static int64_t live_bytes = 0;
@@ -916,7 +936,7 @@ void gc_setmark_buf(jl_ptls_t ptls, void *o, uint8_t mark_mode, size_t minsz) JL
 
 STATIC_INLINE void maybe_collect(jl_ptls_t ptls)
 {
-    if (jl_atomic_load_relaxed(&ptls->gc_num.allocd) >= 0 || jl_gc_debug_check_other()) {
+    if (jl_atomic_load_relaxed(&gc_heap_stats.heap_size) >= jl_atomic_load_relaxed(&gc_heap_stats.heap_target) || jl_gc_debug_check_other()) {
         jl_gc_collect(JL_GC_AUTO);
     }
     else {
@@ -1005,6 +1025,13 @@ 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);
+    }
 #ifdef MEMDEBUG
     memset(v, 0xee, allocsz);
 #endif
@@ -1050,6 +1077,8 @@ static bigval_t **sweep_big_list(int sweep_full, bigval_t **pv) JL_NOTSAFEPOINT
             if (nxt)
                 nxt->prev = pv;
             gc_num.freed += v->sz&~3;
+            jl_atomic_store_relaxed(&gc_heap_stats.heap_size,
+                jl_atomic_load_relaxed(&gc_heap_stats.heap_size) - (v->sz&~3));
 #ifdef MEMDEBUG
             memset(v, 0xbb, v->sz&~3);
 #endif
@@ -1109,6 +1138,13 @@ 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);
+    }
 }
 
 static void combine_thread_gc_counts(jl_gc_num_t *dest) JL_NOTSAFEPOINT
@@ -1121,12 +1157,13 @@ static void combine_thread_gc_counts(jl_gc_num_t *dest) JL_NOTSAFEPOINT
         jl_ptls_t ptls = gc_all_tls_states[i];
         if (ptls) {
             dest->allocd += (jl_atomic_load_relaxed(&ptls->gc_num.allocd) + gc_num.interval);
-            dest->freed += jl_atomic_load_relaxed(&ptls->gc_num.freed);
             dest->malloc += jl_atomic_load_relaxed(&ptls->gc_num.malloc);
             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);
-            dest->freecall += jl_atomic_load_relaxed(&ptls->gc_num.freecall);
+            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);
+            jl_atomic_store_relaxed(&gc_heap_stats.heap_size, alloc_acc - free_acc + jl_atomic_load_relaxed(&gc_heap_stats.heap_size));
         }
     }
 }
@@ -1183,6 +1220,8 @@ static void jl_gc_free_array(jl_array_t *a) JL_NOTSAFEPOINT
             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++;
     }
@@ -1257,6 +1296,7 @@ static NOINLINE jl_taggedvalue_t *gc_add_page(jl_gc_pool_t *p) JL_NOTSAFEPOINT
     set_page_metadata(pg);
     push_page_metadata_back(&ptls->page_metadata_allocd, pg);
     jl_taggedvalue_t *fl = gc_reset_page(ptls, p, pg);
+    jl_atomic_fetch_add_relaxed(&gc_heap_stats.heap_size, GC_PAGE_SZ);
     p->newpages = fl;
     return fl;
 }
@@ -1451,8 +1491,10 @@ static jl_taggedvalue_t **gc_sweep_page(jl_gc_pool_t *p, jl_gc_pagemeta_t **allo
     else if (freed_lazily) {
         gc_alloc_map_set(pg->data, GC_PAGE_LAZILY_FREED);
         push_page_metadata_back(lazily_freed, pg);
+        jl_atomic_fetch_add_relaxed(&gc_heap_stats.heap_size, -GC_PAGE_SZ);
     }
     else {
+        jl_atomic_fetch_add_relaxed(&gc_heap_stats.heap_size, -GC_PAGE_SZ);
     #ifdef _P64 // only enable concurrent sweeping on 64bit
         if (jl_n_sweepthreads == 0) {
             jl_gc_free_page(pg);
@@ -3067,6 +3109,11 @@ 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)
+{
+    return factor * old_val + (1.0-factor) * new_val;
+}
+
 size_t jl_maxrss(void);
 
 // Only one thread should be running in this function
@@ -3081,6 +3128,8 @@ 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 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();
     JL_PROBE_GC_MARK_BEGIN();
@@ -3171,19 +3220,14 @@ static int _jl_gc_collect(jl_ptls_t ptls, jl_gc_collection_t collection)
     uint64_t mark_time = end_mark_time - start_mark_time;
     gc_num.mark_time = mark_time;
     gc_num.total_mark_time += mark_time;
-    int64_t allocd = gc_num.allocd;
     gc_settime_postmark_end();
     // marking is over
 
     // Flush everything in mark cache
     gc_sync_all_caches_nolock(ptls);
 
-    int64_t live_sz_ub = live_bytes + allocd;
-    int64_t live_sz_est = scanned_bytes + perm_scanned_bytes;
-    int64_t estimate_freed = live_sz_ub - live_sz_est;
 
     gc_verify(ptls);
-
     gc_stats_all_pool();
     gc_stats_big_obj();
     objprofile_printall();
@@ -3192,42 +3236,17 @@ static int _jl_gc_collect(jl_ptls_t ptls, jl_gc_collection_t collection)
     if (!prev_sweep_full)
         promoted_bytes += perm_scanned_bytes - last_perm_scanned_bytes;
     // 5. next collection decision
-    int not_freed_enough = (collection == JL_GC_AUTO) && estimate_freed < (7*(allocd/10));
-    int nptr = 0;
+    int remset_nptr = 0;
+    int sweep_full = next_sweep_full;
+    int recollect = 0;
     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)
-            nptr += ptls2->heap.remset_nptr;
+            remset_nptr += ptls2->heap.remset_nptr;
     }
+    (void)remset_nptr; //Use this information for something?
 
-    // many pointers in the intergen frontier => "quick" mark is not quick
-    int large_frontier = nptr*sizeof(void*) >= default_collect_interval;
-    int sweep_full = 0;
-    int recollect = 0;
-
-    // update heuristics only if this GC was automatically triggered
-    if (collection == JL_GC_AUTO) {
-        if (large_frontier) {
-            sweep_full = 1;
-            gc_num.interval = last_long_collect_interval;
-        }
-        if (not_freed_enough || large_frontier) {
-            gc_num.interval = gc_num.interval * 2;
-        }
-
-        size_t maxmem = 0;
-#ifdef _P64
-        // on a big memory machine, increase max_collect_interval to totalmem / nthreads / 2
-        maxmem = total_mem / (gc_n_threads - jl_n_gcthreads) / 2;
-#endif
-        if (maxmem < max_collect_interval)
-            maxmem = max_collect_interval;
-        if (gc_num.interval > maxmem) {
-            sweep_full = 1;
-            gc_num.interval = maxmem;
-        }
-    }
 
     // If the live data outgrows the suggested max_total_memory
     // we keep going with minimum intervals and full gcs until
@@ -3247,7 +3266,6 @@ static int _jl_gc_collect(jl_ptls_t ptls, jl_gc_collection_t collection)
         // on the first collection after sweep_full, and the current scan
         perm_scanned_bytes = 0;
         promoted_bytes = 0;
-        last_long_collect_interval = gc_num.interval;
     }
     scanned_bytes = 0;
     // 6. start sweeping
@@ -3272,9 +3290,10 @@ static int _jl_gc_collect(jl_ptls_t ptls, jl_gc_collection_t collection)
         if (sweep_full)
             gc_sweep_perm_alloc();
     }
+
     JL_PROBE_GC_SWEEP_END();
 
-    uint64_t gc_end_time = jl_hrtime();
+    gc_end_time = jl_hrtime();
     uint64_t pause = gc_end_time - gc_start_time;
     uint64_t sweep_time = gc_end_time - start_sweep_time;
     gc_num.total_sweep_time += sweep_time;
@@ -3283,6 +3302,49 @@ static int _jl_gc_collect(jl_ptls_t ptls, jl_gc_collection_t collection)
         gc_num.last_full_sweep = gc_end_time;
     }
 
+    int thrashing = 0; // maybe we should report this to the user or error out?
+    size_t heap_size = jl_atomic_load_relaxed(&gc_heap_stats.heap_size);
+    double target_allocs = 0.0;
+    double min_interval = default_collect_interval;
+    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;
+        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, alloc_smooth_factor);
+        double gc_mem = jl_gc_smooth(old_freed_diff, freed_diff, collect_smooth_factor);
+        double gc_time = jl_gc_smooth(old_pause_time, pause, 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;
+        thrashing = gc_time > mutator_time * 98 ? 1 : 0;
+        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 (target_allocs == 0.0 || thrashing) // 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)
+        next_sweep_full = 1;
+    else
+        next_sweep_full = 0;
+    if (heap_size > max_total_memory * 0.8 || thrashing)
+        under_pressure = 1;
     // sweeping is over
     // 7. if it is a quick sweep, put back the remembered objects in queued state
     // so that we don't trigger the barrier again on them.
@@ -3314,55 +3376,19 @@ static int _jl_gc_collect(jl_ptls_t ptls, jl_gc_collection_t collection)
     }
 #endif
 
-    _report_gc_finished(pause, gc_num.freed, sweep_full, recollect);
-
-    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_num.full_sweep += sweep_full;
+    _report_gc_finished(pause, gc_num.freed, sweep_full, recollect, live_bytes);
     uint64_t max_memory = last_live_bytes + gc_num.allocd;
     if (max_memory > gc_num.max_memory) {
         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_num.full_sweep += sweep_full;
     last_live_bytes = live_bytes;
-    // Can't call inc_live_bytes here because we already added allocd
-    // to the graph earlier
     live_bytes += -gc_num.freed + gc_num.allocd;
     jl_timing_counter_dec(JL_TIMING_COUNTER_HeapSize, gc_num.freed);
 
-    if (collection == JL_GC_AUTO) {
-        //If we aren't freeing enough or are seeing lots and lots of pointers let it increase faster
-        if (!not_freed_enough || large_frontier) {
-            int64_t tot = 2 * (live_bytes + gc_num.allocd) / 3;
-            if (gc_num.interval > tot) {
-                gc_num.interval = tot;
-                last_long_collect_interval = tot;
-            }
-        // If the current interval is larger than half the live data decrease the interval
-        }
-        else {
-            int64_t half = (live_bytes / 2);
-            if (gc_num.interval > half)
-                gc_num.interval = half;
-        }
-
-        // But never go below default
-        if (gc_num.interval < default_collect_interval) gc_num.interval = default_collect_interval;
-    }
-
-    if (gc_num.interval + live_bytes > max_total_memory) {
-        if (live_bytes < max_total_memory) {
-            gc_num.interval = max_total_memory - live_bytes;
-            last_long_collect_interval = max_total_memory - live_bytes;
-        }
-        else {
-            // We can't stay under our goal so let's go back to
-            // the minimum interval and hope things get better
-            gc_num.interval = default_collect_interval;
-        }
-    }
-
     gc_time_summary(sweep_full, t_start, gc_end_time, gc_num.freed,
                     live_bytes, gc_num.interval, pause,
                     gc_num.time_to_safepoint,
@@ -3468,6 +3494,10 @@ JL_DLLEXPORT void jl_gc_collect(jl_gc_collection_t collection)
 
     gc_invoke_callbacks(jl_gc_cb_post_gc_t,
         gc_cblist_post_gc, (collection));
+    if (under_pressure)
+        gc_invoke_callbacks(jl_gc_cb_notify_gc_pressure_t,
+            gc_cblist_notify_gc_pressure, ());
+    under_pressure = 0;
 #ifdef _OS_WINDOWS_
     SetLastError(last_error);
 #endif
@@ -3553,7 +3583,7 @@ void jl_gc_init(void)
 
     arraylist_new(&finalizer_list_marked, 0);
     arraylist_new(&to_finalize, 0);
-
+    jl_atomic_store_relaxed(&gc_heap_stats.heap_target, default_collect_interval);
     gc_num.interval = default_collect_interval;
     last_long_collect_interval = default_collect_interval;
     gc_num.allocd = 0;
@@ -3565,12 +3595,6 @@ void jl_gc_init(void)
     uint64_t constrained_mem = uv_get_constrained_memory();
     if (constrained_mem > 0 && constrained_mem < total_mem)
         total_mem = constrained_mem;
-    double percent;
-    if (total_mem < 128e9)
-        percent = total_mem * 2.34375e-12 + 0.6; // 60% at 0 gigs and 90% at 128 to not
-    else                                         // overcommit too much on memory contrained devices
-        percent = 0.9;
-    max_total_memory = total_mem * percent;
 #endif
     if (jl_options.heap_size_hint)
         jl_gc_set_max_memory(jl_options.heap_size_hint);
@@ -3582,7 +3606,11 @@ JL_DLLEXPORT void jl_gc_set_max_memory(uint64_t max_mem)
 {
     if (max_mem > 0
         && max_mem < (uint64_t)1 << (sizeof(memsize_t) * 8 - 1)) {
+        #ifdef _P64
         max_total_memory = max_mem;
+        #else
+        max_total_memory = max_mem < MAX32HEAP ? max_mem : MAX32HEAP;
+        #endif
     }
 }
 
@@ -3610,6 +3638,13 @@ 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);
+        }
     }
     return malloc(sz);
 }
@@ -3625,6 +3660,13 @@ 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);
+        }
     }
     return calloc(nm, sz);
 }
@@ -3636,10 +3678,13 @@ JL_DLLEXPORT void jl_gc_counted_free_with_size(void *p, size_t sz)
     free(p);
     if (pgcstack != NULL && ct->world_age) {
         jl_ptls_t ptls = ct->ptls;
-        jl_atomic_store_relaxed(&ptls->gc_num.freed,
-            jl_atomic_load_relaxed(&ptls->gc_num.freed) + sz);
-        jl_atomic_store_relaxed(&ptls->gc_num.freecall,
-            jl_atomic_load_relaxed(&ptls->gc_num.freecall) + 1);
+        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);
+        }
     }
 }
 
@@ -3650,14 +3695,12 @@ JL_DLLEXPORT void *jl_gc_counted_realloc_with_old_size(void *p, size_t old, size
     if (pgcstack != NULL && ct->world_age) {
         jl_ptls_t ptls = ct->ptls;
         maybe_collect(ptls);
-        if (sz < old)
-            jl_atomic_store_relaxed(&ptls->gc_num.freed,
-                jl_atomic_load_relaxed(&ptls->gc_num.freed) + (old - sz));
-        else
+        if (!(sz < old))
             jl_atomic_store_relaxed(&ptls->gc_num.allocd,
                 jl_atomic_load_relaxed(&ptls->gc_num.allocd) + (sz - old));
         jl_atomic_store_relaxed(&ptls->gc_num.realloc,
             jl_atomic_load_relaxed(&ptls->gc_num.realloc) + 1);
+        jl_atomic_fetch_add_relaxed(&gc_heap_stats.heap_size, sz-old);
     }
     return realloc(p, sz);
 }
@@ -3732,6 +3775,13 @@ 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);
+    }
     int last_errno = errno;
 #ifdef _OS_WINDOWS_
     DWORD last_error = GetLastError();
@@ -3762,15 +3812,12 @@ static void *gc_managed_realloc_(jl_ptls_t ptls, void *d, size_t sz, size_t olds
         ptls->gc_cache.perm_scanned_bytes += allocsz - oldsz;
         inc_live_bytes(allocsz - oldsz);
     }
-    else if (allocsz < oldsz)
-        jl_atomic_store_relaxed(&ptls->gc_num.freed,
-            jl_atomic_load_relaxed(&ptls->gc_num.freed) + (oldsz - allocsz));
-    else
+    else if (!(allocsz < oldsz))
         jl_atomic_store_relaxed(&ptls->gc_num.allocd,
             jl_atomic_load_relaxed(&ptls->gc_num.allocd) + (allocsz - oldsz));
     jl_atomic_store_relaxed(&ptls->gc_num.realloc,
         jl_atomic_load_relaxed(&ptls->gc_num.realloc) + 1);
-
+    jl_atomic_fetch_add_relaxed(&gc_heap_stats.heap_size, allocsz-oldsz);
     int last_errno = errno;
 #ifdef _OS_WINDOWS_
     DWORD last_error = GetLastError();
@@ -3859,6 +3906,7 @@ static void *gc_perm_alloc_large(size_t sz, int zero, unsigned align, unsigned o
 #ifdef _OS_WINDOWS_
     SetLastError(last_error);
 #endif
+    jl_atomic_fetch_add_relaxed(&gc_heap_stats.heap_size,sz);
     errno = last_errno;
     jl_may_leak(base);
     assert(align > 0);
diff --git a/src/gc.h b/src/gc.h
index b1eee5a1d5bda..4bfe5dc328e9d 100644
--- a/src/gc.h
+++ b/src/gc.h
@@ -10,6 +10,7 @@
 #define JL_GC_H
 
 #include <stddef.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 #include <strings.h>
@@ -257,6 +258,13 @@ typedef struct {
     pagetable1_t *meta1[REGION2_PG_COUNT];
 } pagetable_t;
 
+typedef struct {
+    _Atomic(size_t) bytes_mapped;
+    _Atomic(size_t) bytes_resident;
+    _Atomic(size_t) heap_size;
+    _Atomic(size_t) heap_target;
+} gc_heapstatus_t;
+
 #define GC_PAGE_UNMAPPED        0
 #define GC_PAGE_ALLOCATED       1
 #define GC_PAGE_LAZILY_FREED    2
@@ -374,6 +382,7 @@ extern int64_t lazy_freed_pages;
 extern int gc_first_tid;
 extern int gc_n_threads;
 extern jl_ptls_t* gc_all_tls_states;
+extern gc_heapstatus_t gc_heap_stats;
 
 STATIC_INLINE bigval_t *bigval_header(jl_taggedvalue_t *o) JL_NOTSAFEPOINT
 {
@@ -637,7 +646,7 @@ void gc_count_pool(void);
 size_t jl_array_nbytes(jl_array_t *a) JL_NOTSAFEPOINT;
 
 JL_DLLEXPORT void jl_enable_gc_logging(int enable);
-void _report_gc_finished(uint64_t pause, uint64_t freed, int full, int recollect) JL_NOTSAFEPOINT;
+void _report_gc_finished(uint64_t pause, uint64_t freed, int full, int recollect, int64_t live_bytes) JL_NOTSAFEPOINT;
 
 #ifdef __cplusplus
 }
diff --git a/src/jl_exported_funcs.inc b/src/jl_exported_funcs.inc
index c2b2a1578fd76..a7ffedd5cba10 100644
--- a/src/jl_exported_funcs.inc
+++ b/src/jl_exported_funcs.inc
@@ -191,6 +191,7 @@
     XX(jl_gc_schedule_foreign_sweepfunc) \
     XX(jl_gc_set_cb_notify_external_alloc) \
     XX(jl_gc_set_cb_notify_external_free) \
+    XX(jl_gc_set_cb_notify_gc_pressure) \
     XX(jl_gc_set_cb_post_gc) \
     XX(jl_gc_set_cb_pre_gc) \
     XX(jl_gc_set_cb_root_scanner) \
diff --git a/src/julia_threads.h b/src/julia_threads.h
index f4c235243e684..d4cbb88e619ba 100644
--- a/src/julia_threads.h
+++ b/src/julia_threads.h
@@ -130,12 +130,12 @@ typedef struct {
 
 typedef struct {
     _Atomic(int64_t) allocd;
-    _Atomic(int64_t) freed;
     _Atomic(uint64_t) malloc;
     _Atomic(uint64_t) realloc;
     _Atomic(uint64_t) poolalloc;
     _Atomic(uint64_t) bigalloc;
-    _Atomic(uint64_t) freecall;
+    _Atomic(int64_t) free_acc;
+    _Atomic(uint64_t) alloc_acc;
 } jl_thread_gc_num_t;
 
 typedef struct {
diff --git a/test/testenv.jl b/test/testenv.jl
index 41706dd24e75e..21f3ee3b31dd1 100644
--- a/test/testenv.jl
+++ b/test/testenv.jl
@@ -37,6 +37,15 @@ if !@isdefined(testenv_defined)
 
     function addprocs_with_testenv(X; rr_allowed=true, kwargs...)
         exename = rr_allowed ? `$rr_exename $test_exename` : test_exename
+        if X isa Integer
+            if Sys.iswindows()
+                heap_size=round(Int,(Sys.free_memory()/(1024^2)/(X+1)))
+                heap_size -= 300 # I don't know anymore
+            else
+                heap_size=round(Int,(Sys.total_memory()/(1024^2)/(X+1)))
+            end
+            push!(test_exeflags.exec, "--heap-size-hint=$(heap_size)M")
+        end
         addprocs(X; exename=exename, exeflags=test_exeflags, kwargs...)
     end
 

From 152f0e94f67286925c8d63b17e23d13776ef5d85 Mon Sep 17 00:00:00 2001
From: Nicholas Bauer <nicholasbauer@outlook.com>
Date: Fri, 7 Jul 2023 15:11:29 -0400
Subject: [PATCH 41/41] Merge new `reinterpret` with essentials.jl
 `reinterpret` (#50367)

(cherry picked from commit b99f251e86c7c09b957a1b362b6408dbba106ff0)
---
 base/essentials.jl       | 32 ++++++++++++++++++++++++++------
 base/reinterpretarray.jl | 36 ++----------------------------------
 test/core.jl             |  2 +-
 test/numbers.jl          |  4 ++--
 4 files changed, 31 insertions(+), 43 deletions(-)

diff --git a/base/essentials.jl b/base/essentials.jl
index c0d871608b1a9..68dd0c06d646f 100644
--- a/base/essentials.jl
+++ b/base/essentials.jl
@@ -543,21 +543,41 @@ unsafe_convert(::Type{T}, x::T) where {T<:Ptr} = x  # to resolve ambiguity with
 unsafe_convert(::Type{P}, x::Ptr) where {P<:Ptr} = convert(P, x)
 
 """
-    reinterpret(type, x)
+    reinterpret(::Type{Out}, x::In)
 
-Change the type-interpretation of the binary data in the primitive value `x`
-to that of the primitive type `type`.
-The size of `type` has to be the same as that of the type of `x`.
+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).
 
-# Examples
 ```jldoctest
 julia> reinterpret(Float32, UInt32(7))
 1.0f-44
+
+julia> reinterpret(NTuple{2, UInt8}, 0x1234)
+(0x34, 0x12)
+
+julia> reinterpret(UInt16, (0x34, 0x12))
+0x1234
+
+julia> reinterpret(Tuple{UInt16, UInt8}, (0x01, 0x0203))
+(0x0301, 0x02)
 ```
+
+!!! 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.
 """
-reinterpret(::Type{T}, x) where {T} = bitcast(T, x)
+function reinterpret(Out::Type, x::In) where {In}
+    if isprimitivetype(Out) && isprimitivetype(In)
+        return bitcast(Out, x)
+    end
+    # only available when Base is fully loaded.
+    return _reinterpret(Out, x)
+end
 
 """
     sizeof(T::DataType)
diff --git a/base/reinterpretarray.jl b/base/reinterpretarray.jl
index d33c127b78c76..74b888a39fd76 100644
--- a/base/reinterpretarray.jl
+++ b/base/reinterpretarray.jl
@@ -795,42 +795,10 @@ function _copyfrompacked!(ptr_out::Ptr{Out}, ptr_in::Ptr{In}) where {Out, In}
     end
 end
 
-"""
-    reinterpret(::Type{Out}, x::In)
-
-Reinterpret the valid non-padding bytes of an isbits value `x` as isbits type `Out`.
-
-Both types must have the same amount of non-padding bytes. This operation is guaranteed
-to be reversible.
-
-```jldoctest
-julia> reinterpret(NTuple{2, UInt8}, 0x1234)
-(0x34, 0x12)
-
-julia> reinterpret(UInt16, (0x34, 0x12))
-0x1234
-
-julia> reinterpret(Tuple{UInt16, UInt8}, (0x01, 0x0203))
-(0x0301, 0x02)
-```
-
-!!! 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.
-"""
-@inline function reinterpret(::Type{Out}, x::In) where {Out, In}
+@inline function _reinterpret(::Type{Out}, x::In) where {Out, In}
+    # handle non-primitive types
     isbitstype(Out) || throw(ArgumentError("Target type for `reinterpret` must be isbits"))
     isbitstype(In) || throw(ArgumentError("Source type for `reinterpret` must be isbits"))
-    if isprimitivetype(Out) && isprimitivetype(In)
-        outsize = sizeof(Out)
-        insize = sizeof(In)
-        outsize == insize ||
-            throw(ArgumentError("Sizes of types $Out and $In do not match; got $outsize \
-                and $insize, respectively."))
-        return bitcast(Out, x)
-    end
     inpackedsize = packedsize(In)
     outpackedsize = packedsize(Out)
     inpackedsize == outpackedsize ||
diff --git a/test/core.jl b/test/core.jl
index 13f4640210f51..087234abe1a94 100644
--- a/test/core.jl
+++ b/test/core.jl
@@ -1897,7 +1897,7 @@ function f4528(A, B)
     end
 end
 @test f4528(false, Int32(12)) === nothing
-@test_throws ArgumentError f4528(true, Int32(12))
+@test_throws ErrorException f4528(true, Int32(12))
 
 # issue #4518
 f4518(x, y::Union{Int32,Int64}) = 0
diff --git a/test/numbers.jl b/test/numbers.jl
index d7fd6531b157d..e89dffd8e33cf 100644
--- a/test/numbers.jl
+++ b/test/numbers.jl
@@ -2216,11 +2216,11 @@ end
     @test round(Int16, -32768.1) === Int16(-32768)
 end
 # issue #7508
-@test_throws ArgumentError reinterpret(Int, 0x01)
+@test_throws ErrorException reinterpret(Int, 0x01)
 
 @testset "issue #12832" begin
     @test_throws ArgumentError reinterpret(Float64, Complex{Int64}(1))
-    @test_throws ArgumentError reinterpret(Int32, false)
+    @test_throws ErrorException reinterpret(Int32, false)
 end
 # issue #41
 ndigf(n) = Float64(log(Float32(n)))