From d48bc9a61aebf68b1cbbf65890204c25d9f99a80 Mon Sep 17 00:00:00 2001
From: Volker-Weissmann <39418860+Volker-Weissmann@users.noreply.github.com>
Date: Fri, 25 Dec 2020 08:35:05 +0100
Subject: [PATCH 01/54] fixed a bug in the build system (#38997)

(cherry picked from commit 9fa97f9a031e81fb073f7defdfbdc96428b1c955)
---
 Make.inc | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/Make.inc b/Make.inc
index a071fd0c995ba..f272bedca956c 100644
--- a/Make.inc
+++ b/Make.inc
@@ -1556,9 +1556,11 @@ endif
 LIBGCC_BUILD_DEPLIB := $(call dep_lib_path,$(build_libdir),$(build_shlibdir)/$(LIBGCC_NAME))
 LIBGCC_INSTALL_DEPLIB := $(call dep_lib_path,$(libdir),$(private_shlibdir)/$(LIBGCC_NAME))
 
-# USE_SYSTEM_LIBM causes it to get symlinked into build_private_shlibdir
+# USE_SYSTEM_LIBM and USE_SYSTEM_OPENLIBM causes it to get symlinked into build_private_shlibdir
 ifeq ($(USE_SYSTEM_LIBM),1)
 LIBM_BUILD_DEPLIB := $(call dep_lib_path,$(build_libdir),$(build_private_shlibdir)/$(LIBMNAME).$(SHLIB_EXT))
+else ifeq ($(USE_SYSTEM_OPENLIBM),1)
+LIBM_BUILD_DEPLIB := $(call dep_lib_path,$(build_libdir),$(build_private_shlibdir)/$(LIBMNAME).$(SHLIB_EXT))
 else
 LIBM_BUILD_DEPLIB := $(call dep_lib_path,$(build_libdir),$(build_shlibdir)/$(LIBMNAME).$(SHLIB_EXT))
 endif

From 8ea14b068a8764fc2b83234ff6d324fd08f3f45e Mon Sep 17 00:00:00 2001
From: Sebastian Stock <42280794+sostock@users.noreply.github.com>
Date: Sat, 6 Feb 2021 03:10:41 +0100
Subject: [PATCH 02/54] Add missing imports to SuiteSparse tests (#39539)

(cherry picked from commit 55baf8a5218cd59f97b011fcdd729e7929ad91cb)
---
 stdlib/SuiteSparse/test/cholmod.jl |  6 +++++-
 stdlib/SuiteSparse/test/spqr.jl    |  4 +++-
 stdlib/SuiteSparse/test/umfpack.jl | 24 ++++++++++++++----------
 3 files changed, 22 insertions(+), 12 deletions(-)

diff --git a/stdlib/SuiteSparse/test/cholmod.jl b/stdlib/SuiteSparse/test/cholmod.jl
index e1efe7f85ee27..020c7129cc56f 100644
--- a/stdlib/SuiteSparse/test/cholmod.jl
+++ b/stdlib/SuiteSparse/test/cholmod.jl
@@ -1,11 +1,15 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using SuiteSparse.CHOLMOD
+using SuiteSparse
 using DelimitedFiles
 using Test
 using Random
 using Serialization
-using LinearAlgebra: issuccess, PosDefException, ZeroPivotException
+using LinearAlgebra:
+    I, cholesky, cholesky!, det, diag, eigmax, ishermitian, isposdef, issuccess,
+    issymmetric, ldlt, ldlt!, logdet, norm, opnorm, Diagonal, Hermitian, Symmetric,
+    PosDefException, ZeroPivotException
 using SparseArrays
 using SparseArrays: getcolptr
 
diff --git a/stdlib/SuiteSparse/test/spqr.jl b/stdlib/SuiteSparse/test/spqr.jl
index d008bd58201b4..d1802c7ccc3b3 100644
--- a/stdlib/SuiteSparse/test/spqr.jl
+++ b/stdlib/SuiteSparse/test/spqr.jl
@@ -2,7 +2,9 @@
 
 using SuiteSparse.SPQR
 using SuiteSparse.CHOLMOD
-using LinearAlgebra: rmul!, lmul!, Adjoint, Transpose
+using SuiteSparse
+using LinearAlgebra: I, istriu, norm, qr, rank, rmul!, lmul!, Adjoint, Transpose
+using SparseArrays: sparse, sprandn, spzeros, SparseMatrixCSC
 
 @testset "Sparse QR" begin
 m, n = 100, 10
diff --git a/stdlib/SuiteSparse/test/umfpack.jl b/stdlib/SuiteSparse/test/umfpack.jl
index dc17d71a727e0..a4f749f1ce58b 100644
--- a/stdlib/SuiteSparse/test/umfpack.jl
+++ b/stdlib/SuiteSparse/test/umfpack.jl
@@ -1,8 +1,12 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
+using SuiteSparse.UMFPACK
+using SuiteSparse
 using SuiteSparse: increment!
 using Serialization
-using LinearAlgebra: Adjoint, Transpose, SingularException
+using LinearAlgebra:
+    I, det, issuccess, ldiv!, lu, lu!, Adjoint, Transpose, SingularException, Diagonal
+using SparseArrays: nnz, sparse, sprand, sprandn, SparseMatrixCSC
 
 @testset "UMFPACK wrappers" begin
     se33 = sparse(1.0I, 3, 3)
@@ -33,11 +37,11 @@ using LinearAlgebra: Adjoint, Transpose, SingularException
 
             @test A*x ≈ b
             z = complex.(b)
-            x = LinearAlgebra.ldiv!(lua, z)
+            x = ldiv!(lua, z)
             @test x ≈ float([1:5;])
             @test z === x
             y = similar(z)
-            LinearAlgebra.ldiv!(y, lua, complex.(b))
+            ldiv!(y, lua, complex.(b))
             @test y ≈ x
 
             @test A*x ≈ b
@@ -48,11 +52,11 @@ using LinearAlgebra: Adjoint, Transpose, SingularException
 
             @test A'*x ≈ b
             z = complex.(b)
-            x = LinearAlgebra.ldiv!(adjoint(lua), z)
+            x = ldiv!(adjoint(lua), z)
             @test x ≈ float([1:5;])
             @test x === z
             y = similar(x)
-            LinearAlgebra.ldiv!(y, adjoint(lua), complex.(b))
+            ldiv!(y, adjoint(lua), complex.(b))
             @test y ≈ x
 
             @test A'*x ≈ b
@@ -60,10 +64,10 @@ using LinearAlgebra: Adjoint, Transpose, SingularException
             @test x ≈ float([1:5;])
 
             @test transpose(A) * x ≈ b
-            x = LinearAlgebra.ldiv!(transpose(lua), complex.(b))
+            x = ldiv!(transpose(lua), complex.(b))
             @test x ≈ float([1:5;])
             y = similar(x)
-            LinearAlgebra.ldiv!(y, transpose(lua), complex.(b))
+            ldiv!(y, transpose(lua), complex.(b))
             @test y ≈ x
 
             @test transpose(A) * x ≈ b
@@ -165,9 +169,9 @@ using LinearAlgebra: Adjoint, Transpose, SingularException
         X = zeros(ComplexF64, N, N)
         B = complex.(rand(N, N), rand(N, N))
         luA, lufA = lu(A), lu(Array(A))
-        @test LinearAlgebra.ldiv!(copy(X), luA, B) ≈ LinearAlgebra.ldiv!(copy(X), lufA, B)
-        @test LinearAlgebra.ldiv!(copy(X), adjoint(luA), B) ≈ LinearAlgebra.ldiv!(copy(X), adjoint(lufA), B)
-        @test LinearAlgebra.ldiv!(copy(X), transpose(luA), B) ≈ LinearAlgebra.ldiv!(copy(X), transpose(lufA), B)
+        @test ldiv!(copy(X), luA, B) ≈ ldiv!(copy(X), lufA, B)
+        @test ldiv!(copy(X), adjoint(luA), B) ≈ ldiv!(copy(X), adjoint(lufA), B)
+        @test ldiv!(copy(X), transpose(luA), B) ≈ ldiv!(copy(X), transpose(lufA), B)
     end
 
     @testset "singular matrix" begin

From cb191811a8513778a756598cef190956c905b477 Mon Sep 17 00:00:00 2001
From: Elliot Saba <staticfloat@gmail.com>
Date: Sat, 6 Feb 2021 20:16:33 -0800
Subject: [PATCH 03/54] [cli/trampolines] Clean up definitions, fix win32
 exporting issue (#39543)

(cherry picked from commit 9cf5b23f799ff1a67554952f8a90757296b52210)
---
 cli/Makefile                              |  2 +-
 cli/trampolines/common.h                  | 70 +++++++++++++++++++++++
 cli/trampolines/trampolines_aarch64.S     | 14 +----
 cli/trampolines/trampolines_arm.S         | 13 +++--
 cli/trampolines/trampolines_i686.S        | 24 ++------
 cli/trampolines/trampolines_powerpc64le.S | 19 +++---
 cli/trampolines/trampolines_x86_64.S      | 35 +-----------
 7 files changed, 95 insertions(+), 82 deletions(-)
 create mode 100644 cli/trampolines/common.h

diff --git a/cli/Makefile b/cli/Makefile
index 7493df64cf055..e798b9c0a821e 100644
--- a/cli/Makefile
+++ b/cli/Makefile
@@ -53,7 +53,7 @@ $(BUILDDIR)/loader_exe.o : $(SRCDIR)/loader_exe.c $(HEADERS) $(JULIAHOME)/VERSIO
 	@$(call PRINT_CC, $(CC) $(SHIPFLAGS) $(LOADER_CFLAGS) -c $< -o $@)
 $(BUILDDIR)/loader_exe.dbg.obj : $(SRCDIR)/loader_exe.c $(HEADERS) $(JULIAHOME)/VERSION
 	@$(call PRINT_CC, $(CC) $(DEBUGFLAGS) $(LOADER_CFLAGS) -c $< -o $@)
-$(BUILDDIR)/loader_trampolines.o : $(SRCDIR)/trampolines/trampolines_$(ARCH).S
+$(BUILDDIR)/loader_trampolines.o : $(SRCDIR)/trampolines/trampolines_$(ARCH).S $(HEADERS) $(SRCDIR)/trampolines/common.h
 	@$(call PRINT_CC, $(CC) $(SHIPFLAGS) $(LOADER_CFLAGS) $< -c -o $@)
 
 # Debugging target to help us see what kind of code is being generated for our trampolines
diff --git a/cli/trampolines/common.h b/cli/trampolines/common.h
new file mode 100644
index 0000000000000..743d697d2467b
--- /dev/null
+++ b/cli/trampolines/common.h
@@ -0,0 +1,70 @@
+// Preprocessor annoyances
+#define CONCAT_(x,y)    x##y
+#define CONCAT(x,y)     CONCAT_(x, y)
+#define CNAMEADDR(name) CONCAT(CNAME(name),_addr)
+#define STR_(x)         #x
+#define STR(x)          STR_(x)
+#define I(x)            x
+
+// On macOS and 32-bit windows, we need to prepend underscores on symbols to match the C ABI
+#if defined(__APPLE__) || (defined(_WIN32) && !defined(_WIN64))
+#define UNDERSCORE(x) _##x
+#else
+#define UNDERSCORE(x)    x
+#endif
+
+// Windows requires some help with the linker when it comes to debuginfo/exporting
+#if defined(_WIN32) || defined(_WIN64)
+#define DEBUGINFO(name)     .def name; \
+                            .scl 2; \
+                            .type 32; \
+                            .endef
+#define EXPORT(name)        .section .drectve,"r"; \
+                            .ascii STR(-export:##I(name)); \
+                            .ascii " "; \
+                            .section .text
+#else
+#define DEBUGINFO(name)
+#define EXPORT(name)
+#endif
+
+// Windows 64-bit uses SEH
+#if defined(_WIN64)
+#define SEH_START1(name)    .seh_proc CNAME(name)
+#define SEH_START2()        .seh_endprologue
+#define SEH_END()           .seh_endproc
+#else
+#define SEH_START1(name)
+#define SEH_START2()
+#define SEH_END()
+#endif
+
+// If we're compiling with control-flow branch protection, mark the trampoline entry
+// points with `endbr{32,64}`, as appropriate on this arch
+#if defined(__CET__) && __CET__ & 1 != 0
+#if defined(__x86_64__)
+#define CET_START()     endbr64
+#else
+#define CET_START()     endbr32
+#endif
+#else
+#define CET_START()
+#endif
+
+// aarch64 on mac requires some special assembler syntax for both calculating memory
+// offsets and even just the assembler statement separator token
+#if defined(__aarch64__)
+#if defined(__APPLE__)
+#define PAGE(x)     x##@PAGE
+#define PAGEOFF(x)  x##@PAGEOFF
+#define SEP         %%
+#else
+#define PAGE(x)     x
+#define PAGEOFF(x)  :lo12:##x
+#define SEP         ;
+#endif
+#endif
+
+// If someday we need to mangle everything, we do so by defining this `CNAME()`
+// to do something more complex than just `UNDERSCORE(x)`.
+#define CNAME(x)    UNDERSCORE(x)
diff --git a/cli/trampolines/trampolines_aarch64.S b/cli/trampolines/trampolines_aarch64.S
index 090c6c8cd4599..bffeab76c1763 100644
--- a/cli/trampolines/trampolines_aarch64.S
+++ b/cli/trampolines/trampolines_aarch64.S
@@ -1,18 +1,6 @@
+#include "common.h"
 #include "../../src/jl_exported_funcs.inc"
 
-// On macOS, we need to prepend underscores on symbols
-#if defined(__APPLE__) && defined(__MACH__)
-#define CNAME(x)    _##x
-#define PAGE(x)     x##@PAGE
-#define PAGEOFF(x)  x##@PAGEOFF
-#define SEP         %%
-#else
-#define CNAME(x)    x
-#define PAGE(x)     x
-#define PAGEOFF(x)  #:lo12:##x
-#define SEP         ;
-#endif
-
 #define XX(name) \
 .global CNAME(name) SEP \
 .cfi_startproc SEP \
diff --git a/cli/trampolines/trampolines_arm.S b/cli/trampolines/trampolines_arm.S
index dd8a875f5624d..1bb924168525b 100644
--- a/cli/trampolines/trampolines_arm.S
+++ b/cli/trampolines/trampolines_arm.S
@@ -1,16 +1,17 @@
+#include "common.h"
 #include "../../src/jl_exported_funcs.inc"
 
 #define XX(name) \
-.global name; \
+.global CNAME(name); \
 .cfi_startproc; \
-name##:; \
-    ldr ip, .L##name; \
-.L##name: ;\
+CNAME(name)##:; \
+    ldr ip, CONCAT(.L,CNAME(name)); \
+CONCAT(.L,CNAME(name)): ;\
     add ip, pc, ip; \
     ldr pc, [ip]; \
     .align 2; \
-.L##name##_addr: ; \
-    .word name##_addr-(.L##name + 8); \
+CONCAT(.L,CNAMEADDR(name))##: ; \
+    .word CNAMEADDR(name)##-(CONCAT(.L,CNAME(name)) + 8); \
 .cfi_endproc; \
 
 JL_EXPORTED_FUNCS(XX)
diff --git a/cli/trampolines/trampolines_i686.S b/cli/trampolines/trampolines_i686.S
index 2f2971ec81321..f27949afa47b8 100644
--- a/cli/trampolines/trampolines_i686.S
+++ b/cli/trampolines/trampolines_i686.S
@@ -1,32 +1,16 @@
+#include "common.h"
 #include "../../src/jl_exported_funcs.inc"
 
-// On Windows, we need to prepend underscores on symbols
-#if defined(_WIN32)
-#define CNAME(x) _##x
-#define DEBUGINFO(name)     .def CNAME(name); \
-                            .scl 2; \
-                            .type 32; \
-                            .endef
-#else
-#define CNAME(x) x
-#define DEBUGINFO(name)
-#endif
-
-#if defined(__CET__) && __CET__ & 1 != 0
-#define CET_START() endbr32
-#else
-#define CET_START()
-#endif
-
 #define XX(name) \
-DEBUGINFO(name); \
+DEBUGINFO(CNAME(name)); \
 .global CNAME(name); \
 .cfi_startproc; \
 CNAME(name)##:; \
     CET_START(); \
-    jmpl *(CNAME(name##_addr)); \
+    jmpl *(CNAMEADDR(name)); \
     ud2; \
 .cfi_endproc; \
+EXPORT(name); \
 
 JL_EXPORTED_FUNCS(XX)
 #undef XX
diff --git a/cli/trampolines/trampolines_powerpc64le.S b/cli/trampolines/trampolines_powerpc64le.S
index 9c7f8ab6790ca..cd64f656362d0 100644
--- a/cli/trampolines/trampolines_powerpc64le.S
+++ b/cli/trampolines/trampolines_powerpc64le.S
@@ -1,3 +1,4 @@
+#include "common.h"
 #include "../../src/jl_exported_funcs.inc"
 
 // Notes:
@@ -7,19 +8,19 @@
 // See 64-Bit ELF V2 ABI Specification: Power Architecture v1.4
 
 #define XX(name) \
-.global name; \
-.type name##, @function; \
+.global CNAME(name); \
+.type CNAME(name)##, @function; \
 .cfi_startproc; \
-name##: ; \
-    addis 2, 12, .TOC.-name##@ha; \
-    addi 2, 2, .TOC.-name##@l; \
-    .localentry name##,.-name##; \
-    addis 9,2,name##_addr@toc@ha; \
-    ld 12,name##_addr@toc@l(9); \
+CNAME(name)##: ; \
+    addis 2, 12, .TOC.-CNAME(name)##@ha; \
+    addi 2, 2, .TOC.-CNAME(name)##@l; \
+    .localentry CNAME(name)##,.-CNAME(name)##; \
+    addis 12,2,CNAMEADDR(name)##@toc@ha; \
+    ld 12,CNAMEADDR(name)##@toc@l(12); \
     mtctr 12; \
     bctr; \
 .cfi_endproc; \
-.size name##,.-name##; \
+.size CNAME(name)##,.-CNAME(name)##; \
 
 JL_EXPORTED_FUNCS(XX)
 #undef XX
diff --git a/cli/trampolines/trampolines_x86_64.S b/cli/trampolines/trampolines_x86_64.S
index f80b4bb478c97..e06434cf540e5 100644
--- a/cli/trampolines/trampolines_x86_64.S
+++ b/cli/trampolines/trampolines_x86_64.S
@@ -1,37 +1,6 @@
+#include "common.h"
 #include "../../src/jl_exported_funcs.inc"
 
-// On macOS, we need to prepend underscores on symbols
-#if defined(__APPLE__) && defined(__MACH__)
-#define CNAME(x) _##x
-#else
-#define CNAME(x) x
-#endif
-
-#if defined(_WIN64)
-#define DEBUGINFO(name)     .def CNAME(name); \
-                            .scl 2; \
-                            .type 32; \
-                            .endef
-#define EXPORT(name)        .section .drectve,"r"; \
-                            .ascii " -export:"#name""; \
-                            .section .text
-#define SEH_START1(name)    .seh_proc name
-#define SEH_START2()        .seh_endprologue
-#define SEH_END()           .seh_endproc
-#else
-#define DEBUGINFO(name)
-#define EXPORT(name)
-#define SEH_START1(name)
-#define SEH_START2()
-#define SEH_END()
-#endif
-
-#if defined(__CET__) && __CET__ & 1 != 0
-#define CET_START() endbr64
-#else
-#define CET_START()
-#endif
-
 #define XX(name) \
 DEBUGINFO(name); \
 .global CNAME(name); \
@@ -40,7 +9,7 @@ SEH_START1(name); \
 CNAME(name)##:; \
 SEH_START2(); \
     CET_START(); \
-    mov CNAME(name##_addr)(%rip),%r11; \
+    mov CNAMEADDR(name)(%rip),%r11; \
     jmpq *%r11; \
     ud2; \
 SEH_END(); \

From 28e8adcce2cd0cfa8936a2f629dd870961f8b011 Mon Sep 17 00:00:00 2001
From: Mark Huang <32028289+Markhng@users.noreply.github.com>
Date: Mon, 8 Feb 2021 22:31:45 +0800
Subject: [PATCH 04/54] Improve first/last docstrings (#39560)

* improve first/last docstrings

improve `first`/`last` docstrings to indicate that two new methods have been added since v1.6 (#34868)

* Update abstractarray.jl

remove the trailing whitespaces

(cherry picked from commit bc2b854d688480bf28b41b1cd758410415e8ccd3)
---
 base/abstractarray.jl | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/base/abstractarray.jl b/base/abstractarray.jl
index a880b4eecfd3f..b60c1f20e9069 100644
--- a/base/abstractarray.jl
+++ b/base/abstractarray.jl
@@ -394,6 +394,9 @@ end
 Get the first `n` elements of the iterable collection `itr`, or fewer elements if `v` is not
 long enough.
 
+!!! compat "Julia 1.6"
+    This method requires at least Julia 1.6.
+
 # Examples
 ```jldoctest
 julia> first(["foo", "bar", "qux"], 2)
@@ -439,6 +442,9 @@ last(a) = a[end]
 Get the last `n` elements of the iterable collection `itr`, or fewer elements if `v` is not
 long enough.
 
+!!! compat "Julia 1.6"
+    This method requires at least Julia 1.6.
+
 # Examples
 ```jldoctest
 julia> last(["foo", "bar", "qux"], 2)

From 62400b58751dae0070bfc6ae74b48d0029c5610e Mon Sep 17 00:00:00 2001
From: Alfredo Braunstein <alfredo.braunstein@polito.it>
Date: Mon, 8 Feb 2021 15:37:47 +0100
Subject: [PATCH 05/54] use sparse multiplication for sparse arrays time
 BitMatrix and BitVector and wrappers (#39557)

(cherry picked from commit e3753e1d7b5fcdea656ec07c08f1a45f20aa0358)
---
 stdlib/SparseArrays/src/linalg.jl | 43 +++++++++++++++++--------------
 1 file changed, 23 insertions(+), 20 deletions(-)

diff --git a/stdlib/SparseArrays/src/linalg.jl b/stdlib/SparseArrays/src/linalg.jl
index 25ddb3222f6b2..1ed2c680059ce 100644
--- a/stdlib/SparseArrays/src/linalg.jl
+++ b/stdlib/SparseArrays/src/linalg.jl
@@ -4,8 +4,10 @@ import LinearAlgebra: checksquare, sym_uplo
 using Random: rand!
 
 # In matrix-vector multiplication, the correct orientation of the vector is assumed.
-const StridedOrTriangularMatrix{T} = Union{StridedMatrix{T}, LowerTriangular{T}, UnitLowerTriangular{T}, UpperTriangular{T}, UnitUpperTriangular{T}}
-const AdjOrTransStridedOrTriangularMatrix{T} = Union{StridedOrTriangularMatrix{T},Adjoint{<:Any,<:StridedOrTriangularMatrix{T}},Transpose{<:Any,<:StridedOrTriangularMatrix{T}}}
+const DenseMatrixUnion = Union{StridedMatrix, LowerTriangular, UnitLowerTriangular, UpperTriangular, UnitUpperTriangular, BitMatrix}
+const AdjOrTransDenseMatrix = Union{DenseMatrixUnion,Adjoint{<:Any,<:DenseMatrixUnion},Transpose{<:Any,<:DenseMatrixUnion}}
+const DenseInputVector = Union{StridedVector, BitVector}
+const DenseInputVecOrMat = Union{AdjOrTransDenseMatrix, DenseInputVector}
 
 for op ∈ (:+, :-), Wrapper ∈ (:Hermitian, :Symmetric)
     @eval begin
@@ -25,7 +27,7 @@ for op ∈ (:+, :-)
     end
 end
 
-function mul!(C::StridedVecOrMat, A::AbstractSparseMatrixCSC, B::Union{StridedVector,AdjOrTransStridedOrTriangularMatrix}, α::Number, β::Number)
+function mul!(C::StridedVecOrMat, A::AbstractSparseMatrixCSC, B::DenseInputVecOrMat, α::Number, β::Number)
     size(A, 2) == size(B, 1) || throw(DimensionMismatch())
     size(A, 1) == size(C, 1) || throw(DimensionMismatch())
     size(B, 2) == size(C, 2) || throw(DimensionMismatch())
@@ -44,13 +46,14 @@ function mul!(C::StridedVecOrMat, A::AbstractSparseMatrixCSC, B::Union{StridedVe
     end
     C
 end
-*(A::SparseMatrixCSCUnion{TA}, x::StridedVector{Tx}) where {TA,Tx} =
-    (T = promote_op(matprod, TA, Tx); mul!(similar(x, T, size(A, 1)), A, x, true, false))
-*(A::SparseMatrixCSCUnion{TA}, B::AdjOrTransStridedOrTriangularMatrix{Tx}) where {TA,Tx} =
-    (T = promote_op(matprod, TA, Tx); mul!(similar(B, T, (size(A, 1), size(B, 2))), A, B, true, false))
+
+*(A::SparseMatrixCSCUnion{TA}, x::DenseInputVector) where {TA} =
+    (T = promote_op(matprod, TA, eltype(x)); mul!(similar(x, T, size(A, 1)), A, x, true, false))
+*(A::SparseMatrixCSCUnion{TA}, B::AdjOrTransDenseMatrix) where {TA} =
+    (T = promote_op(matprod, TA, eltype(B)); mul!(similar(B, T, (size(A, 1), size(B, 2))), A, B, true, false))
 
 for (T, t) in ((Adjoint, adjoint), (Transpose, transpose))
-    @eval function mul!(C::StridedVecOrMat, xA::$T{<:Any,<:AbstractSparseMatrixCSC}, B::Union{StridedVector,AdjOrTransStridedOrTriangularMatrix}, α::Number, β::Number)
+    @eval function mul!(C::StridedVecOrMat, xA::$T{<:Any,<:AbstractSparseMatrixCSC}, B::DenseInputVecOrMat, α::Number, β::Number)
         A = xA.parent
         size(A, 2) == size(C, 1) || throw(DimensionMismatch())
         size(A, 1) == size(B, 1) || throw(DimensionMismatch())
@@ -72,16 +75,16 @@ for (T, t) in ((Adjoint, adjoint), (Transpose, transpose))
         C
     end
 end
-*(adjA::Adjoint{<:Any,<:AbstractSparseMatrixCSC}, x::StridedVector{Tx}) where {Tx} =
-    (T = promote_op(matprod, eltype(adjA), Tx); mul!(similar(x, T, size(adjA, 1)), adjA, x, true, false))
-*(adjA::Adjoint{<:Any,<:AbstractSparseMatrixCSC}, B::AdjOrTransStridedOrTriangularMatrix) =
+*(adjA::Adjoint{<:Any,<:AbstractSparseMatrixCSC}, x::DenseInputVector) =
+    (T = promote_op(matprod, eltype(adjA), eltype(x)); mul!(similar(x, T, size(adjA, 1)), adjA, x, true, false))
+*(adjA::Adjoint{<:Any,<:AbstractSparseMatrixCSC}, B::AdjOrTransDenseMatrix) =
     (T = promote_op(matprod, eltype(adjA), eltype(B)); mul!(similar(B, T, (size(adjA, 1), size(B, 2))), adjA, B, true, false))
-*(transA::Transpose{<:Any,<:AbstractSparseMatrixCSC}, x::StridedVector{Tx}) where {Tx} =
-    (T = promote_op(matprod, eltype(transA), Tx); mul!(similar(x, T, size(transA, 1)), transA, x, true, false))
-*(transA::Transpose{<:Any,<:AbstractSparseMatrixCSC}, B::AdjOrTransStridedOrTriangularMatrix) =
+*(transA::Transpose{<:Any,<:AbstractSparseMatrixCSC}, x::DenseInputVector) =
+    (T = promote_op(matprod, eltype(transA), eltype(x)); mul!(similar(x, T, size(transA, 1)), transA, x, true, false))
+*(transA::Transpose{<:Any,<:AbstractSparseMatrixCSC}, B::AdjOrTransDenseMatrix) =
     (T = promote_op(matprod, eltype(transA), eltype(B)); mul!(similar(B, T, (size(transA, 1), size(B, 2))), transA, B, true, false))
 
-function mul!(C::StridedVecOrMat, X::AdjOrTransStridedOrTriangularMatrix, A::AbstractSparseMatrixCSC, α::Number, β::Number)
+function mul!(C::StridedVecOrMat, X::AdjOrTransDenseMatrix, A::AbstractSparseMatrixCSC, α::Number, β::Number)
     mX, nX = size(X)
     nX == size(A, 1) || throw(DimensionMismatch())
     mX == size(C, 1) || throw(DimensionMismatch())
@@ -91,7 +94,7 @@ function mul!(C::StridedVecOrMat, X::AdjOrTransStridedOrTriangularMatrix, A::Abs
     if β != 1
         β != 0 ? rmul!(C, β) : fill!(C, zero(eltype(C)))
     end
-    if X isa StridedOrTriangularMatrix
+    if X isa DenseMatrixUnion
         @inbounds for col in 1:size(A, 2), k in nzrange(A, col)
             Aiα = nzv[k] * α
             rvk = rv[k]
@@ -108,11 +111,11 @@ function mul!(C::StridedVecOrMat, X::AdjOrTransStridedOrTriangularMatrix, A::Abs
     end
     C
 end
-*(X::AdjOrTransStridedOrTriangularMatrix, A::SparseMatrixCSCUnion{TvA}) where {TvA} =
+*(X::AdjOrTransDenseMatrix, A::SparseMatrixCSCUnion{TvA}) where {TvA} =
     (T = promote_op(matprod, eltype(X), TvA); mul!(similar(X, T, (size(X, 1), size(A, 2))), X, A, true, false))
 
 for (T, t) in ((Adjoint, adjoint), (Transpose, transpose))
-    @eval function mul!(C::StridedVecOrMat, X::AdjOrTransStridedOrTriangularMatrix, xA::$T{<:Any,<:AbstractSparseMatrixCSC}, α::Number, β::Number)
+    @eval function mul!(C::StridedVecOrMat, X::AdjOrTransDenseMatrix, xA::$T{<:Any,<:AbstractSparseMatrixCSC}, α::Number, β::Number)
         A = xA.parent
         mX, nX = size(X)
         nX == size(A, 2) || throw(DimensionMismatch())
@@ -133,9 +136,9 @@ for (T, t) in ((Adjoint, adjoint), (Transpose, transpose))
         C
     end
 end
-*(X::AdjOrTransStridedOrTriangularMatrix, adjA::Adjoint{<:Any,<:AbstractSparseMatrixCSC}) =
+*(X::AdjOrTransDenseMatrix, adjA::Adjoint{<:Any,<:AbstractSparseMatrixCSC}) =
     (T = promote_op(matprod, eltype(X), eltype(adjA)); mul!(similar(X, T, (size(X, 1), size(adjA, 2))), X, adjA, true, false))
-*(X::AdjOrTransStridedOrTriangularMatrix, transA::Transpose{<:Any,<:AbstractSparseMatrixCSC}) =
+*(X::AdjOrTransDenseMatrix, transA::Transpose{<:Any,<:AbstractSparseMatrixCSC}) =
     (T = promote_op(matprod, eltype(X), eltype(transA)); mul!(similar(X, T, (size(X, 1), size(transA, 2))), X, transA, true, false))
 
 function (*)(D::Diagonal, A::AbstractSparseMatrixCSC)

From 6ebd6128f123353f8dd3fc0d5421e35b6dafe44f Mon Sep 17 00:00:00 2001
From: Elliot Saba <staticfloat@gmail.com>
Date: Mon, 8 Feb 2021 12:23:51 -0800
Subject: [PATCH 06/54] [build] Fix out-of-tree `stringreplace` invocations
 (#39567)

Because we now store these strings in `libjulia-internal`, we need to
call `stringreplace` on that library instead of `libjulia`.

(cherry picked from commit 4c5d62b9d0e48feb939d3cd8991883dbd3dcdeac)
---
 Makefile | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/Makefile b/Makefile
index ed64b921a4f4a..fde327557d968 100644
--- a/Makefile
+++ b/Makefile
@@ -344,16 +344,16 @@ else ifneq (,$(findstring $(OS),Linux FreeBSD))
 	done
 endif
 
-	# Overwrite JL_SYSTEM_IMAGE_PATH in julia library
-	if [ $(DARWIN_FRAMEWORK) = 0 ]; then \
-		RELEASE_TARGET=$(DESTDIR)$(libdir)/libjulia.$(SHLIB_EXT); \
-		DEBUG_TARGET=$(DESTDIR)$(libdir)/libjulia-debug.$(SHLIB_EXT); \
+	# Overwrite JL_SYSTEM_IMAGE_PATH in libjulia-internal
+	if [ "$(DARWIN_FRAMEWORK)" = "0" ]; then \
+		RELEASE_TARGET=$(DESTDIR)$(private_libdir)/libjulia-internal.$(SHLIB_EXT); \
+		DEBUG_TARGET=$(DESTDIR)$(private_libdir)/libjulia-internal-debug.$(SHLIB_EXT); \
 	else \
 		RELEASE_TARGET=$(DESTDIR)$(prefix)/$(framework_dylib); \
 		DEBUG_TARGET=$(DESTDIR)$(prefix)/$(framework_dylib)_debug; \
 	fi; \
 	$(call stringreplace,$${RELEASE_TARGET},sys.$(SHLIB_EXT)$$,$(private_libdir_rel)/sys.$(SHLIB_EXT)); \
-	if [ $(BUNDLE_DEBUG_LIBS) = 1 ]; then \
+	if [ "$(BUNDLE_DEBUG_LIBS)" = "1" ]; then \
 		$(call stringreplace,$${DEBUG_TARGET},sys-debug.$(SHLIB_EXT)$$,$(private_libdir_rel)/sys-debug.$(SHLIB_EXT)); \
 	fi;
 endif

From 42b064c2ae60d702cd16fd7a65649990732dfd27 Mon Sep 17 00:00:00 2001
From: Jishnu Bhattacharya <jishnub@users.noreply.github.com>
Date: Tue, 9 Feb 2021 12:54:30 +0400
Subject: [PATCH 07/54] Do not print delimiters twice in show(::OffsetMatrix)
 for matrices with certain shifted axes (#39522)

(cherry picked from commit 21557721f2868ef50922f143763d9ee0ae064610)
---
 base/arrayshow.jl   |  5 +++--
 test/offsetarray.jl | 19 +++++++++++++++++++
 2 files changed, 22 insertions(+), 2 deletions(-)

diff --git a/base/arrayshow.jl b/base/arrayshow.jl
index 37adaf13f669e..ecf673da3a764 100644
--- a/base/arrayshow.jl
+++ b/base/arrayshow.jl
@@ -386,7 +386,8 @@ function _show_nonempty(io::IO, X::AbstractMatrix, prefix::String)
     nr, nc = length(indr), length(indc)
     rdots, cdots = false, false
     rr1, rr2 = UnitRange{Int}(indr), 1:0
-    cr1, cr2 = UnitRange{Int}(indc), 1:0
+    cr1 = UnitRange{Int}(indc)
+    cr2 = first(cr1) .+ (0:-1)
     if limit
         if nr > 4
             rr1, rr2 = rr1[1:2], rr1[nr-1:nr]
@@ -417,7 +418,7 @@ function _show_nonempty(io::IO, X::AbstractMatrix, prefix::String)
                 end
             end
         end
-        last(rr) != nr && rdots && print(io, "\u2026 ; ")
+        last(rr) != last(indr) && rdots && print(io, "\u2026 ; ")
     end
     print(io, "]")
 end
diff --git a/test/offsetarray.jl b/test/offsetarray.jl
index ee75623e7a7c8..5deb442f36222 100644
--- a/test/offsetarray.jl
+++ b/test/offsetarray.jl
@@ -757,3 +757,22 @@ end
         @test a[ax[i]] == a[ax][i]
     end
 end
+
+@testset "show OffsetMatrix" begin
+    Y = reshape(1:25, 5, 5)
+    X = OffsetArray(Y, -2:2, -4:0)
+
+    io = IOBuffer()
+    show(io, X)
+    strX = String(take!(io))
+    show(io, Y)
+    strY = String(take!(io))
+    @test strX == strY
+
+    io_limit = IOContext(io, :limit => true)
+    show(io_limit, X)
+    strX = String(take!(io))
+    show(io_limit, Y)
+    strY = String(take!(io))
+    @test strX == strY
+end

From d330214abc6aab3b1372ee5324c46675edd9550a Mon Sep 17 00:00:00 2001
From: Elliot Saba <staticfloat@gmail.com>
Date: Tue, 9 Feb 2021 11:39:43 -0800
Subject: [PATCH 08/54] [file] Fix relative symlinks to directories on Windows
 (#39491)

(cherry picked from commit 78c448f4d6be2599fa833c309ece2df9acd03033)
---
 base/file.jl | 57 ++++++++++++++++++++++++++++++++++++++++++++--------
 test/file.jl | 40 ++++++++++++++++++++++++++++--------
 2 files changed, 81 insertions(+), 16 deletions(-)

diff --git a/base/file.jl b/base/file.jl
index d76e81f62364e..594d6b26c13e2 100644
--- a/base/file.jl
+++ b/base/file.jl
@@ -969,19 +969,44 @@ function sendfile(src::AbstractString, dst::AbstractString)
 end
 
 if Sys.iswindows()
+    const UV_FS_SYMLINK_DIR      = 0x0001
     const UV_FS_SYMLINK_JUNCTION = 0x0002
+    const UV__EPERM              = -4048
 end
 
 """
-    symlink(target::AbstractString, link::AbstractString)
+    symlink(target::AbstractString, link::AbstractString; dir_target = false)
 
 Creates a symbolic link to `target` with the name `link`.
 
+On Windows, symlinks must be explicitly declared as referring to a directory
+or not.  If `target` already exists, by default the type of `link` will be auto-
+detected, however if `target` does not exist, this function defaults to creating
+a file symlink unless `dir_target` is set to `true`.  Note that if the user
+sets `dir_target` but `target` exists and is a file, a directory symlink will
+still be created, but dereferencing the symlink will fail, just as if the user
+creates a file symlink (by calling `symlink()` with `dir_target` set to `false`
+before the directory is created) and tries to dereference it to a directory.
+
+Additionally, there are two methods of making a link on Windows; symbolic links
+and junction points.  Junction points are slightly more efficient, but do not
+support relative paths, so if a relative directory symlink is requested (as
+denoted by `isabspath(target)` returning `false`) a symlink will be used, else
+a junction point will be used.  Best practice for creating symlinks on Windows
+is to create them only after the files/directories they reference are already
+created.
+
 !!! note
     This function raises an error under operating systems that do not support
     soft symbolic links, such as Windows XP.
+
+!!! compat "Julia 1.6"
+    The `dir_target` keyword argument was added in Julia 1.6.  Prior to this,
+    symlinks to nonexistant paths on windows would always be file symlinks, and
+    relative symlinks to directories were not supported.
 """
-function symlink(p::AbstractString, np::AbstractString)
+function symlink(target::AbstractString, link::AbstractString;
+                 dir_target::Bool = false)
     @static if Sys.iswindows()
         if Sys.windows_version() < Sys.WINDOWS_VISTA_VER
             error("Windows XP does not support soft symlinks")
@@ -989,16 +1014,32 @@ function symlink(p::AbstractString, np::AbstractString)
     end
     flags = 0
     @static if Sys.iswindows()
-        if isdir(p)
-            flags |= UV_FS_SYMLINK_JUNCTION
-            p = abspath(p)
+        # If we're going to create a directory link, we need to know beforehand.
+        # First, if `target` is not an absolute path, let's immediately resolve
+        # it so that we can peek and see if it's a directory.
+        resolved_target = target
+        if !isabspath(target)
+            resolved_target = joinpath(dirname(link), target)
+        end
+
+        # If it is a directory (or `dir_target` is set), we'll need to add one
+        # of `UV_FS_SYMLINK_{DIR,JUNCTION}` to the flags, depending on whether
+        # `target` is an absolute path or not.
+        if (ispath(resolved_target) && isdir(resolved_target)) || dir_target
+            if isabspath(target)
+                flags |= UV_FS_SYMLINK_JUNCTION
+            else
+                flags |= UV_FS_SYMLINK_DIR
+            end
         end
     end
-    err = ccall(:jl_fs_symlink, Int32, (Cstring, Cstring, Cint), p, np, flags)
+    err = ccall(:jl_fs_symlink, Int32, (Cstring, Cstring, Cint), target, link, flags)
     if err < 0
-        msg = "symlink($(repr(p)), $(repr(np)))"
+        msg = "symlink($(repr(target)), $(repr(link)))"
         @static if Sys.iswindows()
-            if !isdir(p)
+            # creating file/directory symlinks requires Administrator privileges
+            # while junction points apparently do not
+            if !(flags & UV_FS_SYMLINK_JUNCTION) && err == UV__EPERM
                 msg = "On Windows, creating symlinks requires Administrator privileges.\n$msg"
             end
         end
diff --git a/test/file.jl b/test/file.jl
index 98a9de50c2806..0f39bc7c140f6 100644
--- a/test/file.jl
+++ b/test/file.jl
@@ -29,23 +29,49 @@ end
 if !Sys.iswindows() || Sys.windows_version() >= Sys.WINDOWS_VISTA_VER
     dirlink = joinpath(dir, "dirlink")
     symlink(subdir, dirlink)
+    @test stat(dirlink) == stat(subdir)
+    @test readdir(dirlink) == readdir(subdir)
+
     # relative link
-    cd(subdir)
     relsubdirlink = joinpath(subdir, "rel_subdirlink")
     reldir = joinpath("..", "adir2")
     symlink(reldir, relsubdirlink)
-    cd(pwd_)
+    @test stat(relsubdirlink) == stat(subdir2)
+    @test readdir(relsubdirlink) == readdir(subdir2)
+
+    # creation of symlink to directory that does not yet exist
+    new_dir = joinpath(subdir, "new_dir")
+    foo_file = joinpath(subdir, "new_dir", "foo")
+    nedlink = joinpath(subdir, "non_existant_dirlink")
+    symlink("new_dir", nedlink; dir_target=true)
+    try
+        readdir(nedlink)
+        @test false
+    catch e
+        @test isa(e, Base.IOError)
+        # It's surprisingly difficult to know what numeric value this will be across platforms
+        # so we'll just check the string representation instead. :(
+        @test endswith(e.msg, "(ENOENT)")
+    end
+    mkdir(new_dir)
+    touch(foo_file)
+    @test readdir(new_dir) == readdir(nedlink)
+
+    rm(foo_file)
+    rm(new_dir)
+    rm(nedlink)
 end
 
-if !Sys.iswindows()
+if !Sys.iswindows() || Sys.windows_version() >= Sys.WINDOWS_VISTA_VER
     link = joinpath(dir, "afilelink.txt")
     symlink(file, link)
+    @test stat(file) == stat(link)
+
     # relative link
-    cd(subdir)
     rellink = joinpath(subdir, "rel_afilelink.txt")
     relfile = joinpath("..", "afile.txt")
     symlink(relfile, rellink)
-    cd(pwd_)
+    @test stat(rellink) == stat(file)
 end
 
 using Random
@@ -1350,11 +1376,9 @@ end
 ############
 # Clean up #
 ############
-if !Sys.iswindows()
+if !Sys.iswindows() || (Sys.windows_version() >= Sys.WINDOWS_VISTA_VER)
     rm(link)
     rm(rellink)
-end
-if !Sys.iswindows() || (Sys.windows_version() >= Sys.WINDOWS_VISTA_VER)
     rm(dirlink)
     rm(relsubdirlink)
 end

From 29209368e56f04eb368eaee26238f36a78c4ffce Mon Sep 17 00:00:00 2001
From: Fredrik Ekre <ekrefredrik@gmail.com>
Date: Tue, 9 Feb 2021 22:25:37 +0100
Subject: [PATCH 09/54] [loading] Search in Sys.STDLIB if name/uuid is known.
 (#39572)

Locating a package with known uuid means the uuid was either
found in a manifest in LOAD_PATH or a "package folder" in LOAD_PATH.
However, looking up the package entrypoint fails for stdlibs that
are not in the sysimage, even if they have been explicitly added
to project/manifest by the user. This patch allows looking in
Sys.STDLIB after stdlibs, fixes #39504.

(cherry picked from commit 5d7e13f0dec118f86df2cf3d8999549cd47c32c2)
---
 base/loading.jl     | 4 ++++
 test/cmdlineargs.jl | 1 +
 2 files changed, 5 insertions(+)

diff --git a/base/loading.jl b/base/loading.jl
index 093e14e00e74e..41e5e8a55beb4 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -290,6 +290,10 @@ function locate_package(pkg::PkgId)::Union{Nothing,String}
             path = manifest_uuid_path(env, pkg)
             path === nothing || return entry_path(path, pkg.name)
         end
+        # Allow loading of stdlibs if the name/uuid are given
+        # e.g. if they have been explicitly added to the project/manifest
+        path = manifest_uuid_path(Sys.STDLIB::String, pkg)
+        path === nothing || return entry_path(path, pkg.name)
     end
     return nothing
 end
diff --git a/test/cmdlineargs.jl b/test/cmdlineargs.jl
index 3a331d406d886..ebf1525d81e52 100644
--- a/test/cmdlineargs.jl
+++ b/test/cmdlineargs.jl
@@ -71,6 +71,7 @@ let exename = `$(Base.julia_cmd()) --startup-file=no`
     end
     let v = readchomperrors(`$exename -i -e '
             empty!(LOAD_PATH)
+            @eval Sys STDLIB=mktempdir()
             Base.unreference_module(Base.PkgId(Base.UUID(0xb77e0a4c_d291_57a0_90e8_8db25a27a240), "InteractiveUtils"))
             '`)
         # simulate not having a working version of InteractiveUtils,

From dcd618bbecb8b6c0c1b6c4505a9c88359ec0a79d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mos=C3=A8=20Giordano?= <giordano@users.noreply.github.com>
Date: Thu, 11 Feb 2021 00:39:34 +0000
Subject: [PATCH 10/54] [p7zip_jll] Set `LIBPATH` and `LIBPATH_list` at
 init-time (#39591)

(cherry picked from commit 4a3537bab6cb81242e4bf049a9397343f786b3bd)
---
 stdlib/p7zip_jll/src/p7zip_jll.jl | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/stdlib/p7zip_jll/src/p7zip_jll.jl b/stdlib/p7zip_jll/src/p7zip_jll.jl
index d1761813e859e..905d45189092e 100644
--- a/stdlib/p7zip_jll/src/p7zip_jll.jl
+++ b/stdlib/p7zip_jll/src/p7zip_jll.jl
@@ -85,6 +85,8 @@ function __init__()
     init_p7zip_path()
     global PATH[] = dirname(p7zip_path)
     push!(PATH_list, PATH[])
+    append!(LIBPATH_list, [joinpath(Sys.BINDIR, Base.LIBDIR, "julia"), joinpath(Sys.BINDIR, Base.LIBDIR)])
+    LIBPATH[] = join(LIBPATH_list, pathsep)
 end
 
 # JLLWrappers API compatibility shims.  Note that not all of these will really make sense.

From 4558f476e3133e6e45d65c726edc5a2d72da590e Mon Sep 17 00:00:00 2001
From: Fredrik Ekre <ekrefredrik@gmail.com>
Date: Thu, 11 Feb 2021 13:56:52 +0100
Subject: [PATCH 11/54] Update Pkg for 1.6.0-rc2.

Add p7zip_jll to precompile tests since Pkg depends on it now.
---
 .../Pkg-9adb32bb8027815dadc266b94201d772ac4c48b1.tar.gz/md5     | 1 -
 .../Pkg-9adb32bb8027815dadc266b94201d772ac4c48b1.tar.gz/sha512  | 1 -
 .../Pkg-e7830b50918f94301ee03ae9d47dc9b14dac0ba4.tar.gz/md5     | 1 +
 .../Pkg-e7830b50918f94301ee03ae9d47dc9b14dac0ba4.tar.gz/sha512  | 1 +
 stdlib/Pkg.version                                              | 2 +-
 test/precompile.jl                                              | 2 +-
 6 files changed, 4 insertions(+), 4 deletions(-)
 delete mode 100644 deps/checksums/Pkg-9adb32bb8027815dadc266b94201d772ac4c48b1.tar.gz/md5
 delete mode 100644 deps/checksums/Pkg-9adb32bb8027815dadc266b94201d772ac4c48b1.tar.gz/sha512
 create mode 100644 deps/checksums/Pkg-e7830b50918f94301ee03ae9d47dc9b14dac0ba4.tar.gz/md5
 create mode 100644 deps/checksums/Pkg-e7830b50918f94301ee03ae9d47dc9b14dac0ba4.tar.gz/sha512

diff --git a/deps/checksums/Pkg-9adb32bb8027815dadc266b94201d772ac4c48b1.tar.gz/md5 b/deps/checksums/Pkg-9adb32bb8027815dadc266b94201d772ac4c48b1.tar.gz/md5
deleted file mode 100644
index 773576eef8348..0000000000000
--- a/deps/checksums/Pkg-9adb32bb8027815dadc266b94201d772ac4c48b1.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-85308d0346e6e7c773b5618a088d93e4
diff --git a/deps/checksums/Pkg-9adb32bb8027815dadc266b94201d772ac4c48b1.tar.gz/sha512 b/deps/checksums/Pkg-9adb32bb8027815dadc266b94201d772ac4c48b1.tar.gz/sha512
deleted file mode 100644
index d615e3301cd81..0000000000000
--- a/deps/checksums/Pkg-9adb32bb8027815dadc266b94201d772ac4c48b1.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-16f366f671ad2b7431dcd0cd1ebd2fd87310c3f3048584d063e6c73006466ce0da0a8e72f48c238fbf614f33306e72d217c19160e5bd3892ff3a5263ff99f0bb
diff --git a/deps/checksums/Pkg-e7830b50918f94301ee03ae9d47dc9b14dac0ba4.tar.gz/md5 b/deps/checksums/Pkg-e7830b50918f94301ee03ae9d47dc9b14dac0ba4.tar.gz/md5
new file mode 100644
index 0000000000000..d2960ee1d8d54
--- /dev/null
+++ b/deps/checksums/Pkg-e7830b50918f94301ee03ae9d47dc9b14dac0ba4.tar.gz/md5
@@ -0,0 +1 @@
+6bb4b517e34387e79af60311897ee2dd
diff --git a/deps/checksums/Pkg-e7830b50918f94301ee03ae9d47dc9b14dac0ba4.tar.gz/sha512 b/deps/checksums/Pkg-e7830b50918f94301ee03ae9d47dc9b14dac0ba4.tar.gz/sha512
new file mode 100644
index 0000000000000..15a5c97c3ea3e
--- /dev/null
+++ b/deps/checksums/Pkg-e7830b50918f94301ee03ae9d47dc9b14dac0ba4.tar.gz/sha512
@@ -0,0 +1 @@
+5bfc0cc86c03c0c0357675451251ed0fa9858de83fdb782d613041408ecfb4ee7ae28a2cef25b6abfe1a97c814006b18ca962c391870caa44321a1e2873a92ff
diff --git a/stdlib/Pkg.version b/stdlib/Pkg.version
index 8aaf812e816af..bad0753d28db6 100644
--- a/stdlib/Pkg.version
+++ b/stdlib/Pkg.version
@@ -1,2 +1,2 @@
 PKG_BRANCH = release-1.6
-PKG_SHA1 = 9adb32bb8027815dadc266b94201d772ac4c48b1
+PKG_SHA1 = e7830b50918f94301ee03ae9d47dc9b14dac0ba4
diff --git a/test/precompile.jl b/test/precompile.jl
index 22cc2d31db8a0..d0285cf77901e 100644
--- a/test/precompile.jl
+++ b/test/precompile.jl
@@ -314,7 +314,7 @@ precompile_test_harness(false) do dir
                  :Distributed, :Downloads, :FileWatching, :Future, :InteractiveUtils,
                  :LazyArtifacts, :LibCURL, :LibCURL_jll, :LibGit2, :Libdl, :LinearAlgebra,
                  :Logging, :Markdown, :Mmap, :MozillaCACerts_jll, :NetworkOptions, :Pkg, :Printf,
-                 :Profile, :REPL, :Random, :SHA, :Serialization, :SharedArrays, :Sockets,
+                 :Profile, :p7zip_jll, :REPL, :Random, :SHA, :Serialization, :SharedArrays, :Sockets,
                  :SparseArrays, :Statistics, :SuiteSparse, :TOML, :Tar, :Test, :UUIDs, :Unicode,
                  :nghttp2_jll]
             ),

From 0f7dbf7c40e22e4971cdd647f1b5c4c167c5f9ff Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Wed, 17 Feb 2021 01:34:36 +0900
Subject: [PATCH 12/54] improve ~many~ some type stabilities in
 `Core.Compiler.typeinf` (#39549)

All of them are detected by JET.jl's self-profiling.
The following code will print type-instabilities/type-errors for all
code paths reachable from `typeinf(::NativeInterpreter, ::InferenceState)`.
```julia
julia> using JET
julia> report_call(Core.Compiler.typeinf,
(Core.Compiler.NativeInterpreter, Core.Compiler.InferenceState);
annotate_types = true)
```

The remaining error reports (e.g. `variable Core.Compiler.string is not
defined`) are because of missing functionality on error paths.

(cherry picked from part of commit 1bc7f43c946269886983f165a5598e0c16adc63b)
---
 base/compiler/abstractinterpretation.jl | 36 ++++++++++++++-----------
 base/compiler/optimize.jl               |  4 +--
 base/compiler/ssair/driver.jl           |  7 ++---
 base/compiler/ssair/inlining.jl         | 28 ++++++++++---------
 base/compiler/ssair/ir.jl               |  4 ++-
 base/compiler/ssair/slot2ssa.jl         |  2 +-
 base/compiler/ssair/verify.jl           |  4 +--
 base/compiler/typeinfer.jl              |  2 +-
 base/compiler/typelattice.jl            |  6 ++---
 base/compiler/typeutils.jl              |  6 ++---
 base/compiler/validation.jl             |  2 +-
 11 files changed, 56 insertions(+), 45 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index c8b4ff5052e47..2b64c1728f80c 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -434,7 +434,7 @@ function abstract_call_method(interp::AbstractInterpreter, method::Method, @nosp
             # Under direct self-recursion, permit much greater use of reducers.
             # here we assume that complexity(specTypes) :>= complexity(sig)
             comparison = sv.linfo.specTypes
-            l_comparison = length(unwrap_unionall(comparison).parameters)
+            l_comparison = length(unwrap_unionall(comparison).parameters)::Int
             spec_len = max(spec_len, l_comparison)
         else
             comparison = method.sig
@@ -679,16 +679,20 @@ function abstract_apply(interp::AbstractInterpreter, @nospecialize(itft), @nospe
     res = Union{}
     nargs = length(aargtypes)
     splitunions = 1 < unionsplitcost(aargtypes) <= InferenceParams(interp).MAX_APPLY_UNION_ENUM
-    ctypes = Any[Any[aft]]
+    ctypes = [Any[aft]]
     infos = [Union{Nothing, AbstractIterationInfo}[]]
     for i = 1:nargs
-        ctypes´ = []
-        infos′ = []
+        ctypes´ = Vector{Any}[]
+        infos′ = Vector{Union{Nothing, AbstractIterationInfo}}[]
         for ti in (splitunions ? uniontypes(aargtypes[i]) : Any[aargtypes[i]])
             if !isvarargtype(ti)
-                cti, info = precise_container_type(interp, itft, ti, sv)
+                cti_info = precise_container_type(interp, itft, ti, sv)
+                cti = cti_info[1]::Vector{Any}
+                info = cti_info[2]::Union{Nothing,AbstractIterationInfo}
             else
-                cti, info = precise_container_type(interp, itft, unwrapva(ti), sv)
+                cti_info = precise_container_type(interp, itft, unwrapva(ti), sv)
+                cti = cti_info[1]::Vector{Any}
+                info = cti_info[2]::Union{Nothing,AbstractIterationInfo}
                 # We can't represent a repeating sequence of the same types,
                 # so tmerge everything together to get one type that represents
                 # everything.
@@ -705,7 +709,7 @@ function abstract_apply(interp::AbstractInterpreter, @nospecialize(itft), @nospe
                 continue
             end
             for j = 1:length(ctypes)
-                ct = ctypes[j]
+                ct = ctypes[j]::Vector{Any}
                 if isvarargtype(ct[end])
                     # This is vararg, we're not gonna be able to do any inling,
                     # drop the info
@@ -1325,7 +1329,8 @@ function typeinf_local(interp::AbstractInterpreter, frame::InferenceState)
             delete!(W, pc)
             frame.currpc = pc
             frame.cur_hand = frame.handler_at[pc]
-            frame.stmt_edges[pc] === nothing || empty!(frame.stmt_edges[pc])
+            edges = frame.stmt_edges[pc]
+            edges === nothing || empty!(edges)
             stmt = frame.src.code[pc]
             changes = s[pc]::VarTable
             t = nothing
@@ -1338,7 +1343,7 @@ function typeinf_local(interp::AbstractInterpreter, frame::InferenceState)
             elseif isa(stmt, GotoNode)
                 pc´ = (stmt::GotoNode).label
             elseif isa(stmt, GotoIfNot)
-                condt = abstract_eval_value(interp, stmt.cond, s[pc], frame)
+                condt = abstract_eval_value(interp, stmt.cond, changes, frame)
                 if condt === Bottom
                     empty!(frame.pclimitations)
                     break
@@ -1369,7 +1374,7 @@ function typeinf_local(interp::AbstractInterpreter, frame::InferenceState)
                         end
                     end
                     newstate_else = stupdate!(s[l], changes_else)
-                    if newstate_else !== false
+                    if newstate_else !== nothing
                         # add else branch to active IP list
                         if l < frame.pc´´
                             frame.pc´´ = l
@@ -1380,7 +1385,7 @@ function typeinf_local(interp::AbstractInterpreter, frame::InferenceState)
                 end
             elseif isa(stmt, ReturnNode)
                 pc´ = n + 1
-                rt = widenconditional(abstract_eval_value(interp, stmt.val, s[pc], frame))
+                rt = widenconditional(abstract_eval_value(interp, stmt.val, changes, frame))
                 if !isa(rt, Const) && !isa(rt, Type) && !isa(rt, PartialStruct)
                     # only propagate information we know we can store
                     # and is valid inter-procedurally
@@ -1414,9 +1419,8 @@ function typeinf_local(interp::AbstractInterpreter, frame::InferenceState)
                 frame.cur_hand = Pair{Any,Any}(l, frame.cur_hand)
                 # propagate type info to exception handler
                 old = s[l]
-                new = s[pc]::Array{Any,1}
-                newstate_catch = stupdate!(old, new)
-                if newstate_catch !== false
+                newstate_catch = stupdate!(old, changes)
+                if newstate_catch !== nothing
                     if l < frame.pc´´
                         frame.pc´´ = l
                     end
@@ -1483,12 +1487,12 @@ function typeinf_local(interp::AbstractInterpreter, frame::InferenceState)
                 # (such as a terminator for a loop, if-else, or try block),
                 # consider whether we should jump to an older backedge first,
                 # to try to traverse the statements in approximate dominator order
-                if newstate !== false
+                if newstate !== nothing
                     s[pc´] = newstate
                 end
                 push!(W, pc´)
                 pc = frame.pc´´
-            elseif newstate !== false
+            elseif newstate !== nothing
                 s[pc´] = newstate
                 pc = pc´
             elseif pc´ in W
diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index 9d9bc45dc1e9f..f08b05dffe286 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -371,7 +371,7 @@ function statement_cost(ex::Expr, line::Int, src::CodeInfo, sptypes::Vector{Any}
         end
         a = ex.args[2]
         if a isa Expr
-            cost = plus_saturate(cost, statement_cost(a, -1, src, sptypes, slottypes, params, error_path))
+            cost = plus_saturate(cost, statement_cost(a, -1, src, sptypes, slottypes, union_penalties, params, error_path))
         end
         return cost
     elseif head === :copyast
@@ -392,7 +392,7 @@ function statement_or_branch_cost(@nospecialize(stmt), line::Int, src::CodeInfo,
     thiscost = 0
     if stmt isa Expr
         thiscost = statement_cost(stmt, line, src, sptypes, slottypes, union_penalties, params,
-                                  params.unoptimize_throw_blocks && line in throw_blocks)::Int
+                                  throw_blocks !== nothing && line in throw_blocks)::Int
     elseif stmt isa GotoNode
         # loops are generally always expensive
         # but assume that forward jumps are already counted for from
diff --git a/base/compiler/ssair/driver.jl b/base/compiler/ssair/driver.jl
index 83205033342d6..7de0ceba6bee6 100644
--- a/base/compiler/ssair/driver.jl
+++ b/base/compiler/ssair/driver.jl
@@ -43,13 +43,14 @@ function convert_to_ircode(ci::CodeInfo, code::Vector{Any}, coverage::Bool, narg
     labelmap = coverage ? fill(0, length(code)) : changemap
     prevloc = zero(eltype(ci.codelocs))
     stmtinfo = sv.stmt_info
+    ssavaluetypes = ci.ssavaluetypes::Vector{Any}
     while idx <= length(code)
         codeloc = ci.codelocs[idx]
         if coverage && codeloc != prevloc && codeloc != 0
             # insert a side-effect instruction before the current instruction in the same basic block
             insert!(code, idx, Expr(:code_coverage_effect))
             insert!(ci.codelocs, idx, codeloc)
-            insert!(ci.ssavaluetypes, idx, Nothing)
+            insert!(ssavaluetypes, idx, Nothing)
             insert!(stmtinfo, idx, nothing)
             changemap[oldidx] += 1
             if oldidx < length(labelmap)
@@ -58,12 +59,12 @@ function convert_to_ircode(ci::CodeInfo, code::Vector{Any}, coverage::Bool, narg
             idx += 1
             prevloc = codeloc
         end
-        if code[idx] isa Expr && ci.ssavaluetypes[idx] === Union{}
+        if code[idx] isa Expr && ssavaluetypes[idx] === Union{}
             if !(idx < length(code) && isa(code[idx + 1], ReturnNode) && !isdefined((code[idx + 1]::ReturnNode), :val))
                 # insert unreachable in the same basic block after the current instruction (splitting it)
                 insert!(code, idx + 1, ReturnNode())
                 insert!(ci.codelocs, idx + 1, ci.codelocs[idx])
-                insert!(ci.ssavaluetypes, idx + 1, Union{})
+                insert!(ssavaluetypes, idx + 1, Union{})
                 insert!(stmtinfo, idx + 1, nothing)
                 if oldidx < length(changemap)
                     changemap[oldidx + 1] += 1
diff --git a/base/compiler/ssair/inlining.jl b/base/compiler/ssair/inlining.jl
index 0e95f812e5eb6..ae42b59bee28a 100644
--- a/base/compiler/ssair/inlining.jl
+++ b/base/compiler/ssair/inlining.jl
@@ -630,7 +630,7 @@ function rewrite_apply_exprargs!(ir::IRCode, todo::Vector{Pair{Int, Any}}, idx::
                 call = thisarginfo.each[i]
                 new_stmt = Expr(:call, argexprs[2], def, state...)
                 state1 = insert_node!(ir, idx, call.rt, new_stmt)
-                new_sig = with_atype(call_sig(ir, new_stmt))
+                new_sig = with_atype(call_sig(ir, new_stmt)::Signature)
                 if isa(call.info, MethodMatchInfo) || isa(call.info, UnionSplitInfo)
                     info = isa(call.info, MethodMatchInfo) ?
                         MethodMatchInfo[call.info] : call.info.matches
@@ -680,7 +680,7 @@ function resolve_todo(todo::InliningTodo, et::Union{EdgeTracker, Nothing}, cache
     spec = todo.spec::DelayedInliningSpec
     isconst, src = find_inferred(todo.mi, spec.atypes, caches, spec.stmttype)
 
-    if isconst
+    if isconst && et !== nothing
         push!(et, todo.mi)
         return ConstantCase(src)
     end
@@ -988,9 +988,12 @@ function inline_invoke!(ir::IRCode, idx::Int, sig::Signature, invoke_data::Invok
             sig.atype, method.sig)::SimpleVector
     methsp = methsp::SimpleVector
     match = MethodMatch(metharg, methsp, method, true)
-    result = analyze_method!(match, sig.atypes, state.et, state.caches, state.params, calltype)
+    et = state.et
+    result = analyze_method!(match, sig.atypes, et, state.caches, state.params, calltype)
     handle_single_case!(ir, stmt, idx, result, true, todo)
-    intersect!(state.et, WorldRange(invoke_data.min_valid, invoke_data.max_valid))
+    if et !== nothing
+        intersect!(et, WorldRange(invoke_data.min_valid, invoke_data.max_valid))
+    end
     return nothing
 end
 
@@ -1118,6 +1121,7 @@ function analyze_single_call!(ir::IRCode, todo::Vector{Pair{Int, Any}}, idx::Int
                 sig.atype, only_method.sig)::SimpleVector
             match = MethodMatch(metharg, methsp, only_method, true)
         else
+            meth = meth::MethodLookupResult
             @assert length(meth) == 1
             match = meth[1]
         end
@@ -1145,6 +1149,8 @@ end
 function assemble_inline_todo!(ir::IRCode, state::InliningState)
     # todo = (inline_idx, (isva, isinvoke, na), method, spvals, inline_linetable, inline_ir, lie)
     todo = Pair{Int, Any}[]
+    et = state.et
+    method_table = state.method_table
     for idx in 1:length(ir.stmts)
         r = process_simple!(ir, todo, idx, state)
         r === nothing && continue
@@ -1176,20 +1182,18 @@ function assemble_inline_todo!(ir::IRCode, state::InliningState)
         nu = unionsplitcost(sig.atypes)
         if nu == 1 || nu > state.params.MAX_UNION_SPLITTING
             if !isa(info, MethodMatchInfo)
-                if state.method_table === nothing
-                    continue
-                end
-                info = recompute_method_matches(sig.atype, state.params, state.et, state.method_table)
+                method_table === nothing && continue
+                et === nothing && continue
+                info = recompute_method_matches(sig.atype, state.params, et, method_table)
             end
             infos = MethodMatchInfo[info]
         else
             if !isa(info, UnionSplitInfo)
-                if state.method_table === nothing
-                    continue
-                end
+                method_table === nothing && continue
+                et === nothing && continue
                 infos = MethodMatchInfo[]
                 for union_sig in UnionSplitSignature(sig.atypes)
-                    push!(infos, recompute_method_matches(argtypes_to_type(union_sig), state.params, state.et, state.method_table))
+                    push!(infos, recompute_method_matches(argtypes_to_type(union_sig), state.params, et, method_table))
                 end
             else
                 infos = info.matches
diff --git a/base/compiler/ssair/ir.jl b/base/compiler/ssair/ir.jl
index 3960ab44649b1..cc3b3e1ad245f 100644
--- a/base/compiler/ssair/ir.jl
+++ b/base/compiler/ssair/ir.jl
@@ -139,6 +139,7 @@ function compute_basic_blocks(stmts::Vector{Any})
     return CFG(blocks, basic_block_index)
 end
 
+# this function assumes insert position exists
 function first_insert_for_bb(code, cfg::CFG, block::Int)
     for idx in cfg.blocks[block].stmts
         stmt = code[idx]
@@ -146,6 +147,7 @@ function first_insert_for_bb(code, cfg::CFG, block::Int)
             return idx
         end
     end
+    error("any insert position isn't found")
 end
 
 # SSA-indexed nodes
@@ -890,7 +892,7 @@ function kill_edge!(compact::IncrementalCompact, active_bb::Int, from::Int, to::
     # Check if the block is now dead
     if length(preds) == 0
         for succ in copy(compact.result_bbs[compact.bb_rename_succ[to]].succs)
-            kill_edge!(compact, active_bb, to, findfirst(x->x === succ, compact.bb_rename_pred))
+            kill_edge!(compact, active_bb, to, findfirst(x->x === succ, compact.bb_rename_pred)::Int)
         end
         if to < active_bb
             # Kill all statements in the block
diff --git a/base/compiler/ssair/slot2ssa.jl b/base/compiler/ssair/slot2ssa.jl
index 057bb72ff1152..46d727605bab4 100644
--- a/base/compiler/ssair/slot2ssa.jl
+++ b/base/compiler/ssair/slot2ssa.jl
@@ -764,7 +764,7 @@ function construct_ssa!(ci::CodeInfo, ir::IRCode, domtree::DomTree, defuse, narg
                     # Having undef_token appear on the RHS is possible if we're on a dead branch.
                     # Do something reasonable here, by marking the LHS as undef as well.
                     if val !== undef_token
-                        incoming_vals[id] = SSAValue(make_ssa!(ci, code, idx, id, typ))
+                        incoming_vals[id] = SSAValue(make_ssa!(ci, code, idx, id, typ)::Int)
                     else
                         code[idx] = nothing
                         incoming_vals[id] = undef_token
diff --git a/base/compiler/ssair/verify.jl b/base/compiler/ssair/verify.jl
index 0365383a576f7..0f29b79b417e6 100644
--- a/base/compiler/ssair/verify.jl
+++ b/base/compiler/ssair/verify.jl
@@ -14,13 +14,13 @@ end
 function check_op(ir::IRCode, domtree::DomTree, @nospecialize(op), use_bb::Int, use_idx::Int, print::Bool)
     if isa(op, SSAValue)
         if op.id > length(ir.stmts)
-            def_bb = block_for_inst(ir.cfg, ir.new_nodes[op.id - length(ir.stmts)].pos)
+            def_bb = block_for_inst(ir.cfg, ir.new_nodes.info[op.id - length(ir.stmts)].pos)
         else
             def_bb = block_for_inst(ir.cfg, op.id)
         end
         if (def_bb == use_bb)
             if op.id > length(ir.stmts)
-                @assert ir.new_nodes[op.id - length(ir.stmts)].pos <= use_idx
+                @assert ir.new_nodes.info[op.id - length(ir.stmts)].pos <= use_idx
             else
                 if op.id >= use_idx
                     @verify_error "Def ($(op.id)) does not dominate use ($(use_idx)) in same BB"
diff --git a/base/compiler/typeinfer.jl b/base/compiler/typeinfer.jl
index 9a456660807da..510eec52ed623 100644
--- a/base/compiler/typeinfer.jl
+++ b/base/compiler/typeinfer.jl
@@ -712,8 +712,8 @@ function merge_call_chain!(parent::InferenceState, ancestor::InferenceState, chi
         add_cycle_backedge!(child, parent, parent.currpc)
         union_caller_cycle!(ancestor, child)
         child = parent
-        parent = child.parent
         child === ancestor && break
+        parent = child.parent::InferenceState
     end
 end
 
diff --git a/base/compiler/typelattice.jl b/base/compiler/typelattice.jl
index 5df8dfd411ba3..4f96a883b150c 100644
--- a/base/compiler/typelattice.jl
+++ b/base/compiler/typelattice.jl
@@ -299,7 +299,7 @@ function stupdate!(state::VarTable, changes::StateUpdate)
     if !isa(changes.var, Slot)
         return stupdate!(state, changes.state)
     end
-    newstate = false
+    newstate = nothing
     changeid = slot_id(changes.var::Slot)
     for i = 1:length(state)
         if i == changeid
@@ -328,7 +328,7 @@ function stupdate!(state::VarTable, changes::StateUpdate)
 end
 
 function stupdate!(state::VarTable, changes::VarTable)
-    newstate = false
+    newstate = nothing
     for i = 1:length(state)
         newtype = changes[i]
         oldtype = state[i]
@@ -342,7 +342,7 @@ end
 
 stupdate!(state::Nothing, changes::VarTable) = copy(changes)
 
-stupdate!(state::Nothing, changes::Nothing) = false
+stupdate!(state::Nothing, changes::Nothing) = nothing
 
 function stupdate1!(state::VarTable, change::StateUpdate)
     if !isa(change.var, Slot)
diff --git a/base/compiler/typeutils.jl b/base/compiler/typeutils.jl
index 954f14cfbfbbc..2600cfeafea24 100644
--- a/base/compiler/typeutils.jl
+++ b/base/compiler/typeutils.jl
@@ -187,17 +187,17 @@ end
 # unioncomplexity estimates the number of calls to `tmerge` to obtain the given type by
 # counting the Union instances, taking also into account those hidden in a Tuple or UnionAll
 function unioncomplexity(u::Union)
-    return unioncomplexity(u.a) + unioncomplexity(u.b) + 1
+    return unioncomplexity(u.a)::Int + unioncomplexity(u.b)::Int + 1
 end
 function unioncomplexity(t::DataType)
     t.name === Tuple.name || isvarargtype(t) || return 0
     c = 0
     for ti in t.parameters
-        c = max(c, unioncomplexity(ti))
+        c = max(c, unioncomplexity(ti)::Int)
     end
     return c
 end
-unioncomplexity(u::UnionAll) = max(unioncomplexity(u.body), unioncomplexity(u.var.ub))
+unioncomplexity(u::UnionAll) = max(unioncomplexity(u.body)::Int, unioncomplexity(u.var.ub)::Int)
 unioncomplexity(@nospecialize(x)) = 0
 
 function improvable_via_constant_propagation(@nospecialize(t))
diff --git a/base/compiler/validation.jl b/base/compiler/validation.jl
index df618d0033f60..4bf4447e39e94 100644
--- a/base/compiler/validation.jl
+++ b/base/compiler/validation.jl
@@ -1,7 +1,7 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
 # Expr head => argument count bounds
-const VALID_EXPR_HEADS = IdDict{Any,Any}(
+const VALID_EXPR_HEADS = IdDict{Symbol,UnitRange}(
     :call => 1:typemax(Int),
     :invoke => 2:typemax(Int),
     :static_parameter => 1:1,

From 27f3ae728eae6fca454836c42956a8b406ecd912 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Thu, 4 Feb 2021 14:03:37 -0500
Subject: [PATCH 13/54] fix 'error during bootstrap' printing (#39515)

(cherry picked from commit a07089e040ec1b918470859aa64f4e66ffb47be8)
---
 src/jlapi.c | 41 ++++++++++++++++++++++-------------------
 src/julia.h | 12 ++++++------
 2 files changed, 28 insertions(+), 25 deletions(-)

diff --git a/src/jlapi.c b/src/jlapi.c
index 1c14232fb8f8f..9d41f1066b99e 100644
--- a/src/jlapi.c
+++ b/src/jlapi.c
@@ -163,15 +163,16 @@ JL_DLLEXPORT const char *jl_string_ptr(jl_value_t *s)
 JL_DLLEXPORT jl_value_t *jl_call(jl_function_t *f, jl_value_t **args, int32_t nargs)
 {
     jl_value_t *v;
+    nargs++; // add f to args
     JL_TRY {
         jl_value_t **argv;
-        JL_GC_PUSHARGS(argv, nargs+1);
+        JL_GC_PUSHARGS(argv, nargs);
         argv[0] = (jl_value_t*)f;
-        for(int i=1; i<nargs+1; i++)
-            argv[i] = args[i-1];
+        for (int i = 1; i < nargs; i++)
+            argv[i] = args[i - 1];
         size_t last_age = jl_get_ptls_states()->world_age;
         jl_get_ptls_states()->world_age = jl_get_world_counter();
-        v = jl_apply(argv, nargs+1);
+        v = jl_apply(argv, nargs);
         jl_get_ptls_states()->world_age = last_age;
         JL_GC_POP();
         jl_exception_clear();
@@ -190,7 +191,7 @@ JL_DLLEXPORT jl_value_t *jl_call0(jl_function_t *f)
         JL_GC_PUSH1(&f);
         size_t last_age = jl_get_ptls_states()->world_age;
         jl_get_ptls_states()->world_age = jl_get_world_counter();
-        v = jl_apply(&f, 1);
+        v = jl_apply_generic(f, NULL, 0);
         jl_get_ptls_states()->world_age = last_age;
         JL_GC_POP();
         jl_exception_clear();
@@ -208,7 +209,8 @@ JL_DLLEXPORT jl_value_t *jl_call1(jl_function_t *f, jl_value_t *a)
     JL_TRY {
         jl_value_t **argv;
         JL_GC_PUSHARGS(argv, 2);
-        argv[0] = f; argv[1] = a;
+        argv[0] = f;
+        argv[1] = a;
         size_t last_age = jl_get_ptls_states()->world_age;
         jl_get_ptls_states()->world_age = jl_get_world_counter();
         v = jl_apply(argv, 2);
@@ -229,7 +231,9 @@ JL_DLLEXPORT jl_value_t *jl_call2(jl_function_t *f, jl_value_t *a, jl_value_t *b
     JL_TRY {
         jl_value_t **argv;
         JL_GC_PUSHARGS(argv, 3);
-        argv[0] = f; argv[1] = a; argv[2] = b;
+        argv[0] = f;
+        argv[1] = a;
+        argv[2] = b;
         size_t last_age = jl_get_ptls_states()->world_age;
         jl_get_ptls_states()->world_age = jl_get_world_counter();
         v = jl_apply(argv, 3);
@@ -251,7 +255,10 @@ JL_DLLEXPORT jl_value_t *jl_call3(jl_function_t *f, jl_value_t *a,
     JL_TRY {
         jl_value_t **argv;
         JL_GC_PUSHARGS(argv, 4);
-        argv[0] = f; argv[1] = a; argv[2] = b; argv[3] = c;
+        argv[0] = f;
+        argv[1] = a;
+        argv[2] = b;
+        argv[3] = c;
         size_t last_age = jl_get_ptls_states()->world_age;
         jl_get_ptls_states()->world_age = jl_get_world_counter();
         v = jl_apply(argv, 4);
@@ -496,25 +503,21 @@ static int exec_program(char *program)
         // TODO: It is possible for this output
         //       to be mangled due to `jlbacktrace`
         //       printing directly to STDERR_FILENO.
-        jl_value_t *errs = jl_stderr_obj();
-        JL_GC_PUSH1(&errs);
-        volatile int shown_err = 0;
+        int shown_err = 0;
         jl_printf(JL_STDERR, "error during bootstrap:\n");
-        JL_TRY {
+        jl_value_t *exc = jl_current_exception();
+        jl_value_t *showf = jl_get_function(jl_base_module, "show");
+        if (showf) {
+            jl_value_t *errs = jl_stderr_obj();
             if (errs) {
-                jl_value_t *showf = jl_get_function(jl_base_module, "show");
-                if (showf != NULL) {
-                    jl_call2(showf, errs, jl_current_exception());
+                if (jl_call2(showf, errs, exc)) {
                     jl_printf(JL_STDERR, "\n");
                     shown_err = 1;
                 }
             }
         }
-        JL_CATCH {
-        }
-        JL_GC_POP();
         if (!shown_err) {
-            jl_static_show((JL_STREAM*)STDERR_FILENO, jl_current_exception());
+            jl_static_show((JL_STREAM*)STDERR_FILENO, exc);
             jl_printf((JL_STREAM*)STDERR_FILENO, "\n");
         }
         jlbacktrace(); // written to STDERR_FILENO
diff --git a/src/julia.h b/src/julia.h
index 8bebcef1ebb74..b445404e76046 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -1703,12 +1703,12 @@ STATIC_INLINE jl_value_t *jl_apply(jl_value_t **args, uint32_t nargs)
     return jl_apply_generic(args[0], &args[1], nargs - 1);
 }
 
-JL_DLLEXPORT jl_value_t *jl_call(jl_function_t *f, jl_value_t **args, int32_t nargs);
-JL_DLLEXPORT jl_value_t *jl_call0(jl_function_t *f);
-JL_DLLEXPORT jl_value_t *jl_call1(jl_function_t *f, jl_value_t *a);
-JL_DLLEXPORT jl_value_t *jl_call2(jl_function_t *f, jl_value_t *a, jl_value_t *b);
-JL_DLLEXPORT jl_value_t *jl_call3(jl_function_t *f, jl_value_t *a,
-                                  jl_value_t *b, jl_value_t *c);
+JL_DLLEXPORT jl_value_t *jl_call(jl_function_t *f JL_MAYBE_UNROOTED, jl_value_t **args, int32_t nargs);
+JL_DLLEXPORT jl_value_t *jl_call0(jl_function_t *f JL_MAYBE_UNROOTED);
+JL_DLLEXPORT jl_value_t *jl_call1(jl_function_t *f JL_MAYBE_UNROOTED, jl_value_t *a JL_MAYBE_UNROOTED);
+JL_DLLEXPORT jl_value_t *jl_call2(jl_function_t *f JL_MAYBE_UNROOTED, jl_value_t *a JL_MAYBE_UNROOTED, jl_value_t *b JL_MAYBE_UNROOTED);
+JL_DLLEXPORT jl_value_t *jl_call3(jl_function_t *f JL_MAYBE_UNROOTED, jl_value_t *a JL_MAYBE_UNROOTED,
+                                  jl_value_t *b JL_MAYBE_UNROOTED, jl_value_t *c JL_MAYBE_UNROOTED);
 
 // interfacing with Task runtime
 JL_DLLEXPORT void jl_yield(void);

From 4ad0ffdb2476ef1c9e9f5553d4ca191ea56927a6 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Wed, 10 Feb 2021 15:42:42 -0500
Subject: [PATCH 14/54] another fix for 'error during bootstrap' printing

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

diff --git a/src/jlapi.c b/src/jlapi.c
index 9d41f1066b99e..d27f7e03d958c 100644
--- a/src/jlapi.c
+++ b/src/jlapi.c
@@ -506,7 +506,7 @@ static int exec_program(char *program)
         int shown_err = 0;
         jl_printf(JL_STDERR, "error during bootstrap:\n");
         jl_value_t *exc = jl_current_exception();
-        jl_value_t *showf = jl_get_function(jl_base_module, "show");
+        jl_value_t *showf = jl_base_module ? jl_get_function(jl_base_module, "show") : NULL;
         if (showf) {
             jl_value_t *errs = jl_stderr_obj();
             if (errs) {

From 8a03167f92d73573a15cd2722f7acb8d2695014d Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Wed, 10 Feb 2021 15:07:12 -0500
Subject: [PATCH 15/54] inference: add missing reset for stmt_info

This only would matter if we transition a call from T -> Union{}, which
is unlikely to happen, and even less likely to be observed, but it is
more correct this way.

(cherry picked from commit e67a3fda55ecbf0a758fb9aa11e3e3ed9e3933dd)
---
 base/compiler/abstractinterpretation.jl | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index 2b64c1728f80c..575421e40bf71 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -1329,8 +1329,8 @@ function typeinf_local(interp::AbstractInterpreter, frame::InferenceState)
             delete!(W, pc)
             frame.currpc = pc
             frame.cur_hand = frame.handler_at[pc]
-            edges = frame.stmt_edges[pc]
-            edges === nothing || empty!(edges)
+            frame.stmt_edges[pc] === nothing || empty!(frame.stmt_edges[pc])
+            frame.stmt_info[pc] = nothing
             stmt = frame.src.code[pc]
             changes = s[pc]::VarTable
             t = nothing

From c74bc146f4c98b20160e2549f828cb0fe8fad794 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Wed, 10 Feb 2021 15:20:26 -0500
Subject: [PATCH 16/54] inference: fix widenconst call for ReturnNode of
 PartialStruct
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Previously, we might accidentally leave behind content in the fields
that should not be there. For example:

```
julia> code_typed(() -> (TypeVar(:x),), (), optimize=false)
1-element Vector{Any}:
 CodeInfo(
    @ REPL[1]:1 within `#3'
1 ─ %1 = Main.TypeVar(:x)::Core.Compiler.PartialTypeVar(x, true, true)
│   %2 = Core.tuple(%1)::Core.PartialStruct(Tuple{TypeVar}, Any[Core.Compiler.PartialTypeVar(x, true, true)])
└──      return %2
) => Tuple{TypeVar}

julia> ans[1][1].rettype
Core.PartialStruct(Tuple{TypeVar}, Any[Core.Compiler.PartialTypeVar(x, true, true)])
```

(cherry picked from commit 7c8114c85914ec748f1be91759567cabc190245f)
---
 base/compiler/abstractinterpretation.jl | 29 ++++++++++++++++++++-----
 base/compiler/tfuncs.jl                 |  2 +-
 base/compiler/typeutils.jl              |  2 ++
 3 files changed, 26 insertions(+), 7 deletions(-)

diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index 575421e40bf71..f3615810faf5f 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -1308,6 +1308,28 @@ function abstract_eval_ssavalue(s::SSAValue, src::CodeInfo)
     return typ
 end
 
+function widenreturn(@nospecialize rt)
+    # only propagate information we know we can store
+    # and is valid and good inter-procedurally
+    rt = widenconditional(rt)
+    isa(rt, Const) && return rt
+    isa(rt, Type) && return rt
+    if isa(rt, PartialStruct)
+        fields = copy(rt.fields)
+        haveconst = false
+        for i in 1:length(fields)
+            a = widenreturn(fields[i])
+            if !haveconst && has_const_info(a)
+                # TODO: consider adding && const_prop_profitable(a) here?
+                haveconst = true
+            end
+            fields[i] = a
+        end
+        haveconst && return PartialStruct(rt.typ, fields)
+    end
+    return widenconst(rt)
+end
+
 # make as much progress on `frame` as possible (without handling cycles)
 function typeinf_local(interp::AbstractInterpreter, frame::InferenceState)
     @assert !frame.inferred
@@ -1385,12 +1407,7 @@ function typeinf_local(interp::AbstractInterpreter, frame::InferenceState)
                 end
             elseif isa(stmt, ReturnNode)
                 pc´ = n + 1
-                rt = widenconditional(abstract_eval_value(interp, stmt.val, changes, frame))
-                if !isa(rt, Const) && !isa(rt, Type) && !isa(rt, PartialStruct)
-                    # only propagate information we know we can store
-                    # and is valid inter-procedurally
-                    rt = widenconst(rt)
-                end
+                rt = widenreturn(abstract_eval_value(interp, stmt.val, changes, frame))
                 # copy limitations to return value
                 if !isempty(frame.pclimitations)
                     union!(frame.limitations, frame.pclimitations)
diff --git a/base/compiler/tfuncs.jl b/base/compiler/tfuncs.jl
index 3d5ad1768e5a4..859935bd916ea 100644
--- a/base/compiler/tfuncs.jl
+++ b/base/compiler/tfuncs.jl
@@ -1284,7 +1284,7 @@ function tuple_tfunc(atypes::Vector{Any})
         x = atypes[i]
         # TODO ignore singleton Const (don't forget to update cache logic if you implement this)
         if !anyinfo
-            anyinfo = !isa(x, Type) || isType(x)
+            anyinfo = has_const_info(x)
         end
         if isa(x, Const)
             params[i] = typeof(x.val)
diff --git a/base/compiler/typeutils.jl b/base/compiler/typeutils.jl
index 2600cfeafea24..bf95a69154d54 100644
--- a/base/compiler/typeutils.jl
+++ b/base/compiler/typeutils.jl
@@ -39,6 +39,8 @@ function has_nontrivial_const_info(@nospecialize t)
     return !isdefined(typeof(val), :instance) && !(isa(val, Type) && hasuniquerep(val))
 end
 
+has_const_info(@nospecialize x) = !isa(x, Type) || isType(x)
+
 # Subtyping currently intentionally answers certain queries incorrectly for kind types. For
 # some of these queries, this check can be used to somewhat protect against making incorrect
 # decisions based on incorrect subtyping. Note that this check, itself, is broken for

From 2e322bebcb6b7c041e4663c2868ccc53e603005a Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Mon, 14 Dec 2020 13:01:41 -0500
Subject: [PATCH 17/54] optimize invokelatest call performance (#38835)

Applications typically shouldn't use this function in
performance sensitive places, as it hints that their design is flawed,
but might as well make it faster anyways.

and optimize invokelatest kwcall too, while we are at it

(cherry picked from commit 2ff110ba199fbdc574ba4462035801b9eb9c08af)
---
 base/essentials.jl        | 13 ++++++-------
 src/builtin_proto.h       |  4 ++--
 src/builtins.c            | 19 +++++++++----------
 src/codegen.cpp           |  4 ++--
 src/jl_exported_funcs.inc |  6 +++---
 src/jlfrontend.scm        |  4 ++--
 src/staticdata.c          |  2 +-
 test/cmdlineargs.jl       | 12 ++++++------
 8 files changed, 31 insertions(+), 33 deletions(-)

diff --git a/base/essentials.jl b/base/essentials.jl
index 31c746bab5d28..aba10a1a011c6 100644
--- a/base/essentials.jl
+++ b/base/essentials.jl
@@ -703,12 +703,11 @@ call obsolete versions of a function `f`.
 `f` directly, and the type of the result cannot be inferred by the compiler.)
 """
 function invokelatest(@nospecialize(f), @nospecialize args...; kwargs...)
+    kwargs = Base.merge(NamedTuple(), kwargs)
     if isempty(kwargs)
-        return Core._apply_latest(f, args)
+        return Core._call_latest(f, args...)
     end
-    # We use a closure (`inner`) to handle kwargs.
-    inner() = f(args...; kwargs...)
-    Core._apply_latest(inner)
+    return Core._call_latest(Core.kwfunc(f), kwargs, f, args...)
 end
 
 """
@@ -738,11 +737,11 @@ of [`invokelatest`](@ref).
     world age refers to system state unrelated to the main Julia session.
 """
 function invoke_in_world(world::UInt, @nospecialize(f), @nospecialize args...; kwargs...)
+    kwargs = Base.merge(NamedTuple(), kwargs)
     if isempty(kwargs)
-        return Core._apply_in_world(world, f, args)
+        return Core._call_in_world(world, f, args...)
     end
-    inner() = f(args...; kwargs...)
-    Core._apply_in_world(world, inner)
+    return Core._call_in_world(world, Core.kwfunc(f), kwargs, f, args...)
 end
 
 # TODO: possibly make this an intrinsic
diff --git a/src/builtin_proto.h b/src/builtin_proto.h
index 8021c404bd5e7..e66af64eb4118 100644
--- a/src/builtin_proto.h
+++ b/src/builtin_proto.h
@@ -23,8 +23,8 @@ DECLARE_BUILTIN(throw);      DECLARE_BUILTIN(is);
 DECLARE_BUILTIN(typeof);     DECLARE_BUILTIN(sizeof);
 DECLARE_BUILTIN(issubtype);  DECLARE_BUILTIN(isa);
 DECLARE_BUILTIN(_apply);     DECLARE_BUILTIN(_apply_pure);
-DECLARE_BUILTIN(_apply_latest); DECLARE_BUILTIN(_apply_iterate);
-DECLARE_BUILTIN(_apply_in_world);
+DECLARE_BUILTIN(_call_latest); DECLARE_BUILTIN(_apply_iterate);
+DECLARE_BUILTIN(_call_in_world);
 DECLARE_BUILTIN(isdefined);  DECLARE_BUILTIN(nfields);
 DECLARE_BUILTIN(tuple);      DECLARE_BUILTIN(svec);
 DECLARE_BUILTIN(getfield);   DECLARE_BUILTIN(setfield);
diff --git a/src/builtins.c b/src/builtins.c
index 8cbce6c5b6188..de5318b59295e 100644
--- a/src/builtins.c
+++ b/src/builtins.c
@@ -712,21 +712,21 @@ JL_CALLABLE(jl_f__apply_pure)
     return ret;
 }
 
-// this is like `_apply`, but always runs in the newest world
-JL_CALLABLE(jl_f__apply_latest)
+// this is like a regular call, but always runs in the newest world
+JL_CALLABLE(jl_f__call_latest)
 {
     jl_ptls_t ptls = jl_get_ptls_states();
     size_t last_age = ptls->world_age;
     if (!ptls->in_pure_callback)
         ptls->world_age = jl_world_counter;
-    jl_value_t *ret = jl_f__apply(NULL, args, nargs);
+    jl_value_t *ret = jl_apply(args, nargs);
     ptls->world_age = last_age;
     return ret;
 }
 
-// Like `_apply`, but runs in the specified world.
+// Like call_in_world, but runs in the specified world.
 // If world > jl_world_counter, run in the latest world.
-JL_CALLABLE(jl_f__apply_in_world)
+JL_CALLABLE(jl_f__call_in_world)
 {
     JL_NARGSV(_apply_in_world, 2);
     jl_ptls_t ptls = jl_get_ptls_states();
@@ -734,10 +734,9 @@ JL_CALLABLE(jl_f__apply_in_world)
     JL_TYPECHK(_apply_in_world, ulong, args[0]);
     size_t world = jl_unbox_ulong(args[0]);
     world = world <= jl_world_counter ? world : jl_world_counter;
-    if (!ptls->in_pure_callback) {
+    if (!ptls->in_pure_callback)
         ptls->world_age = world;
-    }
-    jl_value_t *ret = do_apply(NULL, args+1, nargs-1, NULL);
+    jl_value_t *ret = jl_apply(&args[1], nargs - 1);
     ptls->world_age = last_age;
     return ret;
 }
@@ -1555,8 +1554,8 @@ void jl_init_primitives(void) JL_GC_DISABLED
     jl_builtin__expr = add_builtin_func("_expr", jl_f__expr);
     jl_builtin_svec = add_builtin_func("svec", jl_f_svec);
     add_builtin_func("_apply_pure", jl_f__apply_pure);
-    add_builtin_func("_apply_latest", jl_f__apply_latest);
-    add_builtin_func("_apply_in_world", jl_f__apply_in_world);
+    add_builtin_func("_call_latest", jl_f__call_latest);
+    add_builtin_func("_call_in_world", jl_f__call_in_world);
     add_builtin_func("_typevar", jl_f__typevar);
     add_builtin_func("_structtype", jl_f__structtype);
     add_builtin_func("_abstracttype", jl_f__abstracttype);
diff --git a/src/codegen.cpp b/src/codegen.cpp
index 126146e3ba811..713b3494bc144 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -841,8 +841,8 @@ static const std::map<jl_fptr_args_t, JuliaFunction*> builtin_func_map = {
     { &jl_f__apply,             new JuliaFunction{"jl_f__apply", get_func_sig, get_func_attrs} },
     { &jl_f__apply_iterate,     new JuliaFunction{"jl_f__apply_iterate", get_func_sig, get_func_attrs} },
     { &jl_f__apply_pure,        new JuliaFunction{"jl_f__apply_pure", get_func_sig, get_func_attrs} },
-    { &jl_f__apply_latest,      new JuliaFunction{"jl_f__apply_latest", get_func_sig, get_func_attrs} },
-    { &jl_f__apply_in_world,    new JuliaFunction{"jl_f__apply_in_world", get_func_sig, get_func_attrs} },
+    { &jl_f__call_latest,       new JuliaFunction{"jl_f__call_latest", get_func_sig, get_func_attrs} },
+    { &jl_f__call_in_world,     new JuliaFunction{"jl_f__call_in_world", get_func_sig, get_func_attrs} },
     { &jl_f_throw,              new JuliaFunction{"jl_f_throw", get_func_sig, get_func_attrs} },
     { &jl_f_tuple,              jltuple_func },
     { &jl_f_svec,               new JuliaFunction{"jl_f_svec", get_func_sig, get_func_attrs} },
diff --git a/src/jl_exported_funcs.inc b/src/jl_exported_funcs.inc
index b53a5c20244fb..ca49e08071aed 100644
--- a/src/jl_exported_funcs.inc
+++ b/src/jl_exported_funcs.inc
@@ -177,12 +177,12 @@
     XX(jl_expand_with_loc_warn) \
     XX(jl_extern_c) \
     XX(jl_f__abstracttype) \
-    XX(jl_f_applicable) \
     XX(jl_f__apply) \
-    XX(jl_f__apply_in_world) \
     XX(jl_f__apply_iterate) \
-    XX(jl_f__apply_latest) \
     XX(jl_f__apply_pure) \
+    XX(jl_f__call_in_world) \
+    XX(jl_f__call_latest) \
+    XX(jl_f_applicable) \
     XX(jl_f_apply_type) \
     XX(jl_f_arrayref) \
     XX(jl_f_arrayset) \
diff --git a/src/jlfrontend.scm b/src/jlfrontend.scm
index 39a3adc3ee467..fb3e732d41ca0 100644
--- a/src/jlfrontend.scm
+++ b/src/jlfrontend.scm
@@ -191,11 +191,11 @@
        (= (call include ,x)
           (block
            ,@loc
-           (call (core _apply_latest) (top include) (call (core svec) ,name ,x))))
+           (call (core _call_latest) (top include) ,name ,x)))
        (= (call include (:: ,mex (top Function)) ,x)
           (block
            ,@loc
-           (call (core _apply_latest) (top include) (call (core svec) ,mex ,name ,x))))))
+           (call (core _call_latest) (top include) ,mex ,name ,x)))))
    'none 0))
 
 ; run whole frontend on a string. useful for testing.
diff --git a/src/staticdata.c b/src/staticdata.c
index 625cc6c197309..d7607f013aced 100644
--- a/src/staticdata.c
+++ b/src/staticdata.c
@@ -237,7 +237,7 @@ void *native_functions;
 static const jl_fptr_args_t id_to_fptrs[] = {
     &jl_f_throw, &jl_f_is, &jl_f_typeof, &jl_f_issubtype, &jl_f_isa,
     &jl_f_typeassert, &jl_f__apply, &jl_f__apply_iterate, &jl_f__apply_pure,
-    &jl_f__apply_latest, &jl_f__apply_in_world, &jl_f_isdefined,
+    &jl_f__call_latest, &jl_f__call_in_world, &jl_f_isdefined,
     &jl_f_tuple, &jl_f_svec, &jl_f_intrinsic_call, &jl_f_invoke_kwsorter,
     &jl_f_getfield, &jl_f_setfield, &jl_f_fieldtype, &jl_f_nfields,
     &jl_f_arrayref, &jl_f_const_arrayref, &jl_f_arrayset, &jl_f_arraysize, &jl_f_apply_type,
diff --git a/test/cmdlineargs.jl b/test/cmdlineargs.jl
index ebf1525d81e52..05b3c867bb2a6 100644
--- a/test/cmdlineargs.jl
+++ b/test/cmdlineargs.jl
@@ -317,15 +317,15 @@ let exename = `$(Base.julia_cmd()) --startup-file=no`
         @test popfirst!(got) == "       80     []"
         if Sys.WORD_SIZE == 64
             # P64 pools with 64 bit tags
-            @test popfirst!(got) == "       32     Base.invokelatest(g, 0)"
-            @test popfirst!(got) == "       48     Base.invokelatest(g, x)"
+            @test popfirst!(got) == "       16     Base.invokelatest(g, 0)"
+            @test popfirst!(got) == "       32     Base.invokelatest(g, x)"
         elseif 12 == (() -> @allocated ccall(:jl_gc_allocobj, Ptr{Cvoid}, (Csize_t,), 8))()
             # See if we have a 12-byte pool with 32 bit tags (MAX_ALIGN = 4)
-            @test popfirst!(got) == "       24     Base.invokelatest(g, 0)"
-            @test popfirst!(got) == "       36     Base.invokelatest(g, x)"
+            @test popfirst!(got) == "       12     Base.invokelatest(g, 0)"
+            @test popfirst!(got) == "       24     Base.invokelatest(g, x)"
         else # MAX_ALIGN >= 8
-            @test popfirst!(got) == "       16     Base.invokelatest(g, 0)"
-            @test popfirst!(got) == "       48     Base.invokelatest(g, x)"
+            @test popfirst!(got) == "        8     Base.invokelatest(g, 0)"
+            @test popfirst!(got) == "       32     Base.invokelatest(g, x)"
         end
         @test popfirst!(got) == "       80     []"
         @test popfirst!(got) == "        - end"

From 20b967a1aaf1314de596e4d98ee7ec4a623b5205 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Thu, 7 Jan 2021 11:57:16 -0500
Subject: [PATCH 18/54] remove Core._apply Builtin (#39115)

We can emulate this deprecated function, until we delete it in v2.
This in turn revealed some missing error checks, which we also add.

Fixes #39113

(cherry picked from commit 59eb9f98ce9860cf25ec2a58ddab451d6b15c2c7)
---
 base/boot.jl                            |  3 +++
 base/compiler/abstractinterpretation.jl | 20 ++++++--------------
 base/compiler/compiler.jl               |  4 ++--
 base/compiler/optimize.jl               |  6 +++---
 base/compiler/ssair/inlining.jl         |  8 ++++----
 base/compiler/types.jl                  |  6 +++---
 src/builtin_proto.h                     |  2 +-
 src/builtins.c                          | 20 ++++----------------
 src/codegen.cpp                         | 11 ++++-------
 src/module.c                            |  2 ++
 src/staticdata.c                        |  5 ++---
 src/toplevel.c                          |  8 +++-----
 stdlib/InteractiveUtils/src/macros.jl   | 10 +++++-----
 test/compiler/inference.jl              |  9 +++++----
 test/compiler/inline.jl                 |  2 +-
 15 files changed, 48 insertions(+), 68 deletions(-)

diff --git a/base/boot.jl b/base/boot.jl
index 54d852ca96416..feaf1bff87b7b 100644
--- a/base/boot.jl
+++ b/base/boot.jl
@@ -800,4 +800,7 @@ Integer(x::Union{Float16, Float32, Float64}) = Int(x)
 # The internal jl_parse which will call into Core._parse if not `nothing`.
 _parse = nothing
 
+# support for deprecated uses of internal _apply function
+_apply(x...) = Core._apply_iterate(Main.Base.iterate, x...)
+
 ccall(:jl_set_istopmod, Cvoid, (Any, Bool), Core, true)
diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index f3615810faf5f..368dc602b98a7 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -589,13 +589,7 @@ end
 
 # simulate iteration protocol on container type up to fixpoint
 function abstract_iteration(interp::AbstractInterpreter, @nospecialize(itft), @nospecialize(itertype), sv::InferenceState)
-    if !isdefined(Main, :Base) || !isdefined(Main.Base, :iterate) || !isconst(Main.Base, :iterate)
-        return Any[Vararg{Any}], nothing
-    end
-    if itft === nothing
-        iteratef = getfield(Main.Base, :iterate)
-        itft = Const(iteratef)
-    elseif isa(itft, Const)
+    if isa(itft, Const)
         iteratef = itft.val
     else
         return Any[Vararg{Any}], nothing
@@ -607,6 +601,7 @@ function abstract_iteration(interp::AbstractInterpreter, @nospecialize(itft), @n
     # Return Bottom if this is not an iterator.
     # WARNING: Changes to the iteration protocol must be reflected here,
     # this is not just an optimization.
+    # TODO: this doesn't realize that Array, SimpleVector, Tuple, and NamedTuple do not use the iterate protocol
     stateordonet === Bottom && return Any[Bottom], AbstractIterationInfo(CallMeta[CallMeta(Bottom, info)])
     valtype = statetype = Bottom
     ret = Any[]
@@ -670,7 +665,7 @@ function abstract_apply(interp::AbstractInterpreter, @nospecialize(itft), @nospe
     aftw = widenconst(aft)
     if !isa(aft, Const) && (!isType(aftw) || has_free_typevars(aftw))
         if !isconcretetype(aftw) || (aftw <: Builtin)
-            add_remark!(interp, sv, "Core._apply called on a function of a non-concrete type")
+            add_remark!(interp, sv, "Core._apply_iterate called on a function of a non-concrete type")
             # bail now, since it seems unlikely that abstract_call will be able to do any better after splitting
             # this also ensures we don't call abstract_call_gf_by_type below on an IntrinsicFunction or Builtin
             return CallMeta(Any, false)
@@ -830,7 +825,8 @@ function abstract_call_builtin(interp::AbstractInterpreter, f::Builtin, fargs::U
     end
     rt = builtin_tfunction(interp, f, argtypes[2:end], sv)
     if f === getfield && isa(fargs, Vector{Any}) && la == 3 && isa(argtypes[3], Const) && isa(argtypes[3].val, Int) && argtypes[2] ⊑ Tuple
-        cti, _ = precise_container_type(interp, nothing, argtypes[2], sv)
+        # TODO: why doesn't this use the getfield_tfunc?
+        cti, _ = precise_container_type(interp, iterate, argtypes[2], sv)
         idx = argtypes[3].val::Int
         if 1 <= idx <= length(cti)
             rt = unwrapva(cti[idx])
@@ -949,11 +945,7 @@ function abstract_call_known(interp::AbstractInterpreter, @nospecialize(f),
     la = length(argtypes)
 
     if isa(f, Builtin)
-        if f === _apply
-            ft = argtype_by_index(argtypes, 2)
-            ft === Bottom && return CallMeta(Bottom, false)
-            return abstract_apply(interp, nothing, ft, argtype_tail(argtypes, 3), sv, max_methods)
-        elseif f === _apply_iterate
+        if f === _apply_iterate
             itft = argtype_by_index(argtypes, 2)
             ft = argtype_by_index(argtypes, 3)
             (itft === Bottom || ft === Bottom) && return CallMeta(Bottom, false)
diff --git a/base/compiler/compiler.jl b/base/compiler/compiler.jl
index 37e281f2f2724..0b1d03f61b704 100644
--- a/base/compiler/compiler.jl
+++ b/base/compiler/compiler.jl
@@ -1,11 +1,11 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
-getfield(getfield(Main, :Core), :eval)(getfield(Main, :Core), :(baremodule Compiler
+getfield(Core, :eval)(Core, :(baremodule Compiler
 
 using Core.Intrinsics, Core.IR
 
 import Core: print, println, show, write, unsafe_write, stdout, stderr,
-             _apply, _apply_iterate, svec, apply_type, Builtin, IntrinsicFunction,
+             _apply_iterate, svec, apply_type, Builtin, IntrinsicFunction,
              MethodInstance, CodeInstance, MethodMatch
 
 const getproperty = Core.getfield
diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
index f08b05dffe286..ce0c2e769d325 100644
--- a/base/compiler/optimize.jl
+++ b/base/compiler/optimize.jl
@@ -326,19 +326,19 @@ function statement_cost(ex::Expr, line::Int, src::CodeInfo, sptypes::Vector{Any}
             # The efficiency of operations like a[i] and s.b
             # depend strongly on whether the result can be
             # inferred, so check the type of ex
-            if f === Main.Core.getfield || f === Main.Core.tuple
+            if f === Core.getfield || f === Core.tuple
                 # we might like to penalize non-inferrability, but
                 # tuple iteration/destructuring makes that impossible
                 # return plus_saturate(argcost, isknowntype(extyp) ? 1 : params.inline_nonleaf_penalty)
                 return 0
-            elseif f === Main.Core.isa
+            elseif f === Core.isa
                 # If we're in a union context, we penalize type computations
                 # on union types. In such cases, it is usually better to perform
                 # union splitting on the outside.
                 if union_penalties && isa(argextype(ex.args[2],  src, sptypes, slottypes), Union)
                     return params.inline_nonleaf_penalty
                 end
-            elseif (f === Main.Core.arrayref || f === Main.Core.const_arrayref) && length(ex.args) >= 3
+            elseif (f === Core.arrayref || f === Core.const_arrayref) && length(ex.args) >= 3
                 atyp = argextype(ex.args[3], src, sptypes, slottypes)
                 return isknowntype(atyp) ? 4 : error_path ? params.inline_error_path_cost : params.inline_nonleaf_penalty
             end
diff --git a/base/compiler/ssair/inlining.jl b/base/compiler/ssair/inlining.jl
index ae42b59bee28a..1dce18bc35393 100644
--- a/base/compiler/ssair/inlining.jl
+++ b/base/compiler/ssair/inlining.jl
@@ -573,7 +573,7 @@ function batch_inline!(todo::Vector{Pair{Int, Any}}, ir::IRCode, linetable::Vect
     return ir
 end
 
-# This assumes the caller has verified that all arguments to the _apply call are Tuples.
+# This assumes the caller has verified that all arguments to the _apply_iterate call are Tuples.
 function rewrite_apply_exprargs!(ir::IRCode, todo::Vector{Pair{Int, Any}}, idx::Int,
         argexprs::Vector{Any}, atypes::Vector{Any}, arginfos::Vector{Any},
         arg_start::Int, et::Union{EdgeTracker, Nothing}, caches::Union{InferenceCaches, Nothing},
@@ -909,7 +909,7 @@ end
 function inline_apply!(ir::IRCode, todo::Vector{Pair{Int, Any}}, idx::Int, sig::Signature,
                        et, caches, params::OptimizationParams)
     stmt = ir.stmts[idx][:inst]
-    while sig.f === Core._apply || sig.f === Core._apply_iterate
+    while sig.f === Core._apply_iterate
         info = ir.stmts[idx][:info]
         if isa(info, UnionSplitApplyCallInfo)
             if length(info.infos) != 1
@@ -923,7 +923,7 @@ function inline_apply!(ir::IRCode, todo::Vector{Pair{Int, Any}}, idx::Int, sig::
             @assert info === nothing || info === false
             new_info = info = nothing
         end
-        arg_start = sig.f === Core._apply ? 2 : 3
+        arg_start = 3
         atypes = sig.atypes
         if arg_start > length(atypes)
             return nothing
@@ -1013,7 +1013,7 @@ function process_simple!(ir::IRCode, todo::Vector{Pair{Int, Any}}, idx::Int, sta
     sig = call_sig(ir, stmt)
     sig === nothing && return nothing
 
-    # Handle _apply
+    # Handle _apply_iterate
     sig = inline_apply!(ir, todo, idx, sig, state.et, state.caches, state.params)
     sig === nothing && return nothing
 
diff --git a/base/compiler/types.jl b/base/compiler/types.jl
index 1a1cbb0890e65..24e8c24379886 100644
--- a/base/compiler/types.jl
+++ b/base/compiler/types.jl
@@ -102,14 +102,14 @@ struct InferenceParams
     # before computing the set of matching methods
     MAX_UNION_SPLITTING::Int
     # the maximum number of union-tuples to swap / expand
-    # when inferring a call to _apply
+    # when inferring a call to _apply_iterate
     MAX_APPLY_UNION_ENUM::Int
 
     # parameters limiting large (tuple) types
     TUPLE_COMPLEXITY_LIMIT_DEPTH::Int
 
-    # when attempting to inlining _apply, abort the optimization if the tuple
-    # contains more than this many elements
+    # when attempting to inline _apply_iterate, abort the optimization if the
+    # tuple contains more than this many elements
     MAX_TUPLE_SPLAT::Int
 
     function InferenceParams(;
diff --git a/src/builtin_proto.h b/src/builtin_proto.h
index e66af64eb4118..c4d6166a5c194 100644
--- a/src/builtin_proto.h
+++ b/src/builtin_proto.h
@@ -22,7 +22,7 @@ extern "C" {
 DECLARE_BUILTIN(throw);      DECLARE_BUILTIN(is);
 DECLARE_BUILTIN(typeof);     DECLARE_BUILTIN(sizeof);
 DECLARE_BUILTIN(issubtype);  DECLARE_BUILTIN(isa);
-DECLARE_BUILTIN(_apply);     DECLARE_BUILTIN(_apply_pure);
+DECLARE_BUILTIN(_apply_pure);
 DECLARE_BUILTIN(_call_latest); DECLARE_BUILTIN(_apply_iterate);
 DECLARE_BUILTIN(_call_in_world);
 DECLARE_BUILTIN(isdefined);  DECLARE_BUILTIN(nfields);
diff --git a/src/builtins.c b/src/builtins.c
index de5318b59295e..6280cf63aa01e 100644
--- a/src/builtins.c
+++ b/src/builtins.c
@@ -506,7 +506,7 @@ STATIC_INLINE void _grow_to(jl_value_t **root, jl_value_t ***oldargs, jl_svec_t
 
 static jl_function_t *jl_iterate_func JL_GLOBALLY_ROOTED;
 
-static jl_value_t *do_apply(jl_value_t *F, jl_value_t **args, uint32_t nargs, jl_value_t *iterate)
+static jl_value_t *do_apply( jl_value_t **args, uint32_t nargs, jl_value_t *iterate)
 {
     jl_function_t *f = args[0];
     if (nargs == 2) {
@@ -548,12 +548,7 @@ static jl_value_t *do_apply(jl_value_t *F, jl_value_t **args, uint32_t nargs, jl
         }
     }
     if (extra && iterate == NULL) {
-        if (jl_iterate_func == NULL) {
-            jl_iterate_func = jl_get_function(jl_top_module, "iterate");
-            if (jl_iterate_func == NULL)
-                jl_undefined_var_error(jl_symbol("iterate"));
-        }
-        iterate = jl_iterate_func;
+        jl_undefined_var_error(jl_symbol("iterate"));
     }
     // allocate space for the argument array and gc roots for it
     // based on our previous estimates
@@ -677,13 +672,7 @@ static jl_value_t *do_apply(jl_value_t *F, jl_value_t **args, uint32_t nargs, jl
 JL_CALLABLE(jl_f__apply_iterate)
 {
     JL_NARGSV(_apply_iterate, 2);
-    return do_apply(F, args+1, nargs-1, args[0]);
-}
-
-JL_CALLABLE(jl_f__apply)
-{
-    JL_NARGSV(_apply, 1);
-    return do_apply(F, args, nargs, NULL);
+    return do_apply(args + 1, nargs - 1, args[0]);
 }
 
 // this is like `_apply`, but with quasi-exact checks to make sure it is pure
@@ -701,7 +690,7 @@ JL_CALLABLE(jl_f__apply_pure)
         // and `promote` works better this way
         size_t last_age = ptls->world_age;
         ptls->world_age = jl_world_counter;
-        ret = jl_f__apply(NULL, args, nargs);
+        ret = do_apply(args, nargs, NULL);
         ptls->world_age = last_age;
         ptls->in_pure_callback = last_in;
     }
@@ -1549,7 +1538,6 @@ void jl_init_primitives(void) JL_GC_DISABLED
 
     // internal functions
     jl_builtin_apply_type = add_builtin_func("apply_type", jl_f_apply_type);
-    jl_builtin__apply = add_builtin_func("_apply", jl_f__apply);
     jl_builtin__apply_iterate = add_builtin_func("_apply_iterate", jl_f__apply_iterate);
     jl_builtin__expr = add_builtin_func("_expr", jl_f__expr);
     jl_builtin_svec = add_builtin_func("svec", jl_f_svec);
diff --git a/src/codegen.cpp b/src/codegen.cpp
index 713b3494bc144..b6e52ecbd6091 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -838,7 +838,6 @@ static const std::map<jl_fptr_args_t, JuliaFunction*> builtin_func_map = {
     { &jl_f_isa,                new JuliaFunction{"jl_f_isa", get_func_sig, get_func_attrs} },
     { &jl_f_typeassert,         new JuliaFunction{"jl_f_typeassert", get_func_sig, get_func_attrs} },
     { &jl_f_ifelse,             new JuliaFunction{"jl_f_ifelse", get_func_sig, get_func_attrs} },
-    { &jl_f__apply,             new JuliaFunction{"jl_f__apply", get_func_sig, get_func_attrs} },
     { &jl_f__apply_iterate,     new JuliaFunction{"jl_f__apply_iterate", get_func_sig, get_func_attrs} },
     { &jl_f__apply_pure,        new JuliaFunction{"jl_f__apply_pure", get_func_sig, get_func_attrs} },
     { &jl_f__call_latest,       new JuliaFunction{"jl_f__call_latest", get_func_sig, get_func_attrs} },
@@ -2695,13 +2694,11 @@ static bool emit_builtin_call(jl_codectx_t &ctx, jl_cgval_t *ret, jl_value_t *f,
         }
     }
 
-    else if (((f == jl_builtin__apply && nargs == 2) ||
-              (f == jl_builtin__apply_iterate && nargs == 3)) && ctx.vaSlot > 0) {
-        int arg_start = f == jl_builtin__apply ? 2 : 3;
-        // turn Core._apply(f, Tuple) ==> f(Tuple...) using the jlcall calling convention if Tuple is the va allocation
-        if (LoadInst *load = dyn_cast_or_null<LoadInst>(argv[arg_start].V)) {
+    else if ((f == jl_builtin__apply_iterate && nargs == 3) && ctx.vaSlot > 0) {
+        // turn Core._apply_iterate(iter, f, Tuple) ==> f(Tuple...) using the jlcall calling convention if Tuple is the va allocation
+        if (LoadInst *load = dyn_cast_or_null<LoadInst>(argv[3].V)) {
             if (load->getPointerOperand() == ctx.slots[ctx.vaSlot].boxroot && ctx.argArray) {
-                Value *theF = boxed(ctx, argv[arg_start-1]);
+                Value *theF = boxed(ctx, argv[2]);
                 Value *nva = emit_n_varargs(ctx);
 #ifdef _P64
                 nva = ctx.builder.CreateTrunc(nva, T_int32);
diff --git a/src/module.c b/src/module.c
index 3bc1f22ea4cbc..20c119bedc27c 100644
--- a/src/module.c
+++ b/src/module.c
@@ -623,6 +623,8 @@ JL_DLLEXPORT jl_value_t *jl_get_global(jl_module_t *m, jl_sym_t *var)
 
 JL_DLLEXPORT void jl_set_global(jl_module_t *m JL_ROOTING_ARGUMENT, jl_sym_t *var, jl_value_t *val JL_ROOTED_ARGUMENT)
 {
+    JL_TYPECHK(jl_set_global, module, (jl_value_t*)m);
+    JL_TYPECHK(jl_set_global, symbol, (jl_value_t*)var);
     jl_binding_t *bp = jl_get_binding_wr(m, var, 1);
     JL_GC_PROMISE_ROOTED(bp);
     jl_checked_assignment(bp, val);
diff --git a/src/staticdata.c b/src/staticdata.c
index d7607f013aced..2938062d0ad9a 100644
--- a/src/staticdata.c
+++ b/src/staticdata.c
@@ -30,7 +30,7 @@ extern "C" {
 // TODO: put WeakRefs on the weak_refs list during deserialization
 // TODO: handle finalizers
 
-#define NUM_TAGS    146
+#define NUM_TAGS    145
 
 // An array of references that need to be restored from the sysimg
 // This is a manually constructed dual of the gvars array, which would be produced by codegen for Julia code, for C.
@@ -176,7 +176,6 @@ jl_value_t **const*const get_tags(void) {
         INSERT_TAG(jl_builtin_issubtype);
         INSERT_TAG(jl_builtin_isa);
         INSERT_TAG(jl_builtin_typeassert);
-        INSERT_TAG(jl_builtin__apply);
         INSERT_TAG(jl_builtin__apply_iterate);
         INSERT_TAG(jl_builtin_isdefined);
         INSERT_TAG(jl_builtin_nfields);
@@ -236,7 +235,7 @@ void *native_functions;
 // This is a manually constructed dual of the fvars array, which would be produced by codegen for Julia code, for C.
 static const jl_fptr_args_t id_to_fptrs[] = {
     &jl_f_throw, &jl_f_is, &jl_f_typeof, &jl_f_issubtype, &jl_f_isa,
-    &jl_f_typeassert, &jl_f__apply, &jl_f__apply_iterate, &jl_f__apply_pure,
+    &jl_f_typeassert, &jl_f__apply_iterate, &jl_f__apply_pure,
     &jl_f__call_latest, &jl_f__call_in_world, &jl_f_isdefined,
     &jl_f_tuple, &jl_f_svec, &jl_f_intrinsic_call, &jl_f_invoke_kwsorter,
     &jl_f_getfield, &jl_f_setfield, &jl_f_fieldtype, &jl_f_nfields,
diff --git a/src/toplevel.c b/src/toplevel.c
index 5ddf139e5f086..56523f2d09b54 100644
--- a/src/toplevel.c
+++ b/src/toplevel.c
@@ -45,15 +45,13 @@ JL_DLLEXPORT void jl_add_standard_imports(jl_module_t *m)
 // create a new top-level module
 void jl_init_main_module(void)
 {
-    if (jl_main_module != NULL)
-        jl_error("Main module already initialized.");
-
+    assert(jl_main_module == NULL);
     jl_main_module = jl_new_module(jl_symbol("Main"));
     jl_main_module->parent = jl_main_module;
     jl_set_const(jl_main_module, jl_symbol("Core"),
                  (jl_value_t*)jl_core_module);
-    jl_set_global(jl_core_module, jl_symbol("Main"),
-                  (jl_value_t*)jl_main_module);
+    jl_set_const(jl_core_module, jl_symbol("Main"),
+                 (jl_value_t*)jl_main_module);
 }
 
 static jl_function_t *jl_module_get_initializer(jl_module_t *m JL_PROPAGATES_ROOT)
diff --git a/stdlib/InteractiveUtils/src/macros.jl b/stdlib/InteractiveUtils/src/macros.jl
index 505178f6310ea..011a0034378b2 100644
--- a/stdlib/InteractiveUtils/src/macros.jl
+++ b/stdlib/InteractiveUtils/src/macros.jl
@@ -153,12 +153,12 @@ function gen_call_with_extracted_types(__module__, fcn, ex0, kws=Expr[])
     exret = Expr(:none)
     if ex.head === :call
         if any(e->(isa(e, Expr) && e.head === :(...)), ex0.args) &&
-            (ex.args[1] === GlobalRef(Core,:_apply) ||
-             ex.args[1] === GlobalRef(Base,:_apply))
+            (ex.args[1] === GlobalRef(Core,:_apply_iterate) ||
+             ex.args[1] === GlobalRef(Base,:_apply_iterate))
             # check for splatting
-            exret = Expr(:call, ex.args[1], fcn,
-                        Expr(:tuple, esc(ex.args[2]),
-                            Expr(:call, typesof, map(esc, ex.args[3:end])...)))
+            exret = Expr(:call, ex.args[2], fcn,
+                        Expr(:tuple, esc(ex.args[3]),
+                            Expr(:call, typesof, map(esc, ex.args[4:end])...)))
         else
             exret = Expr(:call, fcn, esc(ex.args[1]),
                          Expr(:call, typesof, map(esc, ex.args[2:end])...), kws...)
diff --git a/test/compiler/inference.jl b/test/compiler/inference.jl
index 8d5f9a2feba4b..6d1986e1fbecf 100644
--- a/test/compiler/inference.jl
+++ b/test/compiler/inference.jl
@@ -855,7 +855,7 @@ end
 aa20704(x) = x(nothing)
 @test code_typed(aa20704, (typeof(a20704),))[1][1].pure
 
-#issue #21065, elision of _apply when splatted expression is not effect_free
+#issue #21065, elision of _apply_iterate when splatted expression is not effect_free
 function f21065(x,y)
     println("x=$x, y=$y")
     return x, y
@@ -865,7 +865,7 @@ function test_no_apply(expr::Expr)
     return all(test_no_apply, expr.args)
 end
 function test_no_apply(ref::GlobalRef)
-    return ref.mod != Core || ref.name !== :_apply
+    return ref.mod != Core || ref.name !== :_apply_iterate
 end
 test_no_apply(::Any) = true
 @test all(test_no_apply, code_typed(g21065, Tuple{Int,Int})[1].first.code)
@@ -2041,6 +2041,7 @@ T27078 = Vector{Vector{T}} where T
 # issue #28070
 g28070(f, args...) = f(args...)
 @test @inferred g28070(Core._apply, Base.:/, (1.0, 1.0)) == 1.0
+@test @inferred g28070(Core._apply_iterate, Base.iterate, Base.:/, (1.0, 1.0)) == 1.0
 
 # issue #28079
 struct Foo28079 end
@@ -2298,9 +2299,9 @@ end
 
 @test @inferred(g28955((1,), 1.0)) === Bool
 
-# Test that inlining can look through repeated _applys
+# Test that inlining can look through repeated _apply_iterates
 foo_inlining_apply(args...) = ccall(:jl_, Nothing, (Any,), args[1])
-bar_inlining_apply() = Core._apply(Core._apply, (foo_inlining_apply,), ((1,),))
+bar_inlining_apply() = Core._apply_iterate(iterate, Core._apply_iterate, (iterate,), (foo_inlining_apply,), ((1,),))
 let ci = code_typed(bar_inlining_apply, Tuple{})[1].first
     @test length(ci.code) == 2
     @test ci.code[1].head == :foreigncall
diff --git a/test/compiler/inline.jl b/test/compiler/inline.jl
index e8b4c4f4cc77e..152aaac50d971 100644
--- a/test/compiler/inline.jl
+++ b/test/compiler/inline.jl
@@ -163,7 +163,7 @@ end
 # 2 for now because the compiler leaves a GotoNode around
 @test_broken length(code_typed(f_ifelse, (String,))[1][1].code) <= 2
 
-# Test that inlining of _apply properly hits the inference cache
+# Test that inlining of _apply_iterate properly hits the inference cache
 @noinline cprop_inline_foo1() = (1, 1)
 @noinline cprop_inline_foo2() = (2, 2)
 function cprop_inline_bar(x...)

From 56a3fb71f2a54a4deeaf765b7a318b72897f6891 Mon Sep 17 00:00:00 2001
From: Jeff Bezanson <jeff.bezanson@gmail.com>
Date: Thu, 7 Jan 2021 21:28:41 -0500
Subject: [PATCH 19/54] fix some compiler warnings (#39142)

- unused jl_iterate_func
- cast type of realloc in jl_init_threading

(cherry picked from commit 83bee67631bc3d532b6b0bc47b02753ad5865673)
---
 src/builtins.c  | 2 --
 src/threading.c | 4 ++--
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/builtins.c b/src/builtins.c
index 6280cf63aa01e..67c3564653e83 100644
--- a/src/builtins.c
+++ b/src/builtins.c
@@ -504,8 +504,6 @@ STATIC_INLINE void _grow_to(jl_value_t **root, jl_value_t ***oldargs, jl_svec_t
     *n_alloc = newalloc;
 }
 
-static jl_function_t *jl_iterate_func JL_GLOBALLY_ROOTED;
-
 static jl_value_t *do_apply( jl_value_t **args, uint32_t nargs, jl_value_t *iterate)
 {
     jl_function_t *f = args[0];
diff --git a/src/threading.c b/src/threading.c
index fc66e6bcbfdd5..efecc568f1db1 100644
--- a/src/threading.c
+++ b/src/threading.c
@@ -401,8 +401,8 @@ void jl_init_threading(void)
         jl_n_threads = (uint64_t)strtol(cp, NULL, 10);
     if (jl_n_threads <= 0)
         jl_n_threads = 1;
-    jl_measure_compile_time = realloc( jl_measure_compile_time, jl_n_threads * sizeof *jl_measure_compile_time );
-    jl_cumulative_compile_time = realloc( jl_cumulative_compile_time, jl_n_threads * sizeof *jl_cumulative_compile_time );
+    jl_measure_compile_time = (uint8_t*)realloc(jl_measure_compile_time, jl_n_threads * sizeof(*jl_measure_compile_time));
+    jl_cumulative_compile_time = (uint64_t*)realloc(jl_cumulative_compile_time, jl_n_threads * sizeof(*jl_cumulative_compile_time));
 #ifndef __clang_analyzer__
     jl_all_tls_states = (jl_ptls_t*)calloc(jl_n_threads, sizeof(void*));
 #endif

From 5f6094a6e2f715ad93b282b3010125f0a1e17852 Mon Sep 17 00:00:00 2001
From: Jeff Bezanson <jeff.bezanson@gmail.com>
Date: Tue, 9 Feb 2021 15:08:55 -0500
Subject: [PATCH 20/54] fix bug in `let` when a global var is both shadowed and
 used in an RHS (#39570)

(cherry picked from commit bc4e207dcd0dbc957b4a398488ec7495c47b42e8)
---
 src/julia-syntax.scm | 44 ++++++++++++++------------------------------
 test/core.jl         |  9 ---------
 test/syntax.jl       | 18 ++++++++++++++++++
 3 files changed, 32 insertions(+), 39 deletions(-)

diff --git a/src/julia-syntax.scm b/src/julia-syntax.scm
index b9043f11b8b94..a06eddc6071a3 100644
--- a/src/julia-syntax.scm
+++ b/src/julia-syntax.scm
@@ -1221,41 +1221,25 @@
                     (decl?   (cadar binds)))
                 (let ((vname (decl-var (cadar binds))))
                   (loop (cdr binds)
-                        (if (expr-contains-eq vname (caddar binds))
-                            (let ((tmp (make-ssavalue)))
-                              `(scope-block
-                                (block ,@hs
-                                       (= ,tmp ,(caddar binds))
-                                       (scope-block
-                                        (block
-                                         (local-def ,(cadar binds))
-                                         (= ,vname ,tmp)
-                                         ,blk)))))
-                            `(scope-block
-                              (block ,@hs
-                               (local-def ,(cadar binds))
-                               (= ,vname ,(caddar binds))
-                               ,blk))))))
+                        (let ((tmp (make-ssavalue)))
+                          `(block (= ,tmp ,(caddar binds))
+                                  (scope-block
+                                   (block ,@hs
+                                          (local-def ,(cadar binds))
+                                          (= ,vname ,tmp)
+                                          ,blk)))))))
                ;; (a, b, c, ...) = rhs
                ((and (pair? (cadar binds))
                      (eq? (caadar binds) 'tuple))
                 (let ((vars (lhs-vars (cadar binds))))
                   (loop (cdr binds)
-                        (if (expr-contains-p (lambda (x) (memq x vars)) (caddr (car binds)))
-                            ;; use more careful lowering if there are name conflicts. issue #25652
-                            (let ((temp (make-ssavalue)))
-                              `(block
-                                (= ,temp ,(caddr (car binds)))
-                                (scope-block
-                                 (block ,@hs
-                                  ,@(map (lambda (v) `(local-def ,v)) vars)
-                                  (= ,(cadr (car binds)) ,temp)
-                                  ,blk))))
-                            `(scope-block
-                              (block ,@hs
-                               ,@(map (lambda (v) `(local-def ,v)) vars)
-                               ,(car binds)
-                               ,blk))))))
+                        (let ((tmp (make-ssavalue)))
+                          `(block (= ,tmp ,(caddar binds))
+                                  (scope-block
+                                   (block ,@hs
+                                          ,@(map (lambda (v) `(local-def ,v)) vars)
+                                          (= ,(cadar binds) ,tmp)
+                                          ,blk)))))))
                (else (error "invalid let syntax"))))
              (else (error "invalid let syntax")))))))))
 
diff --git a/test/core.jl b/test/core.jl
index 28af6b88ceb4d..8b492843c2ee2 100644
--- a/test/core.jl
+++ b/test/core.jl
@@ -4124,15 +4124,6 @@ let ex = quote
     @test ex.args[2] == :test
 end
 
-# issue #25652
-x25652 = 1
-x25652_2 = let (x25652, _) = (x25652, nothing)
-    x25652 = x25652 + 1
-    x25652
-end
-@test x25652_2 == 2
-@test x25652 == 1
-
 # issue #15180
 function f15180(x::T) where T
     X = Vector{T}(undef, 1)
diff --git a/test/syntax.jl b/test/syntax.jl
index c6a43116a937d..91881ae0d5f00 100644
--- a/test/syntax.jl
+++ b/test/syntax.jl
@@ -2645,3 +2645,21 @@ end
 
 # issue #38501
 @test :"a $b $("str") c" == Expr(:string, "a ", :b, " ", Expr(:string, "str"), " c")
+
+# issue #25652
+x25652 = 1
+x25652_2 = let (x25652, _) = (x25652, nothing)
+    x25652 = x25652 + 1
+    x25652
+end
+@test x25652_2 == 2
+@test x25652 == 1
+
+@test let x = x25652
+    x25652 = x+3
+    x25652
+end == 4
+@test let (x,) = (x25652,)
+    x25652 = x+3
+    x25652
+end == 4

From 5fcecb402e6a907b2ff954c5cca8443136d8d94a Mon Sep 17 00:00:00 2001
From: Jeff Bezanson <jeff.bezanson@gmail.com>
Date: Fri, 12 Feb 2021 14:51:39 -0500
Subject: [PATCH 21/54] expand use of egal for testing type equality (#39604)

fixes #39565

(cherry picked from commit e7921dae99f64e4dc75f651ffb2721ff6ade4804)
---
 src/builtins.c       | 49 ++++++++++++++++++++++++--------------------
 src/julia_internal.h |  1 +
 src/subtype.c        | 16 ++++-----------
 test/subtype.jl      |  7 +++++++
 4 files changed, 39 insertions(+), 34 deletions(-)

diff --git a/src/builtins.c b/src/builtins.c
index 67c3564653e83..f55fe0f6556bf 100644
--- a/src/builtins.c
+++ b/src/builtins.c
@@ -126,13 +126,27 @@ static int NOINLINE compare_fields(jl_value_t *a, jl_value_t *b, jl_datatype_t *
     return 1;
 }
 
-static int egal_types(jl_value_t *a, jl_value_t *b, jl_typeenv_t *env) JL_NOTSAFEPOINT
+static int egal_types(jl_value_t *a, jl_value_t *b, jl_typeenv_t *env, int tvar_names) JL_NOTSAFEPOINT
 {
     if (a == b)
         return 1;
     jl_datatype_t *dt = (jl_datatype_t*)jl_typeof(a);
     if (dt != (jl_datatype_t*)jl_typeof(b))
         return 0;
+    if (dt == jl_datatype_type) {
+        jl_datatype_t *dta = (jl_datatype_t*)a;
+        jl_datatype_t *dtb = (jl_datatype_t*)b;
+        if (dta->name != dtb->name)
+            return 0;
+        size_t i, l = jl_nparams(dta);
+        if (jl_nparams(dtb) != l)
+            return 0;
+        for (i = 0; i < l; i++) {
+            if (!egal_types(jl_tparam(dta, i), jl_tparam(dtb, i), env, tvar_names))
+                return 0;
+        }
+        return 1;
+    }
     if (dt == jl_tvar_type) {
         jl_typeenv_t *pe = env;
         while (pe != NULL) {
@@ -142,37 +156,28 @@ static int egal_types(jl_value_t *a, jl_value_t *b, jl_typeenv_t *env) JL_NOTSAF
         }
         return 0;
     }
-    if (dt == jl_uniontype_type) {
-        return egal_types(((jl_uniontype_t*)a)->a, ((jl_uniontype_t*)b)->a, env) &&
-            egal_types(((jl_uniontype_t*)a)->b, ((jl_uniontype_t*)b)->b, env);
-    }
     if (dt == jl_unionall_type) {
         jl_unionall_t *ua = (jl_unionall_t*)a;
         jl_unionall_t *ub = (jl_unionall_t*)b;
-        if (ua->var->name != ub->var->name)
+        if (tvar_names && ua->var->name != ub->var->name)
             return 0;
-        if (!(egal_types(ua->var->lb, ub->var->lb, env) && egal_types(ua->var->ub, ub->var->ub, env)))
+        if (!(egal_types(ua->var->lb, ub->var->lb, env, tvar_names) && egal_types(ua->var->ub, ub->var->ub, env, tvar_names)))
             return 0;
         jl_typeenv_t e = { ua->var, (jl_value_t*)ub->var, env };
-        return egal_types(ua->body, ub->body, &e);
+        return egal_types(ua->body, ub->body, &e, tvar_names);
     }
-    if (dt == jl_datatype_type) {
-        jl_datatype_t *dta = (jl_datatype_t*)a;
-        jl_datatype_t *dtb = (jl_datatype_t*)b;
-        if (dta->name != dtb->name)
-            return 0;
-        size_t i, l = jl_nparams(dta);
-        if (jl_nparams(dtb) != l)
-            return 0;
-        for (i = 0; i < l; i++) {
-            if (!egal_types(jl_tparam(dta, i), jl_tparam(dtb, i), env))
-                return 0;
-        }
-        return 1;
+    if (dt == jl_uniontype_type) {
+        return egal_types(((jl_uniontype_t*)a)->a, ((jl_uniontype_t*)b)->a, env, tvar_names) &&
+            egal_types(((jl_uniontype_t*)a)->b, ((jl_uniontype_t*)b)->b, env, tvar_names);
     }
     return jl_egal(a, b);
 }
 
+JL_DLLEXPORT int jl_types_egal(jl_value_t *a, jl_value_t *b)
+{
+    return egal_types(a, b, NULL, 0);
+}
+
 JL_DLLEXPORT int jl_egal(jl_value_t *a JL_MAYBE_UNROOTED, jl_value_t *b JL_MAYBE_UNROOTED) JL_NOTSAFEPOINT
 {
     // warning: a,b may NOT have been gc-rooted by the caller
@@ -207,7 +212,7 @@ JL_DLLEXPORT int jl_egal(jl_value_t *a JL_MAYBE_UNROOTED, jl_value_t *b JL_MAYBE
     if (nf == 0 || !dt->layout->haspadding)
         return bits_equal(a, b, sz);
     if (dt == jl_unionall_type)
-        return egal_types(a, b, NULL);
+        return egal_types(a, b, NULL, 1);
     return compare_fields(a, b, dt);
 }
 
diff --git a/src/julia_internal.h b/src/julia_internal.h
index ab69bb964af9c..172492f540e0a 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -470,6 +470,7 @@ jl_svec_t *jl_outer_unionall_vars(jl_value_t *u);
 jl_value_t *jl_type_intersection_env_s(jl_value_t *a, jl_value_t *b, jl_svec_t **penv, int *issubty);
 jl_value_t *jl_type_intersection_env(jl_value_t *a, jl_value_t *b, jl_svec_t **penv);
 int jl_subtype_matching(jl_value_t *a, jl_value_t *b, jl_svec_t **penv);
+JL_DLLEXPORT int jl_types_egal(jl_value_t *a, jl_value_t *b);
 // specificity comparison assuming !(a <: b) and !(b <: a)
 JL_DLLEXPORT int jl_type_morespecific_no_subtype(jl_value_t *a, jl_value_t *b);
 jl_value_t *jl_instantiate_type_with(jl_value_t *t, jl_value_t **env, size_t n);
diff --git a/src/subtype.c b/src/subtype.c
index 5148232fa58c8..9869b2c993886 100644
--- a/src/subtype.c
+++ b/src/subtype.c
@@ -1860,7 +1860,7 @@ JL_DLLEXPORT int jl_subtype_env(jl_value_t *x, jl_value_t *y, jl_value_t **env,
     if (x == y ||
         (jl_typeof(x) == jl_typeof(y) &&
          (jl_is_unionall(y) || jl_is_uniontype(y)) &&
-         jl_egal(x, y))) {
+         jl_types_egal(x, y))) {
         if (envsz != 0) { // quickly copy env from x
             jl_unionall_t *ua = (jl_unionall_t*)x;
             int i;
@@ -1926,7 +1926,9 @@ JL_DLLEXPORT int jl_subtype(jl_value_t *x, jl_value_t *y)
 
 JL_DLLEXPORT int jl_types_equal(jl_value_t *a, jl_value_t *b)
 {
-    if (obviously_egal(a, b))
+    if (a == b)
+        return 1;
+    if (jl_typeof(a) == jl_typeof(b) && jl_types_egal(a, b))
         return 1;
     if (obviously_unequal(a, b))
         return 0;
@@ -1945,11 +1947,6 @@ JL_DLLEXPORT int jl_types_equal(jl_value_t *a, jl_value_t *b)
     if (b == (jl_value_t*)jl_any_type || a == jl_bottom_type) {
         subtype_ab = 1;
     }
-    else if (jl_typeof(a) == jl_typeof(b) &&
-        (jl_is_unionall(b) || jl_is_uniontype(b)) &&
-        jl_egal(a, b)) {
-        subtype_ab = 1;
-    }
     else if (jl_obvious_subtype(a, b, &subtype_ab)) {
 #ifdef NDEBUG
         if (subtype_ab == 0)
@@ -1964,11 +1961,6 @@ JL_DLLEXPORT int jl_types_equal(jl_value_t *a, jl_value_t *b)
     if (a == (jl_value_t*)jl_any_type || b == jl_bottom_type) {
         subtype_ba = 1;
     }
-    else if (jl_typeof(b) == jl_typeof(a) &&
-        (jl_is_unionall(a) || jl_is_uniontype(a)) &&
-        jl_egal(b, a)) {
-        subtype_ba = 1;
-    }
     else if (jl_obvious_subtype(b, a, &subtype_ba)) {
 #ifdef NDEBUG
         if (subtype_ba == 0)
diff --git a/test/subtype.jl b/test/subtype.jl
index 6298097b9b3d9..4b4cd750bdc80 100644
--- a/test/subtype.jl
+++ b/test/subtype.jl
@@ -1865,3 +1865,10 @@ g39218(a, b) = (@nospecialize; if a isa AB39218 && b isa AB39218; f39218(a, b);
 # issue #39521
 @test Tuple{Type{Tuple{A}} where A, DataType, DataType} <: Tuple{Vararg{B}} where B
 @test Tuple{DataType, Type{Tuple{A}} where A, DataType} <: Tuple{Vararg{B}} where B
+
+let A = Tuple{Type{<:Union{Number, T}}, Ref{T}} where T,
+    B = Tuple{Type{<:Union{Number, T}}, Ref{T}} where T
+    # TODO: these are caught by the egal check, but the core algorithm gets them wrong
+    @test A == B
+    @test A <: B
+end

From 4266e6d651f39670aa7d6cb24f2088be5febdf06 Mon Sep 17 00:00:00 2001
From: Max Horn <max@quendi.de>
Date: Wed, 13 Jan 2021 11:56:42 +0100
Subject: [PATCH 22/54] Fix a compiler warning

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

diff --git a/src/gf.c b/src/gf.c
index 4b07e35e2edba..fe9d904f2c9d5 100644
--- a/src/gf.c
+++ b/src/gf.c
@@ -1025,7 +1025,7 @@ static jl_method_instance_t *cache_method(
         // In most cases `!jl_isa_compileable_sig(tt, definition))`,
         // although for some cases, (notably Varargs)
         // we might choose a replacement type that's preferable but not strictly better
-        cache_with_orig = !jl_subtype(compilationsig, definition->sig);
+        cache_with_orig = !jl_subtype((jl_value_t*)compilationsig, definition->sig);
     }
     // TODO: maybe assert(jl_isa_compileable_sig(compilationsig, definition));
     newmeth = jl_specializations_get_linfo(definition, (jl_value_t*)compilationsig, sparams);

From 8e316dcacfbf488e0b936fcaee9476782216325b Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Tue, 9 Feb 2021 08:57:21 -0500
Subject: [PATCH 23/54] Fix misunwind during Profile test under rr (#39553)

Libunwind improperly aliases RSP and CFA, which are separate concepts.
Fix that.

(cherry picked from commit bbf7f9733ab25d91d2d966d05454393c17e863e0)
---
 deps/Versions.make                   |   1 +
 deps/checksums/unwind                |  48 ++++----
 deps/patches/libunwind-rsp-cfa.patch | 177 +++++++++++++++++++++++++++
 deps/unwind.mk                       |   6 +-
 4 files changed, 207 insertions(+), 25 deletions(-)
 create mode 100644 deps/patches/libunwind-rsp-cfa.patch

diff --git a/deps/Versions.make b/deps/Versions.make
index 4d7d31cfbfb37..965bbc7332bb4 100644
--- a/deps/Versions.make
+++ b/deps/Versions.make
@@ -101,6 +101,7 @@ SUITESPARSE_JLL_NAME := SuiteSparse
 # unwind
 UNWIND_VER := 1.3.2
 UNWIND_JLL_NAME := LibUnwind
+UNWIND_JLL_VER  := 1.3.2+3
 
 # zlib
 ZLIB_VER := 1.2.11
diff --git a/deps/checksums/unwind b/deps/checksums/unwind
index 1ec7c6189c85a..545c756d07f9a 100644
--- a/deps/checksums/unwind
+++ b/deps/checksums/unwind
@@ -1,26 +1,26 @@
 LibOSXUnwind.v0.0.6+1.x86_64-apple-darwin.tar.gz/md5/fd98df2005d13aa16341c5aecba1af70
 LibOSXUnwind.v0.0.6+1.x86_64-apple-darwin.tar.gz/sha512/2d2263c3e5f095ad9eba7fea7cb882a19fece8a10486489d0a15b8e81ea0f8626804c4822b8c92a26a608d568c0ff1a4e976ea6d746be47ac1a70891455162a6
-LibUnwind.v1.3.2+0.aarch64-linux-gnu.tar.gz/md5/36281b8ba75cab684c843585dc949b72
-LibUnwind.v1.3.2+0.aarch64-linux-gnu.tar.gz/sha512/7f5224fe3bfd9dd579fa2efb40b65ca785da3f7ddee1bd41e072f7f5be1ce8fa24c2eab71a1233406ce532ba9f900d1f0e288f84631684b3cbc8a0f3a8347e41
-LibUnwind.v1.3.2+0.aarch64-linux-musl.tar.gz/md5/ba21435b80f4f50fbb13cf4653e3fac3
-LibUnwind.v1.3.2+0.aarch64-linux-musl.tar.gz/sha512/25cfe1f1cbfe2b9ee748348e2b0df0fba3607dedbcf88f864e88a15544bfe0781de502157353915b62387abdb467c40e51b08e847f0d2cc096a3d2d13f061559
-LibUnwind.v1.3.2+0.armv6l-linux-gnueabihf.tar.gz/md5/81fc18e166b8de9de171ca202ee43816
-LibUnwind.v1.3.2+0.armv6l-linux-gnueabihf.tar.gz/sha512/e41f0224d79dc5725b327ad7f24eb09aef0fc687842d43eecc8ac60c4dcdc1d2877d45c88015d0e32014f8bef38712f540c27093d135dd0bc7e7eafb6bd64b18
-LibUnwind.v1.3.2+0.armv6l-linux-musleabihf.tar.gz/md5/69da77d1e7124dee0c60d4fc15cf0040
-LibUnwind.v1.3.2+0.armv6l-linux-musleabihf.tar.gz/sha512/a1c6d70971a7375c26ce761039f06a940db140b06028534557f3b608363af0da9d7ef570d5f3b388f84d9649d378293bb6b59d44cf34ebf24f0a260a6824f142
-LibUnwind.v1.3.2+0.armv7l-linux-gnueabihf.tar.gz/md5/b7a6b251f30cd6d1fc890a8be4a19476
-LibUnwind.v1.3.2+0.armv7l-linux-gnueabihf.tar.gz/sha512/d143588edb96b31de4d1347ddc867e5982ccee8a39a35f705114f6fa12aca054f14a05a24ca0850be26c62a92a4c52837e898765b3fa8fa6e5259e45eebbe281
-LibUnwind.v1.3.2+0.armv7l-linux-musleabihf.tar.gz/md5/bdfa9757e7631387cb64f3897e1847fc
-LibUnwind.v1.3.2+0.armv7l-linux-musleabihf.tar.gz/sha512/54f8529bb836cddff61e0112294ae3165eb6498b0c881b59047a40e180785f63c01e4ad82bcffb045b783e015c255c7b0e2f8ec43411ff647f860ef25551f540
-LibUnwind.v1.3.2+0.i686-linux-gnu.tar.gz/md5/17b1c29c3387dc3b685e75ce402caad6
-LibUnwind.v1.3.2+0.i686-linux-gnu.tar.gz/sha512/e8551b4771acf7eb31fc5db3423905b17c545aa0895b5e5369c56186841631f188186e585f0384cfca62269e1b2fffe9d9b24274d51e1ccad9bc89c3dbf6072b
-LibUnwind.v1.3.2+0.i686-linux-musl.tar.gz/md5/df7e34217c1dc931c88e573179218cf6
-LibUnwind.v1.3.2+0.i686-linux-musl.tar.gz/sha512/995318e65520eae55647b2d1065f5ac5bb15cdf7b4980000b17338c59e1657e408ba711c622b450df96712a5c1c75c85c03d7952a1fd7f0b65712fa9ac6ffbab
-LibUnwind.v1.3.2+0.powerpc64le-linux-gnu.tar.gz/md5/775e9c77ff9de48d40b2a2f18e5f081e
-LibUnwind.v1.3.2+0.powerpc64le-linux-gnu.tar.gz/sha512/3f4d12ba171227c11ad0e774e003742c1cd69d7e0e8ae571accea561ff930ae6aec119fc8b539caf52960886cde3978912e03d663aa7fb6416978e304767dde8
-LibUnwind.v1.3.2+0.x86_64-linux-gnu.tar.gz/md5/d63ca2bc34d4bc87498d28b47e530f54
-LibUnwind.v1.3.2+0.x86_64-linux-gnu.tar.gz/sha512/2e95d1648414fa9bccf6012a9f6690cf3c209dbb138bf59da76be538793c5caca319eed3b063f18725212844e21bd67157da2aec49ec9424e38664c23dde9f45
-LibUnwind.v1.3.2+0.x86_64-linux-musl.tar.gz/md5/56a9c951e75e38bf5787c928862924cf
-LibUnwind.v1.3.2+0.x86_64-linux-musl.tar.gz/sha512/8ea0c4d0e412a3792c6d33fe6dab6ae9f4c4103341842e42a9ae7efcb31c29d977970caa383373c6694d6cd8736ce75c727fa2af8f59bc3eff8d8f93ac0b9c89
-LibUnwind.v1.3.2+0.x86_64-unknown-freebsd.tar.gz/md5/10507e55604be0137c4531b5e35fbafc
-LibUnwind.v1.3.2+0.x86_64-unknown-freebsd.tar.gz/sha512/a795c02b48a3b44d6b7df0b07ed31f44c3c1e189b0732a5a41ce6f2eac952da4cc376eefab17c283a20a84aae4c3dc6618e58ca86003390b4ab396d085fa83c4
+LibUnwind.v1.3.2+3.aarch64-linux-gnu.tar.gz/md5/fba1f405a3a7c8bc4f68c17d771100b0
+LibUnwind.v1.3.2+3.aarch64-linux-gnu.tar.gz/sha512/a37d3f9da9a133bb270cc1046c7018579731897fed0ef6ab1fbeb0dde38e7be294a4e2abf41096c7edde617e266f1acc95777b34e22b6a8ced0e27b2228b0ec5
+LibUnwind.v1.3.2+3.aarch64-linux-musl.tar.gz/md5/587de98245251124c0d29b0b478374ec
+LibUnwind.v1.3.2+3.aarch64-linux-musl.tar.gz/sha512/9f10eee8e4f5117dfc4689378c93ba16e205aaa89eec5681e0b1e34e7c2d334717b327cae8d5024db6a1f6a2633454cb77b577112a0a03a3282e566705c1a81e
+LibUnwind.v1.3.2+3.armv6l-linux-gnueabihf.tar.gz/md5/953bfa931cb8e44d39ae22d7ccab1f22
+LibUnwind.v1.3.2+3.armv6l-linux-gnueabihf.tar.gz/sha512/54ee57c35895cbaed2160d451ca33ac9e8adf157b7f825853f7e92f8304f799f2671f5361dae7d2e7d111a3ab1f749cddb96a2c04b7b8fc7844b1e021dbc443f
+LibUnwind.v1.3.2+3.armv6l-linux-musleabihf.tar.gz/md5/5d16fd194ec5a7e46e1e1679072cec0f
+LibUnwind.v1.3.2+3.armv6l-linux-musleabihf.tar.gz/sha512/1ae68a77eadaf73de9de266bb3e2f61457faae6b2f971988363d2d1bebf855bdbc55ad848266335a9b3c040308e0bd3e3b66d5b66fe8807e0fb774c22bac928d
+LibUnwind.v1.3.2+3.armv7l-linux-gnueabihf.tar.gz/md5/569da138256de02784ba81b01e08a3db
+LibUnwind.v1.3.2+3.armv7l-linux-gnueabihf.tar.gz/sha512/264636b57ca49feb005752636671fe1c24264b15d1caca0c0808e89966a7683e7821a56e41b89cde9e32b688cf94647ae61de74f0428b7b1f92be2bed6674114
+LibUnwind.v1.3.2+3.armv7l-linux-musleabihf.tar.gz/md5/c9d2f634a742d71e471dd7ff691bf39d
+LibUnwind.v1.3.2+3.armv7l-linux-musleabihf.tar.gz/sha512/01c2085d49390ace5c128507a86d23b99d746cce080cc7b6415e1c75e63082d01b047b2cf98f3f76768fb49423c5524f53d253858d82864f09e8182a86be57ad
+LibUnwind.v1.3.2+3.i686-linux-gnu.tar.gz/md5/92e075574e65c735f6202cc49ec51593
+LibUnwind.v1.3.2+3.i686-linux-gnu.tar.gz/sha512/03f9a71b1b1b0752a835201248cdb2d17f076a82b0928e20f45fc2b8db0914128028c0d589ff94a97847265c216420240b2369af83c4a343d3ca37c58fdcf35a
+LibUnwind.v1.3.2+3.i686-linux-musl.tar.gz/md5/fa506359a72ffdf2c3713b5724ad4413
+LibUnwind.v1.3.2+3.i686-linux-musl.tar.gz/sha512/0558e871e838e6ce265c73fd7335bd0a486722ce9a710957b2e67731c494c5781a3a37176ba758f74fee37d48ee43acf02aac5092e24230523dd537610b58720
+LibUnwind.v1.3.2+3.powerpc64le-linux-gnu.tar.gz/md5/3f76849a52550e169d6f47ef95ca3d75
+LibUnwind.v1.3.2+3.powerpc64le-linux-gnu.tar.gz/sha512/2f3a119ccf1fffa8460e2350b66bf2303d11d636e649e144750e362d2e08f61d076adda71b5441b4337eaee6fb1e95049aac87de89be1415ca80f1b69c77f310
+LibUnwind.v1.3.2+3.x86_64-linux-gnu.tar.gz/md5/624779c4bc930ae2ba5f6a5d25c73aeb
+LibUnwind.v1.3.2+3.x86_64-linux-gnu.tar.gz/sha512/2eb467537e5f2acee7d5b2a5939c712ca96195584c37606d1ff1bcc0683514decefcae042f566633905472c177115c1467c1503bf331d8d7293b3026628bc138
+LibUnwind.v1.3.2+3.x86_64-linux-musl.tar.gz/md5/7ddcbe93c8bdb1edde0ffab23db3ced7
+LibUnwind.v1.3.2+3.x86_64-linux-musl.tar.gz/sha512/06901d074c15c34002957122897b6b9c449f9c64745363f6fe2886c862197cc6848ca17c3d777eac315fd1d8d90fe236a223167b0aa9fd3b625fd80e3db97655
+LibUnwind.v1.3.2+3.x86_64-unknown-freebsd.tar.gz/md5/ca388d44a8ca365b66999e4b4d1853a2
+LibUnwind.v1.3.2+3.x86_64-unknown-freebsd.tar.gz/sha512/dfbe0a6b5835b51ebea181bb996ffc8fcd8b08acf71243e171c59edb655fd65b6ba59291c10af923f75b7cbb2f52b46adf65ebdca3eee172d279ae357a35205c
diff --git a/deps/patches/libunwind-rsp-cfa.patch b/deps/patches/libunwind-rsp-cfa.patch
new file mode 100644
index 0000000000000..05986b0e7010a
--- /dev/null
+++ b/deps/patches/libunwind-rsp-cfa.patch
@@ -0,0 +1,177 @@
+commit 66f68ab50d35bb17a7ae3ac47f17e1ba5913760c
+Author: Keno Fischer <keno@juliacomputing.com>
+Date:   Sat Feb 6 18:13:16 2021 -0500
+
+    x86_64: Stop aliasing RSP and CFA
+    
+    RSP and CFA are different concepts. RSP refers to the physical
+    register, CFA is a virtual register that serves as the base
+    address for various other saved registers. It is true that
+    in many frames these are set to alias, however this is not
+    a requirement. For example, a function that performs a stack
+    switch would likely change the rsp in the middle of the function,
+    but would keep the CFA at the original RSP such that saved registers
+    may be appropriately recovered.
+    
+    We are seeing incorrect unwinds in the Julia runtime when running
+    julia under rr. This is because injects code (with correct CFI)
+    that performs just such a stack switch [1]. GDB manages to unwind
+    this correctly, but libunwind incorrectly sets the rsp to the CFA
+    address, causing a misunwind.
+    
+    Tested on x86_64, patches for other architectures are ported, but
+    not tested.
+    
+    [1] https://github.com/rr-debugger/rr/blob/469c22059a4a1798d33a8a224457faf22b2c178c/src/preload/syscall_hook.S#L454
+
+diff --git a/include/dwarf.h b/include/dwarf.h
+index fab93c61..b845e2eb 100644
+--- a/include/dwarf.h
++++ b/include/dwarf.h
+@@ -227,6 +227,7 @@ typedef enum
+     DWARF_WHERE_REG,            /* register saved in another register */
+     DWARF_WHERE_EXPR,           /* register saved */
+     DWARF_WHERE_VAL_EXPR,       /* register has computed value */
++    DWARF_WHERE_CFA,            /* register is set to the computed cfa value */
+   }
+ dwarf_where_t;
+ 
+@@ -309,7 +310,7 @@ typedef struct dwarf_cursor
+     void *as_arg;               /* argument to address-space callbacks */
+     unw_addr_space_t as;        /* reference to per-address-space info */
+ 
+-    unw_word_t cfa;     /* canonical frame address; aka frame-/stack-pointer */
++    unw_word_t cfa;     /* canonical frame address; aka frame-pointer */
+     unw_word_t ip;              /* instruction pointer */
+     unw_word_t args_size;       /* size of arguments */
+     unw_word_t eh_args[UNW_TDEP_NUM_EH_REGS];
+diff --git a/src/dwarf/Gparser.c b/src/dwarf/Gparser.c
+index 7d255aee..986c4a89 100644
+--- a/src/dwarf/Gparser.c
++++ b/src/dwarf/Gparser.c
+@@ -500,6 +500,8 @@ setup_fde (struct dwarf_cursor *c, dwarf_state_record_t *sr)
+   memset (sr, 0, sizeof (*sr));
+   for (i = 0; i < DWARF_NUM_PRESERVED_REGS + 2; ++i)
+     set_reg (sr, i, DWARF_WHERE_SAME, 0);
++  // SP defaults to CFA (but is overridable)
++  set_reg (sr, UNW_TDEP_SP, DWARF_WHERE_CFA, 0);
+ 
+   struct dwarf_cie_info *dci = c->pi.unwind_info;
+   sr->rs_current.ret_addr_column  = dci->ret_addr_column;
+@@ -826,6 +828,10 @@ apply_reg_state (struct dwarf_cursor *c, struct dwarf_reg_state *rs)
+         case DWARF_WHERE_SAME:
+           break;
+ 
++        case DWARF_WHERE_CFA:
++          new_loc[i] = DWARF_VAL_LOC (c, cfa);
++          break;
++
+         case DWARF_WHERE_CFAREL:
+           new_loc[i] = DWARF_MEM_LOC (c, cfa + rs->reg.val[i]);
+           break;
+diff --git a/src/x86/Gos-freebsd.c b/src/x86/Gos-freebsd.c
+index 7dd01404..1b251d02 100644
+--- a/src/x86/Gos-freebsd.c
++++ b/src/x86/Gos-freebsd.c
+@@ -138,6 +138,7 @@ x86_handle_signal_frame (unw_cursor_t *cursor)
+     c->dwarf.loc[ST0] = DWARF_NULL_LOC;
+   } else if (c->sigcontext_format == X86_SCF_FREEBSD_SYSCALL) {
+     c->dwarf.loc[EIP] = DWARF_LOC (c->dwarf.cfa, 0);
++    c->dwarf.loc[ESP] = DWARF_VAL_LOC (c, c->dwarf.cfa + 4);
+     c->dwarf.loc[EAX] = DWARF_NULL_LOC;
+     c->dwarf.cfa += 4;
+     c->dwarf.use_prev_instr = 1;
+diff --git a/src/x86/Gregs.c b/src/x86/Gregs.c
+index 4a959261..9446d6c6 100644
+--- a/src/x86/Gregs.c
++++ b/src/x86/Gregs.c
+@@ -53,7 +53,6 @@ tdep_access_reg (struct cursor *c, unw_regnum_t reg, unw_word_t *valp,
+       break;
+ 
+     case UNW_X86_CFA:
+-    case UNW_X86_ESP:
+       if (write)
+         return -UNW_EREADONLYREG;
+       *valp = c->dwarf.cfa;
+@@ -81,6 +80,7 @@ tdep_access_reg (struct cursor *c, unw_regnum_t reg, unw_word_t *valp,
+     case UNW_X86_ECX: loc = c->dwarf.loc[ECX]; break;
+     case UNW_X86_EBX: loc = c->dwarf.loc[EBX]; break;
+ 
++    case UNW_X86_ESP: loc = c->dwarf.loc[ESP]; break;
+     case UNW_X86_EBP: loc = c->dwarf.loc[EBP]; break;
+     case UNW_X86_ESI: loc = c->dwarf.loc[ESI]; break;
+     case UNW_X86_EDI: loc = c->dwarf.loc[EDI]; break;
+diff --git a/src/x86/Gstep.c b/src/x86/Gstep.c
+index 129b739a..061dcbaa 100644
+--- a/src/x86/Gstep.c
++++ b/src/x86/Gstep.c
+@@ -47,7 +47,7 @@ unw_step (unw_cursor_t *cursor)
+     {
+       /* DWARF failed, let's see if we can follow the frame-chain
+          or skip over the signal trampoline.  */
+-      struct dwarf_loc ebp_loc, eip_loc;
++      struct dwarf_loc ebp_loc, eip_loc, esp_loc;
+ 
+       /* We could get here because of missing/bad unwind information.
+          Validate all addresses before dereferencing. */
+@@ -77,6 +77,7 @@ unw_step (unw_cursor_t *cursor)
+                  c->dwarf.cfa);
+ 
+           ebp_loc = DWARF_LOC (c->dwarf.cfa, 0);
++          esp_loc = DWARF_VAL_LOC (c, c->dwarf.cfa + 8);
+           eip_loc = DWARF_LOC (c->dwarf.cfa + 4, 0);
+           c->dwarf.cfa += 8;
+ 
+@@ -87,6 +88,7 @@ unw_step (unw_cursor_t *cursor)
+             c->dwarf.loc[i] = DWARF_NULL_LOC;
+ 
+           c->dwarf.loc[EBP] = ebp_loc;
++          c->dwarf.loc[ESP] = esp_loc;
+           c->dwarf.loc[EIP] = eip_loc;
+           c->dwarf.use_prev_instr = 1;
+         }
+diff --git a/src/x86_64/Gos-freebsd.c b/src/x86_64/Gos-freebsd.c
+index 883025c8..8bb101ea 100644
+--- a/src/x86_64/Gos-freebsd.c
++++ b/src/x86_64/Gos-freebsd.c
+@@ -133,6 +133,7 @@ x86_64_handle_signal_frame (unw_cursor_t *cursor)
+     c->dwarf.loc[RCX] = c->dwarf.loc[R10];
+     /*  rsp_loc = DWARF_LOC(c->dwarf.cfa - 8, 0);       */
+     /*  rbp_loc = c->dwarf.loc[RBP];                    */
++    c->dwarf.loc[RSP] = DWARF_VAL_LOC (c, c->dwarf.cfa + 8);
+     c->dwarf.loc[RIP] = DWARF_LOC (c->dwarf.cfa, 0);
+     ret = dwarf_get (&c->dwarf, c->dwarf.loc[RIP], &c->dwarf.ip);
+     Debug (1, "Frame Chain [RIP=0x%Lx] = 0x%Lx\n",
+diff --git a/src/x86_64/Gregs.c b/src/x86_64/Gregs.c
+index baf8a24f..dff5bcbe 100644
+--- a/src/x86_64/Gregs.c
++++ b/src/x86_64/Gregs.c
+@@ -79,7 +79,6 @@ tdep_access_reg (struct cursor *c, unw_regnum_t reg, unw_word_t *valp,
+       break;
+ 
+     case UNW_X86_64_CFA:
+-    case UNW_X86_64_RSP:
+       if (write)
+         return -UNW_EREADONLYREG;
+       *valp = c->dwarf.cfa;
+@@ -107,6 +106,7 @@ tdep_access_reg (struct cursor *c, unw_regnum_t reg, unw_word_t *valp,
+     case UNW_X86_64_RCX: loc = c->dwarf.loc[RCX]; break;
+     case UNW_X86_64_RBX: loc = c->dwarf.loc[RBX]; break;
+ 
++    case UNW_X86_64_RSP: loc = c->dwarf.loc[RSP]; break;
+     case UNW_X86_64_RBP: loc = c->dwarf.loc[RBP]; break;
+     case UNW_X86_64_RSI: loc = c->dwarf.loc[RSI]; break;
+     case UNW_X86_64_RDI: loc = c->dwarf.loc[RDI]; break;
+diff --git a/src/x86_64/Gstep.c b/src/x86_64/Gstep.c
+index 10498170..5425e3db 100644
+--- a/src/x86_64/Gstep.c
++++ b/src/x86_64/Gstep.c
+@@ -160,7 +160,7 @@ unw_step (unw_cursor_t *cursor)
+             {
+               unw_word_t rbp1 = 0;
+               rbp_loc = DWARF_LOC(rbp, 0);
+-              rsp_loc = DWARF_NULL_LOC;
++              rsp_loc = DWARF_VAL_LOC(c, rbp + 16);
+               rip_loc = DWARF_LOC (rbp + 8, 0);
+               ret = dwarf_get (&c->dwarf, rbp_loc, &rbp1);
+               Debug (1, "[RBP=0x%lx] = 0x%lx (cfa = 0x%lx) -> 0x%lx\n",
diff --git a/deps/unwind.mk b/deps/unwind.mk
index 351f9b3df745f..4dec41f58a32b 100644
--- a/deps/unwind.mk
+++ b/deps/unwind.mk
@@ -24,7 +24,11 @@ $(SRCCACHE)/libunwind-$(UNWIND_VER)/libunwind-static-arm.patch-applied: $(SRCCAC
 	cd $(SRCCACHE)/libunwind-$(UNWIND_VER) && patch -p1 -f < $(SRCDIR)/patches/libunwind-static-arm.patch
 	echo 1 > $@
 
-$(BUILDDIR)/libunwind-$(UNWIND_VER)/build-configured: $(SRCCACHE)/libunwind-$(UNWIND_VER)/source-extracted $(SRCCACHE)/libunwind-$(UNWIND_VER)/libunwind-static-arm.patch-applied
+$(SRCCACHE)/libunwind-$(UNWIND_VER)/libunwind-rsp-cfa.patch-applied: $(SRCCACHE)/libunwind-$(UNWIND_VER)/libunwind-static-arm.patch-applied
+	cd $(SRCCACHE)/libunwind-$(UNWIND_VER) && patch -p1 -f -u < $(SRCDIR)/patches/libunwind-rsp-cfa.patch
+	echo 1 > $@
+
+$(BUILDDIR)/libunwind-$(UNWIND_VER)/build-configured: $(SRCCACHE)/libunwind-$(UNWIND_VER)/source-extracted $(SRCCACHE)/libunwind-$(UNWIND_VER)/libunwind-rsp-cfa.patch-applied
 	mkdir -p $(dir $@)
 	cd $(dir $@) && \
 	$(dir $<)/configure $(CONFIGURE_COMMON) CPPFLAGS="$(CPPFLAGS) $(LIBUNWIND_CPPFLAGS)" CFLAGS="$(CFLAGS) $(LIBUNWIND_CFLAGS)" --disable-shared --disable-minidebuginfo --disable-tests

From 7ce2441cbc32bda2ca7dc2189e3657ee90ca43d4 Mon Sep 17 00:00:00 2001
From: Jeffrey Lin <jeffrey@icurse.nl>
Date: Thu, 11 Feb 2021 11:06:50 +0000
Subject: [PATCH 24/54] special/exp.jl: fix broken jldoctest block (#39610)

This was introduced in 0097bddf900c16a7c7591671a6a3a0e2bd8acb4d.

(cherry picked from commit 99f98dd36b0acd1c53b200e2ab3cdbd5de6b9b2a)
---
 base/special/exp.jl | 1 +
 1 file changed, 1 insertion(+)

diff --git a/base/special/exp.jl b/base/special/exp.jl
index fd1befeb14b36..938c5e8b66626 100644
--- a/base/special/exp.jl
+++ b/base/special/exp.jl
@@ -255,4 +255,5 @@ Compute the natural base exponential of `x`, in other words ``e^x``.
 ```jldoctest
 julia> exp(1.0)
 2.718281828459045
+```
 """ exp(x::Real)

From d37a8d4e8f2d76924cb46e94931e03fa7c3417f7 Mon Sep 17 00:00:00 2001
From: Fredrik Ekre <ekrefredrik@gmail.com>
Date: Thu, 11 Feb 2021 22:47:35 +0100
Subject: [PATCH 25/54] Update Downloads.jl: (#39615)

$ git log --pretty=oneline --abbrev=commit 0d798cf..2b4bed9
2b4bed901185edcb59389515378eba2f26aaa577 Disable HTTP/2. (#96)
88a217c50bc165a10009c7b8c617e458a1e0ad0e Fix optoin typo (#92)

(cherry picked from commit 2687bbbf14e90cbb2654ac6eb4deed223a04d18d)
---
 .../md5                                                         | 1 -
 .../sha512                                                      | 1 -
 .../md5                                                         | 1 +
 .../sha512                                                      | 1 +
 stdlib/Downloads.version                                        | 2 +-
 5 files changed, 3 insertions(+), 3 deletions(-)
 delete mode 100644 deps/checksums/Downloads-0d798cfe2c06c304833dde913552fe13559a0c20.tar.gz/md5
 delete mode 100644 deps/checksums/Downloads-0d798cfe2c06c304833dde913552fe13559a0c20.tar.gz/sha512
 create mode 100644 deps/checksums/Downloads-2b4bed901185edcb59389515378eba2f26aaa577.tar.gz/md5
 create mode 100644 deps/checksums/Downloads-2b4bed901185edcb59389515378eba2f26aaa577.tar.gz/sha512

diff --git a/deps/checksums/Downloads-0d798cfe2c06c304833dde913552fe13559a0c20.tar.gz/md5 b/deps/checksums/Downloads-0d798cfe2c06c304833dde913552fe13559a0c20.tar.gz/md5
deleted file mode 100644
index 4a1d720b1d763..0000000000000
--- a/deps/checksums/Downloads-0d798cfe2c06c304833dde913552fe13559a0c20.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-258aee97c44956a2ef94525b24899b66
diff --git a/deps/checksums/Downloads-0d798cfe2c06c304833dde913552fe13559a0c20.tar.gz/sha512 b/deps/checksums/Downloads-0d798cfe2c06c304833dde913552fe13559a0c20.tar.gz/sha512
deleted file mode 100644
index bd810322f68bd..0000000000000
--- a/deps/checksums/Downloads-0d798cfe2c06c304833dde913552fe13559a0c20.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-882a552472b1023eed52ffbeeafd320a178dcb54f1dc36a5cc8c8c8f06c1038e13e8cd257784851532deaa3faaf9809146a0873c3dff28219b9ee6492366ee2c
diff --git a/deps/checksums/Downloads-2b4bed901185edcb59389515378eba2f26aaa577.tar.gz/md5 b/deps/checksums/Downloads-2b4bed901185edcb59389515378eba2f26aaa577.tar.gz/md5
new file mode 100644
index 0000000000000..33255ee0c5bb1
--- /dev/null
+++ b/deps/checksums/Downloads-2b4bed901185edcb59389515378eba2f26aaa577.tar.gz/md5
@@ -0,0 +1 @@
+faaf8972874d14ecb073a2d5dba1e27c
diff --git a/deps/checksums/Downloads-2b4bed901185edcb59389515378eba2f26aaa577.tar.gz/sha512 b/deps/checksums/Downloads-2b4bed901185edcb59389515378eba2f26aaa577.tar.gz/sha512
new file mode 100644
index 0000000000000..9d907f4d5d172
--- /dev/null
+++ b/deps/checksums/Downloads-2b4bed901185edcb59389515378eba2f26aaa577.tar.gz/sha512
@@ -0,0 +1 @@
+7d33d7411c57dd5d5d6e5052d6c3065eb652e2889d7f3d6f350eb8bad3948be90fd86226d0a6f0b60c15d17e2a2fa1a13ad32d358285ac69bbe89a18edcc1b2c
diff --git a/stdlib/Downloads.version b/stdlib/Downloads.version
index 4d5a67afafcad..a1bc2b90f72d4 100644
--- a/stdlib/Downloads.version
+++ b/stdlib/Downloads.version
@@ -1,2 +1,2 @@
 DOWNLOADS_BRANCH = master
-DOWNLOADS_SHA1 = 0d798cfe2c06c304833dde913552fe13559a0c20
+DOWNLOADS_SHA1 = 2b4bed901185edcb59389515378eba2f26aaa577

From 295995aa07fd27b8dccf883bff11ac0c1dfc9f3b Mon Sep 17 00:00:00 2001
From: Simeon Schaub <simeondavidschaub99@gmail.com>
Date: Fri, 12 Feb 2021 20:55:26 +0100
Subject: [PATCH 26/54] fix #39600: broadcast fusion broken for comparison
 (#39602)

(cherry picked from commit fc47e951f945a22eb550bc91a95f52086c7a7fed)
---
 src/julia-syntax.scm | 55 ++++++++++++++++++++++----------------------
 test/syntax.jl       | 11 +++++++++
 2 files changed, 39 insertions(+), 27 deletions(-)

diff --git a/src/julia-syntax.scm b/src/julia-syntax.scm
index a06eddc6071a3..620253de26bbc 100644
--- a/src/julia-syntax.scm
+++ b/src/julia-syntax.scm
@@ -1769,33 +1769,34 @@
              (args (map dot-to-fuse (cdr kws+args)))
              (make `(call (top ,(if (null? kws) 'broadcasted 'broadcasted_kwsyntax)) ,@kws ,f ,@args)))
         (if top (cons 'fuse make) make)))
-    (if (and (length= e 3) (eq? (car e) '|.|))
-        (let ((f (cadr e)) (x (caddr e)))
-          (cond ((or (atom? x) (eq? (car x) 'quote) (eq? (car x) 'inert) (eq? (car x) '$))
-                 `(call (top getproperty) ,f ,x))
-                ((eq? (car x) 'tuple)
-                 (if (and (eq? (identifier-name f) '^) (length= x 3) (integer? (caddr x)))
-                     (make-fuse '(top literal_pow)
-                                (list f (cadr x) (expand-forms `(call (call (core apply_type) (top Val) ,(caddr x))))))
-                     (make-fuse f (cdr x))))
-                (else
-                 (error (string "invalid syntax \"" (deparse e) "\"")))))
-        (if (and (pair? e) (eq? (car e) 'call))
-            (begin
-              (define (make-fuse- f x)
-                (if (and (eq? (identifier-name f) '^) (length= x 2) (integer? (cadr x)))
-                    (make-fuse '(top literal_pow)
-                               (list f (car x) (expand-forms `(call (call (core apply_type) (top Val) ,(cadr x))))))
-                    (make-fuse f x)))
-              (let ((f (cadr e)))
-                (cond ((dotop-named? f)
-                       (make-fuse- (undotop f) (cddr e)))
-                      ;; (.+)(a, b) is parsed as (call (|.| +) a b), but we still want it to fuse
-                      ((and (length= f 2) (eq? (car f) '|.|))
-                       (make-fuse- (cadr f) (cddr e)))
-                      (else
-                        e))))
-            e)))
+    (cond ((and (length= e 3) (eq? (car e) '|.|))
+           (let ((f (cadr e)) (x (caddr e)))
+             (cond ((or (atom? x) (eq? (car x) 'quote) (eq? (car x) 'inert) (eq? (car x) '$))
+                    `(call (top getproperty) ,f ,x))
+                   ((eq? (car x) 'tuple)
+                    (if (and (eq? (identifier-name f) '^) (length= x 3) (integer? (caddr x)))
+                        (make-fuse '(top literal_pow)
+                                   (list f (cadr x) (expand-forms `(call (call (core apply_type) (top Val) ,(caddr x))))))
+                        (make-fuse f (cdr x))))
+                   (else
+                    (error (string "invalid syntax \"" (deparse e) "\""))))))
+          ((and (pair? e) (eq? (car e) 'call))
+           (define (make-fuse- f x)
+             (if (and (eq? (identifier-name f) '^) (length= x 2) (integer? (cadr x)))
+                 (make-fuse '(top literal_pow)
+                            (list f (car x) (expand-forms `(call (call (core apply_type) (top Val) ,(cadr x))))))
+                 (make-fuse f x)))
+           (let ((f (cadr e)))
+             (cond ((dotop-named? f)
+                    (make-fuse- (undotop f) (cddr e)))
+                   ;; (.+)(a, b) is parsed as (call (|.| +) a b), but we still want it to fuse
+                   ((and (length= f 2) (eq? (car f) '|.|))
+                    (make-fuse- (cadr f) (cddr e)))
+                   (else
+                     e))))
+          ((and (pair? e) (eq? (car e) 'comparison))
+           (dot-to-fuse (expand-compare-chain (cdr e)) top))
+          (else e)))
   (let ((e (dot-to-fuse rhs #t)) ; an expression '(fuse func args) if expr is a dot call
         (lhs-view (ref-to-view lhs))) ; x[...] expressions on lhs turn in to view(x, ...) to update x in-place
     (if (fuse? e)
diff --git a/test/syntax.jl b/test/syntax.jl
index 91881ae0d5f00..eb113ed4da2c5 100644
--- a/test/syntax.jl
+++ b/test/syntax.jl
@@ -2663,3 +2663,14 @@ end == 4
     x25652 = x+3
     x25652
 end == 4
+
+@testset "issue #39600" begin
+    A = 1:.5:2
+    @test (!).(1 .< A .< 2) == [true, false, true]
+    @test .!(1 .< A .< 2) == [true, false, true]
+    @test (.!)(1 .< A .< 2) == [true, false, true]
+
+    @test ncalls_in_lowered(:((!).(1 .< A .< 2)), GlobalRef(Base, :materialize)) == 1
+    @test ncalls_in_lowered(:(.!(1 .< A .< 2)), GlobalRef(Base, :materialize)) == 1
+    @test ncalls_in_lowered(:((.!)(1 .< A .< 2)), GlobalRef(Base, :materialize)) == 1
+end

From 999e12d50e7e014191bac340b6898a53c1066526 Mon Sep 17 00:00:00 2001
From: Tim Besard <tim.besard@gmail.com>
Date: Sat, 13 Feb 2021 03:44:29 +0100
Subject: [PATCH 27/54] Lock cfunction trampoline cache and freelist accesses.
 (#39621)

Co-authored-by: Valentin Churavy <v.churavy@gmail.com>
(cherry picked from commit 6468dcb04ea2947f43a11f556da9a5588de512a0)
---
 src/runtime_ccall.cpp | 13 ++++++++++---
 test/threads_exec.jl  |  7 +------
 2 files changed, 11 insertions(+), 9 deletions(-)

diff --git a/src/runtime_ccall.cpp b/src/runtime_ccall.cpp
index 0dd727749f30e..1f176afac7ebf 100644
--- a/src/runtime_ccall.cpp
+++ b/src/runtime_ccall.cpp
@@ -210,9 +210,11 @@ extern "C" JL_DLLEXPORT char *jl_format_filename(const char *output_pattern)
 }
 
 
+static jl_mutex_t trampoline_lock;          // for accesses to the cache and freelist
+
 static void *trampoline_freelist;
 
-static void *trampoline_alloc()
+static void *trampoline_alloc()             // lock taken by caller
 {
     const int sz = 64; // oversized for most platforms. todo: use precise value?
     if (!trampoline_freelist) {
@@ -245,7 +247,7 @@ static void *trampoline_alloc()
     return tramp;
 }
 
-static void trampoline_free(void *tramp)
+static void trampoline_free(void *tramp)    // lock taken by caller
 {
     *(void**)tramp = trampoline_freelist;
     trampoline_freelist = tramp;
@@ -260,17 +262,18 @@ static void trampoline_deleter(void **f)
     f[0] = NULL;
     f[2] = NULL;
     f[3] = NULL;
+    JL_LOCK_NOGC(&trampoline_lock);
     if (tramp)
         trampoline_free(tramp);
     if (fobj && cache)
         ptrhash_remove((htable_t*)cache, fobj);
     if (nval)
         free(nval);
+    JL_UNLOCK_NOGC(&trampoline_lock);
 }
 
 // Use of `cache` is not clobbered in JL_TRY
 JL_GCC_IGNORE_START("-Wclobbered")
-// TODO: need a thread lock around the cache access parts of this function
 extern "C" JL_DLLEXPORT
 jl_value_t *jl_get_cfunction_trampoline(
     // dynamic inputs:
@@ -284,6 +287,7 @@ jl_value_t *jl_get_cfunction_trampoline(
     jl_value_t **vals)
 {
     // lookup (fobj, vals) in cache
+    JL_LOCK_NOGC(&trampoline_lock);
     if (!cache->table)
         htable_new(cache, 1);
     if (fill != jl_emptysvec) {
@@ -295,6 +299,7 @@ jl_value_t *jl_get_cfunction_trampoline(
         }
     }
     void *tramp = ptrhash_get(cache, (void*)fobj);
+    JL_UNLOCK_NOGC(&trampoline_lock);
     if (tramp != HT_NOTFOUND) {
         assert((jl_datatype_t*)jl_typeof(tramp) == result_type);
         return (jl_value_t*)tramp;
@@ -347,10 +352,12 @@ jl_value_t *jl_get_cfunction_trampoline(
         free(nval);
         jl_rethrow();
     }
+    JL_LOCK_NOGC(&trampoline_lock);
     tramp = trampoline_alloc();
     ((void**)result)[0] = tramp;
     tramp = init_trampoline(tramp, nval);
     ptrhash_put(cache, (void*)fobj, result);
+    JL_UNLOCK_NOGC(&trampoline_lock);
     return result;
 }
 JL_GCC_IGNORE_STOP
diff --git a/test/threads_exec.jl b/test/threads_exec.jl
index 691fca2fb2afa..87b3edc7c8025 100644
--- a/test/threads_exec.jl
+++ b/test/threads_exec.jl
@@ -471,7 +471,6 @@ end
 
 function test_thread_cfunction()
     # ensure a runtime call to `get_trampoline` will be created
-    # TODO: get_trampoline is not thread-safe (as this test shows)
     fs = [ Core.Box() for i in 1:1000 ]
     @noinline cf(f) = @cfunction $f Float64 ()
     cfs = Vector{Base.CFunction}(undef, length(fs))
@@ -494,11 +493,7 @@ function test_thread_cfunction()
     @test sum(ok) == 10000
 end
 if cfunction_closure
-    if nthreads() == 1
-        test_thread_cfunction()
-    else
-        @test_broken "cfunction trampoline code not thread-safe"
-    end
+    test_thread_cfunction()
 end
 
 # Compare the two ways of checking if threading is enabled.

From 502bb3878895aa5922a65804abf79fdd95fa8be6 Mon Sep 17 00:00:00 2001
From: Milan Bouchet-Valat <nalimilan@club.fr>
Date: Mon, 15 Feb 2021 17:00:23 +0100
Subject: [PATCH 28/54] Use lower limit on number of threads in cmdlineargs
 test (#39667)

200 is still too high for some 32-bit systems.

(cherry picked from commit 37aea067b702d6e8bc374209ac4a8423bc00b888)
---
 test/cmdlineargs.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/cmdlineargs.jl b/test/cmdlineargs.jl
index 05b3c867bb2a6..e24794e255dc1 100644
--- a/test/cmdlineargs.jl
+++ b/test/cmdlineargs.jl
@@ -205,7 +205,7 @@ let exename = `$(Base.julia_cmd()) --startup-file=no`
     end
     # We want to test oversubscription, but on manycore machines, this can
     # actually exhaust limited PID spaces
-    cpu_threads = max(2*cpu_threads, min(200, 10*cpu_threads))
+    cpu_threads = max(2*cpu_threads, min(50, 10*cpu_threads))
     @test read(`$exename -t $cpu_threads -e $code`, String) == string(cpu_threads)
     withenv("JULIA_NUM_THREADS" => string(cpu_threads)) do
         @test read(`$exename -e $code`, String) == string(cpu_threads)

From 7fb0434d9dc2629416a567790b2af0d5030bdf27 Mon Sep 17 00:00:00 2001
From: Sebastian Stock <42280794+sostock@users.noreply.github.com>
Date: Mon, 15 Feb 2021 18:40:39 +0100
Subject: [PATCH 29/54] Add compat notes for Julia 1.6 (#39671)

(cherry picked from commit 715e6264e33a408a576966dc9ca2a75ddc4cc160)
---
 base/cmd.jl                                      | 3 +++
 base/floatfuncs.jl                               | 3 +++
 base/operators.jl                                | 3 +++
 base/strings/search.jl                           | 3 +++
 base/subarray.jl                                 | 4 ++++
 stdlib/LinearAlgebra/src/dense.jl                | 3 +++
 stdlib/Printf/src/Printf.jl                      | 6 ++++++
 stdlib/REPL/src/TerminalMenus/AbstractMenu.jl    | 6 ++++++
 stdlib/REPL/src/TerminalMenus/MultiSelectMenu.jl | 3 +++
 9 files changed, 34 insertions(+)

diff --git a/base/cmd.jl b/base/cmd.jl
index e1f93413a2fbc..809bc0f3c0a57 100644
--- a/base/cmd.jl
+++ b/base/cmd.jl
@@ -251,6 +251,9 @@ setenv(cmd::Cmd; dir="") = Cmd(cmd; dir=dir)
 Merge new environment mappings into the given `Cmd` object, returning a new `Cmd` object.
 Duplicate keys are replaced.  If `command` does not contain any environment values set already,
 it inherits the current environment at time of `addenv()` call if `inherit` is `true`.
+
+!!! compat "Julia 1.6"
+    This function requires Julia 1.6 or later.
 """
 function addenv(cmd::Cmd, env::Dict; inherit::Bool = true)
     new_env = Dict{String,String}()
diff --git a/base/floatfuncs.jl b/base/floatfuncs.jl
index 97f72134c28f4..2bca2989bab0b 100644
--- a/base/floatfuncs.jl
+++ b/base/floatfuncs.jl
@@ -253,6 +253,9 @@ for example, in `x - y ≈ 0`, `atol=1e-9` is an absurdly small tolerance if `x`
 but an absurdly large tolerance if `x` is the
 [radius of a Hydrogen atom](https://en.wikipedia.org/wiki/Bohr_radius) in meters.
 
+!!! compat "Julia 1.6"
+    Passing the `norm` keyword argument when comparing numeric (non-array) arguments
+    requires Julia 1.6 or later.
 
 # Examples
 ```jldoctest
diff --git a/base/operators.jl b/base/operators.jl
index 45690a25a2a04..d591b6254255a 100644
--- a/base/operators.jl
+++ b/base/operators.jl
@@ -1157,6 +1157,9 @@ Avoid adding methods to this function; define `in` instead.
 
 Create a function that checks whether its argument contains the given `item`, i.e.
 a function equivalent to `y -> item in y`.
+
+!!! compat "Julia 1.6"
+    This method requires Julia 1.6 or later.
 """
 ∋(x) = Fix2(∋, x)
 
diff --git a/base/strings/search.jl b/base/strings/search.jl
index c9a1ec921c6e1..51b23705671f7 100644
--- a/base/strings/search.jl
+++ b/base/strings/search.jl
@@ -628,6 +628,9 @@ Create a function that checks whether its argument occurs in `haystack`, i.e.
 a function equivalent to `needle -> occursin(needle, haystack)`.
 
 The returned function is of type `Base.Fix2{typeof(occursin)}`.
+
+!!! compat "Julia 1.6"
+    This method requires Julia 1.6 or later.
 """
 occursin(haystack) = Base.Fix2(occursin, haystack)
 
diff --git a/base/subarray.jl b/base/subarray.jl
index 7b705be82a31f..bd2d0dc231a6c 100644
--- a/base/subarray.jl
+++ b/base/subarray.jl
@@ -135,6 +135,10 @@ Some immutable parent arrays (like ranges) may choose to simply
 recompute a new array in some circumstances instead of returning
 a `SubArray` if doing so is efficient and provides compatible semantics.
 
+!!! compat "Julia 1.6"
+    In Julia 1.6 or later, `view` can be called on an `AbstractString`, returning a
+    `SubString`.
+
 # Examples
 ```jldoctest
 julia> A = [1 2; 3 4]
diff --git a/stdlib/LinearAlgebra/src/dense.jl b/stdlib/LinearAlgebra/src/dense.jl
index f6c8c34e5531a..47473dd39e4bc 100644
--- a/stdlib/LinearAlgebra/src/dense.jl
+++ b/stdlib/LinearAlgebra/src/dense.jl
@@ -347,6 +347,9 @@ overwriting the existing value of `C`.
 !!! tip
     Bounds checking can be disabled by [`@inbounds`](@ref), but you need to take care of the shape
     of `C`, `A`, `B` yourself.
+
+!!! compat "Julia 1.6"
+    This function requires Julia 1.6 or later.
 """
 @inline function kron!(C::AbstractMatrix, A::AbstractMatrix, B::AbstractMatrix)
     require_one_based_indexing(A, B)
diff --git a/stdlib/Printf/src/Printf.jl b/stdlib/Printf/src/Printf.jl
index 8efd25ec9556c..ac57f95ec6bb9 100644
--- a/stdlib/Printf/src/Printf.jl
+++ b/stdlib/Printf/src/Printf.jl
@@ -56,6 +56,9 @@ formatted string directly to `io`.
 
 For convenience, the `Printf.format"..."` string macro form can be used for building
 a `Printf.Format` object at macro-expansion-time.
+
+!!! compat "Julia 1.6"
+    `Printf.Format` requires Julia 1.6 or later.
 """
 struct Format{S, T}
     str::S # original full format string as CodeUnits
@@ -375,6 +378,9 @@ For arbitrary precision numerics, you might extend the method like:
 ```julia
 Printf.tofloat(x::MyArbitraryPrecisionType) = BigFloat(x)
 ```
+
+!!! compat "Julia 1.6"
+    This function requires Julia 1.6 or later.
 """
 tofloat(x) = Float64(x)
 tofloat(x::Base.IEEEFloat) = x
diff --git a/stdlib/REPL/src/TerminalMenus/AbstractMenu.jl b/stdlib/REPL/src/TerminalMenus/AbstractMenu.jl
index 4dff0c31595ee..f01df5c389324 100644
--- a/stdlib/REPL/src/TerminalMenus/AbstractMenu.jl
+++ b/stdlib/REPL/src/TerminalMenus/AbstractMenu.jl
@@ -149,6 +149,9 @@ keypress(m::AbstractMenu, i::UInt32) = false
     numoptions(m::AbstractMenu) -> Int
 
 Return the number of options in menu `m`. Defaults to `length(options(m))`.
+
+!!! compat "Julia 1.6"
+    This function requires Julia 1.6 or later.
 """
 numoptions(m::AbstractMenu) = length(options(m))
 
@@ -169,6 +172,9 @@ number used for the initial cursor position. `cursor` can be either an
 control of the cursor position from the outside.
 
 Returns `selected(m)`.
+
+!!! compat "Julia 1.6"
+    The `cursor` argument requires Julia 1.6 or later.
 """
 request(m::AbstractMenu; kwargs...) = request(terminal, m; kwargs...)
 
diff --git a/stdlib/REPL/src/TerminalMenus/MultiSelectMenu.jl b/stdlib/REPL/src/TerminalMenus/MultiSelectMenu.jl
index 77bf4197e9a81..bf686dec28d19 100644
--- a/stdlib/REPL/src/TerminalMenus/MultiSelectMenu.jl
+++ b/stdlib/REPL/src/TerminalMenus/MultiSelectMenu.jl
@@ -51,6 +51,9 @@ were selected by the user.
   - `selected=[]`: pre-selected items. `i ∈ selected` means that `options[i]` is preselected.
 
 Any additional keyword arguments will be passed to [`TerminalMenus.MultiSelectConfig`](@ref).
+
+!!! compat "Julia 1.6"
+    The `selected` argument requires Julia 1.6 or later.
 """
 function MultiSelectMenu(options::Array{String,1}; pagesize::Int=10, selected=Int[], warn::Bool=true, kwargs...)
     length(options) < 1 && error("MultiSelectMenu must have at least one option")

From 684587d83e9a6e5cd6901d8e6ed174322935d3f7 Mon Sep 17 00:00:00 2001
From: Jeff Bezanson <jeff.bezanson@gmail.com>
Date: Tue, 16 Feb 2021 22:08:42 -0500
Subject: [PATCH 30/54] avoid excessive renaming in subtype of intersection
 result (#39623)

fixes #39505, fixes #39394

do fewer subtype checks in `jl_type_intersection2`

(cherry picked from commit 093b2a6ea943f4c70fef4742453e73dd1aba255c)
---
 src/gf.c        | 30 +++++++++++++-----------------
 src/subtype.c   | 22 +++++++++++++++++++---
 test/subtype.jl |  8 +++++++-
 3 files changed, 39 insertions(+), 21 deletions(-)

diff --git a/src/gf.c b/src/gf.c
index fe9d904f2c9d5..8861144e92e38 100644
--- a/src/gf.c
+++ b/src/gf.c
@@ -1586,26 +1586,22 @@ JL_DLLEXPORT void jl_method_table_disable(jl_methtable_t *mt, jl_method_t *metho
 static int jl_type_intersection2(jl_value_t *t1, jl_value_t *t2, jl_value_t **isect, jl_value_t **isect2)
 {
     *isect2 = NULL;
-    *isect = jl_type_intersection(t1, t2);
+    int is_subty = 0;
+    *isect = jl_type_intersection_env_s(t1, t2, NULL, &is_subty);
     if (*isect == jl_bottom_type)
         return 0;
+    if (is_subty)
+        return 1;
     // determine if type-intersection can be convinced to give a better, non-bad answer
-    if (!(jl_subtype(*isect, t1) && jl_subtype(*isect, t2))) {
-        // if the intersection was imprecise, see if we can do
-        // better by switching the types
-        *isect2 = jl_type_intersection(t2, t1);
-        if (*isect2 == jl_bottom_type) {
-            *isect = jl_bottom_type;
-            *isect2 = NULL;
-            return 0;
-        }
-        if (jl_subtype(*isect2, t1) && jl_subtype(*isect2, t2)) {
-            *isect = *isect2;
-            *isect2 = NULL;
-        }
-        else if (jl_types_equal(*isect2, *isect)) {
-            *isect2 = NULL;
-        }
+    // if the intersection was imprecise, see if we can do better by switching the types
+    *isect2 = jl_type_intersection(t2, t1);
+    if (*isect2 == jl_bottom_type) {
+        *isect = jl_bottom_type;
+        *isect2 = NULL;
+        return 0;
+    }
+    if (jl_types_egal(*isect2, *isect)) {
+        *isect2 = NULL;
     }
     return 1;
 }
diff --git a/src/subtype.c b/src/subtype.c
index 9869b2c993886..76fcab4c0a301 100644
--- a/src/subtype.c
+++ b/src/subtype.c
@@ -2431,7 +2431,9 @@ static jl_value_t *finish_unionall(jl_value_t *res JL_MAYBE_UNROOTED, jl_varbind
         }
     }
 
-    if (!varval && (vb->lb != vb->var->lb || vb->ub != vb->var->ub))
+    // prefer generating a fresh typevar, to avoid repeated renaming if the result
+    // is compared to one of the intersected types later.
+    if (!varval)
         newvar = jl_new_typevar(vb->var->name, vb->lb, vb->ub);
 
     // remove/replace/rewrap free occurrences of this var in the environment
@@ -3268,11 +3270,25 @@ jl_svec_t *jl_outer_unionall_vars(jl_value_t *u)
 static jl_value_t *switch_union_tuple(jl_value_t *a, jl_value_t *b)
 {
     if (jl_is_unionall(a)) {
-        jl_value_t *ans = switch_union_tuple(((jl_unionall_t*)a)->body, b);
+        jl_unionall_t *ua = (jl_unionall_t*)a;
+        if (jl_is_unionall(b)) {
+            jl_unionall_t *ub = (jl_unionall_t*)b;
+            if (ub->var->lb == ua->var->lb && ub->var->ub == ua->var->ub) {
+                jl_value_t *ub2 = jl_instantiate_unionall(ub, (jl_value_t*)ua->var);
+                jl_value_t *ans = NULL;
+                JL_GC_PUSH2(&ub2, &ans);
+                ans = switch_union_tuple(ua->body, ub2);
+                if (ans != NULL)
+                    ans = jl_type_unionall(ua->var, ans);
+                JL_GC_POP();
+                return ans;
+            }
+        }
+        jl_value_t *ans = switch_union_tuple(ua->body, b);
         if (ans == NULL)
             return NULL;
         JL_GC_PUSH1(&ans);
-        ans = jl_type_unionall(((jl_unionall_t*)a)->var, ans);
+        ans = jl_type_unionall(ua->var, ans);
         JL_GC_POP();
         return ans;
     }
diff --git a/test/subtype.jl b/test/subtype.jl
index 4b4cd750bdc80..57d49bc13fa8c 100644
--- a/test/subtype.jl
+++ b/test/subtype.jl
@@ -1057,12 +1057,18 @@ function test_intersection()
 end
 
 function test_intersection_properties()
+    approx = Tuple{Vector{Vector{T}} where T, Vector{Vector{T}} where T}
     for T in menagerie
         for S in menagerie
             I = _type_intersect(T,S)
             I2 = _type_intersect(S,T)
             @test isequal_type(I, I2)
-            @test issub(I, T) && issub(I, S)
+            if I == approx
+                # TODO: some of these cases give a conservative answer
+                @test issub(I, T) || issub(I, S)
+            else
+                @test issub(I, T) && issub(I, S)
+            end
             if issub(T, S)
                 @test isequal_type(I, T)
             end

From de9832c5683d5a588d3f5bd684507751bd28f135 Mon Sep 17 00:00:00 2001
From: Nicholas Bauer <nicholasbauer@outlook.com>
Date: Thu, 11 Feb 2021 18:38:34 -0500
Subject: [PATCH 31/54] Fix for infinite loop when passing 0d array to setindex
 of n-dim arrays (#39608)

* Fix for infinite loop with 0d array

* Consistency

* More consistency

* Test

(cherry picked from commit 296acf20101a502bb4c242192b06666a4b78193a)
---
 base/indices.jl  | 3 +++
 test/arrayops.jl | 6 ++++++
 2 files changed, 9 insertions(+)

diff --git a/base/indices.jl b/base/indices.jl
index 6b7fb04dd2286..e7fc58d98c9b1 100644
--- a/base/indices.jl
+++ b/base/indices.jl
@@ -239,6 +239,9 @@ setindex_shape_check(X::AbstractArray) =
 setindex_shape_check(X::AbstractArray, i::Integer) =
     (length(X)==i || throw_setindex_mismatch(X, (i,)))
 
+setindex_shape_check(X::AbstractArray{<:Any, 0}, i::Integer...) =
+    (length(X) == prod(i) || throw_setindex_mismatch(X, i))
+
 setindex_shape_check(X::AbstractArray{<:Any,1}, i::Integer) =
     (length(X)==i || throw_setindex_mismatch(X, (i,)))
 
diff --git a/test/arrayops.jl b/test/arrayops.jl
index b5e2e45e67bc7..542beffeb72a1 100644
--- a/test/arrayops.jl
+++ b/test/arrayops.jl
@@ -2866,3 +2866,9 @@ end
     @test only(Base.return_types(f, (Int,))) === Union{Array{Int,0}, Array{Nothing,0}}
     @test only(Base.return_types(f, (UnitRange{Int},))) <: Vector
 end
+
+@testset "0-dimensional shape checking #39608" begin
+    @test [fill(1); [2; 2]] == [1; 2; 2]
+    @test [fill(1); fill(2, (2,1,1))] == reshape([1; 2; 2], (3, 1, 1))
+    @test_throws DimensionMismatch [fill(1); rand(2, 2, 2)]
+end

From 194e774be82b4b637779af360b78eb6e0ac65913 Mon Sep 17 00:00:00 2001
From: Valentin Churavy <vchuravy@users.noreply.github.com>
Date: Wed, 17 Feb 2021 17:09:48 -0500
Subject: [PATCH 32/54] Add Half precision ppc patch and codesign LLVM binaries
 (#39712)

(cherry picked from commit 7853ddda3481dac54fe9f1b77d47721476afa295)
---
 deps/Versions.make                            |   6 +-
 deps/checksums/clang                          | 116 +++---
 deps/checksums/llvm                           | 348 +++++++++---------
 deps/llvm.mk                                  |   1 +
 .../llvm-11-D96283-dagcombine-half.patch      | 175 +++++++++
 stdlib/libLLVM_jll/Project.toml               |   2 +-
 6 files changed, 412 insertions(+), 236 deletions(-)
 create mode 100644 deps/patches/llvm-11-D96283-dagcombine-half.patch

diff --git a/deps/Versions.make b/deps/Versions.make
index 965bbc7332bb4..bb49a0624584d 100644
--- a/deps/Versions.make
+++ b/deps/Versions.make
@@ -15,7 +15,7 @@ CSL_JLL_NAME := CompilerSupportLibraries
 
 # Clang (paired with LLVM, only here as a JLL download)
 CLANG_JLL_NAME := Clang
-CLANG_JLL_VER  := 11.0.1+1
+CLANG_JLL_VER  := 11.0.1+2
 
 # DSFMT
 DSFMT_VER := 2.2.4
@@ -46,12 +46,12 @@ LIBUV_JLL_NAME := LibUV
 
 # LLVM
 LLVM_VER := 11.0.1
-LLVM_ASSERT_JLL_VER := 11.0.1+1
+LLVM_ASSERT_JLL_VER := 11.0.1+2
 LLVM_JLL_NAME := libLLVM
 
 # LLVM_tools (downloads LLVM_jll to get things like `lit` and `opt`)
 LLVM_TOOLS_JLL_NAME := LLVM
-LLVM_TOOLS_JLL_VER := 11.0.1+1
+LLVM_TOOLS_JLL_VER := 11.0.1+2
 
 # MbedTLS
 MBEDTLS_VER := 2.24.0
diff --git a/deps/checksums/clang b/deps/checksums/clang
index 48a6fafb88103..3513a3e212ef7 100644
--- a/deps/checksums/clang
+++ b/deps/checksums/clang
@@ -1,58 +1,58 @@
-Clang.v11.0.1+1.aarch64-apple-darwin.tar.gz/md5/bd2ac8ac75a73330dc045157e80b595a
-Clang.v11.0.1+1.aarch64-apple-darwin.tar.gz/sha512/fdd59e424bcbfa909a9e7c89d6ebcb798b5261ba6dd9f24d77543e7aaabec90ca4faebb3c1d58969ee7cf17d893b794a83a7426c399b5b393f31153a93a48212
-Clang.v11.0.1+1.aarch64-linux-gnu-cxx03.tar.gz/md5/f141613a2365f74f5ab5a9a04484e55d
-Clang.v11.0.1+1.aarch64-linux-gnu-cxx03.tar.gz/sha512/7c53fee9b9e46f2a2cfeb6435221af79c0b6458e7a3848c889f11f235802899df36d36e584c6aa86b171e85ef56326527006f8d489f6189e6806321ac6da7b42
-Clang.v11.0.1+1.aarch64-linux-gnu-cxx11.tar.gz/md5/e047f96317ab0ba21d5bffe75bdeca22
-Clang.v11.0.1+1.aarch64-linux-gnu-cxx11.tar.gz/sha512/c486a1b8a44dbeca94eaea7d9f97ff2c9b9b639e155e3e17e375c8c12a04d43bd30301d1fbdf7aef528389a990afe585fe7a7f6eade57586944e7f8ae47e0009
-Clang.v11.0.1+1.aarch64-linux-musl-cxx03.tar.gz/md5/cd7e2019d43abba512b712efb7b5f809
-Clang.v11.0.1+1.aarch64-linux-musl-cxx03.tar.gz/sha512/98e2e7790ac81ed3d5f454b6229f5b719e194ca8f7b9584182e208335c395eced30b9a4b24b63c5e0d8fd2a220f73e8afafb78d34c7e621b140f92f7e63481ba
-Clang.v11.0.1+1.aarch64-linux-musl-cxx11.tar.gz/md5/8676d3feee0188193109c0795fa2dbdf
-Clang.v11.0.1+1.aarch64-linux-musl-cxx11.tar.gz/sha512/fe568279563e4372946a8a9cac38d4a0132c8003f65875e524adf25f7ceda78dfa9215d05d3e0ce96c48c0e7d962e85283110e4067cc2b477f2995f6f1bd6a18
-Clang.v11.0.1+1.armv6l-linux-gnueabihf-cxx03.tar.gz/md5/471271ca81b52643d528e99deab4002c
-Clang.v11.0.1+1.armv6l-linux-gnueabihf-cxx03.tar.gz/sha512/502c189d2d30b42fa1a4faaca4846d749fa8bbed2b581947e86905a7863431b11a44c257c48f56969fc67580fbfbc0d8e21cf77b94c0eea05ca56d9fde53d20c
-Clang.v11.0.1+1.armv6l-linux-gnueabihf-cxx11.tar.gz/md5/41e2dda7887edf35646dc8b3f41c91fc
-Clang.v11.0.1+1.armv6l-linux-gnueabihf-cxx11.tar.gz/sha512/6a34a1141e22194f08b5410a4389df35242fec2b8e4364399a0de52d591ab2eb06dcd5c1849bd08fa6dad1a75fa05660a11995fc6781624b8f47d19c84286096
-Clang.v11.0.1+1.armv6l-linux-musleabihf-cxx03.tar.gz/md5/c4a9a40ebd87dcf2aeed2936da13718f
-Clang.v11.0.1+1.armv6l-linux-musleabihf-cxx03.tar.gz/sha512/1b78ddd6486d8cab17f7e9673c39bfa87f83c2be56769a2045e778f3b04bb5f2f68725c15454426da98e236c636eded1660802cd1c2defdd61497d0de88e5c92
-Clang.v11.0.1+1.armv6l-linux-musleabihf-cxx11.tar.gz/md5/57feaf3f44e9247bd61fd3b6975745b7
-Clang.v11.0.1+1.armv6l-linux-musleabihf-cxx11.tar.gz/sha512/ba04642da7feed8de983c5bb265fb23fcfdb6703241ed3a2abcae95ee19e0e58cb4d1e7346534eb12a9a0b48ca117697c07783b928b46c6c80d86c7f2317a9c1
-Clang.v11.0.1+1.armv7l-linux-gnueabihf-cxx03.tar.gz/md5/f4f70ff9ac4a37d202d8ecd24a236ced
-Clang.v11.0.1+1.armv7l-linux-gnueabihf-cxx03.tar.gz/sha512/0ad4fb61b5343205e2219ce636fe3aaf54aab7b0b0a2c46bd4b9991a31460ac8b8f0cb99a5832dbf302ddebb84110d077b94f56c5132453ac6ceb49699fe7372
-Clang.v11.0.1+1.armv7l-linux-gnueabihf-cxx11.tar.gz/md5/bfd93acb62b2f57b155b52e0c77e24a3
-Clang.v11.0.1+1.armv7l-linux-gnueabihf-cxx11.tar.gz/sha512/9890b586cec7c29cd7203d35e9327f4e961a789fb5009fc2bf70f8e9d943453a897d62846599e76a37094d0a338933d8ad84d002f5a20c457f7fe233ab3c5b16
-Clang.v11.0.1+1.armv7l-linux-musleabihf-cxx03.tar.gz/md5/4c2fb61ee10b885b1d65ee5b8012483e
-Clang.v11.0.1+1.armv7l-linux-musleabihf-cxx03.tar.gz/sha512/a899a471353464dd55c6885b46d6a6f6fec295aec9a1919bd2f5c404cb4f23a03ea110a07493b7aad832f846e492b16050e2256e0612339848c8d0b591b8d2ec
-Clang.v11.0.1+1.armv7l-linux-musleabihf-cxx11.tar.gz/md5/bd44ec910a0a07fc8957e88e30ba2f4a
-Clang.v11.0.1+1.armv7l-linux-musleabihf-cxx11.tar.gz/sha512/03b6aefc302617ee74ca49b34bbf250de87d23dc5b51ea327c7d7764b2f4d6c42195a98db4f94efb5681c4c4a9c6f51b2f98a425ddc6fb153a1c0268fb2c319b
-Clang.v11.0.1+1.i686-linux-gnu-cxx03.tar.gz/md5/5e0936c5030749f5299efaf713c89f69
-Clang.v11.0.1+1.i686-linux-gnu-cxx03.tar.gz/sha512/9c61c143532fb8dbb2b7f6f2350f6d7e613a9d5ff99715fb10f878fbfd1b8fc6f5057ed3a0bd50b4589a5160f3c544415447ea5409539b28613532d9e5249e46
-Clang.v11.0.1+1.i686-linux-gnu-cxx11.tar.gz/md5/bc13934cf87a25614a94d60125508228
-Clang.v11.0.1+1.i686-linux-gnu-cxx11.tar.gz/sha512/b4f40135b31aaf266ecabbacf9c59f3814bac7e29c24fc1aa34e37ab091a92f0bd7345887dbcff90eb6654abf4a00d25ea1507b1a0583c8cbaa92211f123cb45
-Clang.v11.0.1+1.i686-linux-musl-cxx03.tar.gz/md5/fe168dda805e979ecbdc253682465980
-Clang.v11.0.1+1.i686-linux-musl-cxx03.tar.gz/sha512/3360ed8b06abf3e4a153446daed8f4a7eacad92a9f0cadfcdc92ce17496f42d2ae4847e460e8a32b7e04c62344595ec06f17429d449712f73ad9dfa91be99ed8
-Clang.v11.0.1+1.i686-linux-musl-cxx11.tar.gz/md5/d45c9e2fa36f9c996e9176a8e3766f71
-Clang.v11.0.1+1.i686-linux-musl-cxx11.tar.gz/sha512/774e8e77164d8051c50875ad2a197500d17b7caa07932fccb9b051943466c84783786c740d75a95fa8003e76c5af60405e9679e158da4fdc2f3fa5b989bd9368
-Clang.v11.0.1+1.i686-w64-mingw32-cxx03.tar.gz/md5/6d42179f36d59f7447f60dea4f8ee637
-Clang.v11.0.1+1.i686-w64-mingw32-cxx03.tar.gz/sha512/1fe29043428a35f655181820ff05111a1805aedf92ccd10bc82642033db7cd622cf9468b7d7dd5852db10fedfd67d1a935bbe1731b997da531770dd94a227b52
-Clang.v11.0.1+1.i686-w64-mingw32-cxx11.tar.gz/md5/68005aec251193f22dc52f3723428325
-Clang.v11.0.1+1.i686-w64-mingw32-cxx11.tar.gz/sha512/e2f4a6947e08192dccffa7866e9a91a762ffa4d939c23556e0190369761487936b052328081a4818719acb460f7cfa6bdd081607e9f8347fc11b4b1c3dec58e4
-Clang.v11.0.1+1.powerpc64le-linux-gnu-cxx03.tar.gz/md5/8c920b50e5d0eeaad7e6eaf908cbecab
-Clang.v11.0.1+1.powerpc64le-linux-gnu-cxx03.tar.gz/sha512/8fc9840f4e8431f8b9e250ea131057f4a5ad21237d7822c6da5f773479cde9c19733cbd0b9a2540406ba48810473ab5bfabc4fa787ae26004879301ed1af3e2a
-Clang.v11.0.1+1.powerpc64le-linux-gnu-cxx11.tar.gz/md5/e635c668aac1987b1a6819cb692b623b
-Clang.v11.0.1+1.powerpc64le-linux-gnu-cxx11.tar.gz/sha512/4fb84fe7ab533f511d28d4e57680d7e0e6000d35f38a56cd60dd43b4ab2734e5a1851aa12d00f5957ea887a8e93dd30837e11f66130832e02470ce2f00859e8e
-Clang.v11.0.1+1.x86_64-apple-darwin.tar.gz/md5/de3d9417237218d4ff2767a9733f748d
-Clang.v11.0.1+1.x86_64-apple-darwin.tar.gz/sha512/dca6e930abedaccaa7a53559bd54df205a03c4e8c8a8cf35bb3afc1d53c1f8775511e095242c8eda76f40622c07536b14b8e334c43514e565a4c8528bf0b2fb4
-Clang.v11.0.1+1.x86_64-linux-gnu-cxx03.tar.gz/md5/dbf3d18ff1c178d0d4d82917b22f8432
-Clang.v11.0.1+1.x86_64-linux-gnu-cxx03.tar.gz/sha512/04a40c512d6bf562a204d8de6fb0e0c24649953816093eb1636e613771046d6b5800669e8f88dfe105a63d00da27e8444382f0c0960bc5b6fe3449ea0fd54ebd
-Clang.v11.0.1+1.x86_64-linux-gnu-cxx11.tar.gz/md5/62ce0306c66963ccc467f65bc1d5dbc1
-Clang.v11.0.1+1.x86_64-linux-gnu-cxx11.tar.gz/sha512/cf5d67e1375a57c86bacc4a47d8454db2f9184e8fa30b51e511c1d6b2ca771f2a1d10c4c8b9a1a4356e5248ec5dd8291b279ded83abf7535641aba903e708d4a
-Clang.v11.0.1+1.x86_64-linux-musl-cxx03.tar.gz/md5/90f967cf84e4eb344e635526703fcb17
-Clang.v11.0.1+1.x86_64-linux-musl-cxx03.tar.gz/sha512/26afc541b4ef5cbd2c7c74d6dd7fed031f3fa50412af568b06557308a7f3034332b7eb01ad36d86a0d81e3453ed0dbc5b2671921a69cef5d2d021ad3c9b6e6f4
-Clang.v11.0.1+1.x86_64-linux-musl-cxx11.tar.gz/md5/c86b41b136688ceeef43bbb6e8969127
-Clang.v11.0.1+1.x86_64-linux-musl-cxx11.tar.gz/sha512/1f4c008371a3da3af04047528248c7fb3349d57b40003035d7bf4468091d33c912b9855a6f1c7e3e3643ebaee6f09a293dac599135451853f972d05893e5e082
-Clang.v11.0.1+1.x86_64-unknown-freebsd.tar.gz/md5/e04fdc6c07cecc64ab6b48a70cded13b
-Clang.v11.0.1+1.x86_64-unknown-freebsd.tar.gz/sha512/ade4a8c247ce6843ad4692bb3b7539dd49c554d677e7d8fd727b423e82b6c9846fffdf9a7dfe151f54d815976e451f9c20c1196e716be73e09e6fa3e50e9a543
-Clang.v11.0.1+1.x86_64-w64-mingw32-cxx03.tar.gz/md5/abebe4c6fd4d7555e6fb02182fe6f8c6
-Clang.v11.0.1+1.x86_64-w64-mingw32-cxx03.tar.gz/sha512/82fb13c9cdb8301e151502fda81e7365ba110d93e8b65bfd97125324b9f7f891f647a61d4a6de5c0313a066fe57bda54f87e83d1ba55e044e6fd25af83ff0f9f
-Clang.v11.0.1+1.x86_64-w64-mingw32-cxx11.tar.gz/md5/3f833f97f599abe996791936ab1abd95
-Clang.v11.0.1+1.x86_64-w64-mingw32-cxx11.tar.gz/sha512/05495d82b051957180a5e5b3f460eacda2f565307a3e27d7fc88cc9baf875f0d67b679a54b57cdb50a60e96816207c74ebb06bdd2eb3580a3a1677e4c104a80d
+Clang.v11.0.1+2.aarch64-apple-darwin.tar.gz/md5/17076a7e5d9976318a1ad7deebb49101
+Clang.v11.0.1+2.aarch64-apple-darwin.tar.gz/sha512/e7904c14ec41d49b6582f0e5ffefd1c6ee8afd02cba58f35083320673da855b7292fe824622de3e90a0540064813cbc7c4a53a4d8b724c84727c6fdf47d53bfc
+Clang.v11.0.1+2.aarch64-linux-gnu-cxx03.tar.gz/md5/148e9342612facdf335f8b7f8b651e19
+Clang.v11.0.1+2.aarch64-linux-gnu-cxx03.tar.gz/sha512/d593130812aa5f05a59e6a912b139dfea8b1ad0b2552f32657a767f7b5c41bee0dadcdf15a697717b9e3fdc78140879cb8bd6f6d59fe74ac6d53016691100d4d
+Clang.v11.0.1+2.aarch64-linux-gnu-cxx11.tar.gz/md5/bcd5b0dac3b2a072d60cd165053dcd7c
+Clang.v11.0.1+2.aarch64-linux-gnu-cxx11.tar.gz/sha512/a1866a5b27fb7dc63c897c50d642301150ebc503bbcc5dc545e5132555473f355dffea5117623cafb87a4afae3dd15f607f2d27df56982fbd96ed7d6f63e477e
+Clang.v11.0.1+2.aarch64-linux-musl-cxx03.tar.gz/md5/48691a2f66b975fc722fc36f99709274
+Clang.v11.0.1+2.aarch64-linux-musl-cxx03.tar.gz/sha512/c71867875893ce5440ee75186af2515306c9c2c17387af7dd466a782dfab51b20b0bfd63ce13a8de862df1bf1193fecf485108f98d3de1c60b2ea141aa05da23
+Clang.v11.0.1+2.aarch64-linux-musl-cxx11.tar.gz/md5/d6275cf3a2ca1c18f69a25fd53625942
+Clang.v11.0.1+2.aarch64-linux-musl-cxx11.tar.gz/sha512/fbb629b082d5c34c8b26e13d258fab10c7f6cfebb023586c0e76a087ecf1da11efca49c958c57b773903485cdec0d8fbe15a657789ca00d1c885764ce27a489e
+Clang.v11.0.1+2.armv6l-linux-gnueabihf-cxx03.tar.gz/md5/325db47117dbb6b958cf99e4bf94f6e1
+Clang.v11.0.1+2.armv6l-linux-gnueabihf-cxx03.tar.gz/sha512/4fdd788a2795eb7a9aa9d51578e575e65ee5296f7585d5dc10301264da189802680ce7cf0c5741ffff9922849b078432b74e907e724befb21d54408e6b74e7ff
+Clang.v11.0.1+2.armv6l-linux-gnueabihf-cxx11.tar.gz/md5/3fe294ae362745993fcca0b8ae27094d
+Clang.v11.0.1+2.armv6l-linux-gnueabihf-cxx11.tar.gz/sha512/299895793a91f98e69000176a44591c4c02f35665575ce669616be90ecaaa0e0ed40eeb204902fbda0df3d0793be4d1bdc0677d40f1eb1dce6afb5093d679606
+Clang.v11.0.1+2.armv6l-linux-musleabihf-cxx03.tar.gz/md5/0d9b7ec9c4205d96a125629005568cbe
+Clang.v11.0.1+2.armv6l-linux-musleabihf-cxx03.tar.gz/sha512/8645b138c858aaab046efd1b9c0621a1093631dd6dcc1aabbd67863e04ec20550e37c73e6ffef4959230c0ce1f555a4b3cb3ad17f0344747a45fea8619eefed8
+Clang.v11.0.1+2.armv6l-linux-musleabihf-cxx11.tar.gz/md5/52c291184a47b777f569ac4e72f51d36
+Clang.v11.0.1+2.armv6l-linux-musleabihf-cxx11.tar.gz/sha512/5c953a7798216e369ab1ff2d19d4a94b207f971604e55daec3332e276dacb6f47bbf98195f91e15ef94df030ec894b704e96d13f40180abfef34516aad802520
+Clang.v11.0.1+2.armv7l-linux-gnueabihf-cxx03.tar.gz/md5/76aed4280fb00efbfc31d7567b369686
+Clang.v11.0.1+2.armv7l-linux-gnueabihf-cxx03.tar.gz/sha512/900324075af8fcdb18f8584a302d5c65bb7fd79b2dfc78374334849ab0bb2954d5377c4ec72684ab26d792540fab546a12f03ecae5860c3979a3d70f09abe924
+Clang.v11.0.1+2.armv7l-linux-gnueabihf-cxx11.tar.gz/md5/53ea9d348e7a4be7689b628de423342f
+Clang.v11.0.1+2.armv7l-linux-gnueabihf-cxx11.tar.gz/sha512/c6a455cf500de882270c29b0ea70a15cc47dfffa44419ff0215885b59641b020247a008c0b2b689ba5a5769d239433a8fbdaf89602bda20f51930cb9ee9df5f1
+Clang.v11.0.1+2.armv7l-linux-musleabihf-cxx03.tar.gz/md5/a8c42dc3edb74f3794e6f625b255f243
+Clang.v11.0.1+2.armv7l-linux-musleabihf-cxx03.tar.gz/sha512/fb5c4653ed1951b54492d45cac78b1a5e165e76a69ef91b5a1ea6bcc022b5e540f9a86eeee410f090862760054ee609d22448c0ac214e938281648644a5f8377
+Clang.v11.0.1+2.armv7l-linux-musleabihf-cxx11.tar.gz/md5/edec516bf2996d77b769ef131c2264de
+Clang.v11.0.1+2.armv7l-linux-musleabihf-cxx11.tar.gz/sha512/4b026da65dd8f9160385114865871c75a8e2cb996e0a262a3c507b6a8a7f087875adc3891ea5ca0cdd1ba8f6041f002d3af54fa8aec84b7fdb5f2d3605089e06
+Clang.v11.0.1+2.i686-linux-gnu-cxx03.tar.gz/md5/bc16f50c67419060844bf0e83c969eba
+Clang.v11.0.1+2.i686-linux-gnu-cxx03.tar.gz/sha512/10cf3828b0b96c668c9b5c35bbce32711720d9e73369ea93f7ce43766e4b53009c9ebd02fa28703d07e2c7137c5770696008d136908136a43ad36ac84b90f59f
+Clang.v11.0.1+2.i686-linux-gnu-cxx11.tar.gz/md5/c867d7c038358e4c302cf8a926098417
+Clang.v11.0.1+2.i686-linux-gnu-cxx11.tar.gz/sha512/60ba3147d2fe24c819eecb3339aedad1a15b9b1ef4d71b41a4f4a346317b0a2dfa81a59d56c3742beed56b60fbb0b547ff6fc853619f396a83f74b9fb091f6bd
+Clang.v11.0.1+2.i686-linux-musl-cxx03.tar.gz/md5/3ff50e91834c5df39075dac74d97ca58
+Clang.v11.0.1+2.i686-linux-musl-cxx03.tar.gz/sha512/8a72be62d056d686f0e56de4a0dd530bffcf4214f3724ab51bd89f07b35834bfd6707574e16d650438aff3c6a77536cabc631489df6dae8d245ff6c077915479
+Clang.v11.0.1+2.i686-linux-musl-cxx11.tar.gz/md5/7a28f81a9d7a0021d5a50cbe6a5e715d
+Clang.v11.0.1+2.i686-linux-musl-cxx11.tar.gz/sha512/776fb4d9456473b5293da8dbc3e400ed463e8e6e9c66280cb642907bf2df53bcf837a93f671a10809079e7a9ab2795f3757f9a0e056f8404d210f5596cf62640
+Clang.v11.0.1+2.i686-w64-mingw32-cxx03.tar.gz/md5/ca383ad6ab2d1afad3134efce3c12aa3
+Clang.v11.0.1+2.i686-w64-mingw32-cxx03.tar.gz/sha512/2bdb6e4be9c496657ec9292d34b786860630106179d9217e816c67309695d81a58c95966ffa42a8f52e99e8e1c369f119746e76ba7458df13e78a668e53fa8b1
+Clang.v11.0.1+2.i686-w64-mingw32-cxx11.tar.gz/md5/1772ad1d6a5c00b24048b7ca5be43483
+Clang.v11.0.1+2.i686-w64-mingw32-cxx11.tar.gz/sha512/560c2e0cec8c942223a088239b2158504300c48b323cbbd62a6fc6bed9d73737c7cffcd93792043e6f066f8758c7c43490262e2acf3f4bb49ff8851904b214eb
+Clang.v11.0.1+2.powerpc64le-linux-gnu-cxx03.tar.gz/md5/41baac7852b2caa85de9f0f1e2ecb6bd
+Clang.v11.0.1+2.powerpc64le-linux-gnu-cxx03.tar.gz/sha512/cafed0ce352a265edf6259fbf0b7cc11be5d635f8efca9cd6dc2e8fb3220d10adaecd9dd9dff56adbdcecd109a244d4f683efd7d914954c456c27f3a9be357d6
+Clang.v11.0.1+2.powerpc64le-linux-gnu-cxx11.tar.gz/md5/02b3b9471562527e88b00d1bc9ce3a6c
+Clang.v11.0.1+2.powerpc64le-linux-gnu-cxx11.tar.gz/sha512/1d3da48049e19e3f22c773a0de38a2acfe8b76a85d1b25362dc182d87e431a1579d2366e18370e3f5f339b9b78f1846b043bd083fc2fdb23e784c18215efc7e1
+Clang.v11.0.1+2.x86_64-apple-darwin.tar.gz/md5/c6d7453a30fb40971768f1fd7c9881fa
+Clang.v11.0.1+2.x86_64-apple-darwin.tar.gz/sha512/e444b4487e8c38aac3edc7472f1837d9b063b5ac7c365bb8501863b796fd6957675b462a4b2f06967d057683af256fd2e9bbf84a9f3acaf994ba1e5b1e59e891
+Clang.v11.0.1+2.x86_64-linux-gnu-cxx03.tar.gz/md5/e5068f5b767b7cdf606d7ac96ccc5826
+Clang.v11.0.1+2.x86_64-linux-gnu-cxx03.tar.gz/sha512/9aeb0d97da690274d162d350377e88f0a454c7920da1fc8585754fb1e9464e0ab483c5d44244e676b458a702fe3749a497c1ce7ce3e19e8722d22e89fd845713
+Clang.v11.0.1+2.x86_64-linux-gnu-cxx11.tar.gz/md5/331887c1fc2cd5149936fbab4ded7522
+Clang.v11.0.1+2.x86_64-linux-gnu-cxx11.tar.gz/sha512/7c33b6ec9e018774616c8cda59a25adbad585e295fd7b639951c282f2fd1fa70c8ed50c47a0d34351476876da9554e5e44d0d86d2db474400f00e950ecc5fb36
+Clang.v11.0.1+2.x86_64-linux-musl-cxx03.tar.gz/md5/2ee2a56797af5cb83d4dd5ddcbfaeb0b
+Clang.v11.0.1+2.x86_64-linux-musl-cxx03.tar.gz/sha512/309fc565c70938104a3044ebee70d78075595e0e7958a4273cbbd0994b05c9c5e6725d3784198ce2d7b2b8d1f5d32c8d363561b35348a7bec508787f9217ffd3
+Clang.v11.0.1+2.x86_64-linux-musl-cxx11.tar.gz/md5/30dc9e11dbabd32b2f02168e244ada33
+Clang.v11.0.1+2.x86_64-linux-musl-cxx11.tar.gz/sha512/1ee84e41c9e3ca7a4238467cc747219cf8fe520f4a1259e50d6443414767a5e8fb02a4034328599c92c0b4e5e69274a06fa4878d9651fe8063b8e4daae941e55
+Clang.v11.0.1+2.x86_64-unknown-freebsd.tar.gz/md5/b3efe5acf49dd3f3246e9c5848e94ae8
+Clang.v11.0.1+2.x86_64-unknown-freebsd.tar.gz/sha512/1c6f415d562b18de1ad045e03e06f6e39963962734587fb12119ca0fc8bf455185c2704ac9282b94d1ab7dcc2503a3ca6f41064a61a2a75af772943a3f4f043c
+Clang.v11.0.1+2.x86_64-w64-mingw32-cxx03.tar.gz/md5/cdbef031fde6e57a3aeb161bb865b887
+Clang.v11.0.1+2.x86_64-w64-mingw32-cxx03.tar.gz/sha512/d8047c3a52be6ebc889bd249f887b01dfc60b9c7f847dcb3d0eaec200402183132751f7eac3c60f5be8c30ae612e44fd4d94b88594d2e3c58bfd91a9cec2a42e
+Clang.v11.0.1+2.x86_64-w64-mingw32-cxx11.tar.gz/md5/9993aadfb7b707f976badc0b694a1959
+Clang.v11.0.1+2.x86_64-w64-mingw32-cxx11.tar.gz/sha512/4531b6fc7e618d5448023183a1a7cd28abbd9f0b5e15dcadcf50b5f6b7b3335e437bfc592df8fe1a7570e7dc90e2f0b0681f068e4eaf0d935adef62214e5f9b8
diff --git a/deps/checksums/llvm b/deps/checksums/llvm
index 05222deacd550..a6cce9274ac5a 100644
--- a/deps/checksums/llvm
+++ b/deps/checksums/llvm
@@ -1,176 +1,176 @@
-libLLVM_assert.v11.0.1+1.aarch64-apple-darwin.tar.gz/md5/c9b855046b6f439f666ec415dbe53517
-libLLVM_assert.v11.0.1+1.aarch64-apple-darwin.tar.gz/sha512/431c223b959b8a00b0ac4efda96206e51ddc87120eed6225f888254b8119bbf9f4e87d1a03bbb5ed19d01579538b5448eca9af0d03e97959ab4d380d0207817b
-libLLVM_assert.v11.0.1+1.aarch64-linux-gnu-cxx03.tar.gz/md5/8ce7c0aa0b750a1ff4a64b9f6153b95f
-libLLVM_assert.v11.0.1+1.aarch64-linux-gnu-cxx03.tar.gz/sha512/432942a4975cf840dad1014253ea43771b2be850cad89e8365a95b7307df0d89f4e419f785abd131aa172fa5c7db3359a092ccc6cd8c1bb634dcbb5a146d92b9
-libLLVM_assert.v11.0.1+1.aarch64-linux-gnu-cxx11.tar.gz/md5/c1e04cb76eb77208ff7f299d62106a33
-libLLVM_assert.v11.0.1+1.aarch64-linux-gnu-cxx11.tar.gz/sha512/dc9ea37f712723b69e6e85965a25c65c0bd57b406c991c089f807fb33c2818988d619fe8999390f2c529b973c2153aea1a5d24440fa78f76fb4885ddc953d82c
-libLLVM_assert.v11.0.1+1.aarch64-linux-musl-cxx03.tar.gz/md5/7367d34fd143e277eaae745b8a547e05
-libLLVM_assert.v11.0.1+1.aarch64-linux-musl-cxx03.tar.gz/sha512/00df2bb9b55fe9db8ae74d8b7166e753156f7d85421eef07dc700501dfeede262849ad101f200185ab9e4573c67a9eb743ba35a3e1c71e34cb2107a6dc1cc41d
-libLLVM_assert.v11.0.1+1.aarch64-linux-musl-cxx11.tar.gz/md5/396af2bf32541539f33ac6788f45aa3e
-libLLVM_assert.v11.0.1+1.aarch64-linux-musl-cxx11.tar.gz/sha512/5c7675d5e84119e594260a41ce7905382cb432bc6eb7e06a7ea86fec8b56d6563defdb3c966e499dac98edb9dd37d0c7db2b54f08f9722a9aa861563b4c5977e
-libLLVM_assert.v11.0.1+1.armv6l-linux-gnueabihf-cxx03.tar.gz/md5/062cef64afdf95c560e0036ba888f3ca
-libLLVM_assert.v11.0.1+1.armv6l-linux-gnueabihf-cxx03.tar.gz/sha512/8305b2eaabead7796b1f2248a28b0f9fea507a07c1c72a2d47cbe29c02a3ab66d5bfad67ff0cc475649d13b3865e9c788c24d30e36f7235ef8ff1347ce26cab8
-libLLVM_assert.v11.0.1+1.armv6l-linux-gnueabihf-cxx11.tar.gz/md5/c82e29bf35dbd7e0688d0e76ec7d5a61
-libLLVM_assert.v11.0.1+1.armv6l-linux-gnueabihf-cxx11.tar.gz/sha512/dab85fb625d5bcd95999a8c1776f4cae61ebec650e8ceecf06318666dd67c6e6b61b328088d0c8e3540c0f2b46eccd2465de49d467eab810878e4eec4623b3a1
-libLLVM_assert.v11.0.1+1.armv6l-linux-musleabihf-cxx03.tar.gz/md5/a6fe2dfed05e66fec2c51d3775b4baf9
-libLLVM_assert.v11.0.1+1.armv6l-linux-musleabihf-cxx03.tar.gz/sha512/43ce6d2097770908365fc641231243810c7ab8a50452d9d4f4d1df90f91fbf9841a120c2b6f32bae46edc74aad879db9e9c33a31d29050fe21be6352253c7fa6
-libLLVM_assert.v11.0.1+1.armv6l-linux-musleabihf-cxx11.tar.gz/md5/17b55047bfbf8ee641d13a000d9be7a8
-libLLVM_assert.v11.0.1+1.armv6l-linux-musleabihf-cxx11.tar.gz/sha512/7492f6cc954aa2ada14c989e2a3da03a60db785a312d3efd7fa4c8678a56112d0b07f206911fb63459ddbb05dd5fd8497bd46cda1e4e3766ec0e18dbe225327d
-libLLVM_assert.v11.0.1+1.armv7l-linux-gnueabihf-cxx03.tar.gz/md5/8f61e4f7024f4b8b3a20dd5217daa160
-libLLVM_assert.v11.0.1+1.armv7l-linux-gnueabihf-cxx03.tar.gz/sha512/809a34b6ad78961a9ab6c1bbd769f4a299905eae693375555d4901d7d4629820597a7f5343d354f1c2aad5a058537bf36ab7f6e42a0a5a0407c4b4df5b447494
-libLLVM_assert.v11.0.1+1.armv7l-linux-gnueabihf-cxx11.tar.gz/md5/0e23f4b0bee8da244feac6d5eebc10a8
-libLLVM_assert.v11.0.1+1.armv7l-linux-gnueabihf-cxx11.tar.gz/sha512/e2e13bf2e1bc53dc995d2b9c91c5543090f532d63714028e58ec770450aed1462237e3a73abcda91090863a8cc286b15f49f1ae87866db7bb2e2beb82c8bbfa4
-libLLVM_assert.v11.0.1+1.armv7l-linux-musleabihf-cxx03.tar.gz/md5/821279e10a684f5fa338ebfa7e8893f1
-libLLVM_assert.v11.0.1+1.armv7l-linux-musleabihf-cxx03.tar.gz/sha512/e1e80194ca5d992a92fa4a581de3c85c21ddf8630109849ead05152b302a68fe2df49e9c047a73d6bcfce17b2de8f5ed176b6c367609f7d8025049069d22f031
-libLLVM_assert.v11.0.1+1.armv7l-linux-musleabihf-cxx11.tar.gz/md5/e2d255f456953fcc4525197d8913cc65
-libLLVM_assert.v11.0.1+1.armv7l-linux-musleabihf-cxx11.tar.gz/sha512/1cd2b9230a74351180cad345a8328257179e9e257ebead8e50f60c4bd2396058e89ef517069a204971076ffca85e47c126c61d8001708a28d77059c530118de0
-libLLVM_assert.v11.0.1+1.i686-linux-gnu-cxx03.tar.gz/md5/2960d7427f093eed30a1cddea99df8b1
-libLLVM_assert.v11.0.1+1.i686-linux-gnu-cxx03.tar.gz/sha512/d9e1ca448bdaf12b1e63f40d3b1d4e3ce284a6cba5cf3bbdb44efaa1abbca7221c8912bfd589e08609a78044ba70cb0832e0504fdc5e7def83cc47a032c58440
-libLLVM_assert.v11.0.1+1.i686-linux-gnu-cxx11.tar.gz/md5/f0231f640206a4e8ce7d35ead7c58356
-libLLVM_assert.v11.0.1+1.i686-linux-gnu-cxx11.tar.gz/sha512/da6a85cf1b352e903f54321eaaf1398b7103f284d93469f97b651cccd839340146286f6b96a46263ab0802d5119fa1d2feeacd71d59e2fe99f11f2ecb2ae554d
-libLLVM_assert.v11.0.1+1.i686-linux-musl-cxx03.tar.gz/md5/931843dbc249e6634763c0e810358c81
-libLLVM_assert.v11.0.1+1.i686-linux-musl-cxx03.tar.gz/sha512/4d540b1556da1c9a90fd1fb9662ded55e1f3948b3b612b2dd760b837db820232ebcc4cd39ea2e1922e83b9e61d45e1b661f83d6cdd778669b5ee25c1469f037c
-libLLVM_assert.v11.0.1+1.i686-linux-musl-cxx11.tar.gz/md5/619bec19c3d2c9b097be99e73b5d7f18
-libLLVM_assert.v11.0.1+1.i686-linux-musl-cxx11.tar.gz/sha512/5b4029b1a6798cda9073c2689b7cc566936654ddc8541d101b382456544c5cb6db6a6827f33a47404ce89e547d4979edab3646e51e3025851f5cd586a5f290be
-libLLVM_assert.v11.0.1+1.i686-w64-mingw32-cxx03.tar.gz/md5/05e50013aa09fda6d85136da9ffa923b
-libLLVM_assert.v11.0.1+1.i686-w64-mingw32-cxx03.tar.gz/sha512/121a5de386fd20940622796364e28cb62ccc693906e41863ea6772ef9d802faa9caa70976b24d645094b56f850d29493bb7ee1ea063a94ce38a3e39dff0ae037
-libLLVM_assert.v11.0.1+1.i686-w64-mingw32-cxx11.tar.gz/md5/1ad1baf3e05fc081da46f33d858dd25e
-libLLVM_assert.v11.0.1+1.i686-w64-mingw32-cxx11.tar.gz/sha512/99aeed28f8e1ade9b4a6565dc63ff89bb2a51a0b7cf97158b75e0ea77c50f1a8c9f67dfb92accb24d3fb39d9c2a041e34d09085905ed10cd10f1e306f264234c
-libLLVM_assert.v11.0.1+1.powerpc64le-linux-gnu-cxx03.tar.gz/md5/20093037cef1e6322d87a56c3e0a4d6f
-libLLVM_assert.v11.0.1+1.powerpc64le-linux-gnu-cxx03.tar.gz/sha512/e3bc2b4273df512fdd7e2a644378552aae66268dd173cd280f9400e6c1b2ac9efc6c96ef01a900d27b1e5558e5db252d40f8c269dd58fbb65de32755ba6306d7
-libLLVM_assert.v11.0.1+1.powerpc64le-linux-gnu-cxx11.tar.gz/md5/2dcdcc72d28c26cf68d0ad425ec1f685
-libLLVM_assert.v11.0.1+1.powerpc64le-linux-gnu-cxx11.tar.gz/sha512/17d61c6e10c90602d5b84130cf614464ed52517d94375444e16f2879f14dbf0632ba9232600ce2296f21af4ae4245e2998170f56a4308de34bdd3f6aedeea3af
-libLLVM_assert.v11.0.1+1.x86_64-apple-darwin.tar.gz/md5/91f9e7d6c9f4660788dd2868b016ee7d
-libLLVM_assert.v11.0.1+1.x86_64-apple-darwin.tar.gz/sha512/6efdb27f8675aa427a9aeb2172b8cf932468457d5dcdadef03e7562546e2e1e5d8e7b1bcca527b428f77ae49212e68e3269895dcdcc8cf1819d2d07093a6423b
-libLLVM_assert.v11.0.1+1.x86_64-linux-gnu-cxx03.tar.gz/md5/8c127663c6c13a9ef68258ebd8c78475
-libLLVM_assert.v11.0.1+1.x86_64-linux-gnu-cxx03.tar.gz/sha512/0537cd09b40eaa8215185b134e31607f7234f1ffb8ccca52ee025399456f07a6c51bed8fdf89a7ff32e92308c8d2a389800a68f44e73f7da56832eba08bbfc5b
-libLLVM_assert.v11.0.1+1.x86_64-linux-gnu-cxx11.tar.gz/md5/5b39c1870655632d1e00fedf10b0ae1d
-libLLVM_assert.v11.0.1+1.x86_64-linux-gnu-cxx11.tar.gz/sha512/745ebea91219208ee58a95ea8cf5aeb4db08cb54fb2165c0f1b4ceaeec95e97b83e21fbe1ff186fcdd611052c5c0a33c37848afa468abaa903f05eb253866f6d
-libLLVM_assert.v11.0.1+1.x86_64-linux-musl-cxx03.tar.gz/md5/5c833449f92d2f481751a5a610f37ef7
-libLLVM_assert.v11.0.1+1.x86_64-linux-musl-cxx03.tar.gz/sha512/39b64e911678eb2886635673822e8345ff44e5ce888647d01572774a46a4c28e06ffb2711a5b271b7e304454e92f9ee68e50044f00d337fb3e0844445fbb03cb
-libLLVM_assert.v11.0.1+1.x86_64-linux-musl-cxx11.tar.gz/md5/f8a507adc3cb875b0c91f264b971160a
-libLLVM_assert.v11.0.1+1.x86_64-linux-musl-cxx11.tar.gz/sha512/7cdc82d9459e1a93fc386d19f55fc606001bd6287dc8fe8182f1439e07858bde396d934aee759c9bf6469fe6f5e03c7e4e95f52f718b59dae8d2cd5b4c0b27b7
-libLLVM_assert.v11.0.1+1.x86_64-unknown-freebsd.tar.gz/md5/845a28db01c550eee6e5cba23c950009
-libLLVM_assert.v11.0.1+1.x86_64-unknown-freebsd.tar.gz/sha512/a163a6c3d1c5e76be009f1bd51275fe7d27ba9ddf23ced5a63b3e7b401943cc815c2bef9c665c883f1be918f18c667ffa21f8cf012de8f7715fa91195495a349
-libLLVM_assert.v11.0.1+1.x86_64-w64-mingw32-cxx03.tar.gz/md5/dee317fdd6f8b4f4f2ab960baddadc0d
-libLLVM_assert.v11.0.1+1.x86_64-w64-mingw32-cxx03.tar.gz/sha512/9f2807a1cb1582c3327bc98eac570eddab14354f06c608636060913983e708e18b9f01414f29e347cfb679a5048e9fb6964200620fdd4187886cd0c97c8c5469
-libLLVM_assert.v11.0.1+1.x86_64-w64-mingw32-cxx11.tar.gz/md5/3d049fac6bb62465bc6b913d4fb33aca
-libLLVM_assert.v11.0.1+1.x86_64-w64-mingw32-cxx11.tar.gz/sha512/cb2a66837b9bb14f7e9ca6b5c4ef5e2572a2cc8053769f77b16005bca329734ab93c0f7052e986391d6eebf7765dd718385c284b1d3b9caf6083688940007b6f
-libLLVM.v11.0.1+1.aarch64-apple-darwin.tar.gz/md5/1622ced2d1fb291fa7b79f3c2911a65e
-libLLVM.v11.0.1+1.aarch64-apple-darwin.tar.gz/sha512/afccc9244636220e7f892a6e6aa0be665080090f6b9f2e8f0ad8d350d514ec4ca7f7db20c2186b2a6db3d00178e56ef06faba4cca3f801bef92b934a9207107e
-libLLVM.v11.0.1+1.aarch64-linux-gnu-cxx03.tar.gz/md5/666901e42c570891ab93d05dde73a812
-libLLVM.v11.0.1+1.aarch64-linux-gnu-cxx03.tar.gz/sha512/1365cec23dd60960ff249532cc833684ff9ad2e870d55b321cae6c2b5771512d56dbbe3eece106b71f2012058f5ff4796ccfe09017d3ee08429174953f28baef
-libLLVM.v11.0.1+1.aarch64-linux-gnu-cxx11.tar.gz/md5/72fdeff0e297b61d285ec2d99261abe0
-libLLVM.v11.0.1+1.aarch64-linux-gnu-cxx11.tar.gz/sha512/b6061df19c6cca7b96853a0fcde397c8ceb833758b2a6cd71d16042e551db082341dfc63c6278326a0c83ab6651d09bae68c2f746b44ff33f86d3c8db98620c1
-libLLVM.v11.0.1+1.aarch64-linux-musl-cxx03.tar.gz/md5/bb43cd1360f79f6ee4df73c454977718
-libLLVM.v11.0.1+1.aarch64-linux-musl-cxx03.tar.gz/sha512/aa5c1e0c1292b9c59efe41de65ff4a5cb20af499963abab44714aa1c17db3aaaec3e1a13526241349dc30576fee090d522eddf2cd1c569800323b923e1f60cd4
-libLLVM.v11.0.1+1.aarch64-linux-musl-cxx11.tar.gz/md5/b48cc232f36ecd03249decfe6f9e5080
-libLLVM.v11.0.1+1.aarch64-linux-musl-cxx11.tar.gz/sha512/487f2e3d31905c9a68b1021edb6e930b3af06ac1ec7c75249acc18e16df6407db157b95f23cda9b033a07d6a0f0925b3cfbe8bf21c302857b366509d63051075
-libLLVM.v11.0.1+1.armv6l-linux-gnueabihf-cxx03.tar.gz/md5/dee3ccb2973e47f4d8683df2a0dc3e13
-libLLVM.v11.0.1+1.armv6l-linux-gnueabihf-cxx03.tar.gz/sha512/6ab2ad568836a11664e5f31950a0146fac925af7eef11f347a29e549c9312adec6430e3b75a2ffc5d945d0e7a7fb175920a8633613916d9ba5f8da0930a1853f
-libLLVM.v11.0.1+1.armv6l-linux-gnueabihf-cxx11.tar.gz/md5/1d45125767f31c302a2f9929f95f3930
-libLLVM.v11.0.1+1.armv6l-linux-gnueabihf-cxx11.tar.gz/sha512/a1c360785a2f310e978b92d053a17149935227b98c46acae12fec18d692542ab4a109424faa2d62fc02c2234b784a51afaffe44aca24689201939329eec6b569
-libLLVM.v11.0.1+1.armv6l-linux-musleabihf-cxx03.tar.gz/md5/0bb9a73b15469000b67ccabb401ff501
-libLLVM.v11.0.1+1.armv6l-linux-musleabihf-cxx03.tar.gz/sha512/cf8522609d49d0fe184d56f4dd1a6e83ac0a004ae42587619575e01c5d7ce5812867a5394009603231b4d8c6d682dd2505c1d7b4b61935e7b0cfa24dfa7a68a5
-libLLVM.v11.0.1+1.armv6l-linux-musleabihf-cxx11.tar.gz/md5/d1d9ffe09bd844439f2393ca5d580eee
-libLLVM.v11.0.1+1.armv6l-linux-musleabihf-cxx11.tar.gz/sha512/9c56a4b1cfda1e4442a0e65950a1ae250901ca1faeb6288f56ec378c142f762629f2e07029a4c40a3da882292358b2aaf38894fe2a3d341f0ca6b08ec1b6867f
-libLLVM.v11.0.1+1.armv7l-linux-gnueabihf-cxx03.tar.gz/md5/d4f45247ea38672c913812e2f912ff02
-libLLVM.v11.0.1+1.armv7l-linux-gnueabihf-cxx03.tar.gz/sha512/1906a20aed81d36063a47b96a1a6f09876d977f56a2327241e050205c054f704d160fb066aaa0d0672f78101952a811e0bc0b67f88e5a5cfc0ed9253aca0c056
-libLLVM.v11.0.1+1.armv7l-linux-gnueabihf-cxx11.tar.gz/md5/c9e91730b469a4632a654c3861a24e7e
-libLLVM.v11.0.1+1.armv7l-linux-gnueabihf-cxx11.tar.gz/sha512/f975049c38897bb1619f5e624e5c57cd2dbd0060b7cacbbd4eb25bc6fb5a8843f8dfc68560d9f13f393d22d78de0f1fa4fbca9d3455021f06a65e44fe783504d
-libLLVM.v11.0.1+1.armv7l-linux-musleabihf-cxx03.tar.gz/md5/d8a2bdcdcd713e12286f80b504760937
-libLLVM.v11.0.1+1.armv7l-linux-musleabihf-cxx03.tar.gz/sha512/d0cebbf7ae1b9ce8a55752b10f285fec9a5714eac484644fc0aff8333d5a556be3472e9d332efa4725be78e100bb2b1d1ea70ee56bef55366a345d5932a03813
-libLLVM.v11.0.1+1.armv7l-linux-musleabihf-cxx11.tar.gz/md5/870242cc57777cecbece68dcc2cf97dc
-libLLVM.v11.0.1+1.armv7l-linux-musleabihf-cxx11.tar.gz/sha512/5f21baf5097671e6c2d792f52b65c919b08ce17398ebf2220118b4588cb46182d405c8c379872d0e28abd6d8c5e8695cbd0bb8a9d6454cd7a56eec476a0d390c
-libLLVM.v11.0.1+1.i686-linux-gnu-cxx03.tar.gz/md5/62fd82cd980da63413b37aa9452b02d0
-libLLVM.v11.0.1+1.i686-linux-gnu-cxx03.tar.gz/sha512/e69b412bcd8a653570fc20b977d16ece2bbc40669b61aa2383f26f11510a36948aabe930a003ba99c695bf18fe3a1d6162c4bf9d47d265ccdddf6310004726f9
-libLLVM.v11.0.1+1.i686-linux-gnu-cxx11.tar.gz/md5/d65dc4edcea1e1eb9c4657c730d514c1
-libLLVM.v11.0.1+1.i686-linux-gnu-cxx11.tar.gz/sha512/217c515ee9da368ca1fbd5b43537865f67b3229e71ff6edd04840edea59fd07385ee3055a78b8a390ff8a1c73b89c3f2b9318669a85f476c94b1ebb0c27464d1
-libLLVM.v11.0.1+1.i686-linux-musl-cxx03.tar.gz/md5/81960d2abfaf01c7ecfd3dc260d4faed
-libLLVM.v11.0.1+1.i686-linux-musl-cxx03.tar.gz/sha512/dc31a9337d2321ee3fa1c7aab0afe349b9427a4a743723e5a9ae6eaa8d8cb0d31740ee690361b554a75c372f316a6e595279cc35e06bc48bc972f3863b051129
-libLLVM.v11.0.1+1.i686-linux-musl-cxx11.tar.gz/md5/08b2e6709a5be7b6d6c8beea0c593707
-libLLVM.v11.0.1+1.i686-linux-musl-cxx11.tar.gz/sha512/291aafc45cd9ab282d1be9f983949510a3d478c040aac874f611c83b64061cb99367f4f958e3169c4700abb5649a8e778ce2e9666c4ea82981bfe58306372cf6
-libLLVM.v11.0.1+1.i686-w64-mingw32-cxx03.tar.gz/md5/640d49b3005923d9b1ba96a870fc897c
-libLLVM.v11.0.1+1.i686-w64-mingw32-cxx03.tar.gz/sha512/4e7ef6c4b339a3291e5574ece46e94ee5ce5f78c842d232271324386e269387af7b90a55160b177d3b063407475ddcf2e4a88d4e892a1e1c37c81a90bcbada1f
-libLLVM.v11.0.1+1.i686-w64-mingw32-cxx11.tar.gz/md5/64a706b22f1d573f4aeef77fcb25ad22
-libLLVM.v11.0.1+1.i686-w64-mingw32-cxx11.tar.gz/sha512/637593ddf0f30e2d0a5721fdd755ef103349b937c4296246c6fd6e2a026545547d3a21564663af1ffbaabb0d599cb86bb3ac267b5ca258745189be63a83f3dd8
-libLLVM.v11.0.1+1.powerpc64le-linux-gnu-cxx03.tar.gz/md5/67990d0806ece4f547f1454c81f7dad1
-libLLVM.v11.0.1+1.powerpc64le-linux-gnu-cxx03.tar.gz/sha512/de93f18d38fb07a4a27273ef9bfd2abcef2733d63db72c48f6b7f2d22dbcd63d33ff1f5c4e625f6467160867dd3f63db28ae741131b0c3afd6cd2031e798f85d
-libLLVM.v11.0.1+1.powerpc64le-linux-gnu-cxx11.tar.gz/md5/6416aa0d10dd8912872f85a0a48d7510
-libLLVM.v11.0.1+1.powerpc64le-linux-gnu-cxx11.tar.gz/sha512/cec6b63281b14b30d2ad763558409efa85248116e21b25f4a18cc3b81fe7a1f4dca01fe6c4fbc5b63d1c4bca520d0b97c5a87d64e7cc3ea1ed57ca391a5b89f5
-libLLVM.v11.0.1+1.x86_64-apple-darwin.tar.gz/md5/4a3770cb3bcb52fad0002d8eb6ea81d3
-libLLVM.v11.0.1+1.x86_64-apple-darwin.tar.gz/sha512/a79c451f9802859a40eb9163f2fb1202d47f3422ef024f5935d359953401fa0b7bb803efa2a5d28580a1c40dce0d008283ee996b2eaa3988c758dc54ef50d289
-libLLVM.v11.0.1+1.x86_64-linux-gnu-cxx03.tar.gz/md5/121cc23d1f7c21f72c46033fd69afc2a
-libLLVM.v11.0.1+1.x86_64-linux-gnu-cxx03.tar.gz/sha512/b0ae33078f61cb7481de09566b3642b28f9cbdd74db664d9f80267c6261fba5df4e934f8988d1cc4c36ab6187b7d1f0d79bed7a7ec8dadd0c5b003a891d65635
-libLLVM.v11.0.1+1.x86_64-linux-gnu-cxx11.tar.gz/md5/5037fb20393bc2a5d8cad3ac05ed5d6c
-libLLVM.v11.0.1+1.x86_64-linux-gnu-cxx11.tar.gz/sha512/40c7cd78c0327b814d12579df154c69d61146f6ef46daa469aff27bebeb05fa5b99a4a6c9c9b11058612e15dbe822758d7ece39265dfb0e27183bae4928036d8
-libLLVM.v11.0.1+1.x86_64-linux-musl-cxx03.tar.gz/md5/f92f9a96669af2d90cc28b4f7d1f9c19
-libLLVM.v11.0.1+1.x86_64-linux-musl-cxx03.tar.gz/sha512/6b9312b00a44098cb0bfe2182095eb7d5f93b3906a435159bf73c26c61497a381c38a714d92a36f38e986662f185d31171e28789f8877de4ed86d8be61e6bc42
-libLLVM.v11.0.1+1.x86_64-linux-musl-cxx11.tar.gz/md5/c85897b5e200ae778cef4d8ad0eeab88
-libLLVM.v11.0.1+1.x86_64-linux-musl-cxx11.tar.gz/sha512/a8eff9c0c3b3c433cd8c08a692e1768c7747f6b4dd090dcbb9b24ccecc3f0012370e5b0d5c08bcf456bc9b6d93d9f60936328b407dc2296c77d24d8742ee6cc1
-libLLVM.v11.0.1+1.x86_64-unknown-freebsd.tar.gz/md5/656661b0993b406f47cc082f10e05fbb
-libLLVM.v11.0.1+1.x86_64-unknown-freebsd.tar.gz/sha512/90b27206281eaf6e44ff7be00d2fb9601879756e7dcbc1cfc648b097a012383aef2b0817f25e31ff95e92a422aaea2495eb3d186fcf6f8812ee1af96c190126e
-libLLVM.v11.0.1+1.x86_64-w64-mingw32-cxx03.tar.gz/md5/6a435b420e3632de07a6fd28d014182a
-libLLVM.v11.0.1+1.x86_64-w64-mingw32-cxx03.tar.gz/sha512/f11e2486b861d73577c0a237dfd23a6910322df1e140e5a3bce0fe7e12a3131498bc264057bffb0a42a54cd538887c31b403ab9f3fcce60bc4ec85f44ec0a0fd
-libLLVM.v11.0.1+1.x86_64-w64-mingw32-cxx11.tar.gz/md5/670204d9d98d85aae9592f1fd82acf33
-libLLVM.v11.0.1+1.x86_64-w64-mingw32-cxx11.tar.gz/sha512/b115bc8a87aececbee7ece6f9701a3fe07ccb6c06e7732ee9667bc6b1d58586e31f4f400b06d60e066f521f9fa2e6186903fd5ae36917185040bdb941adfb41c
+libLLVM_assert.v11.0.1+2.aarch64-apple-darwin.tar.gz/md5/cf33f847ac2d3c6108ae8ceef33bf8d8
+libLLVM_assert.v11.0.1+2.aarch64-apple-darwin.tar.gz/sha512/a303e03394bfb2770bbf5d2190044875d8d2bd72f342f4796b31b11074904fc0b7a4561994fe47c1a00b9e519a91887de98f09001e453e9c03a8364b9bd19599
+libLLVM_assert.v11.0.1+2.aarch64-linux-gnu-cxx03.tar.gz/md5/2e625a9743e39245b81699370ad444bc
+libLLVM_assert.v11.0.1+2.aarch64-linux-gnu-cxx03.tar.gz/sha512/1765c600c0e0db34f90d6d8a9e9c868bc5b5c26375f87e67efd4e0e2b283e79018b49f6d14f092fd4a339530aa6f5f932e25a2151c6dc9cd333e85102b8d05fb
+libLLVM_assert.v11.0.1+2.aarch64-linux-gnu-cxx11.tar.gz/md5/117a4147d0ad8a0bd8fe6b1bf1291fde
+libLLVM_assert.v11.0.1+2.aarch64-linux-gnu-cxx11.tar.gz/sha512/0e450102c53e2322d0a38e37399cd973a528724a7b651ad10968b23869d0a9e7dbd5686f716740649ac36e0b165bddee6b9c820b85bcce7272b5a7e79ef898ec
+libLLVM_assert.v11.0.1+2.aarch64-linux-musl-cxx03.tar.gz/md5/1cc34396ceab6867b037f1ee8195fd2b
+libLLVM_assert.v11.0.1+2.aarch64-linux-musl-cxx03.tar.gz/sha512/50c85525c8ceb7c90abe4f456f4db911ae9da00aa803dd55468d661015d41afd7417fa19ec11beca90e5a9aebd75c534381fd2f82859c70cc70404c1bd5ede05
+libLLVM_assert.v11.0.1+2.aarch64-linux-musl-cxx11.tar.gz/md5/e0cb52242f74ede9e759db8fe9f05d15
+libLLVM_assert.v11.0.1+2.aarch64-linux-musl-cxx11.tar.gz/sha512/01d8f8b7023dc1ebe588e825741df66a5abf398a53d1ff87f3f3ff3e467bff99f13c48e3de8056844c687407cc3550958919d01090f85e9a1ae68ed7f5a34ede
+libLLVM_assert.v11.0.1+2.armv6l-linux-gnueabihf-cxx03.tar.gz/md5/31346b6d139261edbf7af16b445d046e
+libLLVM_assert.v11.0.1+2.armv6l-linux-gnueabihf-cxx03.tar.gz/sha512/1e9e1fd6fae43dea84589613e1c3adda7dfc5a67fc0e78b02687696c2ccc4df1b2feae909c79eaeb08f217ed22e8c00a15d1cb455bedc0047574d4596cc9cd72
+libLLVM_assert.v11.0.1+2.armv6l-linux-gnueabihf-cxx11.tar.gz/md5/2c27762aa16f1ae06f42e1069369b0c5
+libLLVM_assert.v11.0.1+2.armv6l-linux-gnueabihf-cxx11.tar.gz/sha512/bf79dd33b928e3298cfde2cb98f72940937d5b4082605391d2590905b2413550e27db9ff1a3a798793b566f297c1312e845e4157d64ec575bad99b4e6a8e0104
+libLLVM_assert.v11.0.1+2.armv6l-linux-musleabihf-cxx03.tar.gz/md5/424e05233c6260e4b307c6fe2f4e014a
+libLLVM_assert.v11.0.1+2.armv6l-linux-musleabihf-cxx03.tar.gz/sha512/b300d6fc007a8acbb6de8b93be1daaf09bd1a051ec8216dc78a2cc3040e4d243fd8a2c10f6d676b049a7c434278638a3c8b740472f72ed4fc3a3b20a003d2414
+libLLVM_assert.v11.0.1+2.armv6l-linux-musleabihf-cxx11.tar.gz/md5/4b40127aba11d070f2e61103bb71d2ea
+libLLVM_assert.v11.0.1+2.armv6l-linux-musleabihf-cxx11.tar.gz/sha512/a75ed7366c5c0f5b49890edd6e8c570dc15f076caff53fb27613b55ac3dea2d3f7b5a2bea61676aea90821edf94575c7f626c30f1d345c37f66be6ef474daad5
+libLLVM_assert.v11.0.1+2.armv7l-linux-gnueabihf-cxx03.tar.gz/md5/d1cd29c95fc1800b079f75f0404884f4
+libLLVM_assert.v11.0.1+2.armv7l-linux-gnueabihf-cxx03.tar.gz/sha512/e8784f9f6e6550ac38e4faffcf9ea749953aa9502e1e2ac3502638204863c4b96d2f4b41291f1d90901370702ca144a316e518e7288b8c878e7c334868fed3a8
+libLLVM_assert.v11.0.1+2.armv7l-linux-gnueabihf-cxx11.tar.gz/md5/8c295373a52bb8509ad04f77a5adb8e0
+libLLVM_assert.v11.0.1+2.armv7l-linux-gnueabihf-cxx11.tar.gz/sha512/712a43b52d1a691bfc48353553a0db770547c806f89ff1b58bf1c6728c5bb362dedb37d53c16b02c7349063951dfa0b571604daf2fdc34a1c9951695c7e2a327
+libLLVM_assert.v11.0.1+2.armv7l-linux-musleabihf-cxx03.tar.gz/md5/4f2b664fa1d9d14ab2597f1af29bc0c8
+libLLVM_assert.v11.0.1+2.armv7l-linux-musleabihf-cxx03.tar.gz/sha512/ddc0d99a76a37b08b47a2f5cda02fdd682b84fecb048dcbdef717085a895fc918ffb87175e29eb3734b07c36969c75fd9bb29e6d28143eec59cddd661b08fcda
+libLLVM_assert.v11.0.1+2.armv7l-linux-musleabihf-cxx11.tar.gz/md5/e15a5e9b53a1a70791a0b739dcfe084a
+libLLVM_assert.v11.0.1+2.armv7l-linux-musleabihf-cxx11.tar.gz/sha512/06bebf50e864c4a33332c4ef3a9e89c017ed8e8d432e3e0a2a80513ef0389747f254895b9172ca618f7e889587aa194563bf2c591a6205f3fba5dd542c632588
+libLLVM_assert.v11.0.1+2.i686-linux-gnu-cxx03.tar.gz/md5/c3de397297a7e0fd616b7ce1454b43c1
+libLLVM_assert.v11.0.1+2.i686-linux-gnu-cxx03.tar.gz/sha512/f3008fe3868e8e06dfd664c0486acd913ecf40f099e6abb19e0c4f0dd4830801ff9ce777afc4251028ac08c33d33d49d01a54148660c79b2ffbb75eb1190880a
+libLLVM_assert.v11.0.1+2.i686-linux-gnu-cxx11.tar.gz/md5/015f837e3677e8bfcc66818a6f3ce45b
+libLLVM_assert.v11.0.1+2.i686-linux-gnu-cxx11.tar.gz/sha512/12a22e65ef015136925811667f3e42b9baa51794d81c4b10a3a4df909b3f93c7210af1914d31d5488b00883ccdac25951f3cd1f665c6f26ff97e603e4979b982
+libLLVM_assert.v11.0.1+2.i686-linux-musl-cxx03.tar.gz/md5/c14740eac2b400e02813db8934c1d200
+libLLVM_assert.v11.0.1+2.i686-linux-musl-cxx03.tar.gz/sha512/e520acc6a73a959d2c3a2ef45d4e54ad2a4d3f7fdf639719cdb66ea977b2e7a9f54e6f15b3c92669c66756183e9cc2229238587e4f00986184bbac3ab44e91f0
+libLLVM_assert.v11.0.1+2.i686-linux-musl-cxx11.tar.gz/md5/b8c617925b684ccb519880008947c5eb
+libLLVM_assert.v11.0.1+2.i686-linux-musl-cxx11.tar.gz/sha512/d0f50ef623ddb0209594e5cb7561cbc5b2754e6d3dbdf3f5627bb25de06b2f95ba27bed76460ec68a3cae893fd8c186183a19eabcc6048463aa3f95d9d0935eb
+libLLVM_assert.v11.0.1+2.i686-w64-mingw32-cxx03.tar.gz/md5/9eee10258f8a8cb28b84f6fc22b90e6a
+libLLVM_assert.v11.0.1+2.i686-w64-mingw32-cxx03.tar.gz/sha512/642b2bc4c8637f4013956a331905632901f8082847f81cb77b0f5307a788b170d45c26e84f3395b19b49a3c90ee5d97c3e57461a02031b7a0338b3cb6a5a7a01
+libLLVM_assert.v11.0.1+2.i686-w64-mingw32-cxx11.tar.gz/md5/bff3aa0befc5641ffb06c1c0fa08d897
+libLLVM_assert.v11.0.1+2.i686-w64-mingw32-cxx11.tar.gz/sha512/7fd3373b420dd805d203ece25e9fa09dec0155a848688a433c467dedf8342163f9e2e8fe354b1fab2c63d56b870d36ed92cab6cd122fb94abff48fac48735dc5
+libLLVM_assert.v11.0.1+2.powerpc64le-linux-gnu-cxx03.tar.gz/md5/096643b2d9e132f97fec0dcb8647e365
+libLLVM_assert.v11.0.1+2.powerpc64le-linux-gnu-cxx03.tar.gz/sha512/c2e4fb56c7dc7b1888e23b3c9cfe50093511ed34f09c189e36ceba7e3fcf430f70c5b6f3579b49d7346e52ec77b9f92dffb4c9a864d712ebd2002181c3eabae9
+libLLVM_assert.v11.0.1+2.powerpc64le-linux-gnu-cxx11.tar.gz/md5/0e4696b94e13facaade2b01f326643e3
+libLLVM_assert.v11.0.1+2.powerpc64le-linux-gnu-cxx11.tar.gz/sha512/8637c654f4b5de5d786f274f55c84f6dd697d252af332e10983a6a948240d1c57c9783f03e7947dfdb6ec11d0dd889451d95f8c7ead027f8b04708ac1d4a7e73
+libLLVM_assert.v11.0.1+2.x86_64-apple-darwin.tar.gz/md5/c2b418c6dd79bf464138f73bc90a3987
+libLLVM_assert.v11.0.1+2.x86_64-apple-darwin.tar.gz/sha512/6ebff52a9894673d5d7d6f4afdc1bbceb04f8f6f5ca0d48651c0816e1be6b0fae3e480f2c74cace93605720eac681054c99965e0f862e87cc172e7cf2a97b5e9
+libLLVM_assert.v11.0.1+2.x86_64-linux-gnu-cxx03.tar.gz/md5/2793d01bc42a7c1becea921ad0169192
+libLLVM_assert.v11.0.1+2.x86_64-linux-gnu-cxx03.tar.gz/sha512/c1691db3e5c071040022c2e7b841bc189365aa2c0722769054e0eba2e6e8408cab7e9800293ad1cdbdce4ade9987f2d72e557d88a81ba51e5ffe2c0f6d4e3321
+libLLVM_assert.v11.0.1+2.x86_64-linux-gnu-cxx11.tar.gz/md5/927faa9e9c98bd98c52cd85f0260c3a5
+libLLVM_assert.v11.0.1+2.x86_64-linux-gnu-cxx11.tar.gz/sha512/9b2503f70ee5fcd06e3b661fdc5221a12e8001bdb8f5b774ee109c3b501087e906b9247f7f55fe4b797233a989fb4f4578af8c6b9ab3a702fc5ae4998eb64963
+libLLVM_assert.v11.0.1+2.x86_64-linux-musl-cxx03.tar.gz/md5/f64d51f497030f7ff7071b43ba20e8d4
+libLLVM_assert.v11.0.1+2.x86_64-linux-musl-cxx03.tar.gz/sha512/503e33e7484b3d2c653a2db4c8df8c09b814ca4a0f59c5b756ec3dcb3bebca0d283ac044b4f832d896e06324d1281a30ca1ff98f62e03eef0bb402487865698c
+libLLVM_assert.v11.0.1+2.x86_64-linux-musl-cxx11.tar.gz/md5/3b267ef027fa5a346c2a209bc61d759d
+libLLVM_assert.v11.0.1+2.x86_64-linux-musl-cxx11.tar.gz/sha512/b5eda9fd02a471a0f5589a7b4782c6b39bb763fa2d06bb5506ebada88679256680eeaf5aa493a0b89550a8849b9cfce96c70329faa5cca2b2b2ec3a8e25e8152
+libLLVM_assert.v11.0.1+2.x86_64-unknown-freebsd.tar.gz/md5/1b84541801d81ca3f75f9ecd61deb64f
+libLLVM_assert.v11.0.1+2.x86_64-unknown-freebsd.tar.gz/sha512/ad4e6e84cc49d942494c7ea372f6f038b8c998def46f618451de61145fbdc0cedb20da399100f2941f249bb85fd56ba5bf4c5c7722be8ac093ed3faec8ed7e8f
+libLLVM_assert.v11.0.1+2.x86_64-w64-mingw32-cxx03.tar.gz/md5/c8c553873c052d79a566c1eefbbb8c89
+libLLVM_assert.v11.0.1+2.x86_64-w64-mingw32-cxx03.tar.gz/sha512/de5cf18071d9ce6cd25e615d9788ee4f5391e8855650cd064a36ead9009d054057bf2aa714913dd6006f6c28115b2e78345ac39ee130e154e86d921731e90bf9
+libLLVM_assert.v11.0.1+2.x86_64-w64-mingw32-cxx11.tar.gz/md5/92905d2d2599a2b2039ea51d44c14e40
+libLLVM_assert.v11.0.1+2.x86_64-w64-mingw32-cxx11.tar.gz/sha512/420f6a23013da5bdc1d6d233e960eb9232818b251aabded8f8086e3d5c123d8a77f6b6ce28eed163cc2d502d318db8139507cb05d9615d024467768e66a0c5f4
+libLLVM.v11.0.1+2.aarch64-apple-darwin.tar.gz/md5/f9f07eef3f7eede43b340f719c401eec
+libLLVM.v11.0.1+2.aarch64-apple-darwin.tar.gz/sha512/35023a737a8f14ed209e7f171edf71d2e95ed12d91acefe09a77b44038f6f441337bbe662b24aa1d7da78cf74b7632b6d6233881e79ef41a1c2eb0eb3681d8dc
+libLLVM.v11.0.1+2.aarch64-linux-gnu-cxx03.tar.gz/md5/b6ef2ffdd97d70f39202a94833be4342
+libLLVM.v11.0.1+2.aarch64-linux-gnu-cxx03.tar.gz/sha512/f9d2c0feb5abc658215dab41fe1c186549240912bcbd2f79450048716bb72ad0f9da186a1da31cf33e445b2033e8d24d30fe551ee795399f2b646b62fe80e465
+libLLVM.v11.0.1+2.aarch64-linux-gnu-cxx11.tar.gz/md5/1897d208579686470414561695445d55
+libLLVM.v11.0.1+2.aarch64-linux-gnu-cxx11.tar.gz/sha512/8b011a5d49c4ac716720ca7db21c9b0ce12e9f5a906fecaade8726dea4e30165693e61e34552d8705181b564facdb2de918a56db91ea2f85529563fd919270b0
+libLLVM.v11.0.1+2.aarch64-linux-musl-cxx03.tar.gz/md5/29e687eb45ff43debc08f6544a8c4b20
+libLLVM.v11.0.1+2.aarch64-linux-musl-cxx03.tar.gz/sha512/e40b8ef879b540bf92bd19198289535f9d46afd87e90e49b6103abc714d5329a25e7dcd908401f58ac374a5f2f40cb194f4a85fbf7492743b1a946dfef16ac22
+libLLVM.v11.0.1+2.aarch64-linux-musl-cxx11.tar.gz/md5/e406a526a8e6ca1fc6e7f95f3328e9d7
+libLLVM.v11.0.1+2.aarch64-linux-musl-cxx11.tar.gz/sha512/aaccb3e1fe2fd329cfea6d5cc2589ec50e6d5b84048df4786e7b686ba5cc2f85dffe88198cb667ac422b00c04f57ad7af9fa01415d1aefb1e8594b109f4055d2
+libLLVM.v11.0.1+2.armv6l-linux-gnueabihf-cxx03.tar.gz/md5/d50aeb112f181d95f219950ec9e86e56
+libLLVM.v11.0.1+2.armv6l-linux-gnueabihf-cxx03.tar.gz/sha512/e3f3572d4b2120b4e681a08c2bf359a0165c66b32960a7313564567347349e48417e20f1d71ba4123a3dd433782adab2805448dc64fd6dcdb948c8d4de16afa1
+libLLVM.v11.0.1+2.armv6l-linux-gnueabihf-cxx11.tar.gz/md5/582d0ef077ea8619b18d510c6f59d696
+libLLVM.v11.0.1+2.armv6l-linux-gnueabihf-cxx11.tar.gz/sha512/2f0485436518e07f20f975b172b26cdbaf5b7ae5730c68ff146d9e48f30ee96784e1146717d8142e2cf7ea1b6d0be9bd7ba796f08352c9cd27e00398dca51b19
+libLLVM.v11.0.1+2.armv6l-linux-musleabihf-cxx03.tar.gz/md5/b2453b1dc177ef0445c36246344ca35b
+libLLVM.v11.0.1+2.armv6l-linux-musleabihf-cxx03.tar.gz/sha512/ecd0dfd78861f70ecb92c5e58659588414e0eaa43caf4dc4b4447ec888096423ff61b276bdce191a0f9e218d86db877413e21c34527fd900f5eb51192cb2bcf8
+libLLVM.v11.0.1+2.armv6l-linux-musleabihf-cxx11.tar.gz/md5/89ed91916bab44b1b35cf7a32e50e1ff
+libLLVM.v11.0.1+2.armv6l-linux-musleabihf-cxx11.tar.gz/sha512/a12efcbfa717ab122af87fb5e8ba7676b81d2b58db73df8a52781208c7dada14091ad2a30e6dd1c8e1db8790734cb81c86c85204cb08cbd1f794f3f10834507b
+libLLVM.v11.0.1+2.armv7l-linux-gnueabihf-cxx03.tar.gz/md5/c76c398aeb7e652b9647f74a0e685773
+libLLVM.v11.0.1+2.armv7l-linux-gnueabihf-cxx03.tar.gz/sha512/ebf7a898988ec75a093c7687a451dcbc1968934fe6784e4e73c9387bf9e0d1c15f5466a38c2d9c60a58810fcbe45c7a36860e0fab0b765e177bd1f60c589e819
+libLLVM.v11.0.1+2.armv7l-linux-gnueabihf-cxx11.tar.gz/md5/dd3e28395e524f0a8b48543e37dc065e
+libLLVM.v11.0.1+2.armv7l-linux-gnueabihf-cxx11.tar.gz/sha512/ae34a1b1f063fae29f29ef2be6a2dd929c3df20b2db8fdb5542028e961a9e5c3513dfc56bc129296670f9e2cdb2ccaa1c43ecafc98bdb2acb10de233e95e2567
+libLLVM.v11.0.1+2.armv7l-linux-musleabihf-cxx03.tar.gz/md5/d82e70803993ec10c84bd064d2438ab7
+libLLVM.v11.0.1+2.armv7l-linux-musleabihf-cxx03.tar.gz/sha512/3f15ef9df5ec63a0a9749adae7aac5245b35501137885c36effc840edd905d791b903e06489e0433caee1546cfc8bc14d219be02fa9d26fef16839600202d8bb
+libLLVM.v11.0.1+2.armv7l-linux-musleabihf-cxx11.tar.gz/md5/b017a4827d2d918446c91009be069d30
+libLLVM.v11.0.1+2.armv7l-linux-musleabihf-cxx11.tar.gz/sha512/bc6c559272132158bd76e433717cc1cbe08e34f0a184c867d8a8da69c64e4eee70a77a3e13643f14087bf2a1a9c688a4e9b8aedecc8289813e35d2494f0469f9
+libLLVM.v11.0.1+2.i686-linux-gnu-cxx03.tar.gz/md5/0a0e529f9421234fae117fb448a64ad0
+libLLVM.v11.0.1+2.i686-linux-gnu-cxx03.tar.gz/sha512/051d9ee52fdd62d6c5ac9aa7a1c09b0f35867a81e0e6cfd7695dbdcbeecb8e8d1927edbb1cb658b9cc96ab8134225bfa40c6fd3ad609d216c17cee09f6ae72ba
+libLLVM.v11.0.1+2.i686-linux-gnu-cxx11.tar.gz/md5/a5eb3f0bc3499b559d3d45a48a250749
+libLLVM.v11.0.1+2.i686-linux-gnu-cxx11.tar.gz/sha512/05d3069fe9f907cbf0e6c6b99c55ed0c4dd4ab77c67d756a6c06668244e23b5b3957229332fed95c046f2893d0bafd5ad53537ea477984d042b4122f2a2196c1
+libLLVM.v11.0.1+2.i686-linux-musl-cxx03.tar.gz/md5/fc0593d21d666a77f816686f5971d17a
+libLLVM.v11.0.1+2.i686-linux-musl-cxx03.tar.gz/sha512/c7283d6329e2549ea1fe278f74f6a0bb976be2e9450dbdcb71522b1fb0ff789bd03983eea16eb0e8837c6b965ab7629badb6e005238065908a6823942817805f
+libLLVM.v11.0.1+2.i686-linux-musl-cxx11.tar.gz/md5/d2beae593f940e3f92cc35df3132bf10
+libLLVM.v11.0.1+2.i686-linux-musl-cxx11.tar.gz/sha512/eb04eb0f1ac661806beb2c2324ad12c0af2fcf8511290a72ef03ade32e5d48f651f5eafc58f0509bbf5b3cab181ae3dc9796aae8689ce6c96527dfb8ba47a57c
+libLLVM.v11.0.1+2.i686-w64-mingw32-cxx03.tar.gz/md5/2dd483ed4d99b12d14d8f255d59192d0
+libLLVM.v11.0.1+2.i686-w64-mingw32-cxx03.tar.gz/sha512/ccc305cd0037669761e66815a8425c5060382e6242068260a5aa2068f1f8561d7e629bc787c56c399e6e296ca7fd178c8a3a38ce11c23db72acad8ac3b0f5394
+libLLVM.v11.0.1+2.i686-w64-mingw32-cxx11.tar.gz/md5/fe88a08c6daa25446e44fc0ed5d065e4
+libLLVM.v11.0.1+2.i686-w64-mingw32-cxx11.tar.gz/sha512/fb7c39f3838d6dd8c7ada8b6c5468f93665efa90bacda63a10b63c64cfc4eddb6ba1833930ba2450153633a4937845f7ac8adf961d8e92949c9ead1323e723c6
+libLLVM.v11.0.1+2.powerpc64le-linux-gnu-cxx03.tar.gz/md5/75955466d931ab5eb840bbeba50bd49b
+libLLVM.v11.0.1+2.powerpc64le-linux-gnu-cxx03.tar.gz/sha512/70100f187d81cf2f374a5178c90d1e109ab66e539d28998366ca7cda09f50c2c5461698fb54669134a23435d68f5891deaa537270bd1f3cdfe9b52d3699b7734
+libLLVM.v11.0.1+2.powerpc64le-linux-gnu-cxx11.tar.gz/md5/392097957ae95e62d3a109a043aa1d69
+libLLVM.v11.0.1+2.powerpc64le-linux-gnu-cxx11.tar.gz/sha512/530d2a8838072552813fe3cc558bb020d74b60350380fd88262ef171689531e6b65154c090b40c65a03fc920b59ec9806e136ed6ee3ef8a46c97a58224f26aaf
+libLLVM.v11.0.1+2.x86_64-apple-darwin.tar.gz/md5/1c2aa5d62f6b50dab22a114b62ba9bc6
+libLLVM.v11.0.1+2.x86_64-apple-darwin.tar.gz/sha512/f844c7419d05a41a7a44324d960b787df18cfad676602e2ae7c8614d5f6ded27b1875514a3e81c824d5ef01e676577518dbaba88e280824f79f9384f2777df93
+libLLVM.v11.0.1+2.x86_64-linux-gnu-cxx03.tar.gz/md5/1901bf5fe9ddd564ed377966c7f5bb3c
+libLLVM.v11.0.1+2.x86_64-linux-gnu-cxx03.tar.gz/sha512/6e8f4a03918eadd55384418a8bfa093e6121e04a66af141d160e706383af83ba0cdd3bf5d178fd075970e191c281e0e3ff74de1c27e24ae2b1e30b690b48d5e3
+libLLVM.v11.0.1+2.x86_64-linux-gnu-cxx11.tar.gz/md5/a85134894c98324a6e7d468007c31b01
+libLLVM.v11.0.1+2.x86_64-linux-gnu-cxx11.tar.gz/sha512/253fe81962225ef3b9334a622bf9026a712a2bbc8e83062e399255a514cc7ca73c0c3a12ee51cdfd86d617a008cf5078b6bb33850a20c2d3515867612f5ee9e9
+libLLVM.v11.0.1+2.x86_64-linux-musl-cxx03.tar.gz/md5/905a95270474484a35ada81982233518
+libLLVM.v11.0.1+2.x86_64-linux-musl-cxx03.tar.gz/sha512/c79b3022a13a2640c8170b50cfe540b7579477262d2d4272e90753df679721ed097f73501452927e290aee38e25035d577edc489c20c750594b9949e2e2cf7f5
+libLLVM.v11.0.1+2.x86_64-linux-musl-cxx11.tar.gz/md5/0817fdff6dfc29bdfd89177f9d462978
+libLLVM.v11.0.1+2.x86_64-linux-musl-cxx11.tar.gz/sha512/a5e352ed9a16fe2b1c0116637f190b4da08eca0de8573562a687d5aa74e0301ea7883a726d3a71a920572df65dd3a4c5ebe199aaedcc6a4a54756228d5512f88
+libLLVM.v11.0.1+2.x86_64-unknown-freebsd.tar.gz/md5/d0bc5b1140f4ce03b603e270cac4f232
+libLLVM.v11.0.1+2.x86_64-unknown-freebsd.tar.gz/sha512/87400be01185a31fd90a57bed74c52529e7615a927cf13c8e665afcad4ff19fd4f4dcd9f7f30ad06b912743a1f3a5b2520d32bbe4a336236c36fde059b5da086
+libLLVM.v11.0.1+2.x86_64-w64-mingw32-cxx03.tar.gz/md5/bfa4b7684833a4179dfe6940616434ff
+libLLVM.v11.0.1+2.x86_64-w64-mingw32-cxx03.tar.gz/sha512/5deff641b7ff86baa2239e1989659f458d0161c6980523e5e300630d4dfb202a3921da3a4bbcc918ae3222d6e11d845e51a0ef5034e0f222e2c8127328322728
+libLLVM.v11.0.1+2.x86_64-w64-mingw32-cxx11.tar.gz/md5/42c2398270442110878aaba30152d4fa
+libLLVM.v11.0.1+2.x86_64-w64-mingw32-cxx11.tar.gz/sha512/b3d4e960fb9376212238c953bd705c4997f0cbe37adaf1153b4e9741af400255ba2ef9afda9400b0dd6ff03615709b75d20b3ba55a674483a59852e0f2e50934
 llvm-11.0.1.src.tar.xz/md5/6ec7ae9fd43da9b87cda15b3ab9cc7af
 llvm-11.0.1.src.tar.xz/sha512/b42c67ef88e09dd94171f85cdf49a421a15cfc82ff715c7ce6de22f98cefbe6c7cdf6bf4af7ca017d56ecf6aa3e36df3d823a78cf2dd5312de4301b54b43dbe8
-LLVM.v11.0.1+1.aarch64-apple-darwin.tar.gz/md5/db112b592fe170025f2e0df99060703b
-LLVM.v11.0.1+1.aarch64-apple-darwin.tar.gz/sha512/c0d196229b42231cb5ef7e4069253eb6a61d6b9cce6455e314f06877461d12f59ba5e797351ac2c039f3f229c746e00ac16a2fa15b70e0dadacb3cbf9fd8280d
-LLVM.v11.0.1+1.aarch64-linux-gnu-cxx03.tar.gz/md5/5cb83dab5e2c67168f1c2568a8b12fb5
-LLVM.v11.0.1+1.aarch64-linux-gnu-cxx03.tar.gz/sha512/9d1af9bada5136691305789f5404eefe673f316c474aef682b88023a7bd719337c3fe5e7d376a993842a693f5fb6cbb1edbcd85217dc046a4951c4faad639615
-LLVM.v11.0.1+1.aarch64-linux-gnu-cxx11.tar.gz/md5/5e2f2852b6dcf4ec4c15cf552540cb0a
-LLVM.v11.0.1+1.aarch64-linux-gnu-cxx11.tar.gz/sha512/36b4c578f97c32a527469942091fa1d83d5cbcbf10ad275537f6b42a6aff5f02a085c4dbc52067343e2ad40f75bef2a87b67d40779ea0c45f040dbb7e3483f5c
-LLVM.v11.0.1+1.aarch64-linux-musl-cxx03.tar.gz/md5/92d6690a6d048612d07f3ec213dad3cf
-LLVM.v11.0.1+1.aarch64-linux-musl-cxx03.tar.gz/sha512/d7f05414a9c7079f0bb36366762e5983834ce78225988c044dc8b2bbe033d6c9ea4f08d64e1bcec3dd4015f48d678329d3d726344cebc03b2f33db1d300b4ed3
-LLVM.v11.0.1+1.aarch64-linux-musl-cxx11.tar.gz/md5/355282f7a8f65607755ade5420122373
-LLVM.v11.0.1+1.aarch64-linux-musl-cxx11.tar.gz/sha512/35f09da76a326185d9b97c01dbae686ffa5cc3626095a15dc8ae094e1e19d7053c4d4147d39d7f29e0c45cc52c1f24fa0ec1228dca996af7caf435c21def0356
-LLVM.v11.0.1+1.armv6l-linux-gnueabihf-cxx03.tar.gz/md5/fdee554069cc9dae0c1f539b196b3d15
-LLVM.v11.0.1+1.armv6l-linux-gnueabihf-cxx03.tar.gz/sha512/6a039ec156049599ce8ee765196f1527c216f2a5c4aaeb7c304777937b4ac7a280d5ad7f5bb717b53925e025c3709065dc656a75193eed4be1a5886cf1076174
-LLVM.v11.0.1+1.armv6l-linux-gnueabihf-cxx11.tar.gz/md5/480a745c2a7e0b6fa0749fa2da8410e5
-LLVM.v11.0.1+1.armv6l-linux-gnueabihf-cxx11.tar.gz/sha512/f2251bd5d14fe701cc2c26a86a54f03a17a8d6c5db2d29834c697223d13dbda664f76cec7ff97d3d8bb9bd1bdd09e782fe81eaf874901f66a2652c71035d7766
-LLVM.v11.0.1+1.armv6l-linux-musleabihf-cxx03.tar.gz/md5/19451e20a3755a2362efa4bd4e8b449e
-LLVM.v11.0.1+1.armv6l-linux-musleabihf-cxx03.tar.gz/sha512/6f661d3e2897af57fd850d91cc21605a1389fc75b2ccc10c980d5f3e4350e0c801168b26bb44466ba3c29870880da64f0a780861530d6315950352c4ad395f1f
-LLVM.v11.0.1+1.armv6l-linux-musleabihf-cxx11.tar.gz/md5/e23ac1cb9c66b9b875fd4eb78831aabb
-LLVM.v11.0.1+1.armv6l-linux-musleabihf-cxx11.tar.gz/sha512/ac1ca2b495878e5a5649d7b6e7c14826f5a34281ca043e30bc212c00ac769adf8627deb6f4137548c71774a9a25d4605185d67b259d19ed9c2ea96ca64b88087
-LLVM.v11.0.1+1.armv7l-linux-gnueabihf-cxx03.tar.gz/md5/91c5fe56e8187dffa815ddad9c221bf4
-LLVM.v11.0.1+1.armv7l-linux-gnueabihf-cxx03.tar.gz/sha512/744c3eca0b97f2399f4cfb34e7ee03aaad68098b69278235f446e23d616a523ddabcabf84b2f4ad65a5ea8876b56c4b1740160c84b9e56b638a732a078996d9b
-LLVM.v11.0.1+1.armv7l-linux-gnueabihf-cxx11.tar.gz/md5/bd97ca229f793ae904e5bbeb2308e6db
-LLVM.v11.0.1+1.armv7l-linux-gnueabihf-cxx11.tar.gz/sha512/8b51dc550446b995afceed525c9fd4a979845dbd8842190f90b524903a74591607ed0624eaf78953a769d96953fb3416c69fc4d85d70f1c8bcbc8a3d59c36555
-LLVM.v11.0.1+1.armv7l-linux-musleabihf-cxx03.tar.gz/md5/48f249ad3d0d4f02fc75f48a8f5b3020
-LLVM.v11.0.1+1.armv7l-linux-musleabihf-cxx03.tar.gz/sha512/d625dc23ee7c73a79947e87790d536423a056c4c5402ebb26c8441c25db29cc19cd49daa92b8cccfb0ed4ff6fa9faa66d40e567c76996ef8d3009921ee86daf8
-LLVM.v11.0.1+1.armv7l-linux-musleabihf-cxx11.tar.gz/md5/efc11d7b9b5915a9c72fa720bbf9c818
-LLVM.v11.0.1+1.armv7l-linux-musleabihf-cxx11.tar.gz/sha512/fc2f15164fcba7cde67729db349370f713eba8bbe2284383a67880e2a34f5cfb1f3be9332fd62fe9aa2a96b2f5acde0f215705431145f60607f817b3a29c495d
-LLVM.v11.0.1+1.i686-linux-gnu-cxx03.tar.gz/md5/f46650c56c150855dff102fc4c322cee
-LLVM.v11.0.1+1.i686-linux-gnu-cxx03.tar.gz/sha512/d741e942fb895f08cb67fa9638b1a21c1bdc091cc0ff7f25c66dcaf2bbef93d2eebabc97466cfb76a7b5d4658620a99ad5199d9472d013cd565d5af30366cf4f
-LLVM.v11.0.1+1.i686-linux-gnu-cxx11.tar.gz/md5/c0cf7ebf06134866f1b0eea66b428c06
-LLVM.v11.0.1+1.i686-linux-gnu-cxx11.tar.gz/sha512/58209415739f3b721f18ded6a3d3512dd6b9517a093ba706cb44017e5ec3a7551ce5cf3c80fae62a94d9dfed5c08ca0486adfd4a917a564e59db1f64e09a511c
-LLVM.v11.0.1+1.i686-linux-musl-cxx03.tar.gz/md5/9c1632ee1e9abb8163d13ed8162df35f
-LLVM.v11.0.1+1.i686-linux-musl-cxx03.tar.gz/sha512/ccfbe98f7ec56ab2416254530eea250101cdeef152956f7a1452e8497700046dfc458df203d86562b4ff28b799f396af11752d600ed0aabfd76af08b8a74da74
-LLVM.v11.0.1+1.i686-linux-musl-cxx11.tar.gz/md5/03e5bcddf8ce4831c030b140afab6d38
-LLVM.v11.0.1+1.i686-linux-musl-cxx11.tar.gz/sha512/df5ddbbba57929d11a8f453eaf14dcd0404378c16e8be4d70ddfe45a012403785f7cf2779912dc171d28f6103d72cdcd777df346a5f37b5abea677df1ccaf516
-LLVM.v11.0.1+1.i686-w64-mingw32-cxx03.tar.gz/md5/4ceee3e48da605586c88b1ac93a1cce3
-LLVM.v11.0.1+1.i686-w64-mingw32-cxx03.tar.gz/sha512/f81e1f20f200074bc94854798ff8c65850124296d6959fa8270a7cd2318f2d7d4b668af6ef6cb8e876d55eb58eb08bf0cfa3bf723b788813667f1817ae610f98
-LLVM.v11.0.1+1.i686-w64-mingw32-cxx11.tar.gz/md5/f9486920a662e1062262ee5550786432
-LLVM.v11.0.1+1.i686-w64-mingw32-cxx11.tar.gz/sha512/12ace5f48836c847e9d8736dd01ada8c3279d3482ad9ff6f5b0ef78d642a5c762042ad6b6fc50d951d50c0a0fe32c0fb3cfef100e5209bec76044836396eab80
-LLVM.v11.0.1+1.powerpc64le-linux-gnu-cxx03.tar.gz/md5/1eaf78f1c43f07e69251c858682dec89
-LLVM.v11.0.1+1.powerpc64le-linux-gnu-cxx03.tar.gz/sha512/1d4d09fc4a7356b7d8931dbac9b1f47de351319c8a29d67e41f32ccc984ea68425aec893b82957d00df43632271566dfd5ddea6f9b505d66d5ce0e67e8aede5e
-LLVM.v11.0.1+1.powerpc64le-linux-gnu-cxx11.tar.gz/md5/7e446672e5221feb33328716d4042c3d
-LLVM.v11.0.1+1.powerpc64le-linux-gnu-cxx11.tar.gz/sha512/d024f37674d9966f78c99d0522bfd697b66d3ed790d6da317a1228cff0a2a8e36f2d5fbeed26963af5f6452e1241ae5f646255afdbc841d161e9f27550d0b116
-LLVM.v11.0.1+1.x86_64-apple-darwin.tar.gz/md5/e28994d105e98409204b0afc8798a3c0
-LLVM.v11.0.1+1.x86_64-apple-darwin.tar.gz/sha512/4bab038a0c1227039340b8f3ecce3318d95852dbafec4480337c00e8f4f8f39508da2176f305c5f7ec27893d5656b0522fc000be13a8df243a3e5ed75e6c4c39
-LLVM.v11.0.1+1.x86_64-linux-gnu-cxx03.tar.gz/md5/262d7ad33c60f16206d0f1b4207da58d
-LLVM.v11.0.1+1.x86_64-linux-gnu-cxx03.tar.gz/sha512/8c172c66d2dae8021805197134760cc29dbc5159850d038c6c28d946207a1c273170228505e63356f6ce5024a8c8e1860092961ef976bc178c1a2b50cec2c8ee
-LLVM.v11.0.1+1.x86_64-linux-gnu-cxx11.tar.gz/md5/1c184178cbc7fcc7cd983541a975d89e
-LLVM.v11.0.1+1.x86_64-linux-gnu-cxx11.tar.gz/sha512/d9d0cde52ec807dd29e941c41c05a5ff495d44d59da8f46a4be4a72f5dbc3b21935727e248b75d1cc6b25e27566cb9157f833fbdaeb7028905e696454b321f78
-LLVM.v11.0.1+1.x86_64-linux-musl-cxx03.tar.gz/md5/778e6605f0ce10e36ada4dcd0207487b
-LLVM.v11.0.1+1.x86_64-linux-musl-cxx03.tar.gz/sha512/8594af15afafe954df5142dc5cc63cec6e4d8bd47c4ac35d59f0eea73c7f74a393d5bd24948e892770fad18deaf42e056d261bc60a480bab39c5dba057147ecb
-LLVM.v11.0.1+1.x86_64-linux-musl-cxx11.tar.gz/md5/41f3efdaa1be437f927d39a779c7da50
-LLVM.v11.0.1+1.x86_64-linux-musl-cxx11.tar.gz/sha512/43791b18e6110b4fd1fe269548419a08ebb29ea6fa5267b039f93c74d21552d429ff30b108ab809bd792ef126875ef8c8f7e1c47cd6743614b280b7f7fdb767c
-LLVM.v11.0.1+1.x86_64-unknown-freebsd.tar.gz/md5/9d33970b74f6185020c3f1f6ba0a19fb
-LLVM.v11.0.1+1.x86_64-unknown-freebsd.tar.gz/sha512/ebcbd9331d667bd8222e5ff6f0665694b5ef20a54b7e969be02f71e39cb0a74e4d5d7148ebc5ba7a0db6e0dbc343de14ea3d85ca67962a1319f21ce77a551041
-LLVM.v11.0.1+1.x86_64-w64-mingw32-cxx03.tar.gz/md5/649946149ecea11bece90249b232d37a
-LLVM.v11.0.1+1.x86_64-w64-mingw32-cxx03.tar.gz/sha512/a5540be90f3a9544e9f150bc26c55f23e1b1e187244b341fe2bc4f70aed80a06b06d68e05b22789505915c85178eb6b6c9493a1641d103bd1cbc52728ac4c0a4
-LLVM.v11.0.1+1.x86_64-w64-mingw32-cxx11.tar.gz/md5/a1d0ca7a0814f98c62c95325f3013e35
-LLVM.v11.0.1+1.x86_64-w64-mingw32-cxx11.tar.gz/sha512/8729f4f20f9b0009f9cd61f8e0a077c264424f828e5929cffe22bd7cd797d158826f7861b853d18aa7ea5460bd9b178ae12bc27ed8e4f0ea848f1dc768fc54b8
+LLVM.v11.0.1+2.aarch64-apple-darwin.tar.gz/md5/643089e5ffc8a089d87f2e729f40a62c
+LLVM.v11.0.1+2.aarch64-apple-darwin.tar.gz/sha512/5647ad774082ad4257e6745ae7638bcbad09ec3de33cdd4a3db3f2e00ec3e47c60804e269d5fb394be736c65479ef1a9c6e707d9d632ec3fdc6263a416afcc3f
+LLVM.v11.0.1+2.aarch64-linux-gnu-cxx03.tar.gz/md5/6d9db51cfac613c743e77f84d7957043
+LLVM.v11.0.1+2.aarch64-linux-gnu-cxx03.tar.gz/sha512/752db15805b292746b49b675eb66d9d3b2c4f2180ba9b4c5a5e75bffe1d309f47ba5bd0fb560648924e80dec3b8ba1bce48a9a5168e399a3776f2661e084dc10
+LLVM.v11.0.1+2.aarch64-linux-gnu-cxx11.tar.gz/md5/7f795319046e33dc37341af6381170c9
+LLVM.v11.0.1+2.aarch64-linux-gnu-cxx11.tar.gz/sha512/6d35efb792aefbe7c3ad7c9cc20dc863f3655df22caa58770ab63515091c8f57f28002ca45e1dda733287ceb92d768f67f53ff0033b74291bc9f67a2f144c5bc
+LLVM.v11.0.1+2.aarch64-linux-musl-cxx03.tar.gz/md5/e504ad861c62ca2cfc68ed85b8b5e22f
+LLVM.v11.0.1+2.aarch64-linux-musl-cxx03.tar.gz/sha512/7fb128c011f03fd881e4e5137b51d80ba1ac7256eca70201c9b9638a85eee485bed25ca3978b42735e5930baf0a93b95fc3c204e508cf667291267fad905b63a
+LLVM.v11.0.1+2.aarch64-linux-musl-cxx11.tar.gz/md5/73c91a8c3cfcbd5249edd397c15d2a0a
+LLVM.v11.0.1+2.aarch64-linux-musl-cxx11.tar.gz/sha512/47ed726e2d4aac874023c5497e7ace6f6d8122c8747825e9b4f8d15ace24d971eb4b6324dc9053686d1bceb2efdad90d0a347c6b5d12a398edcc2afe1eef875a
+LLVM.v11.0.1+2.armv6l-linux-gnueabihf-cxx03.tar.gz/md5/161a8076cb39ae01294321ef915510ef
+LLVM.v11.0.1+2.armv6l-linux-gnueabihf-cxx03.tar.gz/sha512/55c1cd7f688b4ebc5484b4772de37e5db306ece8627e3bc37735daf72379ce562a3537176b40e63c9dd39c729d9bc7074544646cb08d83cc8a95fbb1cd33ccd7
+LLVM.v11.0.1+2.armv6l-linux-gnueabihf-cxx11.tar.gz/md5/e915b79238724fe445a008dae9ffa64f
+LLVM.v11.0.1+2.armv6l-linux-gnueabihf-cxx11.tar.gz/sha512/ad659697413e87dc30338fbf586bf9ba10b08ce39256f5dfcf29a9c2903a029c2e9535a8b6e1c116fc88bb37361804a4ed4010e658fe9a7681a74a541cb79b65
+LLVM.v11.0.1+2.armv6l-linux-musleabihf-cxx03.tar.gz/md5/b061d91ffdc7a49d0e1a6f433b3c866b
+LLVM.v11.0.1+2.armv6l-linux-musleabihf-cxx03.tar.gz/sha512/589d677ac812e68f110accf29292d115ead51f08a36c2cb0d58a0a28b6d035c51fef886808014a5d4422d577426f0f43d249c9d8cad47300c75ad6350f1f9a46
+LLVM.v11.0.1+2.armv6l-linux-musleabihf-cxx11.tar.gz/md5/36b50d11db9a3bcdc72b8975643a425c
+LLVM.v11.0.1+2.armv6l-linux-musleabihf-cxx11.tar.gz/sha512/e7f4cf2a1c6c4b59a9717eaa13eb55598b4312c58a357f079af0d4871b15530c637142b6c41cc536dbe1e328916a28f09e54aa0a898e16a5eeca837e4876e356
+LLVM.v11.0.1+2.armv7l-linux-gnueabihf-cxx03.tar.gz/md5/af4fd5b2e3b38a4512d3e630e791ec12
+LLVM.v11.0.1+2.armv7l-linux-gnueabihf-cxx03.tar.gz/sha512/9d909ac07e4f8174fb93e217420115267897411b7c414090bf9f3515536126a06beb4ef3235d38ebe3f99e023507b8413022e1d2d8d1daf39ecc6f332aa214e2
+LLVM.v11.0.1+2.armv7l-linux-gnueabihf-cxx11.tar.gz/md5/b186a654d8d1b0803cb861ac32f903e8
+LLVM.v11.0.1+2.armv7l-linux-gnueabihf-cxx11.tar.gz/sha512/7de25cfa2852da9d984e5582d523e083ae49d54b5660ed58efbe180d2aee00d0271516b9aceff039492cb64952777e27388e34d6aad18875704a6839f45a829a
+LLVM.v11.0.1+2.armv7l-linux-musleabihf-cxx03.tar.gz/md5/622b4568924282fc3bc402cb3039e935
+LLVM.v11.0.1+2.armv7l-linux-musleabihf-cxx03.tar.gz/sha512/75e55466ad2c7b7c3f5e648adf9421e9735a721cf431a106f324837b8295e2f2b0f9dd68df0743055187e538455e52a6c9b9be495eba25ca6061793f6d59c741
+LLVM.v11.0.1+2.armv7l-linux-musleabihf-cxx11.tar.gz/md5/585dd61369209d70c26d5fb4f17c3608
+LLVM.v11.0.1+2.armv7l-linux-musleabihf-cxx11.tar.gz/sha512/7c87adee39f5ced1a49ca92634995e18bef7dbc040c7083fd2ea061d9391c43c3d124f439e4ad24f5357cadb77569f7f4e9fef1fafb39b1662c1e739f4a8d397
+LLVM.v11.0.1+2.i686-linux-gnu-cxx03.tar.gz/md5/d2a97580540080ef421f5e78be78b956
+LLVM.v11.0.1+2.i686-linux-gnu-cxx03.tar.gz/sha512/4f4b061c07f85280487e2d02528f9e639171e0e85eac757dd9c525f7639149ad5c23db8721204a2e1099915e540496562dd8111ee8188d1b947003ec5256f06d
+LLVM.v11.0.1+2.i686-linux-gnu-cxx11.tar.gz/md5/a35c89244bc09f7dc021286d566d7553
+LLVM.v11.0.1+2.i686-linux-gnu-cxx11.tar.gz/sha512/9a2332863ccc6b73545f2fce1c87f7ce5f9442b3f4d9ff28b228784829eb6688ddd7668726f296f99f2953988657f9968b28a317661377c79c49c0ec86ea6535
+LLVM.v11.0.1+2.i686-linux-musl-cxx03.tar.gz/md5/3510f9922fbf558a96b3e633b2582037
+LLVM.v11.0.1+2.i686-linux-musl-cxx03.tar.gz/sha512/a5d3508636d0e5c670a5a01c55fba85bf0e15b11bdbc29a0c20f42ed6f3fc1e507d2e6414b45637ec88c158e51d26cf156a6e83af26941e205667384ffcbdfeb
+LLVM.v11.0.1+2.i686-linux-musl-cxx11.tar.gz/md5/00a689e3f703513c20dadc727e18360a
+LLVM.v11.0.1+2.i686-linux-musl-cxx11.tar.gz/sha512/ecf5bc194d6b221981d26414037970f5428265955e73e35ca186bd98a07ce2b91ad4df1ce092d06944cd7ebbb450e74d34d1578c7db880bf3e417a36a61951ba
+LLVM.v11.0.1+2.i686-w64-mingw32-cxx03.tar.gz/md5/37de0f4ba020ec4ddfd08db8677a0b05
+LLVM.v11.0.1+2.i686-w64-mingw32-cxx03.tar.gz/sha512/fae73df50c680973f804458f973c5d9e20c173b35da2173ca9cba384d7369bd2f1d4d244104a4b2f93233b93901e79258e7975868a5e47200a4e6e98030e64b5
+LLVM.v11.0.1+2.i686-w64-mingw32-cxx11.tar.gz/md5/aef3ca8f38017759d9d33551d44c7c36
+LLVM.v11.0.1+2.i686-w64-mingw32-cxx11.tar.gz/sha512/a675aa4371003e2d952d45e4f98de139ac03bab483acb7fd69935ee22b3d3958f31872cab8f0b406509454ec7deb912cf1890347810db1162182d197bd0d0fa6
+LLVM.v11.0.1+2.powerpc64le-linux-gnu-cxx03.tar.gz/md5/c17f733e53a5d405472b05d9b94b8872
+LLVM.v11.0.1+2.powerpc64le-linux-gnu-cxx03.tar.gz/sha512/e798f698a6a8e2ccdc087b2503462c20657842c98777bcefd3b30e2ae3d6ada7fa2f0c9f4b0a89c42b1a5a251d0d039161340f1b7b5005411eb39fb6b12265d4
+LLVM.v11.0.1+2.powerpc64le-linux-gnu-cxx11.tar.gz/md5/698644a78d84116938e6a79978af71e3
+LLVM.v11.0.1+2.powerpc64le-linux-gnu-cxx11.tar.gz/sha512/2700d72c7f7f5cf7a76e7f0d4d10d308f4202ea35d67a811871245ba3a4ec3bb8933766c6ac0fe16041def1b4651f4c110e9966fea8b37d8f7b7514405b58196
+LLVM.v11.0.1+2.x86_64-apple-darwin.tar.gz/md5/a65d108986317e1970ff9b3af062e882
+LLVM.v11.0.1+2.x86_64-apple-darwin.tar.gz/sha512/6013d60bcde54f3f916456772f37c1d33a1fe06358deba0dcdd64c6ea3a7d4c20d04c058785f35037915ea5fa226ed53c72c8b1e0982056fe4b4eedd90357450
+LLVM.v11.0.1+2.x86_64-linux-gnu-cxx03.tar.gz/md5/ef0ad19c2a89ef2dced00da0cf342e45
+LLVM.v11.0.1+2.x86_64-linux-gnu-cxx03.tar.gz/sha512/ba28c3532c38c6ab3fd2880a008ae99956ef1e4c8fb1c5afaf8ab7391f9c6b2bed828c4229f5e6e42de916560f57384624cf0766ff09358373e7d07bb1719097
+LLVM.v11.0.1+2.x86_64-linux-gnu-cxx11.tar.gz/md5/a4456e826e353b1e7767a4a1e9b4feb2
+LLVM.v11.0.1+2.x86_64-linux-gnu-cxx11.tar.gz/sha512/cf447db3dfafdef1f89b05ac9988633583e13c9d7cb8f13d95de8c196789ef1831b3f09a8f2af156a1fea99ff8ffa8396b0a8d58c2c16e5b806f7076418a6507
+LLVM.v11.0.1+2.x86_64-linux-musl-cxx03.tar.gz/md5/c0e9ab261069c4b4dca965fb4f89e471
+LLVM.v11.0.1+2.x86_64-linux-musl-cxx03.tar.gz/sha512/f9a6208a0cb8ff62e511064c84d919e154234760c548925f688029e7fa5020da1687f2473e653ee36b031e97068daf23d7fbdf7cc93a8f8bc41ebfd542c59755
+LLVM.v11.0.1+2.x86_64-linux-musl-cxx11.tar.gz/md5/48c8983f295d9500005ae999c980aafc
+LLVM.v11.0.1+2.x86_64-linux-musl-cxx11.tar.gz/sha512/0c6afb6cf49e66a36e6c6a24598eb79ff1fb69cf00622d5200608481a9be66cf364e796652360368bb26b292c5db381d9073c238d75e9b59153bdf1fcd90f881
+LLVM.v11.0.1+2.x86_64-unknown-freebsd.tar.gz/md5/edad57837822c544030a8ea227839f1a
+LLVM.v11.0.1+2.x86_64-unknown-freebsd.tar.gz/sha512/5aaa736bc8e4622c25710cfa411d4ed2703eb77e61dc34fe6928b6a3b2e047f610f41a9d5854761e1438fdb79fea914c3c9080bec1598134d1a9853490b4828b
+LLVM.v11.0.1+2.x86_64-w64-mingw32-cxx03.tar.gz/md5/50020d38e5e7e2162aaad02a9e414fd8
+LLVM.v11.0.1+2.x86_64-w64-mingw32-cxx03.tar.gz/sha512/7b2bafeeae03721fd871b9e164406520de06ef4e5691935e60272c937d29914616c6d4ade7a5cd4be8a8703121a017e3854134d76e67d52fad594c8fb0fecd5c
+LLVM.v11.0.1+2.x86_64-w64-mingw32-cxx11.tar.gz/md5/1b91b38c5bd59096f13bd96e6daca976
+LLVM.v11.0.1+2.x86_64-w64-mingw32-cxx11.tar.gz/sha512/d8f307142fd711d34b99b05276313bce918933ea3840ed1c252e5566f7c0028206a3125d22156b716dafe8e4cb61369d5c02d04ea324b7cc755bdb268006dbcf
diff --git a/deps/llvm.mk b/deps/llvm.mk
index 8e3fe6da9bfc3..a3d67cbaae550 100644
--- a/deps/llvm.mk
+++ b/deps/llvm.mk
@@ -554,6 +554,7 @@ $(eval $(call LLVM_PATCH,llvm-rGb498303066a6-gcc11-header-fix)) # remove for LLV
 $(eval $(call LLVM_PATCH,llvm-11-D94813-mergeicmps))
 $(eval $(call LLVM_PATCH,llvm-11-D94980-CTR-half))
 $(eval $(call LLVM_PATCH,llvm-11-D94058-sext-atomic-ops)) # remove for LLVM 12
+$(eval $(call LLVM_PATCH,llvm-11-D96283-dagcombine-half)) # remove for LLVM 12
 endif # LLVM_VER 11.0
 
 
diff --git a/deps/patches/llvm-11-D96283-dagcombine-half.patch b/deps/patches/llvm-11-D96283-dagcombine-half.patch
new file mode 100644
index 0000000000000..6c0aa9cf414d0
--- /dev/null
+++ b/deps/patches/llvm-11-D96283-dagcombine-half.patch
@@ -0,0 +1,175 @@
+From a5222aa0858a42660629c410a5b669dee16a4359 Mon Sep 17 00:00:00 2001
+From: Nemanja Ivanovic <nemanja.i.ibm@gmail.com>
+Date: Tue, 9 Feb 2021 06:33:48 -0600
+Subject: [PATCH] [DAGCombine] Do not remove masking argument to FP16_TO_FP for
+ some targets
+
+As of commit 284f2bffc9bc5, the DAG Combiner gets rid of the masking of the
+input to this node if the mask only keeps the bottom 16 bits. This is because
+the underlying library function does not use the high order bits. However, on
+PowerPC's ELFv2 ABI, it is the caller that is responsible for clearing the bits
+from the register. Therefore, the library implementation of __gnu_h2f_ieee will
+return an incorrect result if the bits aren't cleared.
+
+This combine is desired for ARM (and possibly other targets) so this patch adds
+a query to Target Lowering to check if this zeroing needs to be kept.
+
+Fixes: https://bugs.llvm.org/show_bug.cgi?id=49092
+
+Differential revision: https://reviews.llvm.org/D96283
+---
+ llvm/include/llvm/CodeGen/TargetLowering.h    |  4 ++
+ llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp |  2 +-
+ llvm/lib/Target/PowerPC/PPCISelLowering.h     |  3 ++
+ .../PowerPC/handle-f16-storage-type.ll        |  4 ++
+ llvm/test/CodeGen/PowerPC/pr48519.ll          |  2 +
+ llvm/test/CodeGen/PowerPC/pr49092.ll          | 39 +++++++++++++++++++
+ 6 files changed, 53 insertions(+), 1 deletion(-)
+ create mode 100644 llvm/test/CodeGen/PowerPC/pr49092.ll
+
+diff --git llvm/include/llvm/CodeGen/TargetLowering.h llvm/include/llvm/CodeGen/TargetLowering.h
+index a8abd2973587..6c1cb1c54d05 100644
+--- llvm/include/llvm/CodeGen/TargetLowering.h
++++ llvm/include/llvm/CodeGen/TargetLowering.h
+@@ -2789,6 +2789,10 @@ public:
+     return false;
+   }
+ 
++  /// Does this target require the clearing of high-order bits in a register
++  /// passed to the fp16 to fp conversion library function.
++  virtual bool shouldKeepZExtForFP16Conv() const { return false; }
++
+   //===--------------------------------------------------------------------===//
+   // Runtime Library hooks
+   //
+diff --git llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
+index a17ac6fe06a2..762f58427649 100644
+--- llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
++++ llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
+@@ -21182,7 +21182,7 @@ SDValue DAGCombiner::visitFP16_TO_FP(SDNode *N) {
+   SDValue N0 = N->getOperand(0);
+ 
+   // fold fp16_to_fp(op & 0xffff) -> fp16_to_fp(op)
+-  if (N0->getOpcode() == ISD::AND) {
++  if (!TLI.shouldKeepZExtForFP16Conv() && N0->getOpcode() == ISD::AND) {
+     ConstantSDNode *AndConst = getAsNonOpaqueConstant(N0.getOperand(1));
+     if (AndConst && AndConst->getAPIntValue() == 0xffff) {
+       return DAG.getNode(ISD::FP16_TO_FP, SDLoc(N), N->getValueType(0),
+diff --git llvm/lib/Target/PowerPC/PPCISelLowering.h llvm/lib/Target/PowerPC/PPCISelLowering.h
+index f1f3cb9e31d9..61e97e6b82d9 100644
+--- llvm/lib/Target/PowerPC/PPCISelLowering.h
++++ llvm/lib/Target/PowerPC/PPCISelLowering.h
+@@ -987,6 +987,9 @@ namespace llvm {
+     shouldExpandBuildVectorWithShuffles(EVT VT,
+                                         unsigned DefinedValues) const override;
+ 
++    // Keep the zero-extensions for arguments to libcalls.
++    bool shouldKeepZExtForFP16Conv() const override { return true; }
++
+     /// createFastISel - This method returns a target-specific FastISel object,
+     /// or null if the target does not support "fast" instruction selection.
+     FastISel *createFastISel(FunctionLoweringInfo &FuncInfo,
+diff --git llvm/test/CodeGen/PowerPC/handle-f16-storage-type.ll llvm/test/CodeGen/PowerPC/handle-f16-storage-type.ll
+index 9977b6b33560..ab19afa2beb5 100644
+--- llvm/test/CodeGen/PowerPC/handle-f16-storage-type.ll
++++ llvm/test/CodeGen/PowerPC/handle-f16-storage-type.ll
+@@ -1156,6 +1156,7 @@ define float @test_sitofp_fadd_i32(i32 %a, half* %b) #0 {
+ ; P8-NEXT:    xscvsxdsp f1, f0
+ ; P8-NEXT:    bl __gnu_f2h_ieee
+ ; P8-NEXT:    nop
++; P8-NEXT:    clrldi r3, r3, 48
+ ; P8-NEXT:    bl __gnu_h2f_ieee
+ ; P8-NEXT:    nop
+ ; P8-NEXT:    xsaddsp f1, f31, f1
+@@ -1175,6 +1176,7 @@ define float @test_sitofp_fadd_i32(i32 %a, half* %b) #0 {
+ ; CHECK-NEXT:    xscvhpdp f0, f0
+ ; CHECK-NEXT:    xscvdphp f1, f1
+ ; CHECK-NEXT:    mffprwz r3, f1
++; CHECK-NEXT:    clrlwi r3, r3, 16
+ ; CHECK-NEXT:    mtfprwz f1, r3
+ ; CHECK-NEXT:    xscvhpdp f1, f1
+ ; CHECK-NEXT:    xsaddsp f1, f0, f1
+@@ -1225,6 +1227,7 @@ define half @PR40273(half) #0 {
+ ; P8-NEXT:    stdu r1, -32(r1)
+ ; P8-NEXT:    bl __gnu_f2h_ieee
+ ; P8-NEXT:    nop
++; P8-NEXT:    clrldi r3, r3, 48
+ ; P8-NEXT:    bl __gnu_h2f_ieee
+ ; P8-NEXT:    nop
+ ; P8-NEXT:    xxlxor f0, f0, f0
+@@ -1245,6 +1248,7 @@ define half @PR40273(half) #0 {
+ ; CHECK-NEXT:    xscvdphp f0, f1
+ ; CHECK-NEXT:    xxlxor f1, f1, f1
+ ; CHECK-NEXT:    mffprwz r3, f0
++; CHECK-NEXT:    clrlwi r3, r3, 16
+ ; CHECK-NEXT:    mtfprwz f0, r3
+ ; CHECK-NEXT:    xscvhpdp f0, f0
+ ; CHECK-NEXT:    fcmpu cr0, f0, f1
+diff --git llvm/test/CodeGen/PowerPC/pr48519.ll llvm/test/CodeGen/PowerPC/pr48519.ll
+index 50970cb185d8..035cc49b93e6 100644
+--- llvm/test/CodeGen/PowerPC/pr48519.ll
++++ llvm/test/CodeGen/PowerPC/pr48519.ll
+@@ -22,6 +22,7 @@ define void @julia__typed_vcat_20() #0 {
+ ; CHECK-NEXT:    xscvsxdsp f1, f0
+ ; CHECK-NEXT:    bl __gnu_f2h_ieee
+ ; CHECK-NEXT:    nop
++; CHECK-NEXT:    clrldi r3, r3, 48
+ ; CHECK-NEXT:    bl __gnu_h2f_ieee
+ ; CHECK-NEXT:    nop
+ ; CHECK-NEXT:    addi r30, r30, -1
+@@ -46,6 +47,7 @@ define void @julia__typed_vcat_20() #0 {
+ ; CHECK-P9-NEXT:    xscvsxdsp f0, f0
+ ; CHECK-P9-NEXT:    xscvdphp f0, f0
+ ; CHECK-P9-NEXT:    mffprwz r3, f0
++; CHECK-P9-NEXT:    clrlwi r3, r3, 16
+ ; CHECK-P9-NEXT:    mtfprwz f0, r3
+ ; CHECK-P9-NEXT:    li r3, 0
+ ; CHECK-P9-NEXT:    xscvhpdp f0, f0
+diff --git llvm/test/CodeGen/PowerPC/pr49092.ll llvm/test/CodeGen/PowerPC/pr49092.ll
+new file mode 100644
+index 000000000000..2fce58418515
+--- /dev/null
++++ llvm/test/CodeGen/PowerPC/pr49092.ll
+@@ -0,0 +1,39 @@
++; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
++; RUN: llc -mcpu=pwr8 -ppc-asm-full-reg-names -ppc-vsr-nums-as-vr \
++; RUN:   -mtriple=powerpc64le-unknown-unknown < %s | FileCheck %s
++; RUN: llc -mcpu=pwr9 -ppc-asm-full-reg-names -ppc-vsr-nums-as-vr \
++; RUN:   -mtriple=powerpc64le-unknown-unknown < %s | FileCheck %s \
++; RUN:   -check-prefix=CHECK-P9
++
++define dso_local half @test2(i64 %a, i64 %b) local_unnamed_addr #0 {
++; CHECK-LABEL: test2:
++; CHECK:       # %bb.0: # %entry
++; CHECK-NEXT:    mflr r0
++; CHECK-NEXT:    std r0, 16(r1)
++; CHECK-NEXT:    stdu r1, -32(r1)
++; CHECK-NEXT:    add r3, r4, r3
++; CHECK-NEXT:    addi r3, r3, 11
++; CHECK-NEXT:    clrlwi r3, r3, 16
++; CHECK-NEXT:    bl __gnu_h2f_ieee
++; CHECK-NEXT:    nop
++; CHECK-NEXT:    addi r1, r1, 32
++; CHECK-NEXT:    ld r0, 16(r1)
++; CHECK-NEXT:    mtlr r0
++; CHECK-NEXT:    blr
++;
++; CHECK-P9-LABEL: test2:
++; CHECK-P9:       # %bb.0: # %entry
++; CHECK-P9-NEXT:    add r3, r4, r3
++; CHECK-P9-NEXT:    addi r3, r3, 11
++; CHECK-P9-NEXT:    clrlwi r3, r3, 16
++; CHECK-P9-NEXT:    mtfprwz f0, r3
++; CHECK-P9-NEXT:    xscvhpdp f1, f0
++; CHECK-P9-NEXT:    blr
++entry:
++  %add = add i64 %b, %a
++  %0 = trunc i64 %add to i16
++  %conv = add i16 %0, 11
++  %call = bitcast i16 %conv to half
++  ret half %call
++}
++attributes #0 = { nounwind }
+-- 
+2.30.0
+
diff --git a/stdlib/libLLVM_jll/Project.toml b/stdlib/libLLVM_jll/Project.toml
index 9918256ae64f6..c572b5c60c25e 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 = "11.0.1+1"
+version = "11.0.1+2"
 
 [deps]
 Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"

From fe155d82de5777b7c33bb7aed97d61982f59b8b7 Mon Sep 17 00:00:00 2001
From: Sheehan Olver <solver@mac.com>
Date: Mon, 15 Feb 2021 17:40:30 +0000
Subject: [PATCH 33/54] UnitRange{Int} -> unitrange (#39668)

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

diff --git a/base/arrayshow.jl b/base/arrayshow.jl
index ecf673da3a764..0b441f8ce5e82 100644
--- a/base/arrayshow.jl
+++ b/base/arrayshow.jl
@@ -385,8 +385,8 @@ function _show_nonempty(io::IO, X::AbstractMatrix, prefix::String)
     indr, indc = axes(X,1), axes(X,2)
     nr, nc = length(indr), length(indc)
     rdots, cdots = false, false
-    rr1, rr2 = UnitRange{Int}(indr), 1:0
-    cr1 = UnitRange{Int}(indc)
+    rr1, rr2 = unitrange(indr), 1:0
+    cr1 = unitrange(indc)
     cr2 = first(cr1) .+ (0:-1)
     if limit
         if nr > 4

From ae95fcc6b05ef519ec9086cf8a6717641e572c85 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Thu, 18 Feb 2021 13:30:25 -0500
Subject: [PATCH 34/54] avoid corrupting String on conversion of StringVector
 to String (#39726)

fix #39717

(cherry picked from commit 0926ed8834827d0bb32c9b5ae013ab74c3e238b9)
---
 src/array.c  |  6 ++++++
 test/core.jl | 10 ++++++++++
 2 files changed, 16 insertions(+)

diff --git a/src/array.c b/src/array.c
index d311e5b152d06..20c6cf7706880 100644
--- a/src/array.c
+++ b/src/array.c
@@ -483,6 +483,12 @@ JL_DLLEXPORT jl_array_t *jl_pchar_to_array(const char *str, size_t len)
 JL_DLLEXPORT jl_value_t *jl_array_to_string(jl_array_t *a)
 {
     size_t len = jl_array_len(a);
+    if (len == 0) {
+        // this may seem like purely an optimization (which it also is), but it
+        // also ensures that calling `String(a)` doesn't corrupt a previous
+        // string also created the same way, where `a = StringVector(_)`.
+        return jl_an_empty_string;
+    }
     if (a->flags.how == 3 && a->offset == 0 && a->elsize == 1 &&
         (jl_array_ndims(a) != 1 ||
          ((a->maxsize + sizeof(void*) + 1 <= GC_MAX_SZCLASS) == (len + sizeof(void*) + 1 <= GC_MAX_SZCLASS)))) {
diff --git a/test/core.jl b/test/core.jl
index 8b492843c2ee2..feea3e4c023df 100644
--- a/test/core.jl
+++ b/test/core.jl
@@ -5298,6 +5298,16 @@ if Sys.WORD_SIZE == 64
     @test_nowarn tester20360()
 end
 
+# issue #39717
+let a = Base.StringVector(2^17)
+    b = String(a)
+    c = String(a)
+    GC.gc()
+    @test sizeof(a) == 0
+    @test sizeof(b) == 2^17
+    @test sizeof(c) == 0
+end
+
 @test_throws ArgumentError eltype(Bottom)
 
 # issue #16424, re-evaluating type definitions

From 73f1cd3bda33bd17f54ab2c183f90f1468d916dc Mon Sep 17 00:00:00 2001
From: Jakob Nybo Nissen <jakobnybonissen@gmail.com>
Date: Thu, 18 Feb 2021 22:32:40 +0100
Subject: [PATCH 35/54] Fix typo in BitVector constructor (#39737)

(cherry picked from commit f07b12b6dfd4037fea0fc8935a04c4bbb5e0c3b4)
---
 base/bitarray.jl | 2 +-
 test/bitarray.jl | 3 +++
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/base/bitarray.jl b/base/bitarray.jl
index acc96f7284a54..6175a492cac75 100644
--- a/base/bitarray.jl
+++ b/base/bitarray.jl
@@ -605,7 +605,7 @@ gen_bitarrayN(::Type{BitVector}, itsz, itr)                        = gen_bitarra
 gen_bitarrayN(::Type{BitVector}, itsz::HasShape{1}, itr)           = gen_bitarray(itsz, itr)
 gen_bitarrayN(::Type{BitArray{N}}, itsz::HasShape{N}, itr) where N = gen_bitarray(itsz, itr)
 # The first of these is just for ambiguity resolution
-gen_bitarrayN(::Type{BitVector}, itsz::HasShape{N}, itr) where N      = throw(DimensionMismatch("cannot create a $T from a $N-dimensional iterator"))
+gen_bitarrayN(::Type{BitVector}, itsz::HasShape{N}, itr) where N      = throw(DimensionMismatch("cannot create a BitVector from a $N-dimensional iterator"))
 gen_bitarrayN(@nospecialize(T::Type), itsz::HasShape{N}, itr) where N = throw(DimensionMismatch("cannot create a $T from a $N-dimensional iterator"))
 gen_bitarrayN(@nospecialize(T::Type), itsz, itr) = throw(DimensionMismatch("cannot create a $T from a generic iterator"))
 
diff --git a/test/bitarray.jl b/test/bitarray.jl
index 23cbeae1ffa5c..f246942452020 100644
--- a/test/bitarray.jl
+++ b/test/bitarray.jl
@@ -198,6 +198,9 @@ timesofar("utils")
                   ((x+y)%5==2 for x = 1:n1 for y = 1:n2))
             @test BitArray(g) == BitArray(collect(g))
         end
+        @test_throws DimensionMismatch BitVector(false)
+        @test_throws DimensionMismatch BitVector((iszero(i%4) for i in 1:n1, j in 1:n2))
+        @test_throws DimensionMismatch BitMatrix((isodd(i) for i in 1:3))
     end
 
     @testset "constructor from NTuple" begin

From 24ed37ff800b24448e282e853119d0d71a681d93 Mon Sep 17 00:00:00 2001
From: Tim Holy <tim.holy@gmail.com>
Date: Fri, 19 Feb 2021 05:46:18 -0600
Subject: [PATCH 36/54] Protect handle_message from Integer subtype
 invalidation (#39689)

Resolves https://github.com/SciML/ArrayInterface.jl/issues/121.
There is a cost, but hopefully there's no strong need to supply
`maxlog` using whacky subtypes of Integer.

(cherry picked from commit 67b9d4db2f699afacf9265d7906f97d9e8b26689)
---
 base/logging.jl                     | 2 +-
 stdlib/Logging/src/ConsoleLogger.jl | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/base/logging.jl b/base/logging.jl
index 1727fc8b16f76..72594f557ce20 100644
--- a/base/logging.jl
+++ b/base/logging.jl
@@ -638,7 +638,7 @@ function handle_message(logger::SimpleLogger, level::LogLevel, message, _module,
                         filepath, line; kwargs...)
     @nospecialize
     maxlog = get(kwargs, :maxlog, nothing)
-    if maxlog isa Integer
+    if maxlog isa Core.BuiltinInts
         remaining = get!(logger.message_limits, id, Int(maxlog)::Int)
         logger.message_limits[id] = remaining - 1
         remaining > 0 || return
diff --git a/stdlib/Logging/src/ConsoleLogger.jl b/stdlib/Logging/src/ConsoleLogger.jl
index ac4b17b59e14a..b3f86774a6ef3 100644
--- a/stdlib/Logging/src/ConsoleLogger.jl
+++ b/stdlib/Logging/src/ConsoleLogger.jl
@@ -101,7 +101,7 @@ function handle_message(logger::ConsoleLogger, level::LogLevel, message, _module
     @nospecialize
     hasmaxlog = haskey(kwargs, :maxlog) ? 1 : 0
     maxlog = get(kwargs, :maxlog, nothing)
-    if maxlog isa Integer
+    if maxlog isa Core.BuiltinInts
         remaining = get!(logger.message_limits, id, Int(maxlog)::Int)
         logger.message_limits[id] = remaining - 1
         remaining > 0 || return

From 65dbb778bcad178a8266dbc014dc12e0ea986dfb Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Sun, 21 Feb 2021 18:41:12 -0500
Subject: [PATCH 37/54] codegen: define return_roots in normalized form
 (#39745)

LLVM will switch to this form, so it is preferable to start that way.

Refs Matcha in #39641

(cherry picked from commit f879cd159da8cb6110028702b787e6e7f816ca12)
---
 src/codegen.cpp               | 18 +++++++++---------
 src/llvm-late-gc-lowering.cpp |  8 ++++----
 2 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/src/codegen.cpp b/src/codegen.cpp
index b6e52ecbd6091..02076a82e9909 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -3307,8 +3307,7 @@ static jl_cgval_t emit_call_specfun_other(jl_codectx_t &ctx, jl_method_instance_
     }
 
     if (returninfo.return_roots) {
-        AllocaInst *return_roots = emit_static_alloca(ctx, T_prjlvalue);
-        return_roots->setOperand(0, ConstantInt::get(T_int32, returninfo.return_roots));
+        AllocaInst *return_roots = emit_static_alloca(ctx, ArrayType::get(T_prjlvalue, returninfo.return_roots));
         argvals[idx] = return_roots;
         idx++;
     }
@@ -4708,8 +4707,11 @@ static void emit_cfunc_invalidate(
         break;
     }
     case jl_returninfo_t::SRet: {
-        if (return_roots)
-            ctx.builder.CreateStore(gf_ret, gf_thunk->arg_begin() + 1);
+        if (return_roots) {
+            Value *root1 = gf_thunk->arg_begin() + 1; // root1 has type [n x {}*]*
+            root1 = ctx.builder.CreateConstInBoundsGEP2_32(root1->getType()->getPointerElementType(), root1, 0, 0);
+            ctx.builder.CreateStore(gf_ret, root1);
+        }
         emit_memcpy(ctx, &*gf_thunk->arg_begin(), nullptr, gf_ret, nullptr, jl_datatype_size(rettype), julia_alignment(rettype));
         ctx.builder.CreateRetVoid();
         break;
@@ -5085,8 +5087,7 @@ static Function* gen_cfun_wrapper(
             args.push_back(result);
         }
         if (returninfo.return_roots) {
-            AllocaInst *return_roots = emit_static_alloca(ctx, T_prjlvalue);
-            return_roots->setOperand(0, ConstantInt::get(T_int32, returninfo.return_roots));
+            AllocaInst *return_roots = emit_static_alloca(ctx, ArrayType::get(T_prjlvalue, returninfo.return_roots));
             args.push_back(return_roots);
         }
         for (size_t i = 0; i < nargs + 1; i++) {
@@ -5506,8 +5507,7 @@ static Function *gen_invoke_wrapper(jl_method_instance_t *lam, jl_value_t *jlret
         break;
     }
     if (f.return_roots) {
-        AllocaInst *return_roots = emit_static_alloca(ctx, T_prjlvalue);
-        return_roots->setOperand(0, ConstantInt::get(T_int32, f.return_roots));
+        AllocaInst *return_roots = emit_static_alloca(ctx, ArrayType::get(T_prjlvalue, f.return_roots));
         args[idx] = return_roots;
         idx++;
     }
@@ -5654,7 +5654,7 @@ static jl_returninfo_t get_specsig_function(jl_codectx_t &ctx, Module *M, String
     }
 
     if (props.return_roots) {
-        fsig.push_back(T_pprjlvalue);
+        fsig.push_back(ArrayType::get(T_prjlvalue, props.return_roots)->getPointerTo(0));
         unsigned argno = fsig.size();
         attributes = attributes.addAttribute(jl_LLVMContext, argno, Attribute::NoAlias);
         attributes = attributes.addAttribute(jl_LLVMContext, argno, Attribute::NoCapture);
diff --git a/src/llvm-late-gc-lowering.cpp b/src/llvm-late-gc-lowering.cpp
index bf842a1182678..99ff45cf61815 100644
--- a/src/llvm-late-gc-lowering.cpp
+++ b/src/llvm-late-gc-lowering.cpp
@@ -1762,8 +1762,8 @@ unsigned TrackWithShadow(Value *Src, Type *STy, bool isptr, Value *Dst, IRBuilde
     auto Ptrs = ExtractTrackedValues(Src, STy, isptr, irbuilder);
     for (unsigned i = 0; i < Ptrs.size(); ++i) {
         Value *Elem = Ptrs[i];
-        assert(Elem->getType()->isPointerTy());
-        Value *Slot = irbuilder.CreateConstInBoundsGEP1_32(Elem->getType(), Dst, i);
+        Type *ET = Dst->getType()->getPointerElementType(); // Dst has type `[n x {}*]*`
+        Value *Slot = irbuilder.CreateConstInBoundsGEP2_32(ET, Dst, 0, i);
         StoreInst *shadowStore = irbuilder.CreateAlignedStore(Elem, Slot, Align(sizeof(void*)));
         shadowStore->setOrdering(AtomicOrdering::NotAtomic);
         // TODO: shadowStore->setMetadata(LLVMContext::MD_tbaa, tbaa_gcframe);
@@ -1790,7 +1790,7 @@ void LateLowerGCFrame::MaybeTrackDst(State &S, MemTransferInst *MI) {
     //            Src = new BitCastInst(Src, STy->getPointerTo(MI->getSourceAddressSpace()), "", MI);
     //            auto &Shadow = S.ShadowAllocas[AI];
     //            if (!Shadow)
-    //                Shadow = new AllocaInst(T_prjlvalue, 0, ConstantInt::get(T_int32, nroots), "", MI);
+    //                Shadow = new AllocaInst(ArrayType::get(T_prjlvalue, nroots), 0, "", MI);
     //            AI = Shadow;
     //            unsigned count = TrackWithShadow(Src, STy, true, AI, IRBuilder<>(MI));
     //            assert(count == tracked.count); (void)count;
@@ -1826,7 +1826,7 @@ void LateLowerGCFrame::MaybeTrackStore(State &S, StoreInst *I) {
     // track the Store with a Shadow
     //auto &Shadow = S.ShadowAllocas[AI];
     //if (!Shadow)
-    //    Shadow = new AllocaInst(T_prjlvalue, 0, ConstantInt::get(T_int32, tracked.count), "", MI);
+    //    Shadow = new AllocaInst(ArrayType::get(T_prjlvalue, tracked.count), 0, "", MI);
     //AI = Shadow;
     //Value *Src = I->getValueOperand();
     //unsigned count = TrackWithShadow(Src, Src->getType(), false, AI, MI, TODO which slots are we actually clobbering?);

From 171f7e6c099ba6633ad7ef462d44745ae5d71820 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Sun, 21 Feb 2021 18:41:22 -0500
Subject: [PATCH 38/54] codegen: guard phi node loads of invalid inputs
 (#39747)

At runtime, it is prohibited to observe these values, but we need to
make sure they are not reading through undefined pointers (and
potentially trying to GC-root the memory there)

Refs ChainRules in #39641

(cherry picked from commit fdd26337fde20b3470f8f3eeb9026b1b05394b36)
---
 src/codegen.cpp | 43 ++++++++++++++++++++++++++++++++-----------
 1 file changed, 32 insertions(+), 11 deletions(-)

diff --git a/src/codegen.cpp b/src/codegen.cpp
index 02076a82e9909..817aceddfe403 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -2336,8 +2336,13 @@ static jl_cgval_t emit_getfield(jl_codectx_t &ctx, const jl_cgval_t &strct, jl_s
 }
 
 template<typename Func>
-static Value *emit_guarded_test(jl_codectx_t &ctx, Value *ifnot, bool defval, Func &&func)
+static Value *emit_guarded_test(jl_codectx_t &ctx, Value *ifnot, Constant *defval, Func &&func)
 {
+    if (auto Cond = dyn_cast<ConstantInt>(ifnot)) {
+        if (Cond->isZero())
+            return defval;
+        return func();
+    }
     BasicBlock *currBB = ctx.builder.GetInsertBlock();
     BasicBlock *passBB = BasicBlock::Create(jl_LLVMContext, "guard_pass", ctx.f);
     BasicBlock *exitBB = BasicBlock::Create(jl_LLVMContext, "guard_exit", ctx.f);
@@ -2347,12 +2352,20 @@ static Value *emit_guarded_test(jl_codectx_t &ctx, Value *ifnot, bool defval, Fu
     passBB = ctx.builder.GetInsertBlock();
     ctx.builder.CreateBr(exitBB);
     ctx.builder.SetInsertPoint(exitBB);
-    PHINode *phi = ctx.builder.CreatePHI(T_int1, 2);
-    phi->addIncoming(ConstantInt::get(T_int1, defval), currBB);
+    if (defval == nullptr)
+        return nullptr;
+    PHINode *phi = ctx.builder.CreatePHI(defval->getType(), 2);
+    phi->addIncoming(defval, currBB);
     phi->addIncoming(res, passBB);
     return phi;
 }
 
+template<typename Func>
+static Value *emit_guarded_test(jl_codectx_t &ctx, Value *ifnot, bool defval, Func &&func)
+{
+    return emit_guarded_test(ctx, ifnot, ConstantInt::get(T_int1, defval), func);
+}
+
 template<typename Func>
 static Value *emit_nullcheck_guard(jl_codectx_t &ctx, Value *nullcheck, Func &&func)
 {
@@ -6842,7 +6855,7 @@ static std::pair<std::unique_ptr<Module>, jl_llvm_functions_t>
 
     auto undef_value_for_type = [&](Type *T) {
         auto tracked = CountTrackedPointers(T);
-        Value *undef;
+        Constant *undef;
         if (tracked.count)
             // make sure gc pointers (including ptr_phi of union-split) are initialized to NULL
             undef = Constant::getNullValue(T);
@@ -6925,23 +6938,31 @@ static std::pair<std::unique_ptr<Module>, jl_llvm_functions_t>
                     if (val.typ == (jl_value_t*)jl_bottom_type) {
                         V = undef_value_for_type(VN->getType());
                     }
-                    else if (VN && VN->getType() == T_prjlvalue) {
+                    else if (VN->getType() == T_prjlvalue) {
                         // Includes the jl_is_uniontype(phiType) && !TindexN case
+                        // TODO: if convert_julia_type says it is wasted effort and to skip it, is it worth using V_rnull (dynamically)?
                         V = boxed(ctx, val);
                     }
                     else {
-                        // XXX: must emit undef here (rather than a bitcast or
-                        //      load of val) if the runtime type of val isn't phiType
-                        V = emit_unbox(ctx, VN->getType(), val, phiType);
+                        // must be careful to emit undef here (rather than a bitcast or
+                        // load of val) if the runtime type of val isn't phiType
+                        Value *isvalid = emit_isa(ctx, val, phiType, NULL).first;
+                        V = emit_guarded_test(ctx, isvalid, undef_value_for_type(VN->getType()), [&] {
+                            return emit_unbox(ctx, VN->getType(), val, phiType);
+                        });
                     }
                     VN->addIncoming(V, ctx.builder.GetInsertBlock());
                     assert(!TindexN);
                 }
                 else if (dest && val.typ != (jl_value_t*)jl_bottom_type) {
-                    // XXX: must emit undef here (rather than a bitcast or
-                    //      load of val) if the runtime type of val isn't phiType
+                    // must be careful to emit undef here (rather than a bitcast or
+                    // load of val) if the runtime type of val isn't phiType
                     assert(lty != T_prjlvalue);
-                    (void)emit_unbox(ctx, lty, val, phiType, maybe_decay_tracked(ctx, dest));
+                    Value *isvalid = emit_isa(ctx, val, phiType, NULL).first;
+                    emit_guarded_test(ctx, isvalid, nullptr, [&] {
+                        (void)emit_unbox(ctx, lty, val, phiType, maybe_decay_tracked(ctx, dest));
+                        return nullptr;
+                    });
                 }
             }
             else {

From df40b3502c30b3edcbeca83351fec027adb0046c Mon Sep 17 00:00:00 2001
From: kimikage <kimikage.ceo@gmail.com>
Date: Mon, 22 Feb 2021 09:39:36 +0900
Subject: [PATCH 39/54] Change Windows CRT func to be considered as libjulia
 func (#39636)

This prefers crtdll over ntdll.
This supports the specialization of `memcpy` ccall on Windows.

(cherry picked from commit 5945f4d659cc02f887602eaa281b1f2dd0cee263)
---
 src/ccall.cpp | 19 ++++++++++++++++++-
 src/dlload.c  | 31 +++++++++++++++++++++----------
 src/init.c    |  7 ++-----
 test/ccall.jl | 13 +++++++++++++
 4 files changed, 54 insertions(+), 16 deletions(-)

diff --git a/src/ccall.cpp b/src/ccall.cpp
index 65c0fa74c9ace..ac59279a8a825 100644
--- a/src/ccall.cpp
+++ b/src/ccall.cpp
@@ -5,6 +5,10 @@
 #include <llvm/Bitcode/BitcodeReader.h>
 #include <llvm/Linker/Linker.h>
 
+#ifdef _OS_WINDOWS_
+extern const char jl_crtdll_basename[];
+#endif
+
 // somewhat unusual variable, in that aotcompile wants to get the address of this for a sanity check
 GlobalVariable *jl_emit_RTLD_DEFAULT_var(Module *M)
 {
@@ -1266,7 +1270,20 @@ static jl_cgval_t emit_ccall(jl_codectx_t &ctx, jl_value_t **args, size_t nargs)
     auto _is_libjulia_func = [&] (uintptr_t ptr, const char *name) {
         if ((uintptr_t)fptr == ptr)
             return true;
-        return (!f_lib || f_lib == JL_LIBJULIA_INTERNAL_DL_LIBNAME) && f_name && !strcmp(f_name, name);
+        if (f_lib) {
+#ifdef _OS_WINDOWS_
+            if ((f_lib == JL_EXE_LIBNAME) || // preventing invalid pointer access
+                (f_lib == JL_LIBJULIA_INTERNAL_DL_LIBNAME) ||
+                (!strcmp(f_lib, jl_crtdll_basename))) {
+                // libjulia-like
+            }
+            else
+                return false;
+#else
+            return false;
+#endif
+        }
+        return f_name && !strcmp(f_name, name);
     };
 #define is_libjulia_func(name) _is_libjulia_func((uintptr_t)&(name), #name)
 
diff --git a/src/dlload.c b/src/dlload.c
index 22017708515db..ecb34d2be57e3 100644
--- a/src/dlload.c
+++ b/src/dlload.c
@@ -57,6 +57,25 @@ static int endswith_extension(const char *path) JL_NOTSAFEPOINT
     return 0;
 }
 
+#ifdef _OS_WINDOWS_
+#ifdef _MSC_VER
+#if (_MSC_VER >= 1930) || (_MSC_VER < 1800)
+#error This version of MSVC has not been tested.
+#elif _MSC_VER >= 1900 // VC++ 2015 / 2017 / 2019
+#define CRTDLL_BASENAME "vcruntime140"
+#elif _MSC_VER >= 1800 // VC++ 2013
+#define CRTDLL_BASENAME "msvcr120"
+#endif
+#else
+#define CRTDLL_BASENAME "msvcrt"
+#endif
+
+const char jl_crtdll_basename[] = CRTDLL_BASENAME;
+const char jl_crtdll_name[] = CRTDLL_BASENAME ".dll";
+
+#undef CRTDLL_BASENAME
+#endif
+
 #define PATHBUF 4096
 
 #define JL_RTLD(flags, FLAG) (flags & JL_RTLD_ ## FLAG ? RTLD_ ## FLAG : 0)
@@ -314,18 +333,10 @@ const char *jl_dlfind_win32(const char *f_name)
         return JL_LIBJULIA_DL_LIBNAME;
     if (jl_dlsym(jl_kernel32_handle, f_name, &dummy, 0))
         return "kernel32";
+    if (jl_dlsym(jl_crtdll_handle, f_name, &dummy, 0)) // Prefer crtdll over ntdll
+        return jl_crtdll_basename;
     if (jl_dlsym(jl_ntdll_handle, f_name, &dummy, 0))
         return "ntdll";
-    if (jl_dlsym(jl_crtdll_handle, f_name, &dummy, 0))
-#if defined(_MSC_VER)
-#if _MSC_VER == 1800
-        return "msvcr120";
-#else
-#error This version of MSVC has not been tested.
-#endif
-#else
-        return "msvcrt";
-#endif
     if (jl_dlsym(jl_winsock_handle, f_name, &dummy, 0))
         return "ws2_32";
     // additional common libraries (libc?) could be added here, but in general,
diff --git a/src/init.c b/src/init.c
index 45c293c8873c0..f66403c58199c 100644
--- a/src/init.c
+++ b/src/init.c
@@ -302,6 +302,7 @@ void *jl_ntdll_handle;
 void *jl_kernel32_handle;
 void *jl_crtdll_handle;
 void *jl_winsock_handle;
+extern const char jl_crtdll_name[];
 #endif
 
 uv_loop_t *jl_io_loop;
@@ -665,11 +666,7 @@ void _julia_init(JL_IMAGE_SEARCH rel)
 #ifdef _OS_WINDOWS_
     jl_ntdll_handle = jl_dlopen("ntdll.dll", 0); // bypass julia's pathchecking for system dlls
     jl_kernel32_handle = jl_dlopen("kernel32.dll", 0);
-#if defined(_MSC_VER) && _MSC_VER == 1800
-    jl_crtdll_handle = jl_dlopen("msvcr120.dll", 0);
-#else
-    jl_crtdll_handle = jl_dlopen("msvcrt.dll", 0);
-#endif
+    jl_crtdll_handle = jl_dlopen(jl_crtdll_name, 0);
     jl_winsock_handle = jl_dlopen("ws2_32.dll", 0);
     jl_exe_handle = GetModuleHandleA(NULL);
     JL_MUTEX_INIT(&jl_in_stackwalk);
diff --git a/test/ccall.jl b/test/ccall.jl
index c8484579929e1..c81d2945f5c74 100644
--- a/test/ccall.jl
+++ b/test/ccall.jl
@@ -1576,6 +1576,19 @@ let
     @test arr[1] == '0'
 end
 
+# issue #38751
+let
+    function f38751!(dest::Vector{UInt8}, src::Vector{UInt8}, n::UInt)
+        d, s = pointer(dest), pointer(src)
+        GC.@preserve dest src ccall(:memcpy, Cvoid, (Ptr{UInt8}, Ptr{UInt8}, Csize_t), d, s, n)
+        return dest
+    end
+    dest = zeros(UInt8, 8)
+    @test f38751!(dest, collect(0x1:0x8), UInt(8)) == 0x1:0x8
+    llvm = sprint(code_llvm, f38751!, (Vector{UInt8}, Vector{UInt8}, UInt))
+    @test !occursin("call void inttoptr", llvm)
+end
+
 # issue #34061
 let o_file = tempname(), err = Base.PipeEndpoint()
     run(pipeline(Cmd(`$(Base.julia_cmd()) --output-o=$o_file -e 'Base.reinit_stdio();

From 8456a426023b58062aa72874d8777b26d22c3ddc Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Sun, 21 Feb 2021 23:56:12 -0500
Subject: [PATCH 40/54] fix type uniquing (caching) in incremental deserializer
 (#39744)

Fixes #39688

(cherry picked from commit 6d4e6979533d0de8c5b21683f9e9fc0bbf017990)
---
 src/dump.c         | 6 +++---
 test/precompile.jl | 2 ++
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/dump.c b/src/dump.c
index 44ed6b0604479..aba97fe317657 100644
--- a/src/dump.c
+++ b/src/dump.c
@@ -196,7 +196,7 @@ static void jl_serialize_datatype(jl_serializer_state *s, jl_datatype_t *dt) JL_
     if (!internal && jl_unwrap_unionall(dt->name->wrapper) == (jl_value_t*)dt) {
         tag = 6; // external primary type
     }
-    else if (!dt->isconcretetype) {
+    else if (jl_is_tuple_type(dt) ? !dt->isconcretetype : dt->hasfreetypevars) {
         tag = 0; // normal struct
     }
     else if (internal) {
@@ -212,8 +212,8 @@ static void jl_serialize_datatype(jl_serializer_state *s, jl_datatype_t *dt) JL_
         tag = 11; // external, but definitely new (still needs caching, but not full unique-ing)
     }
     else {
-        // this'll need unique-ing later
-        // flag this in the backref table as special
+        // this is eligible for (and possibly requires) unique-ing later,
+        // so flag this in the backref table as special
         uintptr_t *bp = (uintptr_t*)ptrhash_bp(&backref_table, dt);
         assert(*bp != (uintptr_t)HT_NOTFOUND);
         *bp |= 1;
diff --git a/test/precompile.jl b/test/precompile.jl
index d0285cf77901e..2fcad7f64113c 100644
--- a/test/precompile.jl
+++ b/test/precompile.jl
@@ -95,6 +95,7 @@ precompile_test_harness(false) do dir
               const t17809s = Any[
                     Tuple{
                         Type{Ptr{MyType{i}}},
+                        Ptr{Type{MyType{i}}},
                         Array{Ptr{MyType{MyType{:sym}()}}(0), 0},
                         Val{Complex{Int}(1, 2)},
                         Val{3},
@@ -341,6 +342,7 @@ precompile_test_harness(false) do dir
         @test all(i -> Foo.t17809s[i + 1] ===
             Tuple{
                 Type{Ptr{Foo.MyType{i}}},
+                Ptr{Type{Foo.MyType{i}}},
                 Array{Ptr{Foo.MyType{Foo.MyType{:sym}()}}(0), 0},
                 Val{Complex{Int}(1, 2)},
                 Val{3},

From dcc2a2df14f6aea9f458b75b26b5d8ca6068f550 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Thu, 18 Feb 2021 01:59:49 -0500
Subject: [PATCH 41/54] ensure to show the whole type, even if the proper
 subset matched an alias

This code should only have been active for make_typealiases, but #38099
already fixed that better, so we can just remove this now.

Fixes #39723

(cherry picked from commit b72966751e13f6e4c7571b33d3675d225d29d940)
---
 base/show.jl | 22 +++++-----------------
 test/show.jl |  7 ++++++-
 2 files changed, 11 insertions(+), 18 deletions(-)

diff --git a/base/show.jl b/base/show.jl
index 2fbc8f50ee737..79ac682f9e22d 100644
--- a/base/show.jl
+++ b/base/show.jl
@@ -522,26 +522,12 @@ function makeproper(io::IO, x::Type)
             end
         end
     end
-    if x isa Union
-        y = []
-        normal = true
-        for typ in uniontypes(x)
-            if isa(typ, TypeVar)
-                normal = false
-            else
-                push!(y, typ)
-            end
-        end
-        if !normal
-            properx = rewrap_unionall(Union{y...}, properx)
-        end
-    end
     has_free_typevars(properx) && return Any
     return properx
 end
 
 function make_typealias(@nospecialize(x::Type))
-    Any <: x && return
+    Any === x && return
     x <: Tuple && return
     mods = modulesof!(Set{Module}(), x)
     Core in mods && push!(mods, Base)
@@ -681,7 +667,7 @@ function show_typealias(io::IO, x::Type)
 end
 
 function make_typealiases(@nospecialize(x::Type))
-    Any <: x && return Core.svec(), Union{}
+    Any === x && return Core.svec(), Union{}
     x <: Tuple && return Core.svec(), Union{}
     mods = modulesof!(Set{Module}(), x)
     Core in mods && push!(mods, Base)
@@ -701,7 +687,9 @@ function make_typealiases(@nospecialize(x::Type))
                 if alias isa Type && !has_free_typevars(alias) && !isvarargtype(alias) && !print_without_params(alias) && !(alias <: Tuple)
                     (ti, env) = ccall(:jl_type_intersection_with_env, Any, (Any, Any), x, alias)::SimpleVector
                     ti === Union{} && continue
-                    mod in modulesof!(Set{Module}(), alias) || continue # make sure this alias wasn't from an unrelated part of the Union
+                    # make sure this alias wasn't from an unrelated part of the Union
+                    mod2 = modulesof!(Set{Module}(), alias)
+                    mod in mod2 || (mod === Base && Core in mods) || continue
                     env = env::SimpleVector
                     applied = alias
                     if !isempty(env)
diff --git a/test/show.jl b/test/show.jl
index b0bc4455d990a..83cee00125702 100644
--- a/test/show.jl
+++ b/test/show.jl
@@ -2070,12 +2070,13 @@ end
 end
 
 module M37012
-export AValue, B2
+export AValue, B2, SimpleU
 struct AnInteger{S<:Integer} end
 struct AStruct{N} end
 const AValue{S} = Union{AStruct{S}, AnInteger{S}}
 struct BStruct{T,S} end
 const B2{S,T} = BStruct{T,S}
+const SimpleU = Union{AnInteger, AStruct, BStruct}
 end
 @test Base.make_typealias(M37012.AStruct{1}) === nothing
 @test isempty(Base.make_typealiases(M37012.AStruct{1})[1])
@@ -2085,6 +2086,10 @@ end
 @test string(M37012.BStruct{T, T} where T) == "$(curmod_prefix)M37012.B2{T, T} where T"
 @test string(M37012.BStruct{T, S} where {T<:Unsigned, S<:Signed}) == "$(curmod_prefix)M37012.B2{S, T} where {T<:Unsigned, S<:Signed}"
 @test string(M37012.BStruct{T, S} where {T<:Signed, S<:T}) == "$(curmod_prefix)M37012.B2{S, T} where {T<:Signed, S<:T}"
+@test string(Union{M37012.SimpleU, Nothing}) == "Union{Nothing, $(curmod_prefix)M37012.SimpleU}"
+@test string(Union{M37012.SimpleU, Nothing, T} where T) == "Union{Nothing, T, $(curmod_prefix)M37012.SimpleU} where T"
+@test string(Union{AbstractVector{T}, T} where T) == "Union{AbstractVector{T}, T} where T"
+@test string(Union{AbstractVector, T} where T) == "Union{T, AbstractVector{T} where T} where T"
 
 @test sprint(show, :(./)) == ":((./))"
 @test sprint(show, :((.|).(.&, b))) == ":((.|).((.&), b))"

From df057a1e46a96f2fa378d0b797febd9508b29c0e Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Thu, 18 Feb 2021 02:25:04 -0500
Subject: [PATCH 42/54] when showing union aliases, keep TypeVars last

(cherry picked from commit edd3c8790abb684cd1dd90a474cfa074059821fa)
---
 base/show.jl | 27 ++++++++++++++++++++-------
 test/show.jl |  4 ++--
 2 files changed, 22 insertions(+), 9 deletions(-)

diff --git a/base/show.jl b/base/show.jl
index 79ac682f9e22d..da50172109846 100644
--- a/base/show.jl
+++ b/base/show.jl
@@ -749,16 +749,21 @@ end
 function show_unionaliases(io::IO, x::Union)
     properx = makeproper(io, x)
     aliases, applied = make_typealiases(properx)
+    isempty(aliases) && return false
     first = true
+    tvar = false
     for typ in uniontypes(x)
-        if !isa(typ, TypeVar) && rewrap_unionall(typ, properx) <: applied
+        if isa(typ, TypeVar)
+            tvar = true # sort bare TypeVars to the end
+            continue
+        elseif rewrap_unionall(typ, properx) <: applied
             continue
         end
         print(io, first ? "Union{" : ", ")
         first = false
         show(io, typ)
     end
-    if first && length(aliases) == 1
+    if first && !tvar && length(aliases) == 1
         alias = aliases[1]
         wheres = make_wheres(io, alias[2], x)
         show_typealias(io, alias[1], x, alias[2], wheres)
@@ -772,8 +777,17 @@ function show_unionaliases(io::IO, x::Union)
             show_typealias(io, alias[1], x, alias[2], wheres)
             show_wheres(io, wheres)
         end
+        if tvar
+            for typ in uniontypes(x)
+                if isa(typ, TypeVar)
+                    print(io, ", ")
+                    show(io, typ)
+                end
+            end
+        end
         print(io, "}")
     end
+    return true
 end
 
 function show(io::IO, ::MIME"text/plain", @nospecialize(x::Type))
@@ -805,12 +819,11 @@ function show(io::IO, @nospecialize(x::Type))
         show_datatype(io, x)
         return
     elseif x isa Union
-        if get(io, :compact, true)
-            show_unionaliases(io, x)
-        else
-            print(io, "Union")
-            show_delim_array(io, uniontypes(x), '{', ',', '}', false)
+        if get(io, :compact, true) && show_unionaliases(io, x)
+            return
         end
+        print(io, "Union")
+        show_delim_array(io, uniontypes(x), '{', ',', '}', false)
         return
     end
 
diff --git a/test/show.jl b/test/show.jl
index 83cee00125702..62388b5ae6613 100644
--- a/test/show.jl
+++ b/test/show.jl
@@ -2087,9 +2087,9 @@ end
 @test string(M37012.BStruct{T, S} where {T<:Unsigned, S<:Signed}) == "$(curmod_prefix)M37012.B2{S, T} where {T<:Unsigned, S<:Signed}"
 @test string(M37012.BStruct{T, S} where {T<:Signed, S<:T}) == "$(curmod_prefix)M37012.B2{S, T} where {T<:Signed, S<:T}"
 @test string(Union{M37012.SimpleU, Nothing}) == "Union{Nothing, $(curmod_prefix)M37012.SimpleU}"
-@test string(Union{M37012.SimpleU, Nothing, T} where T) == "Union{Nothing, T, $(curmod_prefix)M37012.SimpleU} where T"
+@test string(Union{M37012.SimpleU, Nothing, T} where T) == "Union{Nothing, $(curmod_prefix)M37012.SimpleU, T} where T"
 @test string(Union{AbstractVector{T}, T} where T) == "Union{AbstractVector{T}, T} where T"
-@test string(Union{AbstractVector, T} where T) == "Union{T, AbstractVector{T} where T} where T"
+@test string(Union{AbstractVector, T} where T) == "Union{AbstractVector{T} where T, T} where T"
 
 @test sprint(show, :(./)) == ":((./))"
 @test sprint(show, :((.|).(.&, b))) == ":((.|).((.&), b))"

From f6a471c64d9e1fde6c1ef64c0472c52aad73ea66 Mon Sep 17 00:00:00 2001
From: kimikage <kimikage.ceo@gmail.com>
Date: Tue, 23 Feb 2021 11:25:59 +0900
Subject: [PATCH 43/54] [libgit2] Fix zlib stream abandonment causing clone
 error on 32-bit systems (#39772)

This backports libgit2 patch to fix zlib stream handling.

(cherry picked from commit 503c63b2555a7b85cfc056de5ce614e326ec590d)
---
 deps/Versions.make                       |  2 +-
 deps/checksums/libgit2                   | 64 ++++++++++++------------
 deps/libgit2.mk                          |  9 +++-
 deps/patches/libgit2-continue-zlib.patch | 43 ++++++++++++++++
 stdlib/LibGit2_jll/Project.toml          |  2 +-
 5 files changed, 85 insertions(+), 35 deletions(-)
 create mode 100644 deps/patches/libgit2-continue-zlib.patch

diff --git a/deps/Versions.make b/deps/Versions.make
index bb49a0624584d..73449748b0fe7 100644
--- a/deps/Versions.make
+++ b/deps/Versions.make
@@ -33,7 +33,7 @@ CURL_JLL_NAME := LibCURL
 LAPACK_VER := 3.9.0
 
 # LibGit2
-LIBGIT2_JLL_VER := 1.2.2+0
+LIBGIT2_JLL_VER := 1.2.3+0
 LIBGIT2_JLL_NAME := LibGit2
 
 # LibSSH2
diff --git a/deps/checksums/libgit2 b/deps/checksums/libgit2
index 740604792a55b..fbb404eb050e6 100644
--- a/deps/checksums/libgit2
+++ b/deps/checksums/libgit2
@@ -1,34 +1,34 @@
 libgit2-7f4fa178629d559c037a1f72f79f79af9c1ef8ce.tar.gz/md5/c6a819fb0bf924df61e1595624a0988a
 libgit2-7f4fa178629d559c037a1f72f79f79af9c1ef8ce.tar.gz/sha512/3de9c042115b309dae3b8e0008edf2e762addd90a7bdb54b3cf634811271ab9dbfea35656650eb53a3faec73caf33ed199fb885ec21f611c79d909d9f4fe48c5
-LibGit2.v1.2.2+0.aarch64-apple-darwin.tar.gz/md5/768643046e35a7594f731323bebad389
-LibGit2.v1.2.2+0.aarch64-apple-darwin.tar.gz/sha512/7ff1e0eeb2651064cf530468206335bffbc87b13fc310de7f1d0b802b4a53d5aed9267053edeb59b6b2f2ce90548c3a3e90f8f657cb8206eaa19dbe6be065723
-LibGit2.v1.2.2+0.aarch64-linux-gnu.tar.gz/md5/be6570490bbdac65b35c6ab8d8a109df
-LibGit2.v1.2.2+0.aarch64-linux-gnu.tar.gz/sha512/d70c5bf5032f5b48992690951aa3a105341476ca7b2c25b706d03425c0b6323fbb8060c8dffec191721f2ecaa7eeb6cf9cd38d30cd29095443c14d6cc44744f2
-LibGit2.v1.2.2+0.aarch64-linux-musl.tar.gz/md5/d4f7c9d31e1008a08e07eee3ac6a6b46
-LibGit2.v1.2.2+0.aarch64-linux-musl.tar.gz/sha512/bd6b9c0ef8d9b4747594516df0e89f62ae42d0c96dc821428bf554f4bfcd843fb7f54999ea8a445dcbf3ca94096bf2f977311266310fa9928955c57bc78c64a6
-LibGit2.v1.2.2+0.armv6l-linux-gnueabihf.tar.gz/md5/1d50d2d1b3a67a0ad5212473c4421903
-LibGit2.v1.2.2+0.armv6l-linux-gnueabihf.tar.gz/sha512/10fca34a941a62631175b43cb662fde498104ebfa70a12271f319cb5c295dfafd02ce9a0a1cd3c677ccd253811102f32bba46b9e7935aafc63d49db18bc1d930
-LibGit2.v1.2.2+0.armv6l-linux-musleabihf.tar.gz/md5/43bf610eb0ebd793f914c47924b022e0
-LibGit2.v1.2.2+0.armv6l-linux-musleabihf.tar.gz/sha512/5594c836a2e8ea8be7c85ca6063401f8141edf87bd156460792f1d0f21002cf685cea1872edbf7c18412c3201754f350d6c3520c453763041abaf36e53d9a04b
-LibGit2.v1.2.2+0.armv7l-linux-gnueabihf.tar.gz/md5/e0bb95d822e616dce731e0eae26f015b
-LibGit2.v1.2.2+0.armv7l-linux-gnueabihf.tar.gz/sha512/855b7116a52e8a53789697d69c45470d102ed70a9bf6b8ec87370c0bdd530b9e1178ff18fe270f46113e099a88694a42423319db3eb41e53b0bc594c76536fd5
-LibGit2.v1.2.2+0.armv7l-linux-musleabihf.tar.gz/md5/b4acf755de779ed6dbda48cfef8589b4
-LibGit2.v1.2.2+0.armv7l-linux-musleabihf.tar.gz/sha512/fc9dd9a4d3e868085b54061b7eedf4f2331f5338e02b1de2c63ac9f7ddbb1b872b350365a82beb65a791a3872755111c832047622362d8b56d1d2b662b98bf09
-LibGit2.v1.2.2+0.i686-linux-gnu.tar.gz/md5/efa3612e46fbe2826028b70ebdd6ab90
-LibGit2.v1.2.2+0.i686-linux-gnu.tar.gz/sha512/c4d54e381a1ef6d972c5d82ad24bf3b9fd403f988e4ff6779579f994732450a2c93880be096861b9d43c836901eec173ca392bd759f52a7db358ceebd799487f
-LibGit2.v1.2.2+0.i686-linux-musl.tar.gz/md5/72a361323ac5351241b9022a1bf2d6af
-LibGit2.v1.2.2+0.i686-linux-musl.tar.gz/sha512/c6d5d169413f0effa217d35edb74f5cd6db1ca31b98459b2773ce927c66a9a434f206c89a6878218ac14a3e3ff717e8f22935dba17ae4a25d011542045363401
-LibGit2.v1.2.2+0.i686-w64-mingw32.tar.gz/md5/6677a563b679f969c2b0f12eefd10c12
-LibGit2.v1.2.2+0.i686-w64-mingw32.tar.gz/sha512/369944643a179aa6fea6a5ebb82ef07bdb9f220890f670bbf5ccd8285edb68f25d96a33b448c789aea4f649876caa89c00bb52d1e7a65a4ffc5a8c6692aa2523
-LibGit2.v1.2.2+0.powerpc64le-linux-gnu.tar.gz/md5/cb9195eb5ab95d0ec53559ec2b42d4cc
-LibGit2.v1.2.2+0.powerpc64le-linux-gnu.tar.gz/sha512/fc4387327f953174815988c8514c673529e3e2fa1b7209bfd80755890438bf10c644f85c988435bb45cd96d939fa5409f85d47e9a8ae0480b184ff718af53fa4
-LibGit2.v1.2.2+0.x86_64-apple-darwin.tar.gz/md5/693080c66702c9ff106b0935f01d1f96
-LibGit2.v1.2.2+0.x86_64-apple-darwin.tar.gz/sha512/f21d5846b443188a0c604255dce77603ea861db8d4c6fc55cebd5db6da07e94ae40f0a165221c95e13db9df8777fddb05f55c865f554f45e56cd442332a95336
-LibGit2.v1.2.2+0.x86_64-linux-gnu.tar.gz/md5/493a08e9461756a7aff6c6982d54f598
-LibGit2.v1.2.2+0.x86_64-linux-gnu.tar.gz/sha512/d2b4e7965d47cd73572884dc65c3596b0148390bcf22900f199d60663d44fc90ab1bd5dc733711d6acea9f063a6a2e974341e3a602ef11ee928b9f29c934e893
-LibGit2.v1.2.2+0.x86_64-linux-musl.tar.gz/md5/153cc65bd29f4ff78b8f0502ae29f3b6
-LibGit2.v1.2.2+0.x86_64-linux-musl.tar.gz/sha512/7238e6b8a7defdaaff7ca3b81404e6003179ede162fa33e92937f5af1e78ea7f652527dc5968e23d29305812690d88f57c6aeb9270b1f1d9e700a0e0674cc77c
-LibGit2.v1.2.2+0.x86_64-unknown-freebsd.tar.gz/md5/6ff9aa266d900c6e4d894a8ef2c4425e
-LibGit2.v1.2.2+0.x86_64-unknown-freebsd.tar.gz/sha512/e248ff490706f638c23873d90eef6b74e178a964ba80a73b2f330b4633157ecf91609aa19a3163d78b39aec49b9b93fc209877b98e1a631b7a166ad91395ff21
-LibGit2.v1.2.2+0.x86_64-w64-mingw32.tar.gz/md5/4289124917d0ddfbd4bdeb87e3e4b0d9
-LibGit2.v1.2.2+0.x86_64-w64-mingw32.tar.gz/sha512/49ba2217a537d45754cc0929589844b852c6e9ea300775952164510f012446671b799ce1614dcb8a8b82aa387495e5ecca641c2f3a985b788c2350712588aacc
+LibGit2.v1.2.3+0.aarch64-apple-darwin.tar.gz/md5/d41d8cd98f00b204e9800998ecf8427e
+LibGit2.v1.2.3+0.aarch64-apple-darwin.tar.gz/sha512/cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e
+LibGit2.v1.2.3+0.aarch64-linux-gnu.tar.gz/md5/f2f31aa978e43aa68a0e73107067c7cd
+LibGit2.v1.2.3+0.aarch64-linux-gnu.tar.gz/sha512/46f1ed9158cc00fc0ca71768e9a475d99597e4e63d806b061f08c2b5de40ecde61020f60ad4ff5a7377b52dfcd910c6610022fd95c1a08aa9af305489712786f
+LibGit2.v1.2.3+0.aarch64-linux-musl.tar.gz/md5/aa1429e946185092bacda87fb5ff4ed2
+LibGit2.v1.2.3+0.aarch64-linux-musl.tar.gz/sha512/2ab81db22c4ca9855a84835174cee249bc95c3a3158b72fe0c8d18da074ef7a7790bbd90ffb4ec5847ff23ef6098e7d9410ab765c27bdba8bafed5ab3820452a
+LibGit2.v1.2.3+0.armv6l-linux-gnueabihf.tar.gz/md5/07bef4e0e69f1b1cfe870f554262bd3c
+LibGit2.v1.2.3+0.armv6l-linux-gnueabihf.tar.gz/sha512/ccd424e5722e3319aa6dea25e088b7ab4ef30afbab57ba243c92db2cd9906d2b6110b866d4aee61bcd8a29e75fc6399b59109a1457d0fe4dd0e1d2c77aef3808
+LibGit2.v1.2.3+0.armv6l-linux-musleabihf.tar.gz/md5/cb56cabe9e705e8ca81ea8f890498bc5
+LibGit2.v1.2.3+0.armv6l-linux-musleabihf.tar.gz/sha512/45823b4f8fbd472fb508c0186baddb480f02356d193e493a541b064c92a919bbfad83df7ffa8b1631446c099e29cb109f4e1519246f9511ab81973ada9e2e22b
+LibGit2.v1.2.3+0.armv7l-linux-gnueabihf.tar.gz/md5/ea80b5ca2fa469f5056d3716d173e15d
+LibGit2.v1.2.3+0.armv7l-linux-gnueabihf.tar.gz/sha512/9040d8841dfcc26af42b409f776ce19bc232b7bf9679cd291c802d8e8186dd52d55bf085ca5bafdf1090a224c6fdf5bb42722434a8d771809d0bb083a768df90
+LibGit2.v1.2.3+0.armv7l-linux-musleabihf.tar.gz/md5/be089f9e5986deca632f170b137879e3
+LibGit2.v1.2.3+0.armv7l-linux-musleabihf.tar.gz/sha512/3266a3d40278324f4def5ff0823fce4859bc4eb065919500265ff962d01c7ebbcdfb8ba43b09d00a05ea2bb53a82984166442dfbc33ed6870a48b8af6cd26feb
+LibGit2.v1.2.3+0.i686-linux-gnu.tar.gz/md5/27b9d4e956ce649d0c3c412e65662e4d
+LibGit2.v1.2.3+0.i686-linux-gnu.tar.gz/sha512/85160f6950affbc8e161bf054ecdcf5cc09ecfac410765dae5f7ba35b3f2f5eb1a94f5b0299c1500ea6972be8dc2b9f0802a2f587c74aac4236c2c9c325fd573
+LibGit2.v1.2.3+0.i686-linux-musl.tar.gz/md5/5f8f66ace7a0d564d36a93f6c60f2e9a
+LibGit2.v1.2.3+0.i686-linux-musl.tar.gz/sha512/0438682a560ebdd13db1786748e5f08af327a6b9b9b8a4c70606696db4d311b45129ea67b960e14a4db948cbd741039afc3f4e9284adb209de168265b146d8eb
+LibGit2.v1.2.3+0.i686-w64-mingw32.tar.gz/md5/b36dd8bffdc106c2f9cc6c8a694eed01
+LibGit2.v1.2.3+0.i686-w64-mingw32.tar.gz/sha512/72d9230281b51f9530c3a33a139633b0e7199de3e001e1c265ac7d393ba5c6042b8fdc822b8a3bf661e113166459b2d61b8251dfdb68231bc3b7a3f10efc3bb6
+LibGit2.v1.2.3+0.powerpc64le-linux-gnu.tar.gz/md5/6060a6bf226eae115b1af93937523104
+LibGit2.v1.2.3+0.powerpc64le-linux-gnu.tar.gz/sha512/424e6b174c1cf19602fe0c2f01c432bc31e810a533093d990ef5e3bac46e23ff509437151f2932cf21b3bdd626c877689049fbe8891991256d8672dcc3339efc
+LibGit2.v1.2.3+0.x86_64-apple-darwin.tar.gz/md5/10431767db6173db70cfd34a14223f3a
+LibGit2.v1.2.3+0.x86_64-apple-darwin.tar.gz/sha512/8217b832ec98986465d89d3262cb2a9e409595978e39a5e21cc2c808576354515398a597c608258e74c7dc80cebb2563134ee6f903fd2ce371b4fdb953b07323
+LibGit2.v1.2.3+0.x86_64-linux-gnu.tar.gz/md5/2e1d21253669ef438840662d661c0b4f
+LibGit2.v1.2.3+0.x86_64-linux-gnu.tar.gz/sha512/c739d47165dff39800d4f3915c31d06dbe430f26730e00e04314fe813c4170d253f74cda6d8707c9240f3f0774b7e2ee9986c553a2892074756698b9eea6b7f1
+LibGit2.v1.2.3+0.x86_64-linux-musl.tar.gz/md5/cf61d8502d04e9c561da341182c94aae
+LibGit2.v1.2.3+0.x86_64-linux-musl.tar.gz/sha512/74aa67ab5a43fafcf6cb0a6389031e41d996f63b2a9b1fd6b0ff72159a10d199216fe1c4b882c6e7e052178db7d5213d7073ffc14ec648af19bea5eb55733e15
+LibGit2.v1.2.3+0.x86_64-unknown-freebsd.tar.gz/md5/e1623fd3f8f564085d47ec650a40e724
+LibGit2.v1.2.3+0.x86_64-unknown-freebsd.tar.gz/sha512/295d55b78b21ef1c2ba471c8b5618b168dd633e986db9e1ec3e9630e352446ab18e8fd0992010b6afdd922463bb285bc45885a8b35a502d574553fe61c1f7b9f
+LibGit2.v1.2.3+0.x86_64-w64-mingw32.tar.gz/md5/c845901c4d9dc145f76469d45abad934
+LibGit2.v1.2.3+0.x86_64-w64-mingw32.tar.gz/sha512/21951f3bc902f30b8cc75c3af233aa7fe8457e412e7758d556bf71de149c7f2325a5c4c204a7a462cc6a61b3dcb90f0d25e684ffd8617b0a1505a1d31cf2f69a
diff --git a/deps/libgit2.mk b/deps/libgit2.mk
index 82e9817134454..f9b6aba547f7e 100644
--- a/deps/libgit2.mk
+++ b/deps/libgit2.mk
@@ -51,10 +51,17 @@ $(LIBGIT2_SRC_PATH)/libgit2-hostkey.patch-applied: $(LIBGIT2_SRC_PATH)/libgit2-m
 		patch -p1 -f < $(SRCDIR)/patches/libgit2-hostkey.patch
 	echo 1 > $@
 
+# This can be removed once a release with https://github.com/libgit2/libgit2/pull/5740 lands
+$(LIBGIT2_SRC_PATH)/libgit2-continue-zlib.patch-applied: $(LIBGIT2_SRC_PATH)/libgit2-hostkey.patch-applied
+	cd $(LIBGIT2_SRC_PATH) && \
+		patch -p1 -f < $(SRCDIR)/patches/libgit2-continue-zlib.patch
+	echo 1 > $@
+
 $(BUILDDIR)/$(LIBGIT2_SRC_DIR)/build-configured: \
 	$(LIBGIT2_SRC_PATH)/libgit2-agent-nonfatal.patch-applied \
 	$(LIBGIT2_SRC_PATH)/libgit2-mbedtls-incdir.patch-applied \
-	$(LIBGIT2_SRC_PATH)/libgit2-hostkey.patch-applied
+	$(LIBGIT2_SRC_PATH)/libgit2-hostkey.patch-applied \
+	$(LIBGIT2_SRC_PATH)/libgit2-continue-zlib.patch-applied
 
 $(BUILDDIR)/$(LIBGIT2_SRC_DIR)/build-configured: $(LIBGIT2_SRC_PATH)/source-extracted
 	mkdir -p $(dir $@)
diff --git a/deps/patches/libgit2-continue-zlib.patch b/deps/patches/libgit2-continue-zlib.patch
new file mode 100644
index 0000000000000..023b8265187b8
--- /dev/null
+++ b/deps/patches/libgit2-continue-zlib.patch
@@ -0,0 +1,43 @@
+commit 99ddda527b0e1964898c2bc9fbc23ea7afe96ae5
+Author: Edward Thomson <ethomson@edwardthomson.com>
+Date:   Tue Dec 15 23:03:03 2020 +0000
+
+    pack: continue zlib while we can make progress
+    
+    Continue the zlib stream as long as we can make progress; stop when we
+    stop getting output _or_ when zlib stops taking input from us.
+    
+    (cherry picked from commit 93f61c5a9f638e76189cef2dbde7839a9af5ff54)
+
+diff --git a/src/pack.c b/src/pack.c
+index 1b5cf670f..1a208a051 100644
+--- a/src/pack.c
++++ b/src/pack.c
+@@ -841,7 +841,7 @@ static int packfile_unpack_compressed(
+ 
+ 	do {
+ 		size_t bytes = buffer_len - total;
+-		unsigned int window_len;
++		unsigned int window_len, consumed;
+ 		unsigned char *in;
+ 
+ 		if ((in = pack_window_open(p, mwindow, *position, &window_len)) == NULL) {
+@@ -857,10 +857,15 @@ static int packfile_unpack_compressed(
+ 
+ 		git_mwindow_close(mwindow);
+ 
+-		if (!bytes)
+-			break;
++		consumed = window_len - (unsigned int)zstream.in_len;
++
++		if (!bytes && !consumed) {
++			git_error_set(GIT_ERROR_ZLIB, "error inflating zlib stream");
++			error = -1;
++			goto out;
++		}
+ 
+-		*position += window_len - zstream.in_len;
++		*position += consumed;
+ 		total += bytes;
+ 	} while (!git_zstream_eos(&zstream));
+ 
diff --git a/stdlib/LibGit2_jll/Project.toml b/stdlib/LibGit2_jll/Project.toml
index 3cd833bea938c..a10c39822dcec 100644
--- a/stdlib/LibGit2_jll/Project.toml
+++ b/stdlib/LibGit2_jll/Project.toml
@@ -1,6 +1,6 @@
 name = "LibGit2_jll"
 uuid = "e37daf67-58a4-590a-8e99-b0245dd2ffc5"
-version = "1.1.0+0"
+version = "1.2.3+0"
 
 [deps]
 MbedTLS_jll = "c8ffd9c3-330d-5841-b78e-0817d7145fa1"

From cc4f2363129b1bf07b08c9d416ba7bf06537b248 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bogumi=C5=82=20Kami=C5=84ski?= <bkamins@sgh.waw.pl>
Date: Thu, 25 Feb 2021 12:27:16 +0100
Subject: [PATCH 44/54] make copy correctly handle 0-dimensional SubArray
 (#39809)

* make copy correctly handle 0-dimensional SubArray

The current definition of `copy` for `SubArray` [here](https://github.com/JuliaLang/julia/blob/master/base/subarray.jl#L70) has the following consequence:
```
julia> x = [1]
1-element Array{Int64,1}:
 1

julia> y = @view x[1]
0-dimensional view(::Array{Int64,1}, 1) with eltype Int64:
1

julia> copy(y)
1
```

which is inconsistent with the contract for `copy` that promises to produce an array when array is copied, e.g.:
```
julia> x = fill(1)
0-dimensional Array{Int64,0}:
1

julia> copy(x)
0-dimensional Array{Int64,0}:
1
```

(cherry picked from commit a12d0ff63a187ca165f9eb50c00c0b127734ca6b)
---
 base/subarray.jl | 8 +++++++-
 test/subarray.jl | 6 ++++++
 2 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/base/subarray.jl b/base/subarray.jl
index bd2d0dc231a6c..32262058cb55b 100644
--- a/base/subarray.jl
+++ b/base/subarray.jl
@@ -67,7 +67,13 @@ similar(V::SubArray, T::Type, dims::Dims) = similar(V.parent, T, dims)
 sizeof(V::SubArray) = length(V) * sizeof(eltype(V))
 sizeof(V::SubArray{<:Any,<:Any,<:Array}) = length(V) * elsize(V.parent)
 
-copy(V::SubArray) = V.parent[V.indices...]
+function Base.copy(V::SubArray)
+    v = V.parent[V.indices...]
+    ndims(V) == 0 || return v
+    x = similar(V) # ensure proper type of x
+    x[] = v
+    return x
+end
 
 parent(V::SubArray) = V.parent
 parentindices(V::SubArray) = V.indices
diff --git a/test/subarray.jl b/test/subarray.jl
index 985b481438c5b..76f00ab7948cb 100644
--- a/test/subarray.jl
+++ b/test/subarray.jl
@@ -712,3 +712,9 @@ using .Main.InfiniteArrays, Base64
     @test size(v) == (Infinity(),)
     @test stringmime("text/plain", v; context=(:limit => true)) == "$(Infinity())-element view(::$(OneToInf{Int}), 1:1:$(Infinity())) with eltype $Int with indices 1:1:$(Infinity()):\n  1\n  2\n  3\n  4\n  5\n  6\n  7\n  8\n  9\n 10\n  ⋮"
 end
+
+@testset "PR #39809: copy on 0-dimensional SubArray" begin
+    v = [[1]]
+    s = @view v[1]
+    @test copy(s) == fill([1])
+end

From ddf944072a234d59407d02b0dd7fb7138ec0dffd Mon Sep 17 00:00:00 2001
From: Tim Holy <tim.holy@gmail.com>
Date: Thu, 25 Feb 2021 11:07:56 -0600
Subject: [PATCH 45/54] equiv_typedef: don't reject equivalence just for
 gensyms (#39778)

This fixes the following:

```
julia> struct Symmetric{T,S<:AbstractMatrix{<:T}} <: AbstractMatrix{T}
           data::S
           uplo::Char
       end

julia> struct Symmetric{T,S<:AbstractMatrix{<:T}} <: AbstractMatrix{T}
           data::S
           uplo::Char
       end
ERROR: invalid redefinition of constant Symmetric
```

`Core._equiv_typedef` returns false which ends up triggering the error.

(cherry picked from commit 6968e47fa6fff0d12de310103961d70299b7c237)
---
 src/builtins.c |  2 +-
 test/core.jl   | 16 ++++++++++++++++
 2 files changed, 17 insertions(+), 1 deletion(-)

diff --git a/src/builtins.c b/src/builtins.c
index f55fe0f6556bf..30a900045837b 100644
--- a/src/builtins.c
+++ b/src/builtins.c
@@ -1367,7 +1367,7 @@ static int equiv_type(jl_value_t *ta, jl_value_t *tb)
     while (jl_is_unionall(a)) {
         jl_unionall_t *ua = (jl_unionall_t*)a;
         jl_unionall_t *ub = (jl_unionall_t*)b;
-        if (!jl_egal(ua->var->lb, ub->var->lb) || !jl_egal(ua->var->ub, ub->var->ub) ||
+        if (!jl_types_egal(ua->var->lb, ub->var->lb) || !jl_types_egal(ua->var->ub, ub->var->ub) ||
             ua->var->name != ub->var->name)
             goto no;
         a = jl_instantiate_unionall(ua, (jl_value_t*)ub->var);
diff --git a/test/core.jl b/test/core.jl
index feea3e4c023df..8fa47e513f14e 100644
--- a/test/core.jl
+++ b/test/core.jl
@@ -7289,12 +7289,28 @@ end
 
 # issue #36104
 module M36104
+using Test
 struct T36104
     v::Vector{M36104.T36104}
 end
 struct T36104   # check that redefining it works, issue #21816
     v::Vector{T36104}
 end
+# with a gensymmed unionall
+struct Symmetric{T,S<:AbstractMatrix{<:T}} <: AbstractMatrix{T}
+    data::S
+    uplo::Char
+end
+struct Symmetric{T,S<:AbstractMatrix{<:T}} <: AbstractMatrix{T}
+    data::S
+    uplo::Char
+end
+@test_throws ErrorException begin
+    struct Symmetric{T,S<:AbstractMatrix{T}} <: AbstractMatrix{T}
+        data::S
+        uplo::Char
+    end
+end
 end
 @test fieldtypes(M36104.T36104) == (Vector{M36104.T36104},)
 @test_throws ErrorException("expected") @eval(struct X36104; x::error("expected"); end)

From 97383c6b680297b45660816a42630ad11bb6ba84 Mon Sep 17 00:00:00 2001
From: Daniel Bruegmann <danielgbruegmann@gmail.com>
Date: Fri, 26 Feb 2021 09:32:12 +0100
Subject: [PATCH 46/54] LinearAlgebra._generic_matmul! : Avoid division by zero
 for tile_size. (#39790)

(cherry picked from commit eca3e86f412f474037cbb758490d574a7233d266)
---
 stdlib/LinearAlgebra/src/matmul.jl  |  2 +-
 stdlib/LinearAlgebra/test/matmul.jl | 10 ++++++++++
 2 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/stdlib/LinearAlgebra/src/matmul.jl b/stdlib/LinearAlgebra/src/matmul.jl
index 4fed8a577bd63..27bd9c2f23b15 100644
--- a/stdlib/LinearAlgebra/src/matmul.jl
+++ b/stdlib/LinearAlgebra/src/matmul.jl
@@ -823,7 +823,7 @@ function _generic_matmatmul!(C::AbstractVecOrMat{R}, tA, tB, A::AbstractVecOrMat
 
     tile_size = 0
     if isbitstype(R) && isbitstype(T) && isbitstype(S) && (tA == 'N' || tB != 'N')
-        tile_size = floor(Int, sqrt(tilebufsize / max(sizeof(R), sizeof(S), sizeof(T))))
+        tile_size = floor(Int, sqrt(tilebufsize / max(sizeof(R), sizeof(S), sizeof(T), 1)))
     end
     @inbounds begin
     if tile_size > 0
diff --git a/stdlib/LinearAlgebra/test/matmul.jl b/stdlib/LinearAlgebra/test/matmul.jl
index 6a81222174e1f..107c579ba1f94 100644
--- a/stdlib/LinearAlgebra/test/matmul.jl
+++ b/stdlib/LinearAlgebra/test/matmul.jl
@@ -720,6 +720,16 @@ end
     @test D ≈ C
 end
 
+@testset "size zero types in matrix mult (see issue 39362)" begin
+    A = [missing missing; missing missing]
+    v = [missing, missing]
+    @test (A * v == v) === missing
+    M = fill(1.0, 2, 2)
+    a = fill(missing, 2, 1)
+    @test (a' * M * a == fill(missing,1,1)) === missing
+end
+
+
 @testset "multiplication of empty matrices without calling zero" begin
     r, c = rand(0:9, 2)
     A = collect(Number, rand(r, c))

From 4161f4a0888300aca3e41e46a60c0980bcfe66f6 Mon Sep 17 00:00:00 2001
From: Fredrik Ekre <ekrefredrik@gmail.com>
Date: Fri, 26 Feb 2021 13:21:08 +0100
Subject: [PATCH 47/54] Update Downloads.jl to fix download hanging, fixes
 #39789. (#39833)

$ git log --pretty=oneline --abbrev=commit 2b4bed9..6bb8306
6bb83068bd796c4890baaeb39628ff79a4979374 Stop the grace timer iff adding first handle (fix #99) (#102)
af6864d8872247faf2a402d6b2baca5cb74ab96e fix ssh_key_pass bug (fix #91) (#100)

(cherry picked from commit fb500b03c5a929189e2e38034f9bffb2a4e566df)
---
 .../md5                                                         | 1 -
 .../sha512                                                      | 1 -
 .../md5                                                         | 1 +
 .../sha512                                                      | 1 +
 stdlib/Downloads.version                                        | 2 +-
 5 files changed, 3 insertions(+), 3 deletions(-)
 delete mode 100644 deps/checksums/Downloads-2b4bed901185edcb59389515378eba2f26aaa577.tar.gz/md5
 delete mode 100644 deps/checksums/Downloads-2b4bed901185edcb59389515378eba2f26aaa577.tar.gz/sha512
 create mode 100644 deps/checksums/Downloads-6bb83068bd796c4890baaeb39628ff79a4979374.tar.gz/md5
 create mode 100644 deps/checksums/Downloads-6bb83068bd796c4890baaeb39628ff79a4979374.tar.gz/sha512

diff --git a/deps/checksums/Downloads-2b4bed901185edcb59389515378eba2f26aaa577.tar.gz/md5 b/deps/checksums/Downloads-2b4bed901185edcb59389515378eba2f26aaa577.tar.gz/md5
deleted file mode 100644
index 33255ee0c5bb1..0000000000000
--- a/deps/checksums/Downloads-2b4bed901185edcb59389515378eba2f26aaa577.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-faaf8972874d14ecb073a2d5dba1e27c
diff --git a/deps/checksums/Downloads-2b4bed901185edcb59389515378eba2f26aaa577.tar.gz/sha512 b/deps/checksums/Downloads-2b4bed901185edcb59389515378eba2f26aaa577.tar.gz/sha512
deleted file mode 100644
index 9d907f4d5d172..0000000000000
--- a/deps/checksums/Downloads-2b4bed901185edcb59389515378eba2f26aaa577.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-7d33d7411c57dd5d5d6e5052d6c3065eb652e2889d7f3d6f350eb8bad3948be90fd86226d0a6f0b60c15d17e2a2fa1a13ad32d358285ac69bbe89a18edcc1b2c
diff --git a/deps/checksums/Downloads-6bb83068bd796c4890baaeb39628ff79a4979374.tar.gz/md5 b/deps/checksums/Downloads-6bb83068bd796c4890baaeb39628ff79a4979374.tar.gz/md5
new file mode 100644
index 0000000000000..58efffdca88d2
--- /dev/null
+++ b/deps/checksums/Downloads-6bb83068bd796c4890baaeb39628ff79a4979374.tar.gz/md5
@@ -0,0 +1 @@
+7e0ab65c9c6f9413a458ee77ad5e0b29
diff --git a/deps/checksums/Downloads-6bb83068bd796c4890baaeb39628ff79a4979374.tar.gz/sha512 b/deps/checksums/Downloads-6bb83068bd796c4890baaeb39628ff79a4979374.tar.gz/sha512
new file mode 100644
index 0000000000000..c01000751dc6b
--- /dev/null
+++ b/deps/checksums/Downloads-6bb83068bd796c4890baaeb39628ff79a4979374.tar.gz/sha512
@@ -0,0 +1 @@
+b7961928dffd19fb4e5220da694260ae822e80b5ae39ad503f493dcd225f54bc50d4df1b2e833473a164dd42b89c710528d6c58c60f0997492f2551ae1eebaf4
diff --git a/stdlib/Downloads.version b/stdlib/Downloads.version
index a1bc2b90f72d4..9dc2783a1389b 100644
--- a/stdlib/Downloads.version
+++ b/stdlib/Downloads.version
@@ -1,2 +1,2 @@
 DOWNLOADS_BRANCH = master
-DOWNLOADS_SHA1 = 2b4bed901185edcb59389515378eba2f26aaa577
+DOWNLOADS_SHA1 = 6bb83068bd796c4890baaeb39628ff79a4979374

From cc14111fae98bd964b8f480b404fa0c7e10dbbd5 Mon Sep 17 00:00:00 2001
From: Jeff Bezanson <jeff.bezanson@gmail.com>
Date: Fri, 26 Feb 2021 16:48:17 -0500
Subject: [PATCH 48/54] fix #39804, ABI handling of structs with String
 references (#39821)

(cherry picked from commit 9ca31f72ff0ab0ba268e18010582dc2019614e89)
---
 src/abi_aarch64.cpp | 2 +-
 src/abi_ppc64le.cpp | 2 +-
 src/abi_x86_64.cpp  | 4 ++--
 src/ccall.cpp       | 4 ++--
 test/ccall.jl       | 6 ++++++
 5 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/src/abi_aarch64.cpp b/src/abi_aarch64.cpp
index a5d998b527b8e..ce94cc66f0641 100644
--- a/src/abi_aarch64.cpp
+++ b/src/abi_aarch64.cpp
@@ -17,7 +17,7 @@ Type *get_llvm_vectype(jl_datatype_t *dt) const
 {
     // Assume jl_is_datatype(dt) && !jl_is_abstracttype(dt)
     // `!dt->mutabl && dt->pointerfree && !dt->haspadding && dt->nfields > 0`
-    if (dt->layout == NULL)
+    if (dt->layout == NULL || jl_is_layout_opaque(dt->layout))
         return nullptr;
     size_t nfields = dt->layout->nfields;
     assert(nfields > 0);
diff --git a/src/abi_ppc64le.cpp b/src/abi_ppc64le.cpp
index d4b4f0542f30e..dd6f927d9c301 100644
--- a/src/abi_ppc64le.cpp
+++ b/src/abi_ppc64le.cpp
@@ -83,7 +83,7 @@ unsigned isHFA(jl_datatype_t *ty, jl_datatype_t **ty0, bool *hva) const
     int n = 0;
     for (i = 0; i < l; i++) {
         jl_datatype_t *fld = (jl_datatype_t*)jl_field_type(ty, i);
-        if (!jl_is_datatype(fld) || ((jl_datatype_t*)fld)->layout == NULL)
+        if (!jl_is_datatype(fld) || ((jl_datatype_t*)fld)->layout == NULL || jl_is_layout_opaque(((jl_datatype_t*)fld)->layout))
             return 9;
         n += isHFA((jl_datatype_t*)fld, ty0, hva);
         if (n > 8)
diff --git a/src/abi_x86_64.cpp b/src/abi_x86_64.cpp
index 605cd468d7ca4..ac28af3011ecd 100644
--- a/src/abi_x86_64.cpp
+++ b/src/abi_x86_64.cpp
@@ -147,11 +147,11 @@ void classifyType(Classification& accum, jl_datatype_t *dt, uint64_t offset) con
         accum.addField(offset, Sse);
     }
     // Other struct types
-    else if (jl_datatype_size(dt) <= 16) {
+    else if (jl_datatype_size(dt) <= 16 && dt->layout) {
         size_t i;
         for (i = 0; i < jl_datatype_nfields(dt); ++i) {
             jl_value_t *ty = jl_field_type(dt, i);
-            if (!jl_is_datatype(ty) || ((jl_datatype_t*)ty)->layout == NULL || jl_is_array_type(ty))
+            if (jl_field_isptr(dt, i))
                 ty = (jl_value_t*)jl_voidpointer_type;
             classifyType(accum, (jl_datatype_t*)ty, offset + jl_field_offset(dt, i));
         }
diff --git a/src/ccall.cpp b/src/ccall.cpp
index ac59279a8a825..66ab84c264f3a 100644
--- a/src/ccall.cpp
+++ b/src/ccall.cpp
@@ -1011,7 +1011,7 @@ std::string generate_func_sig(const char *fname)
         abi->use_sret(jl_nothing_type);
     }
     else {
-        if (!jl_is_datatype(rt) || ((jl_datatype_t*)rt)->layout == NULL || jl_is_cpointer_type(rt) || jl_is_array_type(rt) || retboxed) {
+        if (!jl_is_datatype(rt) || ((jl_datatype_t*)rt)->layout == NULL || jl_is_layout_opaque(((jl_datatype_t*)rt)->layout) || jl_is_cpointer_type(rt) || retboxed) {
             prt = lrt; // passed as pointer
             abi->use_sret(jl_voidpointer_type);
         }
@@ -1072,7 +1072,7 @@ std::string generate_func_sig(const char *fname)
         }
 
         Type *pat;
-        if (!jl_is_datatype(tti) || ((jl_datatype_t*)tti)->layout == NULL || jl_is_array_type(tti)) {
+        if (!jl_is_datatype(tti) || ((jl_datatype_t*)tti)->layout == NULL || jl_is_layout_opaque(((jl_datatype_t*)tti)->layout)) {
             tti = (jl_value_t*)jl_voidpointer_type; // passed as pointer
         }
 
diff --git a/test/ccall.jl b/test/ccall.jl
index c81d2945f5c74..5f5272c372a11 100644
--- a/test/ccall.jl
+++ b/test/ccall.jl
@@ -1000,6 +1000,12 @@ unstable26078(x) = x > 0 ? x : "foo"
 handle26078 = @cfunction(unstable26078, Int32, (Int32,))
 @test ccall(handle26078, Int32, (Int32,), 1) == 1
 
+# issue #39804
+let f = @cfunction(Base.last, String, (Tuple{Int,String},))
+    # String inside a struct is a pointer even though String.size == 0
+    @test ccall(f, Ref{String}, (Tuple{Int,String},), (1, "a string?")) === "a string?"
+end
+
 # issue 17219
 function ccall_reassigned_ptr(ptr::Ptr{Cvoid})
     ptr = Libdl.dlsym(Libdl.dlopen(libccalltest), "test_echo_p")

From bf093a1ea9a2c0add9fcda5fb3daaef190c1835d Mon Sep 17 00:00:00 2001
From: Dilum Aluthge <dilum@aluthge.com>
Date: Sun, 28 Feb 2021 01:48:02 -0500
Subject: [PATCH 49/54] cmdlineargs test: on 32-bit systems, impose a constant
 upper limit on the number of threads (#39854)

(cherry picked from commit c79309bffa2842f7864d06fc2b135e79da1daec1)
---
 test/cmdlineargs.jl | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/test/cmdlineargs.jl b/test/cmdlineargs.jl
index e24794e255dc1..6b600ad40f934 100644
--- a/test/cmdlineargs.jl
+++ b/test/cmdlineargs.jl
@@ -206,6 +206,9 @@ let exename = `$(Base.julia_cmd()) --startup-file=no`
     # We want to test oversubscription, but on manycore machines, this can
     # actually exhaust limited PID spaces
     cpu_threads = max(2*cpu_threads, min(50, 10*cpu_threads))
+    if Sys.WORD_SIZE == 32
+        cpu_threads = min(cpu_threads, 50)
+    end
     @test read(`$exename -t $cpu_threads -e $code`, String) == string(cpu_threads)
     withenv("JULIA_NUM_THREADS" => string(cpu_threads)) do
         @test read(`$exename -e $code`, String) == string(cpu_threads)

From fef4add3cb34f9a6bf3413a89daa0bfeb90e9973 Mon Sep 17 00:00:00 2001
From: Elliot Saba <staticfloat@gmail.com>
Date: Mon, 1 Mar 2021 18:22:37 -0800
Subject: [PATCH 50/54] [BugReporting] pass `ARGS` through properly (#39839)

When calling `make_interactive_report()`, we really need to pass in
`ARGS` as well, otherwise it always starts an interactive session.

This commit, in combination with `--` allows the user to run an `rr`
session while still passing arguments to the child `julia` process via:

```
julia --bug-report=rr -- --project test/runtests.jl
```

(cherry picked from commit 5e7aaa6c1933f5081acf12a33fd16f92d92e2c05)
---
 stdlib/InteractiveUtils/src/InteractiveUtils.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stdlib/InteractiveUtils/src/InteractiveUtils.jl b/stdlib/InteractiveUtils/src/InteractiveUtils.jl
index ead87cde431f0..87bc01f159d51 100644
--- a/stdlib/InteractiveUtils/src/InteractiveUtils.jl
+++ b/stdlib/InteractiveUtils/src/InteractiveUtils.jl
@@ -404,7 +404,7 @@ function report_bug(kind)
     else
         BugReporting = Base.require(BugReportingId)
     end
-    return Base.invokelatest(BugReporting.make_interactive_report, kind)
+    return Base.invokelatest(BugReporting.make_interactive_report, kind, ARGS)
 end
 
 end

From 859577b102c75702585b07f002e75464385df042 Mon Sep 17 00:00:00 2001
From: KristofferC <kcarlsson89@gmail.com>
Date: Tue, 2 Mar 2021 08:58:28 +0100
Subject: [PATCH 51/54] update Pkg to latest release-1.6

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

diff --git a/deps/checksums/Pkg-05fa7f93f73afdabd251247d03144de9f7b36b50.tar.gz/md5 b/deps/checksums/Pkg-05fa7f93f73afdabd251247d03144de9f7b36b50.tar.gz/md5
new file mode 100644
index 0000000000000..e2ce6025ee72b
--- /dev/null
+++ b/deps/checksums/Pkg-05fa7f93f73afdabd251247d03144de9f7b36b50.tar.gz/md5
@@ -0,0 +1 @@
+4b827aa3727f565648ac27fc9daf7db3
diff --git a/deps/checksums/Pkg-05fa7f93f73afdabd251247d03144de9f7b36b50.tar.gz/sha512 b/deps/checksums/Pkg-05fa7f93f73afdabd251247d03144de9f7b36b50.tar.gz/sha512
new file mode 100644
index 0000000000000..97fc8d97e8e7e
--- /dev/null
+++ b/deps/checksums/Pkg-05fa7f93f73afdabd251247d03144de9f7b36b50.tar.gz/sha512
@@ -0,0 +1 @@
+082bfe39acd6ac6ca08f69cbdeb70bebd7842922741da6ef5b5057c7126b56a5e91fe2ad96dd5f72aedf2a7a6e63b424f9a756ac6eedda089847da3152cb2f4c
diff --git a/deps/checksums/Pkg-e7830b50918f94301ee03ae9d47dc9b14dac0ba4.tar.gz/md5 b/deps/checksums/Pkg-e7830b50918f94301ee03ae9d47dc9b14dac0ba4.tar.gz/md5
deleted file mode 100644
index d2960ee1d8d54..0000000000000
--- a/deps/checksums/Pkg-e7830b50918f94301ee03ae9d47dc9b14dac0ba4.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-6bb4b517e34387e79af60311897ee2dd
diff --git a/deps/checksums/Pkg-e7830b50918f94301ee03ae9d47dc9b14dac0ba4.tar.gz/sha512 b/deps/checksums/Pkg-e7830b50918f94301ee03ae9d47dc9b14dac0ba4.tar.gz/sha512
deleted file mode 100644
index 15a5c97c3ea3e..0000000000000
--- a/deps/checksums/Pkg-e7830b50918f94301ee03ae9d47dc9b14dac0ba4.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-5bfc0cc86c03c0c0357675451251ed0fa9858de83fdb782d613041408ecfb4ee7ae28a2cef25b6abfe1a97c814006b18ca962c391870caa44321a1e2873a92ff
diff --git a/stdlib/Pkg.version b/stdlib/Pkg.version
index bad0753d28db6..f379c4e6af7f9 100644
--- a/stdlib/Pkg.version
+++ b/stdlib/Pkg.version
@@ -1,2 +1,2 @@
 PKG_BRANCH = release-1.6
-PKG_SHA1 = e7830b50918f94301ee03ae9d47dc9b14dac0ba4
+PKG_SHA1 = 05fa7f93f73afdabd251247d03144de9f7b36b50

From d06bab00016d5d372af876e2b56bddc2adbec97c Mon Sep 17 00:00:00 2001
From: Jeff Bezanson <jeff.bezanson@gmail.com>
Date: Tue, 2 Mar 2021 14:40:02 -0500
Subject: [PATCH 52/54] fix #39698 by disabling the unnecessary Vararg var
 bounds error

backports #39875 to 1.6
---
 src/jltypes.c | 5 +++++
 test/core.jl  | 3 ---
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/jltypes.c b/src/jltypes.c
index 2599b47f744c1..d952a68cd4c0d 100644
--- a/src/jltypes.c
+++ b/src/jltypes.c
@@ -1166,9 +1166,14 @@ static jl_value_t *inst_datatype_inner(jl_datatype_t *dt, jl_svec_t *p, jl_value
         if (jl_is_vararg_type((jl_value_t*)dt) && ntp == 2) {
             jl_value_t *lenparam = iparams[1];
             if (jl_is_typevar(lenparam)) {
+                // TODO: this is disabled due to #39698; it is also inconsistent
+                // with other similar checks, where we usually only check substituted
+                // values and not the bounds of variables.
+                /*
                 jl_tvar_t *N = (jl_tvar_t*)lenparam;
                 if (!(N->lb == jl_bottom_type && N->ub == (jl_value_t*)jl_any_type))
                     jl_error("TypeVar in Vararg length must have bounds Union{} and Any");
+                */
             }
             else if (!jl_is_long(lenparam)) {
                 jl_type_error_rt("Vararg", "count", (jl_value_t*)jl_long_type, lenparam);
diff --git a/test/core.jl b/test/core.jl
index 8fa47e513f14e..1fceddb93084f 100644
--- a/test/core.jl
+++ b/test/core.jl
@@ -3521,9 +3521,6 @@ end
 @test_throws TypeError Union{Int, 1}
 
 @test_throws ErrorException Vararg{Any,-2}
-@test_throws ErrorException Vararg{Int, N} where N<:T where T
-@test_throws ErrorException Vararg{Int, N} where N<:Integer
-@test_throws ErrorException Vararg{Int, N} where N>:Integer
 
 mutable struct FooNTuple{N}
     z::Tuple{Integer, Vararg{Int, N}}

From 1e206302cb6393301a27be391772436f3d7791b2 Mon Sep 17 00:00:00 2001
From: Jeff Bezanson <jeff.bezanson@gmail.com>
Date: Mon, 8 Mar 2021 23:43:09 -0500
Subject: [PATCH 53/54] fix #39948, stack overflow due to free typevar during
 `jl_type_intersection2`

(cherry picked from commit bbf14f842868fff7d395e8f81d02124de11180d1)
---
 src/gf.c        | 3 +++
 test/subtype.jl | 7 +++++++
 2 files changed, 10 insertions(+)

diff --git a/src/gf.c b/src/gf.c
index 8861144e92e38..cf22c9b0095a3 100644
--- a/src/gf.c
+++ b/src/gf.c
@@ -1592,6 +1592,9 @@ static int jl_type_intersection2(jl_value_t *t1, jl_value_t *t2, jl_value_t **is
         return 0;
     if (is_subty)
         return 1;
+    // TODO: sometimes type intersection returns types with free variables
+    if (jl_has_free_typevars(t1) || jl_has_free_typevars(t2))
+        return 1;
     // determine if type-intersection can be convinced to give a better, non-bad answer
     // if the intersection was imprecise, see if we can do better by switching the types
     *isect2 = jl_type_intersection(t2, t1);
diff --git a/test/subtype.jl b/test/subtype.jl
index 57d49bc13fa8c..031a1815b2930 100644
--- a/test/subtype.jl
+++ b/test/subtype.jl
@@ -1878,3 +1878,10 @@ let A = Tuple{Type{<:Union{Number, T}}, Ref{T}} where T,
     @test A == B
     @test A <: B
 end
+
+# issue #39948
+let A = Tuple{Array{Pair{T, JT} where JT<:Ref{T}, 1} where T, Vector},
+    I = typeintersect(A, Tuple{Vararg{Vector{T}}} where T)
+    @test_broken I <: A
+    @test_broken !Base.has_free_typevars(I)
+end

From f731fbbedd8d5f59ee56c1573845acef130b0f92 Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Tue, 16 Feb 2021 22:11:06 -0500
Subject: [PATCH 54/54] Try to fix unwind on i686

Turns out libunwind was basically ignoring value locations on the
platform, so that needed to be enabled. Should hopefully fix linux32 CI.

(cherry picked from commit da9e12e31d1f74d76612fa0cc845c2c126166801)
---
 deps/Versions.make                   |   2 +-
 deps/checksums/unwind                |  48 ++--
 deps/patches/libunwind-cfa-rsp.patch | 393 +++++++++++++++++++++++++++
 deps/patches/libunwind-rsp-cfa.patch | 177 ------------
 deps/unwind.mk                       |   6 +-
 5 files changed, 421 insertions(+), 205 deletions(-)
 create mode 100644 deps/patches/libunwind-cfa-rsp.patch
 delete mode 100644 deps/patches/libunwind-rsp-cfa.patch

diff --git a/deps/Versions.make b/deps/Versions.make
index 73449748b0fe7..c30e45a96a355 100644
--- a/deps/Versions.make
+++ b/deps/Versions.make
@@ -101,7 +101,7 @@ SUITESPARSE_JLL_NAME := SuiteSparse
 # unwind
 UNWIND_VER := 1.3.2
 UNWIND_JLL_NAME := LibUnwind
-UNWIND_JLL_VER  := 1.3.2+3
+UNWIND_JLL_VER  := 1.3.2+4
 
 # zlib
 ZLIB_VER := 1.2.11
diff --git a/deps/checksums/unwind b/deps/checksums/unwind
index 545c756d07f9a..f94bd78639bbe 100644
--- a/deps/checksums/unwind
+++ b/deps/checksums/unwind
@@ -1,26 +1,26 @@
 LibOSXUnwind.v0.0.6+1.x86_64-apple-darwin.tar.gz/md5/fd98df2005d13aa16341c5aecba1af70
 LibOSXUnwind.v0.0.6+1.x86_64-apple-darwin.tar.gz/sha512/2d2263c3e5f095ad9eba7fea7cb882a19fece8a10486489d0a15b8e81ea0f8626804c4822b8c92a26a608d568c0ff1a4e976ea6d746be47ac1a70891455162a6
-LibUnwind.v1.3.2+3.aarch64-linux-gnu.tar.gz/md5/fba1f405a3a7c8bc4f68c17d771100b0
-LibUnwind.v1.3.2+3.aarch64-linux-gnu.tar.gz/sha512/a37d3f9da9a133bb270cc1046c7018579731897fed0ef6ab1fbeb0dde38e7be294a4e2abf41096c7edde617e266f1acc95777b34e22b6a8ced0e27b2228b0ec5
-LibUnwind.v1.3.2+3.aarch64-linux-musl.tar.gz/md5/587de98245251124c0d29b0b478374ec
-LibUnwind.v1.3.2+3.aarch64-linux-musl.tar.gz/sha512/9f10eee8e4f5117dfc4689378c93ba16e205aaa89eec5681e0b1e34e7c2d334717b327cae8d5024db6a1f6a2633454cb77b577112a0a03a3282e566705c1a81e
-LibUnwind.v1.3.2+3.armv6l-linux-gnueabihf.tar.gz/md5/953bfa931cb8e44d39ae22d7ccab1f22
-LibUnwind.v1.3.2+3.armv6l-linux-gnueabihf.tar.gz/sha512/54ee57c35895cbaed2160d451ca33ac9e8adf157b7f825853f7e92f8304f799f2671f5361dae7d2e7d111a3ab1f749cddb96a2c04b7b8fc7844b1e021dbc443f
-LibUnwind.v1.3.2+3.armv6l-linux-musleabihf.tar.gz/md5/5d16fd194ec5a7e46e1e1679072cec0f
-LibUnwind.v1.3.2+3.armv6l-linux-musleabihf.tar.gz/sha512/1ae68a77eadaf73de9de266bb3e2f61457faae6b2f971988363d2d1bebf855bdbc55ad848266335a9b3c040308e0bd3e3b66d5b66fe8807e0fb774c22bac928d
-LibUnwind.v1.3.2+3.armv7l-linux-gnueabihf.tar.gz/md5/569da138256de02784ba81b01e08a3db
-LibUnwind.v1.3.2+3.armv7l-linux-gnueabihf.tar.gz/sha512/264636b57ca49feb005752636671fe1c24264b15d1caca0c0808e89966a7683e7821a56e41b89cde9e32b688cf94647ae61de74f0428b7b1f92be2bed6674114
-LibUnwind.v1.3.2+3.armv7l-linux-musleabihf.tar.gz/md5/c9d2f634a742d71e471dd7ff691bf39d
-LibUnwind.v1.3.2+3.armv7l-linux-musleabihf.tar.gz/sha512/01c2085d49390ace5c128507a86d23b99d746cce080cc7b6415e1c75e63082d01b047b2cf98f3f76768fb49423c5524f53d253858d82864f09e8182a86be57ad
-LibUnwind.v1.3.2+3.i686-linux-gnu.tar.gz/md5/92e075574e65c735f6202cc49ec51593
-LibUnwind.v1.3.2+3.i686-linux-gnu.tar.gz/sha512/03f9a71b1b1b0752a835201248cdb2d17f076a82b0928e20f45fc2b8db0914128028c0d589ff94a97847265c216420240b2369af83c4a343d3ca37c58fdcf35a
-LibUnwind.v1.3.2+3.i686-linux-musl.tar.gz/md5/fa506359a72ffdf2c3713b5724ad4413
-LibUnwind.v1.3.2+3.i686-linux-musl.tar.gz/sha512/0558e871e838e6ce265c73fd7335bd0a486722ce9a710957b2e67731c494c5781a3a37176ba758f74fee37d48ee43acf02aac5092e24230523dd537610b58720
-LibUnwind.v1.3.2+3.powerpc64le-linux-gnu.tar.gz/md5/3f76849a52550e169d6f47ef95ca3d75
-LibUnwind.v1.3.2+3.powerpc64le-linux-gnu.tar.gz/sha512/2f3a119ccf1fffa8460e2350b66bf2303d11d636e649e144750e362d2e08f61d076adda71b5441b4337eaee6fb1e95049aac87de89be1415ca80f1b69c77f310
-LibUnwind.v1.3.2+3.x86_64-linux-gnu.tar.gz/md5/624779c4bc930ae2ba5f6a5d25c73aeb
-LibUnwind.v1.3.2+3.x86_64-linux-gnu.tar.gz/sha512/2eb467537e5f2acee7d5b2a5939c712ca96195584c37606d1ff1bcc0683514decefcae042f566633905472c177115c1467c1503bf331d8d7293b3026628bc138
-LibUnwind.v1.3.2+3.x86_64-linux-musl.tar.gz/md5/7ddcbe93c8bdb1edde0ffab23db3ced7
-LibUnwind.v1.3.2+3.x86_64-linux-musl.tar.gz/sha512/06901d074c15c34002957122897b6b9c449f9c64745363f6fe2886c862197cc6848ca17c3d777eac315fd1d8d90fe236a223167b0aa9fd3b625fd80e3db97655
-LibUnwind.v1.3.2+3.x86_64-unknown-freebsd.tar.gz/md5/ca388d44a8ca365b66999e4b4d1853a2
-LibUnwind.v1.3.2+3.x86_64-unknown-freebsd.tar.gz/sha512/dfbe0a6b5835b51ebea181bb996ffc8fcd8b08acf71243e171c59edb655fd65b6ba59291c10af923f75b7cbb2f52b46adf65ebdca3eee172d279ae357a35205c
+LibUnwind.v1.3.2+4.aarch64-linux-gnu.tar.gz/md5/8f5cbf9820033211513f6d33e36194f1
+LibUnwind.v1.3.2+4.aarch64-linux-gnu.tar.gz/sha512/589886c4f141064126aecc1bf63365c610a4c3dd70e386aa8e17ce562505cac873542fa92cea023850e9bf54fcef3cf475d52f035d17d830a81c01d06d0454e4
+LibUnwind.v1.3.2+4.aarch64-linux-musl.tar.gz/md5/836a2d8ea7a11d87a74aee09f82582b5
+LibUnwind.v1.3.2+4.aarch64-linux-musl.tar.gz/sha512/4cd3805ae59854fdceee441967ba4b812246cf1a1e9ed20367f5bbbad9a47f0093731b4f78f881c696e52c101dec83498398c7b798c81c1a441232cd4ee96b58
+LibUnwind.v1.3.2+4.armv6l-linux-gnueabihf.tar.gz/md5/0047d02c4b4888050b363c77106d4ea1
+LibUnwind.v1.3.2+4.armv6l-linux-gnueabihf.tar.gz/sha512/8b02fb5189ca749e421fc17d560601e8624cbcc19a4c5c45e38828323b33db30ced8a92e08ebd429c663e52358c486d3e284e7e04898229cff2839cc01c067d5
+LibUnwind.v1.3.2+4.armv6l-linux-musleabihf.tar.gz/md5/1fe78c6f0ff7120b35c6745b16c6f838
+LibUnwind.v1.3.2+4.armv6l-linux-musleabihf.tar.gz/sha512/9576f913fbc40d00b42573f600c038fea85eb3c9b88a4878cff0e041c4096d9d005b856dbcd0d057dc40a3cdb74deeca6e9c1cc5c213e6e062328f75633ba8e3
+LibUnwind.v1.3.2+4.armv7l-linux-gnueabihf.tar.gz/md5/510db51b0364cf17207eb00e44d58974
+LibUnwind.v1.3.2+4.armv7l-linux-gnueabihf.tar.gz/sha512/76f119654a65b460917f41a321008c5a0593523db53fa12ac9aa82732368ebdee05d6366fdfdcdd300ba0fe4c7239aac25d80fb3b1ad0235f79b235dab68c796
+LibUnwind.v1.3.2+4.armv7l-linux-musleabihf.tar.gz/md5/4bb58bdc423312c74eafe52a781dd712
+LibUnwind.v1.3.2+4.armv7l-linux-musleabihf.tar.gz/sha512/02b69ec40dfcacc447169786bab3aac39c6db6b07874e9657c49a2907654be79efe16863abf09ee1e2a647cd6a651155b65bdbbd6d810a3ceaa332fc0a3ace4b
+LibUnwind.v1.3.2+4.i686-linux-gnu.tar.gz/md5/76f549ae171aad91570d7874e73f44f6
+LibUnwind.v1.3.2+4.i686-linux-gnu.tar.gz/sha512/a5a654dd6233099e841d1b9c54b16cb99d736549d063e28d17d5f2014c3090d829a4a8dc4fee042d0f4a9d8a155fb30c5840cb84b9fd71758256fa072137baad
+LibUnwind.v1.3.2+4.i686-linux-musl.tar.gz/md5/f8b58f061a03f24111f39f2f8cf72c61
+LibUnwind.v1.3.2+4.i686-linux-musl.tar.gz/sha512/cc6dedc551ee4d5e131cdd7ea7dd4a9cc64efe930d16cddb0c21dca7b13076b6810e00e406acb949404c80b506ca9e09d1e223069d8159e9f73fa8aa022e3f41
+LibUnwind.v1.3.2+4.powerpc64le-linux-gnu.tar.gz/md5/2fd4fda3c82c99ff102b630d078723f5
+LibUnwind.v1.3.2+4.powerpc64le-linux-gnu.tar.gz/sha512/b1c7f16d2877e08cfc9d1aa63c5c9acf30049bd11bdad90c6b1425a09f86762c76f0c1a27817ea1b939244f6e24320854552bc860c95f297a772403eeddc053d
+LibUnwind.v1.3.2+4.x86_64-linux-gnu.tar.gz/md5/cd98359922fddcbbcfda56fbc011bea4
+LibUnwind.v1.3.2+4.x86_64-linux-gnu.tar.gz/sha512/7b2d78869be148db23ab8372bb6699abcf26cc58718871f050b8e67054c0c6c909f9a8c59d27c748abeef0ecb5eabc09484043c3b2232469d03c78a42a590e13
+LibUnwind.v1.3.2+4.x86_64-linux-musl.tar.gz/md5/bd8ea5006d6078a1d91743f599f37732
+LibUnwind.v1.3.2+4.x86_64-linux-musl.tar.gz/sha512/1c7feea46d70c60dbecfe6b945a29a086dc120e0d674ea9d488dc7943901711ba0505288694c94a2b0804bab6cd826b32e58912e407ed918724d16b6b6ec1d3d
+LibUnwind.v1.3.2+4.x86_64-unknown-freebsd.tar.gz/md5/e72c36f0563a088282147275de90048b
+LibUnwind.v1.3.2+4.x86_64-unknown-freebsd.tar.gz/sha512/3aaa7e5c21b3bcc30ff7826af4bc0b926865cac3a5b14dfa7f27f0c5d4344fa2a568a78c0c4ee32a18e668758cdac70c09f31f5ca55cc56c3d6a88654aa906fa
diff --git a/deps/patches/libunwind-cfa-rsp.patch b/deps/patches/libunwind-cfa-rsp.patch
new file mode 100644
index 0000000000000..7803f0b52924e
--- /dev/null
+++ b/deps/patches/libunwind-cfa-rsp.patch
@@ -0,0 +1,393 @@
+commit c71298423c26b2143dc6f6ce554ec910ed882f8a
+Author: Keno Fischer <keno@juliacomputing.com>
+Date:   Sat Feb 6 18:13:16 2021 -0500
+
+    x86_64: Stop aliasing RSP and CFA
+    
+    RSP and CFA are different concepts. RSP refers to the physical
+    register, CFA is a virtual register that serves as the base
+    address for various other saved registers. It is true that
+    in many frames these are set to alias, however this is not
+    a requirement. For example, a function that performs a stack
+    switch would likely change the rsp in the middle of the function,
+    but would keep the CFA at the original RSP such that saved registers
+    may be appropriately recovered.
+    
+    We are seeing incorrect unwinds in the Julia runtime when running
+    julia under rr. This is because injects code (with correct CFI)
+    that performs just such a stack switch [1]. GDB manages to unwind
+    this correctly, but libunwind incorrectly sets the rsp to the CFA
+    address, causing a misunwind.
+    
+    Tested on x86_64, patches for other architectures are ported, but
+    not tested.
+    
+    [1] https://github.com/rr-debugger/rr/blob/469c22059a4a1798d33a8a224457faf22b2c178c/src/preload/syscall_hook.S#L454
+
+diff --git a/include/dwarf.h b/include/dwarf.h
+index fab93c61..b845e2eb 100644
+--- a/include/dwarf.h
++++ b/include/dwarf.h
+@@ -227,6 +227,7 @@ typedef enum
+     DWARF_WHERE_REG,            /* register saved in another register */
+     DWARF_WHERE_EXPR,           /* register saved */
+     DWARF_WHERE_VAL_EXPR,       /* register has computed value */
++    DWARF_WHERE_CFA,            /* register is set to the computed cfa value */
+   }
+ dwarf_where_t;
+ 
+@@ -309,7 +310,7 @@ typedef struct dwarf_cursor
+     void *as_arg;               /* argument to address-space callbacks */
+     unw_addr_space_t as;        /* reference to per-address-space info */
+ 
+-    unw_word_t cfa;     /* canonical frame address; aka frame-/stack-pointer */
++    unw_word_t cfa;     /* canonical frame address; aka frame-pointer */
+     unw_word_t ip;              /* instruction pointer */
+     unw_word_t args_size;       /* size of arguments */
+     unw_word_t eh_args[UNW_TDEP_NUM_EH_REGS];
+diff --git a/include/libunwind_i.h b/include/libunwind_i.h
+index 36cf7a14..dcec1683 100644
+--- a/include/libunwind_i.h
++++ b/include/libunwind_i.h
+@@ -351,6 +351,10 @@ static inline void invalidate_edi (struct elf_dyn_info *edi)
+ 
+ #include "tdep/libunwind_i.h"
+ 
++#ifndef TDEP_DWARF_SP
++#define TDEP_DWARF_SP UNW_TDEP_SP
++#endif
++
+ #ifndef tdep_get_func_addr
+ # define tdep_get_func_addr(as,addr,v)          (*(v) = addr, 0)
+ #endif
+diff --git a/include/tdep-x86/dwarf-config.h b/include/tdep-x86/dwarf-config.h
+index f76f9c1c..11398e4e 100644
+--- a/include/tdep-x86/dwarf-config.h
++++ b/include/tdep-x86/dwarf-config.h
+@@ -43,9 +43,7 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.  */
+ typedef struct dwarf_loc
+   {
+     unw_word_t val;
+-#ifndef UNW_LOCAL_ONLY
+     unw_word_t type;            /* see X86_LOC_TYPE_* macros.  */
+-#endif
+   }
+ dwarf_loc_t;
+ 
+diff --git a/include/tdep-x86/libunwind_i.h b/include/tdep-x86/libunwind_i.h
+index 5231189a..1b59fe34 100644
+--- a/include/tdep-x86/libunwind_i.h
++++ b/include/tdep-x86/libunwind_i.h
+@@ -88,14 +88,28 @@ dwarf_get_uc(const struct dwarf_cursor *cursor)
+ 
+ #define DWARF_GET_LOC(l)        ((l).val)
+ 
+-#ifdef UNW_LOCAL_ONLY
++
++#define DWARF_GET_LOC(l)        ((l).val)
++# define DWARF_LOC_TYPE_MEM     (0 << 0)
++# define DWARF_LOC_TYPE_FP      (1 << 0)
++# define DWARF_LOC_TYPE_REG     (1 << 1)
++# define DWARF_LOC_TYPE_VAL     (1 << 2)
++
++# define DWARF_IS_REG_LOC(l)    (((l).type & DWARF_LOC_TYPE_REG) != 0)
++# define DWARF_IS_FP_LOC(l)     (((l).type & DWARF_LOC_TYPE_FP) != 0)
++# define DWARF_IS_MEM_LOC(l)    ((l).type == DWARF_LOC_TYPE_MEM)
++# define DWARF_IS_VAL_LOC(l)    (((l).type & DWARF_LOC_TYPE_VAL) != 0)
++
++# define DWARF_LOC(r, t)        ((dwarf_loc_t) { .val = (r), .type = (t) })
+ # define DWARF_NULL_LOC         DWARF_LOC (0, 0)
+-# define DWARF_IS_NULL_LOC(l)   (DWARF_GET_LOC (l) == 0)
+-# define DWARF_LOC(r, t)        ((dwarf_loc_t) { .val = (r) })
+-# define DWARF_IS_REG_LOC(l)    0
++# define DWARF_IS_NULL_LOC(l)                                           \
++                ({ dwarf_loc_t _l = (l); _l.val == 0 && _l.type == 0; })
++# define DWARF_VAL_LOC(c,v)     DWARF_LOC ((v), DWARF_LOC_TYPE_VAL)
++# define DWARF_MEM_LOC(c,m)     DWARF_LOC ((m), DWARF_LOC_TYPE_MEM)
++
++#ifdef UNW_LOCAL_ONLY
+ # define DWARF_REG_LOC(c,r)     (DWARF_LOC((unw_word_t)                      \
+                                  tdep_uc_addr(dwarf_get_uc(c), (r)), 0))
+-# define DWARF_MEM_LOC(c,m)     DWARF_LOC ((m), 0)
+ # define DWARF_FPREG_LOC(c,r)   (DWARF_LOC((unw_word_t)                      \
+                                  tdep_uc_addr(dwarf_get_uc(c), (r)), 0))
+ 
+@@ -117,35 +131,8 @@ dwarf_putfp (struct dwarf_cursor *c, dwarf_loc_t loc, unw_fpreg_t val)
+   return 0;
+ }
+ 
+-static inline int
+-dwarf_get (struct dwarf_cursor *c, dwarf_loc_t loc, unw_word_t *val)
+-{
+-  if (!DWARF_GET_LOC (loc))
+-    return -1;
+-  return (*c->as->acc.access_mem) (c->as, DWARF_GET_LOC (loc), val,
+-                                   0, c->as_arg);
+-}
+-
+-static inline int
+-dwarf_put (struct dwarf_cursor *c, dwarf_loc_t loc, unw_word_t val)
+-{
+-  if (!DWARF_GET_LOC (loc))
+-    return -1;
+-  return (*c->as->acc.access_mem) (c->as, DWARF_GET_LOC (loc), &val,
+-                                   1, c->as_arg);
+-}
+-
+ #else /* !UNW_LOCAL_ONLY */
+-# define DWARF_LOC_TYPE_FP      (1 << 0)
+-# define DWARF_LOC_TYPE_REG     (1 << 1)
+-# define DWARF_NULL_LOC         DWARF_LOC (0, 0)
+-# define DWARF_IS_NULL_LOC(l)                                           \
+-                ({ dwarf_loc_t _l = (l); _l.val == 0 && _l.type == 0; })
+-# define DWARF_LOC(r, t)        ((dwarf_loc_t) { .val = (r), .type = (t) })
+-# define DWARF_IS_REG_LOC(l)    (((l).type & DWARF_LOC_TYPE_REG) != 0)
+-# define DWARF_IS_FP_LOC(l)     (((l).type & DWARF_LOC_TYPE_FP) != 0)
+ # define DWARF_REG_LOC(c,r)     DWARF_LOC((r), DWARF_LOC_TYPE_REG)
+-# define DWARF_MEM_LOC(c,m)     DWARF_LOC ((m), 0)
+ # define DWARF_FPREG_LOC(c,r)   DWARF_LOC((r), (DWARF_LOC_TYPE_REG      \
+                                                 | DWARF_LOC_TYPE_FP))
+ 
+@@ -195,38 +182,33 @@ dwarf_putfp (struct dwarf_cursor *c, dwarf_loc_t loc, unw_fpreg_t val)
+                                    1, c->as_arg);
+ }
+ 
++#endif /* !UNW_LOCAL_ONLY */
++
+ static inline int
+ dwarf_get (struct dwarf_cursor *c, dwarf_loc_t loc, unw_word_t *val)
+ {
+   if (DWARF_IS_NULL_LOC (loc))
+     return -UNW_EBADREG;
+ 
+-  /* If a code-generator were to save a value of type unw_word_t in a
+-     floating-point register, we would have to support this case.  I
+-     suppose it could happen with MMX registers, but does it really
+-     happen?  */
+-  assert (!DWARF_IS_FP_LOC (loc));
+-
+   if (DWARF_IS_REG_LOC (loc))
+     return (*c->as->acc.access_reg) (c->as, DWARF_GET_LOC (loc), val,
+                                      0, c->as_arg);
+-  else
++  if (DWARF_IS_MEM_LOC (loc))
+     return (*c->as->acc.access_mem) (c->as, DWARF_GET_LOC (loc), val,
+                                      0, c->as_arg);
++  assert(DWARF_IS_VAL_LOC (loc));
++  *val = DWARF_GET_LOC (loc);
++  return 0;
+ }
+ 
+ static inline int
+ dwarf_put (struct dwarf_cursor *c, dwarf_loc_t loc, unw_word_t val)
+ {
++  assert(!DWARF_IS_VAL_LOC (loc));
++
+   if (DWARF_IS_NULL_LOC (loc))
+     return -UNW_EBADREG;
+ 
+-  /* If a code-generator were to save a value of type unw_word_t in a
+-     floating-point register, we would have to support this case.  I
+-     suppose it could happen with MMX registers, but does it really
+-     happen?  */
+-  assert (!DWARF_IS_FP_LOC (loc));
+-
+   if (DWARF_IS_REG_LOC (loc))
+     return (*c->as->acc.access_reg) (c->as, DWARF_GET_LOC (loc), &val,
+                                      1, c->as_arg);
+@@ -235,7 +217,9 @@ dwarf_put (struct dwarf_cursor *c, dwarf_loc_t loc, unw_word_t val)
+                                      1, c->as_arg);
+ }
+ 
+-#endif /* !UNW_LOCAL_ONLY */
++// For historical reasons, the DWARF numbering does not match the libunwind
++// numbering, necessitating this override
++#define TDEP_DWARF_SP 4
+ 
+ #define tdep_getcontext_trace           unw_getcontext
+ #define tdep_init_done                  UNW_OBJ(init_done)
+diff --git a/src/dwarf/Gparser.c b/src/dwarf/Gparser.c
+index 7d255aee..b1308d3c 100644
+--- a/src/dwarf/Gparser.c
++++ b/src/dwarf/Gparser.c
+@@ -28,6 +28,7 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.  */
+ #include <stddef.h>
+ #include <limits.h>
+ 
++
+ #define alloc_reg_state()       (mempool_alloc (&dwarf_reg_state_pool))
+ #define free_reg_state(rs)      (mempool_free (&dwarf_reg_state_pool, rs))
+ 
+@@ -501,6 +502,9 @@ setup_fde (struct dwarf_cursor *c, dwarf_state_record_t *sr)
+   for (i = 0; i < DWARF_NUM_PRESERVED_REGS + 2; ++i)
+     set_reg (sr, i, DWARF_WHERE_SAME, 0);
+ 
++  // SP defaults to CFA (but is overridable)
++  set_reg (sr, TDEP_DWARF_SP, DWARF_WHERE_CFA, 0);
++
+   struct dwarf_cie_info *dci = c->pi.unwind_info;
+   sr->rs_current.ret_addr_column  = dci->ret_addr_column;
+   unw_word_t addr = dci->cie_instr_start;
+@@ -785,14 +789,14 @@ apply_reg_state (struct dwarf_cursor *c, struct dwarf_reg_state *rs)
+       /* As a special-case, if the stack-pointer is the CFA and the
+          stack-pointer wasn't saved, popping the CFA implicitly pops
+          the stack-pointer as well.  */
+-      if ((rs->reg.val[DWARF_CFA_REG_COLUMN] == UNW_TDEP_SP)
+-          && (UNW_TDEP_SP < ARRAY_SIZE(rs->reg.val))
+-          && (rs->reg.where[UNW_TDEP_SP] == DWARF_WHERE_SAME))
++      if ((rs->reg.val[DWARF_CFA_REG_COLUMN] == TDEP_DWARF_SP)
++          && (TDEP_DWARF_SP < ARRAY_SIZE(rs->reg.val))
++          && (DWARF_IS_NULL_LOC(c->loc[TDEP_DWARF_SP])))
+           cfa = c->cfa;
+       else
+         {
+           regnum = dwarf_to_unw_regnum (rs->reg.val[DWARF_CFA_REG_COLUMN]);
+-          if ((ret = unw_get_reg ((unw_cursor_t *) c, regnum, &cfa)) < 0)
++          if ((ret = unw_get_reg (dwarf_to_cursor(c), regnum, &cfa)) < 0)
+             return ret;
+         }
+       cfa += rs->reg.val[DWARF_CFA_OFF_COLUMN];
+@@ -826,6 +830,10 @@ apply_reg_state (struct dwarf_cursor *c, struct dwarf_reg_state *rs)
+         case DWARF_WHERE_SAME:
+           break;
+ 
++        case DWARF_WHERE_CFA:
++          new_loc[i] = DWARF_VAL_LOC (c, cfa);
++          break;
++
+         case DWARF_WHERE_CFAREL:
+           new_loc[i] = DWARF_MEM_LOC (c, cfa + rs->reg.val[i]);
+           break;
+diff --git a/src/x86/Gos-freebsd.c b/src/x86/Gos-freebsd.c
+index 7dd01404..1b251d02 100644
+--- a/src/x86/Gos-freebsd.c
++++ b/src/x86/Gos-freebsd.c
+@@ -138,6 +138,7 @@ x86_handle_signal_frame (unw_cursor_t *cursor)
+     c->dwarf.loc[ST0] = DWARF_NULL_LOC;
+   } else if (c->sigcontext_format == X86_SCF_FREEBSD_SYSCALL) {
+     c->dwarf.loc[EIP] = DWARF_LOC (c->dwarf.cfa, 0);
++    c->dwarf.loc[ESP] = DWARF_VAL_LOC (c, c->dwarf.cfa + 4);
+     c->dwarf.loc[EAX] = DWARF_NULL_LOC;
+     c->dwarf.cfa += 4;
+     c->dwarf.use_prev_instr = 1;
+diff --git a/src/x86/Gregs.c b/src/x86/Gregs.c
+index 4a959261..9446d6c6 100644
+--- a/src/x86/Gregs.c
++++ b/src/x86/Gregs.c
+@@ -53,7 +53,6 @@ tdep_access_reg (struct cursor *c, unw_regnum_t reg, unw_word_t *valp,
+       break;
+ 
+     case UNW_X86_CFA:
+-    case UNW_X86_ESP:
+       if (write)
+         return -UNW_EREADONLYREG;
+       *valp = c->dwarf.cfa;
+@@ -81,6 +80,7 @@ tdep_access_reg (struct cursor *c, unw_regnum_t reg, unw_word_t *valp,
+     case UNW_X86_ECX: loc = c->dwarf.loc[ECX]; break;
+     case UNW_X86_EBX: loc = c->dwarf.loc[EBX]; break;
+ 
++    case UNW_X86_ESP: loc = c->dwarf.loc[ESP]; break;
+     case UNW_X86_EBP: loc = c->dwarf.loc[EBP]; break;
+     case UNW_X86_ESI: loc = c->dwarf.loc[ESI]; break;
+     case UNW_X86_EDI: loc = c->dwarf.loc[EDI]; break;
+diff --git a/src/x86/Gstep.c b/src/x86/Gstep.c
+index 129b739a..061dcbaa 100644
+--- a/src/x86/Gstep.c
++++ b/src/x86/Gstep.c
+@@ -47,7 +47,7 @@ unw_step (unw_cursor_t *cursor)
+     {
+       /* DWARF failed, let's see if we can follow the frame-chain
+          or skip over the signal trampoline.  */
+-      struct dwarf_loc ebp_loc, eip_loc;
++      struct dwarf_loc ebp_loc, eip_loc, esp_loc;
+ 
+       /* We could get here because of missing/bad unwind information.
+          Validate all addresses before dereferencing. */
+@@ -77,6 +77,7 @@ unw_step (unw_cursor_t *cursor)
+                  c->dwarf.cfa);
+ 
+           ebp_loc = DWARF_LOC (c->dwarf.cfa, 0);
++          esp_loc = DWARF_VAL_LOC (c, c->dwarf.cfa + 8);
+           eip_loc = DWARF_LOC (c->dwarf.cfa + 4, 0);
+           c->dwarf.cfa += 8;
+ 
+@@ -87,6 +88,7 @@ unw_step (unw_cursor_t *cursor)
+             c->dwarf.loc[i] = DWARF_NULL_LOC;
+ 
+           c->dwarf.loc[EBP] = ebp_loc;
++          c->dwarf.loc[ESP] = esp_loc;
+           c->dwarf.loc[EIP] = eip_loc;
+           c->dwarf.use_prev_instr = 1;
+         }
+diff --git a/src/x86_64/Ginit.c b/src/x86_64/Ginit.c
+index b7e8e462..64b800af 100644
+--- a/src/x86_64/Ginit.c
++++ b/src/x86_64/Ginit.c
+@@ -49,8 +49,6 @@ static struct unw_addr_space local_addr_space;
+ 
+ unw_addr_space_t unw_local_addr_space = &local_addr_space;
+ 
+-HIDDEN unw_dyn_info_list_t _U_dyn_info_list;
+-
+ /* XXX fix me: there is currently no way to locate the dyn-info list
+        by a remote unwinder.  On ia64, this is done via a special
+        unwind-table entry.  Perhaps something similar can be done with
+@@ -66,7 +64,12 @@ static int
+ get_dyn_info_list_addr (unw_addr_space_t as, unw_word_t *dyn_info_list_addr,
+                         void *arg)
+ {
+-  *dyn_info_list_addr = (unw_word_t) &_U_dyn_info_list;
++#ifndef UNW_LOCAL_ONLY
++# pragma weak _U_dyn_info_list_addr
++  if (!_U_dyn_info_list_addr)
++    return -UNW_ENOINFO;
++#endif
++  *dyn_info_list_addr = _U_dyn_info_list_addr ();
+   return 0;
+ }
+ 
+diff --git a/src/x86_64/Gos-freebsd.c b/src/x86_64/Gos-freebsd.c
+index 883025c8..8bb101ea 100644
+--- a/src/x86_64/Gos-freebsd.c
++++ b/src/x86_64/Gos-freebsd.c
+@@ -133,6 +133,7 @@ x86_64_handle_signal_frame (unw_cursor_t *cursor)
+     c->dwarf.loc[RCX] = c->dwarf.loc[R10];
+     /*  rsp_loc = DWARF_LOC(c->dwarf.cfa - 8, 0);       */
+     /*  rbp_loc = c->dwarf.loc[RBP];                    */
++    c->dwarf.loc[RSP] = DWARF_VAL_LOC (c, c->dwarf.cfa + 8);
+     c->dwarf.loc[RIP] = DWARF_LOC (c->dwarf.cfa, 0);
+     ret = dwarf_get (&c->dwarf, c->dwarf.loc[RIP], &c->dwarf.ip);
+     Debug (1, "Frame Chain [RIP=0x%Lx] = 0x%Lx\n",
+diff --git a/src/x86_64/Gregs.c b/src/x86_64/Gregs.c
+index baf8a24f..dff5bcbe 100644
+--- a/src/x86_64/Gregs.c
++++ b/src/x86_64/Gregs.c
+@@ -79,7 +79,6 @@ tdep_access_reg (struct cursor *c, unw_regnum_t reg, unw_word_t *valp,
+       break;
+ 
+     case UNW_X86_64_CFA:
+-    case UNW_X86_64_RSP:
+       if (write)
+         return -UNW_EREADONLYREG;
+       *valp = c->dwarf.cfa;
+@@ -107,6 +106,7 @@ tdep_access_reg (struct cursor *c, unw_regnum_t reg, unw_word_t *valp,
+     case UNW_X86_64_RCX: loc = c->dwarf.loc[RCX]; break;
+     case UNW_X86_64_RBX: loc = c->dwarf.loc[RBX]; break;
+ 
++    case UNW_X86_64_RSP: loc = c->dwarf.loc[RSP]; break;
+     case UNW_X86_64_RBP: loc = c->dwarf.loc[RBP]; break;
+     case UNW_X86_64_RSI: loc = c->dwarf.loc[RSI]; break;
+     case UNW_X86_64_RDI: loc = c->dwarf.loc[RDI]; break;
+diff --git a/src/x86_64/Gstep.c b/src/x86_64/Gstep.c
+index 10498170..5425e3db 100644
+--- a/src/x86_64/Gstep.c
++++ b/src/x86_64/Gstep.c
+@@ -160,7 +160,7 @@ unw_step (unw_cursor_t *cursor)
+             {
+               unw_word_t rbp1 = 0;
+               rbp_loc = DWARF_LOC(rbp, 0);
+-              rsp_loc = DWARF_NULL_LOC;
++              rsp_loc = DWARF_VAL_LOC(c, rbp + 16);
+               rip_loc = DWARF_LOC (rbp + 8, 0);
+               ret = dwarf_get (&c->dwarf, rbp_loc, &rbp1);
+               Debug (1, "[RBP=0x%lx] = 0x%lx (cfa = 0x%lx) -> 0x%lx\n",
diff --git a/deps/patches/libunwind-rsp-cfa.patch b/deps/patches/libunwind-rsp-cfa.patch
deleted file mode 100644
index 05986b0e7010a..0000000000000
--- a/deps/patches/libunwind-rsp-cfa.patch
+++ /dev/null
@@ -1,177 +0,0 @@
-commit 66f68ab50d35bb17a7ae3ac47f17e1ba5913760c
-Author: Keno Fischer <keno@juliacomputing.com>
-Date:   Sat Feb 6 18:13:16 2021 -0500
-
-    x86_64: Stop aliasing RSP and CFA
-    
-    RSP and CFA are different concepts. RSP refers to the physical
-    register, CFA is a virtual register that serves as the base
-    address for various other saved registers. It is true that
-    in many frames these are set to alias, however this is not
-    a requirement. For example, a function that performs a stack
-    switch would likely change the rsp in the middle of the function,
-    but would keep the CFA at the original RSP such that saved registers
-    may be appropriately recovered.
-    
-    We are seeing incorrect unwinds in the Julia runtime when running
-    julia under rr. This is because injects code (with correct CFI)
-    that performs just such a stack switch [1]. GDB manages to unwind
-    this correctly, but libunwind incorrectly sets the rsp to the CFA
-    address, causing a misunwind.
-    
-    Tested on x86_64, patches for other architectures are ported, but
-    not tested.
-    
-    [1] https://github.com/rr-debugger/rr/blob/469c22059a4a1798d33a8a224457faf22b2c178c/src/preload/syscall_hook.S#L454
-
-diff --git a/include/dwarf.h b/include/dwarf.h
-index fab93c61..b845e2eb 100644
---- a/include/dwarf.h
-+++ b/include/dwarf.h
-@@ -227,6 +227,7 @@ typedef enum
-     DWARF_WHERE_REG,            /* register saved in another register */
-     DWARF_WHERE_EXPR,           /* register saved */
-     DWARF_WHERE_VAL_EXPR,       /* register has computed value */
-+    DWARF_WHERE_CFA,            /* register is set to the computed cfa value */
-   }
- dwarf_where_t;
- 
-@@ -309,7 +310,7 @@ typedef struct dwarf_cursor
-     void *as_arg;               /* argument to address-space callbacks */
-     unw_addr_space_t as;        /* reference to per-address-space info */
- 
--    unw_word_t cfa;     /* canonical frame address; aka frame-/stack-pointer */
-+    unw_word_t cfa;     /* canonical frame address; aka frame-pointer */
-     unw_word_t ip;              /* instruction pointer */
-     unw_word_t args_size;       /* size of arguments */
-     unw_word_t eh_args[UNW_TDEP_NUM_EH_REGS];
-diff --git a/src/dwarf/Gparser.c b/src/dwarf/Gparser.c
-index 7d255aee..986c4a89 100644
---- a/src/dwarf/Gparser.c
-+++ b/src/dwarf/Gparser.c
-@@ -500,6 +500,8 @@ setup_fde (struct dwarf_cursor *c, dwarf_state_record_t *sr)
-   memset (sr, 0, sizeof (*sr));
-   for (i = 0; i < DWARF_NUM_PRESERVED_REGS + 2; ++i)
-     set_reg (sr, i, DWARF_WHERE_SAME, 0);
-+  // SP defaults to CFA (but is overridable)
-+  set_reg (sr, UNW_TDEP_SP, DWARF_WHERE_CFA, 0);
- 
-   struct dwarf_cie_info *dci = c->pi.unwind_info;
-   sr->rs_current.ret_addr_column  = dci->ret_addr_column;
-@@ -826,6 +828,10 @@ apply_reg_state (struct dwarf_cursor *c, struct dwarf_reg_state *rs)
-         case DWARF_WHERE_SAME:
-           break;
- 
-+        case DWARF_WHERE_CFA:
-+          new_loc[i] = DWARF_VAL_LOC (c, cfa);
-+          break;
-+
-         case DWARF_WHERE_CFAREL:
-           new_loc[i] = DWARF_MEM_LOC (c, cfa + rs->reg.val[i]);
-           break;
-diff --git a/src/x86/Gos-freebsd.c b/src/x86/Gos-freebsd.c
-index 7dd01404..1b251d02 100644
---- a/src/x86/Gos-freebsd.c
-+++ b/src/x86/Gos-freebsd.c
-@@ -138,6 +138,7 @@ x86_handle_signal_frame (unw_cursor_t *cursor)
-     c->dwarf.loc[ST0] = DWARF_NULL_LOC;
-   } else if (c->sigcontext_format == X86_SCF_FREEBSD_SYSCALL) {
-     c->dwarf.loc[EIP] = DWARF_LOC (c->dwarf.cfa, 0);
-+    c->dwarf.loc[ESP] = DWARF_VAL_LOC (c, c->dwarf.cfa + 4);
-     c->dwarf.loc[EAX] = DWARF_NULL_LOC;
-     c->dwarf.cfa += 4;
-     c->dwarf.use_prev_instr = 1;
-diff --git a/src/x86/Gregs.c b/src/x86/Gregs.c
-index 4a959261..9446d6c6 100644
---- a/src/x86/Gregs.c
-+++ b/src/x86/Gregs.c
-@@ -53,7 +53,6 @@ tdep_access_reg (struct cursor *c, unw_regnum_t reg, unw_word_t *valp,
-       break;
- 
-     case UNW_X86_CFA:
--    case UNW_X86_ESP:
-       if (write)
-         return -UNW_EREADONLYREG;
-       *valp = c->dwarf.cfa;
-@@ -81,6 +80,7 @@ tdep_access_reg (struct cursor *c, unw_regnum_t reg, unw_word_t *valp,
-     case UNW_X86_ECX: loc = c->dwarf.loc[ECX]; break;
-     case UNW_X86_EBX: loc = c->dwarf.loc[EBX]; break;
- 
-+    case UNW_X86_ESP: loc = c->dwarf.loc[ESP]; break;
-     case UNW_X86_EBP: loc = c->dwarf.loc[EBP]; break;
-     case UNW_X86_ESI: loc = c->dwarf.loc[ESI]; break;
-     case UNW_X86_EDI: loc = c->dwarf.loc[EDI]; break;
-diff --git a/src/x86/Gstep.c b/src/x86/Gstep.c
-index 129b739a..061dcbaa 100644
---- a/src/x86/Gstep.c
-+++ b/src/x86/Gstep.c
-@@ -47,7 +47,7 @@ unw_step (unw_cursor_t *cursor)
-     {
-       /* DWARF failed, let's see if we can follow the frame-chain
-          or skip over the signal trampoline.  */
--      struct dwarf_loc ebp_loc, eip_loc;
-+      struct dwarf_loc ebp_loc, eip_loc, esp_loc;
- 
-       /* We could get here because of missing/bad unwind information.
-          Validate all addresses before dereferencing. */
-@@ -77,6 +77,7 @@ unw_step (unw_cursor_t *cursor)
-                  c->dwarf.cfa);
- 
-           ebp_loc = DWARF_LOC (c->dwarf.cfa, 0);
-+          esp_loc = DWARF_VAL_LOC (c, c->dwarf.cfa + 8);
-           eip_loc = DWARF_LOC (c->dwarf.cfa + 4, 0);
-           c->dwarf.cfa += 8;
- 
-@@ -87,6 +88,7 @@ unw_step (unw_cursor_t *cursor)
-             c->dwarf.loc[i] = DWARF_NULL_LOC;
- 
-           c->dwarf.loc[EBP] = ebp_loc;
-+          c->dwarf.loc[ESP] = esp_loc;
-           c->dwarf.loc[EIP] = eip_loc;
-           c->dwarf.use_prev_instr = 1;
-         }
-diff --git a/src/x86_64/Gos-freebsd.c b/src/x86_64/Gos-freebsd.c
-index 883025c8..8bb101ea 100644
---- a/src/x86_64/Gos-freebsd.c
-+++ b/src/x86_64/Gos-freebsd.c
-@@ -133,6 +133,7 @@ x86_64_handle_signal_frame (unw_cursor_t *cursor)
-     c->dwarf.loc[RCX] = c->dwarf.loc[R10];
-     /*  rsp_loc = DWARF_LOC(c->dwarf.cfa - 8, 0);       */
-     /*  rbp_loc = c->dwarf.loc[RBP];                    */
-+    c->dwarf.loc[RSP] = DWARF_VAL_LOC (c, c->dwarf.cfa + 8);
-     c->dwarf.loc[RIP] = DWARF_LOC (c->dwarf.cfa, 0);
-     ret = dwarf_get (&c->dwarf, c->dwarf.loc[RIP], &c->dwarf.ip);
-     Debug (1, "Frame Chain [RIP=0x%Lx] = 0x%Lx\n",
-diff --git a/src/x86_64/Gregs.c b/src/x86_64/Gregs.c
-index baf8a24f..dff5bcbe 100644
---- a/src/x86_64/Gregs.c
-+++ b/src/x86_64/Gregs.c
-@@ -79,7 +79,6 @@ tdep_access_reg (struct cursor *c, unw_regnum_t reg, unw_word_t *valp,
-       break;
- 
-     case UNW_X86_64_CFA:
--    case UNW_X86_64_RSP:
-       if (write)
-         return -UNW_EREADONLYREG;
-       *valp = c->dwarf.cfa;
-@@ -107,6 +106,7 @@ tdep_access_reg (struct cursor *c, unw_regnum_t reg, unw_word_t *valp,
-     case UNW_X86_64_RCX: loc = c->dwarf.loc[RCX]; break;
-     case UNW_X86_64_RBX: loc = c->dwarf.loc[RBX]; break;
- 
-+    case UNW_X86_64_RSP: loc = c->dwarf.loc[RSP]; break;
-     case UNW_X86_64_RBP: loc = c->dwarf.loc[RBP]; break;
-     case UNW_X86_64_RSI: loc = c->dwarf.loc[RSI]; break;
-     case UNW_X86_64_RDI: loc = c->dwarf.loc[RDI]; break;
-diff --git a/src/x86_64/Gstep.c b/src/x86_64/Gstep.c
-index 10498170..5425e3db 100644
---- a/src/x86_64/Gstep.c
-+++ b/src/x86_64/Gstep.c
-@@ -160,7 +160,7 @@ unw_step (unw_cursor_t *cursor)
-             {
-               unw_word_t rbp1 = 0;
-               rbp_loc = DWARF_LOC(rbp, 0);
--              rsp_loc = DWARF_NULL_LOC;
-+              rsp_loc = DWARF_VAL_LOC(c, rbp + 16);
-               rip_loc = DWARF_LOC (rbp + 8, 0);
-               ret = dwarf_get (&c->dwarf, rbp_loc, &rbp1);
-               Debug (1, "[RBP=0x%lx] = 0x%lx (cfa = 0x%lx) -> 0x%lx\n",
diff --git a/deps/unwind.mk b/deps/unwind.mk
index 4dec41f58a32b..674e3079413bf 100644
--- a/deps/unwind.mk
+++ b/deps/unwind.mk
@@ -24,11 +24,11 @@ $(SRCCACHE)/libunwind-$(UNWIND_VER)/libunwind-static-arm.patch-applied: $(SRCCAC
 	cd $(SRCCACHE)/libunwind-$(UNWIND_VER) && patch -p1 -f < $(SRCDIR)/patches/libunwind-static-arm.patch
 	echo 1 > $@
 
-$(SRCCACHE)/libunwind-$(UNWIND_VER)/libunwind-rsp-cfa.patch-applied: $(SRCCACHE)/libunwind-$(UNWIND_VER)/libunwind-static-arm.patch-applied
-	cd $(SRCCACHE)/libunwind-$(UNWIND_VER) && patch -p1 -f -u < $(SRCDIR)/patches/libunwind-rsp-cfa.patch
+$(SRCCACHE)/libunwind-$(UNWIND_VER)/libunwind-cfa-rsp.patch-applied: $(SRCCACHE)/libunwind-$(UNWIND_VER)/libunwind-static-arm.patch-applied
+	cd $(SRCCACHE)/libunwind-$(UNWIND_VER) && patch -p1 -f -u < $(SRCDIR)/patches/libunwind-cfa-rsp.patch
 	echo 1 > $@
 
-$(BUILDDIR)/libunwind-$(UNWIND_VER)/build-configured: $(SRCCACHE)/libunwind-$(UNWIND_VER)/source-extracted $(SRCCACHE)/libunwind-$(UNWIND_VER)/libunwind-rsp-cfa.patch-applied
+$(BUILDDIR)/libunwind-$(UNWIND_VER)/build-configured: $(SRCCACHE)/libunwind-$(UNWIND_VER)/source-extracted $(SRCCACHE)/libunwind-$(UNWIND_VER)/libunwind-cfa-rsp.patch-applied
 	mkdir -p $(dir $@)
 	cd $(dir $@) && \
 	$(dir $<)/configure $(CONFIGURE_COMMON) CPPFLAGS="$(CPPFLAGS) $(LIBUNWIND_CPPFLAGS)" CFLAGS="$(CFLAGS) $(LIBUNWIND_CFLAGS)" --disable-shared --disable-minidebuginfo --disable-tests