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
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
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)
diff --git a/base/arrayshow.jl b/base/arrayshow.jl
index 37adaf13f669e..0b441f8ce5e82 100644
--- a/base/arrayshow.jl
+++ b/base/arrayshow.jl
@@ -385,8 +385,9 @@ 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, cr2 = UnitRange{Int}(indc), 1:0
+    rr1, rr2 = unitrange(indr), 1:0
+    cr1 = unitrange(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/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/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/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/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index c8b4ff5052e47..368dc602b98a7 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
@@ -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)
@@ -679,16 +674,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 +704,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
@@ -826,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])
@@ -945,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)
@@ -1304,6 +1300,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
@@ -1326,6 +1344,7 @@ function typeinf_local(interp::AbstractInterpreter, frame::InferenceState)
             frame.currpc = pc
             frame.cur_hand = frame.handler_at[pc]
             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
@@ -1338,7 +1357,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 +1388,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,12 +1399,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))
-                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)
@@ -1414,9 +1428,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 +1496,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/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 9d9bc45dc1e9f..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
@@ -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..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},
@@ -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
@@ -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
@@ -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
 
@@ -1010,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
 
@@ -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/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/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/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/base/compiler/typeutils.jl b/base/compiler/typeutils.jl
index 954f14cfbfbbc..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
@@ -187,17 +189,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,
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/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/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/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/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/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/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/show.jl b/base/show.jl
index 2fbc8f50ee737..da50172109846 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)
@@ -761,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)
@@ -784,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))
@@ -817,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/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)
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..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
@@ -135,6 +141,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/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(); \
diff --git a/deps/Versions.make b/deps/Versions.make
index 4d7d31cfbfb37..c30e45a96a355 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
@@ -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
@@ -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
@@ -101,6 +101,7 @@ SUITESPARSE_JLL_NAME := SuiteSparse
 # unwind
 UNWIND_VER := 1.3.2
 UNWIND_JLL_NAME := LibUnwind
+UNWIND_JLL_VER  := 1.3.2+4
 
 # zlib
 ZLIB_VER := 1.2.11
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-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/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-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/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/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/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/checksums/unwind b/deps/checksums/unwind
index 1ec7c6189c85a..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+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+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/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/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/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/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/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/deps/unwind.mk b/deps/unwind.mk
index 351f9b3df745f..674e3079413bf 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-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-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
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/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/src/builtin_proto.h b/src/builtin_proto.h
index 8021c404bd5e7..c4d6166a5c194 100644
--- a/src/builtin_proto.h
+++ b/src/builtin_proto.h
@@ -22,9 +22,9 @@ 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_latest); DECLARE_BUILTIN(_apply_iterate);
-DECLARE_BUILTIN(_apply_in_world);
+DECLARE_BUILTIN(_apply_pure);
+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..30a900045837b 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);
 }
 
@@ -504,9 +509,7 @@ 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 *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 +551,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 +675,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 +693,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;
     }
@@ -712,21 +704,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 +726,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;
 }
@@ -1376,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);
@@ -1550,13 +1541,12 @@ 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);
     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/ccall.cpp b/src/ccall.cpp
index 65c0fa74c9ace..66ab84c264f3a 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)
 {
@@ -1007,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);
         }
@@ -1068,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
         }
 
@@ -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/codegen.cpp b/src/codegen.cpp
index 126146e3ba811..817aceddfe403 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -838,11 +838,10 @@ 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__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} },
@@ -2337,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);
@@ -2348,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)
 {
@@ -2695,13 +2707,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);
@@ -3310,8 +3320,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++;
     }
@@ -4711,8 +4720,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;
@@ -5088,8 +5100,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++) {
@@ -5509,8 +5520,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++;
     }
@@ -5657,7 +5667,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);
@@ -6845,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);
@@ -6928,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 {
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/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/src/gf.c b/src/gf.c
index 4b07e35e2edba..cf22c9b0095a3 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);
@@ -1586,26 +1586,25 @@ 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;
+    // 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 (!(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/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/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/jlapi.c b/src/jlapi.c
index 1c14232fb8f8f..d27f7e03d958c 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_base_module ? jl_get_function(jl_base_module, "show") : NULL;
+        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/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/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/src/julia-syntax.scm b/src/julia-syntax.scm
index b9043f11b8b94..620253de26bbc 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")))))))))
 
@@ -1785,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/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);
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/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?);
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/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/src/staticdata.c b/src/staticdata.c
index 625cc6c197309..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,8 +235,8 @@ 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__apply_latest, &jl_f__apply_in_world, &jl_f_isdefined,
+    &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,
     &jl_f_arrayref, &jl_f_const_arrayref, &jl_f_arrayset, &jl_f_arraysize, &jl_f_apply_type,
diff --git a/src/subtype.c b/src/subtype.c
index 5148232fa58c8..76fcab4c0a301 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)
@@ -2439,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
@@ -3276,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/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
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/Downloads.version b/stdlib/Downloads.version
index 4d5a67afafcad..9dc2783a1389b 100644
--- a/stdlib/Downloads.version
+++ b/stdlib/Downloads.version
@@ -1,2 +1,2 @@
 DOWNLOADS_BRANCH = master
-DOWNLOADS_SHA1 = 0d798cfe2c06c304833dde913552fe13559a0c20
+DOWNLOADS_SHA1 = 6bb83068bd796c4890baaeb39628ff79a4979374
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
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/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"
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/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))
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
diff --git a/stdlib/Pkg.version b/stdlib/Pkg.version
index 8aaf812e816af..f379c4e6af7f9 100644
--- a/stdlib/Pkg.version
+++ b/stdlib/Pkg.version
@@ -1,2 +1,2 @@
 PKG_BRANCH = release-1.6
-PKG_SHA1 = 9adb32bb8027815dadc266b94201d772ac4c48b1
+PKG_SHA1 = 05fa7f93f73afdabd251247d03144de9f7b36b50
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")
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)
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
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"
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.
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
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
diff --git a/test/ccall.jl b/test/ccall.jl
index c8484579929e1..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")
@@ -1576,6 +1582,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();
diff --git a/test/cmdlineargs.jl b/test/cmdlineargs.jl
index 3a331d406d886..6b600ad40f934 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,
@@ -204,7 +205,10 @@ 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))
+    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)
@@ -316,15 +320,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"
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...)
diff --git a/test/core.jl b/test/core.jl
index 28af6b88ceb4d..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}}
@@ -4124,15 +4121,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)
@@ -5307,6 +5295,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
@@ -7288,12 +7286,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)
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
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
diff --git a/test/precompile.jl b/test/precompile.jl
index 22cc2d31db8a0..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},
@@ -314,7 +315,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]
             ),
@@ -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},
diff --git a/test/show.jl b/test/show.jl
index b0bc4455d990a..62388b5ae6613 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, $(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{AbstractVector{T} where T, T} where T"
 
 @test sprint(show, :(./)) == ":((./))"
 @test sprint(show, :((.|).(.&, b))) == ":((.|).((.&), b))"
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
diff --git a/test/subtype.jl b/test/subtype.jl
index 6298097b9b3d9..031a1815b2930 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
@@ -1865,3 +1871,17 @@ 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
+
+# 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
diff --git a/test/syntax.jl b/test/syntax.jl
index c6a43116a937d..eb113ed4da2c5 100644
--- a/test/syntax.jl
+++ b/test/syntax.jl
@@ -2645,3 +2645,32 @@ 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
+
+@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
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.