From 237ad1a1e73170e0efdcf4601c28413b10613e00 Mon Sep 17 00:00:00 2001 From: Klaus Crusius Date: Mon, 22 Apr 2024 05:47:57 +0200 Subject: [PATCH 01/56] power uses Float64 exponents for integers (#53967) Improve performance of `^(::Float64, n::Integer)` in the case of `abs(n) > 2^13`. While `pow_body` is unreliable for `abs(n) > 2^25` this implementation provides errors of a few ULPs, while runtime is capped to that of the `Float64` implementation. Fixes #53881 See also #53886. (cherry picked from commit fe49d5661833e512a557913591514fcd32f7b783) --- base/math.jl | 52 +++++++++++++++++++++++++++++++--------- base/special/exp.jl | 2 +- test/compiler/codegen.jl | 2 +- test/math.jl | 19 +++++++++++++++ 4 files changed, 62 insertions(+), 13 deletions(-) diff --git a/base/math.jl b/base/math.jl index 5266cff8d47fc..9c02b43140aaf 100644 --- a/base/math.jl +++ b/base/math.jl @@ -1140,6 +1140,10 @@ function modf(x::T) where T<:IEEEFloat return (rx, ix) end +@inline function use_power_by_squaring(n::Integer) + -2^12 <= n <= 3 * 2^13 +end + # @constprop aggressive to help the compiler see the switch between the integer and float # variants for callers with constant `y` @constprop :aggressive function ^(x::Float64, y::Float64) @@ -1152,24 +1156,33 @@ end y = sign(y)*0x1.8p62 end yint = unsafe_trunc(Int64, y) # This is actually safe since julia freezes the result - y == yint && return @noinline x^yint - 2*xu==0 && return abs(y)*Inf*(!(y>0)) # if x==0 - x<0 && throw_exp_domainerror(x) # |y| is small enough that y isn't an integer - !isfinite(x) && return x*(y>0 || isnan(x)) # x is inf or NaN + yisint = y == yint + if yisint + yint == 0 && return 1.0 + use_power_by_squaring(yint) && return @noinline pow_body(x, yint) + end + 2*xu==0 && return abs(y)*Inf*(!(y>0)) # if x === +0.0 or -0.0 (Inf * false === 0.0) + s = 1 + if x < 0 + !yisint && throw_exp_domainerror(x) # y isn't an integer + s = ifelse(isodd(yint), -1, 1) + end + !isfinite(x) && return copysign(x,s)*(y>0 || isnan(x)) # x is inf or NaN + return copysign(pow_body(abs(x), y), s) +end + +@assume_effects :foldable @noinline function pow_body(x::Float64, y::Float64) + xu = reinterpret(UInt64, x) if xu < (UInt64(1)<<52) # x is subnormal xu = reinterpret(UInt64, x * 0x1p52) # normalize x xu &= ~sign_mask(Float64) xu -= UInt64(52) << 52 # mess with the exponent end - return pow_body(xu, y) -end - -@inline function pow_body(xu::UInt64, y::Float64) logxhi,logxlo = _log_ext(xu) xyhi, xylo = two_mul(logxhi,y) xylo = muladd(logxlo, y, xylo) hi = xyhi+xylo - return Base.Math.exp_impl(hi, xylo-(hi-xyhi), Val(:ℯ)) + return @inline Base.Math.exp_impl(hi, xylo-(hi-xyhi), Val(:ℯ)) end @constprop :aggressive function ^(x::T, y::T) where T <: Union{Float16, Float32} @@ -1193,12 +1206,29 @@ end return T(exp2(log2(abs(widen(x))) * y)) end -# compensated power by squaring @constprop :aggressive @inline function ^(x::Float64, n::Integer) + x^clamp(n, Int64) +end +@constprop :aggressive @inline function ^(x::Float64, n::Int64) n == 0 && return one(x) - return pow_body(x, n) + if use_power_by_squaring(n) + return pow_body(x, n) + else + s = ifelse(x < 0 && isodd(n), -1.0, 1.0) + x = abs(x) + y = float(n) + if y == n + return copysign(pow_body(x, y), s) + else + n2 = n % 1024 + y = float(n - n2) + return pow_body(x, y) * copysign(pow_body(x, n2), s) + end + end end +# compensated power by squaring +# this method is only reliable for -2^20 < n < 2^20 (cf. #53881 #53886) @assume_effects :terminates_locally @noinline function pow_body(x::Float64, n::Integer) y = 1.0 xnlo = ynlo = 0.0 diff --git a/base/special/exp.jl b/base/special/exp.jl index 32de6b9be296d..38d7509807aed 100644 --- a/base/special/exp.jl +++ b/base/special/exp.jl @@ -252,7 +252,7 @@ end twopk = (k + UInt64(53)) << 52 return reinterpret(T, twopk + reinterpret(UInt64, small_part))*0x1p-53 end - #k == 1024 && return (small_part * 2.0) * 2.0^1023 + k == 1024 && return (small_part * 2.0) * 2.0^1023 end twopk = Int64(k) << 52 return reinterpret(T, twopk + reinterpret(Int64, small_part)) diff --git a/test/compiler/codegen.jl b/test/compiler/codegen.jl index e434899be6e31..2691a8f4ea156 100644 --- a/test/compiler/codegen.jl +++ b/test/compiler/codegen.jl @@ -866,7 +866,7 @@ if Sys.ARCH === :x86_64 foo52079() = Core.Intrinsics.have_fma(Float64) if foo52079() == true let io = IOBuffer() - code_native(io,^,(Float64,Float64), dump_module=false) + code_native(io,Base.Math.exp_impl,(Float64,Float64,Val{:ℯ}), dump_module=false) str = String(take!(io)) @test !occursin("fma_emulated", str) @test occursin("vfmadd", str) diff --git a/test/math.jl b/test/math.jl index c48a0c7f56323..d73c13530f166 100644 --- a/test/math.jl +++ b/test/math.jl @@ -1464,6 +1464,25 @@ end # two cases where we have observed > 1 ULP in the past @test 0.0013653274095082324^-97.60372292227069 == 4.088393948750035e279 @test 8.758520413376658e-5^70.55863059215994 == 5.052076767078296e-287 + + # issue #53881 + c53881 = 2.2844135865398217e222 # check correctness within 2 ULPs + @test prevfloat(1.0) ^ -Int64(2)^62 ≈ c53881 atol=2eps(c53881) + @test 2.0 ^ typemin(Int) == 0.0 + @test (-1.0) ^ typemin(Int) == 1.0 + Z = Int64(2) + E = prevfloat(1.0) + @test E ^ (-Z^54) ≈ 7.38905609893065 + @test E ^ (-Z^62) ≈ 2.2844135865231613e222 + @test E ^ (-Z^63) == Inf + @test abs(E ^ (Z^62-1) * E ^ (-Z^62+1) - 1) <= eps(1.0) + n, x = -1065564664, 0.9999997040311492 + @test abs(x^n - Float64(big(x)^n)) / eps(x^n) == 0 # ULPs + @test E ^ (big(2)^100 + 1) == 0 + @test E ^ 6705320061009595392 == nextfloat(0.0) + n = Int64(1024 / log2(E)) + @test E^n == Inf + @test E^float(n) == Inf end # Test that sqrt behaves correctly and doesn't exhibit fp80 double rounding. From 82b3c6dfd73bf8a4aa44103c1dff1d47aeb2088e Mon Sep 17 00:00:00 2001 From: CY Han Date: Fri, 1 Nov 2024 22:20:10 +0800 Subject: [PATCH 02/56] docs: remove `dirname.c` from THIRDPARTY file (#56413) - `dirname.c` was removed by https://github.com/JuliaLang/julia/commit/c2cec7ad57102e4fbb733b8fb79d617a9524f0ae (cherry picked from commit 85dc2c72110e44f68f483c2b7b2e4dc68c73a143) --- THIRDPARTY.md | 1 - 1 file changed, 1 deletion(-) diff --git a/THIRDPARTY.md b/THIRDPARTY.md index 89d1ce3de3d97..412b84b688758 100644 --- a/THIRDPARTY.md +++ b/THIRDPARTY.md @@ -6,7 +6,6 @@ for exceptions. - [crc32c.c](https://stackoverflow.com/questions/17645167/implementing-sse-4-2s-crc32c-in-software) (CRC-32c checksum code by Mark Adler) [[ZLib](https://opensource.org/licenses/Zlib)]. - [LDC](https://github.com/ldc-developers/ldc/blob/master/LICENSE) (for ccall/cfunction ABI definitions) [BSD-3]. The portion of code that Julia uses from LDC is [BSD-3] licensed. - [LLVM](https://releases.llvm.org/3.9.0/LICENSE.TXT) (for parts of src/disasm.cpp) [UIUC] -- [MINGW](https://sourceforge.net/p/mingw/mingw-org-wsl/ci/legacy/tree/mingwrt/mingwex/dirname.c) (for dirname implementation on Windows) [MIT] - [NetBSD](https://www.netbsd.org/about/redistribution.html) (for setjmp, longjmp, and strptime implementations on Windows) [BSD-3] - [Python](https://docs.python.org/3/license.html) (for strtod implementation on Windows) [PSF] - [FEMTOLISP](https://github.com/JeffBezanson/femtolisp) [BSD-3] From 9833deff08094713cada4ccc763d3b63b9348852 Mon Sep 17 00:00:00 2001 From: Valentin Churavy Date: Tue, 18 Feb 2025 13:28:45 +0100 Subject: [PATCH 03/56] Only strip invariant.load from special pointers (#57386) Other backends (in this case NVPTX) require that `invariant.load` metadata is maintained to generate non-coherent loads. Currently, we unconditionally strip that metadata from all loads, since our other uses of it may have become invalid. x-ref: https://github.com/llvm/llvm-project/pull/112834 https://github.com/JuliaGPU/CUDA.jl/issues/2531 --------- Co-authored-by: Gabriel Baraldi (cherry picked from commit 29da86bb983066dd076439c2c7bc5e28dbd611bb) --- src/llvm-late-gc-lowering.cpp | 6 ++++-- test/llvmpasses/late-lower-gc.ll | 14 ++++++++++++++ 2 files changed, 18 insertions(+), 2 deletions(-) diff --git a/src/llvm-late-gc-lowering.cpp b/src/llvm-late-gc-lowering.cpp index 0fb5b9bb18805..8ba321c75b239 100644 --- a/src/llvm-late-gc-lowering.cpp +++ b/src/llvm-late-gc-lowering.cpp @@ -2331,8 +2331,10 @@ bool LateLowerGCFrame::CleanupIR(Function &F, State *S, bool *CFGModified) { // strip all constant alias information, as it might depend on the gc having // preserved a gc root, which stops being true after this pass (#32215) // similar to RewriteStatepointsForGC::stripNonValidData, but less aggressive - if (I->getMetadata(LLVMContext::MD_invariant_load)) - I->setMetadata(LLVMContext::MD_invariant_load, NULL); + if (auto *LI = dyn_cast(I)){ + if (isSpecialPtr(LI->getPointerOperand()->getType()) && LI->getMetadata(LLVMContext::MD_invariant_load)) + LI->setMetadata(LLVMContext::MD_invariant_load, NULL); + } if (MDNode *TBAA = I->getMetadata(LLVMContext::MD_tbaa)) { if (TBAA->getNumOperands() == 4 && isTBAA(TBAA, {"jtbaa_const", "jtbaa_memoryptr", "jtbaa_memorylen", "tbaa_memoryown"})) { MDNode *MutableTBAA = createMutableTBAAAccessTag(TBAA); diff --git a/test/llvmpasses/late-lower-gc.ll b/test/llvmpasses/late-lower-gc.ll index 6dee18da5975f..8ca588f717ee2 100644 --- a/test/llvmpasses/late-lower-gc.ll +++ b/test/llvmpasses/late-lower-gc.ll @@ -125,6 +125,20 @@ top: ret void } +; Confirm that `invariant.load` on other loads survive +define void @gc_keep_invariant(float addrspace(1)* %0) { +top: +; CHECK-LABEL: @gc_keep_invariant + %pgcstack = call {}*** @julia.get_pgcstack() + %1 = bitcast {}*** %pgcstack to {}** + %current_task = getelementptr inbounds {}*, {}** %1, i64 -12 + +; CHECK: %current_task = getelementptr inbounds ptr, ptr %1, i64 -12 + %2 = load float, ptr addrspace(1) %0, align 4, !invariant.load !1 +; CHECK-NEXT: %2 = load float, ptr addrspace(1) %0, align 4, !invariant.load + ret void +} + define i32 @callee_root({} addrspace(10)* %v0, {} addrspace(10)* %v1) { top: ; CHECK-LABEL: @callee_root From c793367af19337e0f5193dbf34438d99f29d0bb7 Mon Sep 17 00:00:00 2001 From: PatrickHaecker <152268010+PatrickHaecker@users.noreply.github.com> Date: Sun, 23 Feb 2025 16:17:53 +0100 Subject: [PATCH 04/56] `Base.summarysize` for `Memory` with `Union` (#57508) Fixes the double accounting of the union byte array in `Base.summarysize` as described in #57506. If this is the correct fix, can it be backported to 1.11? Fix #57506 (cherry picked from commit 7b7ba33021ba1b427ee0f482999674536e7cbcef) --- base/summarysize.jl | 7 +------ test/misc.jl | 5 +++++ 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/base/summarysize.jl b/base/summarysize.jl index 4f2646c7641b7..62b0ad0849778 100644 --- a/base/summarysize.jl +++ b/base/summarysize.jl @@ -149,13 +149,8 @@ function (ss::SummarySize)(obj::GenericMemory) datakey = unsafe_convert(Ptr{Cvoid}, obj) if !haskey(ss.seen, datakey) ss.seen[datakey] = true - dsize = sizeof(obj) + size += sizeof(obj) T = eltype(obj) - if isbitsunion(T) - # add 1 union selector byte for each element - dsize += length(obj) - end - size += dsize if !isempty(obj) && T !== Symbol && (!Base.allocatedinline(T) || (T isa DataType && !Base.datatype_pointerfree(T))) push!(ss.frontier_x, obj) push!(ss.frontier_i, 1) diff --git a/test/misc.jl b/test/misc.jl index 3907354e9410b..a66c868aa1e17 100644 --- a/test/misc.jl +++ b/test/misc.jl @@ -598,6 +598,11 @@ let z = Z53061[Z53061(S53061(rand(), (rand(),rand())), 0) for _ in 1:10^4] @test abs(summarysize(z) - 640000)/640000 <= 0.01 broken = Sys.WORD_SIZE == 32 && Sys.islinux() end +# issue #57506 +let len = 100, m1 = Memory{UInt8}(1:len), m2 = Memory{Union{Nothing,UInt8}}(1:len) + @test summarysize(m2) == summarysize(m1) + len +end + ## test conversion from UTF-8 to UTF-16 (for Windows APIs) # empty arrays From 0c9ac24f94c50689cab8fe016d26a7351e111445 Mon Sep 17 00:00:00 2001 From: Denis Barucic Date: Thu, 27 Feb 2025 20:49:06 +0100 Subject: [PATCH 05/56] Docs: `circshift!(::AbstractVector, ::Integer)` (#57539) Closes #46016 (cherry picked from commit b0323ab00fe756c5a30aeed80186e6e547417421) --- base/abstractarray.jl | 26 +++++++++++++++++++++++++- 1 file changed, 25 insertions(+), 1 deletion(-) diff --git a/base/abstractarray.jl b/base/abstractarray.jl index 45fff8dae0d24..be78c308afa53 100644 --- a/base/abstractarray.jl +++ b/base/abstractarray.jl @@ -3654,7 +3654,31 @@ function _keepat!(a::AbstractVector, m::AbstractVector{Bool}) deleteat!(a, j:lastindex(a)) end -## 1-d circshift ## +""" + circshift!(a::AbstractVector, shift::Integer) + +Circularly shift, or rotate, the data in vector `a` by `shift` positions. + +# Examples + +```jldoctest +julia> circshift!([1, 2, 3, 4, 5], 2) +5-element Vector{Int64}: + 4 + 5 + 1 + 2 + 3 + +julia> circshift!([1, 2, 3, 4, 5], -2) +5-element Vector{Int64}: + 3 + 4 + 5 + 1 + 2 +``` +""" function circshift!(a::AbstractVector, shift::Integer) n = length(a) n == 0 && return a From 738b0aea6be1fa1ba22f83619cf79ccb9fe6e679 Mon Sep 17 00:00:00 2001 From: Neven Sajko <4944410+nsajko@users.noreply.github.com> Date: Sun, 2 Mar 2025 05:16:47 +0100 Subject: [PATCH 06/56] `Base.Precompilation.ExplicitEnv`: handle type instability better in constructor (#57599) Avoiding the converting `setindex!` should hopefully diminish unwarranted invalidation of user code. (cherry picked from commit 1e03ed6cd5851b30bd140bfc782b9f2a026012a1) --- base/precompilation.jl | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/base/precompilation.jl b/base/precompilation.jl index 254bab05a07dc..b33b5a14728e4 100644 --- a/base/precompilation.jl +++ b/base/precompilation.jl @@ -141,15 +141,16 @@ function ExplicitEnv(envpath::String=Base.active_project()) # Extensions deps_pkg = get(Dict{String, Any}, pkg_info, "extensions")::Dict{String, Any} + deps_pkg_concrete = Dict{String, Vector{String}}() for (ext, triggers) in deps_pkg if triggers isa String triggers = [triggers] else triggers = triggers::Vector{String} end - deps_pkg[ext] = triggers + deps_pkg_concrete[ext] = triggers end - extensions[m_uuid] = deps_pkg + extensions[m_uuid] = deps_pkg_concrete # Determine strategy to find package lookup_strat = begin From 6b4e42665dc78a6ff522f8a87a6ac7a840ae106b Mon Sep 17 00:00:00 2001 From: Neven Sajko <4944410+nsajko@users.noreply.github.com> Date: Mon, 3 Mar 2025 09:41:36 +0100 Subject: [PATCH 07/56] strings: type assert in the generic `nextind`, `prevind` methods (#57608) The type assertions are valid according to the doc strings of these functions in the case of `AbstractString`. Should prevent some invalidation on loading user code. Fixes #57605 (cherry picked from commit 6c9c336d2acc71ed740b0cc470c0b76bbbda136c) --- base/strings/basic.jl | 12 ++++++------ test/strings/basic.jl | 5 +++++ 2 files changed, 11 insertions(+), 6 deletions(-) diff --git a/base/strings/basic.jl b/base/strings/basic.jl index 2d5f0cea26e36..438789758cfe0 100644 --- a/base/strings/basic.jl +++ b/base/strings/basic.jl @@ -512,11 +512,11 @@ prevind(s::AbstractString, i::Int) = prevind(s, i, 1) function prevind(s::AbstractString, i::Int, n::Int) n < 0 && throw(ArgumentError("n cannot be negative: $n")) - z = ncodeunits(s) + 1 + z = ncodeunits(s)::Int + 1 @boundscheck 0 < i ≤ z || throw(BoundsError(s, i)) - n == 0 && return thisind(s, i) == i ? i : string_index_err(s, i) + n == 0 && return thisind(s, i)::Int == i ? i : string_index_err(s, i) while n > 0 && 1 < i - @inbounds n -= isvalid(s, i -= 1) + @inbounds n -= isvalid(s, i -= 1)::Bool end return i - n end @@ -571,11 +571,11 @@ nextind(s::AbstractString, i::Int) = nextind(s, i, 1) function nextind(s::AbstractString, i::Int, n::Int) n < 0 && throw(ArgumentError("n cannot be negative: $n")) - z = ncodeunits(s) + z = ncodeunits(s)::Int @boundscheck 0 ≤ i ≤ z || throw(BoundsError(s, i)) - n == 0 && return thisind(s, i) == i ? i : string_index_err(s, i) + n == 0 && return thisind(s, i)::Int == i ? i : string_index_err(s, i) while n > 0 && i < z - @inbounds n -= isvalid(s, i += 1) + @inbounds n -= isvalid(s, i += 1)::Bool end return i + n end diff --git a/test/strings/basic.jl b/test/strings/basic.jl index 87d812c5bf201..955da2d7c4564 100644 --- a/test/strings/basic.jl +++ b/test/strings/basic.jl @@ -878,6 +878,11 @@ end end end end + + @testset "return type infers to `Int`" begin + @test Int === Base.infer_return_type(prevind, Tuple{AbstractString, Vararg}) + @test Int === Base.infer_return_type(nextind, Tuple{AbstractString, Vararg}) + end end @testset "first and last" begin From 2be5e6d1923b3668f00667b49f4cb83854630178 Mon Sep 17 00:00:00 2001 From: Junfeng Qiao Date: Wed, 5 Mar 2025 11:42:42 +0100 Subject: [PATCH 08/56] Add missing arg in TOML `printvalue` (#57584) Otherwise error when calling `print_inline_table` (cherry picked from commit f20722476de363e55c8d3a7775ef6fbdcae5d5ef) --- stdlib/TOML/src/print.jl | 4 ++-- stdlib/TOML/test/print.jl | 16 ++++++++++++++++ 2 files changed, 18 insertions(+), 2 deletions(-) diff --git a/stdlib/TOML/src/print.jl b/stdlib/TOML/src/print.jl index 63f65b017d393..c6c046b9b40c6 100644 --- a/stdlib/TOML/src/print.jl +++ b/stdlib/TOML/src/print.jl @@ -77,7 +77,7 @@ end # Fallback function printvalue(f::MbyFunc, io::IO, value, sorted::Bool) toml_value = to_toml_value(f, value) - @invokelatest printvalue(f, io, toml_value) + @invokelatest printvalue(f, io, toml_value, sorted) end function printvalue(f::MbyFunc, io::IO, value::AbstractVector, sorted::Bool) @@ -156,7 +156,7 @@ function print_table(f::MbyFunc, io::IO, a::AbstractDict, ) if a in inline_tables - @invokelatest print_inline_table(f, io, a) + @invokelatest print_inline_table(f, io, a, sorted) return end diff --git a/stdlib/TOML/test/print.jl b/stdlib/TOML/test/print.jl index 8fba1b1c1df10..e8a6431cb34a7 100644 --- a/stdlib/TOML/test/print.jl +++ b/stdlib/TOML/test/print.jl @@ -94,6 +94,14 @@ loaders = ["gzip", { driver = "csv", args = {delim = "\t"}}] a = 222 d = 333 """ + + # https://github.com/JuliaLang/julia/pull/57584 + d = Dict("b" => [MyStruct(1), MyStruct(2)]) + @test toml_str(d) do x + x isa MyStruct && return Dict("a" => x.a) + end == """ + b = [{a = 1}, {a = 2}] + """ end @testset "unsigned integers" for (x, s) in [ @@ -196,6 +204,14 @@ LocalPkg = {path = "LocalPkg"} @test toml_str(d; sorted=true, inline_tables) == s @test roundtrip(s) + +# https://github.com/JuliaLang/julia/pull/57584 +d = Dict("a" => 1, "b" => 2) +inline_tables = IdSet{Dict}([d]) +s = "{a = 1, b = 2}" +@test toml_str(d; sorted=true, inline_tables) == s + + # multiline strings (#55083) s = """ a = \"\"\"lorem ipsum From 8d8f2ee3274c600d890bc6c892acf0ff3b30e438 Mon Sep 17 00:00:00 2001 From: N5N3 <2642243996@qq.com> Date: Thu, 6 Mar 2025 21:25:41 +0800 Subject: [PATCH 09/56] Intersect: try normal+reverse+existential subtyping during intersection (#57476) Typevars are all existential (in the sense of variable lb/ub) during intersection. This fix is somehow costly as we have to perform 3 times check to prove a false result. But a single existential <: seems too dangerous as it cause many circular env in the past. fix #57429 fix #41561 (cherry picked from commit beb928bfec532c8f038e113df2960c7b9609edb6) --- src/subtype.c | 127 ++++++++++++++++++++++++++++++++++++------------ test/subtype.jl | 33 ++++++++----- 2 files changed, 118 insertions(+), 42 deletions(-) diff --git a/src/subtype.c b/src/subtype.c index 2d1221904d149..8bb7a2070c23c 100644 --- a/src/subtype.c +++ b/src/subtype.c @@ -2667,31 +2667,22 @@ static void set_bound(jl_value_t **bound, jl_value_t *val, jl_tvar_t *v, jl_sten // subtype, treating all vars as existential static int subtype_in_env_existential(jl_value_t *x, jl_value_t *y, jl_stenv_t *e) { - jl_varbinding_t *v = e->vars; - int len = 0; if (x == jl_bottom_type || y == (jl_value_t*)jl_any_type) return 1; - while (v != NULL) { - len++; - v = v->prev; - } - int8_t *rs = (int8_t*)malloc_s(len); + int8_t *rs = (int8_t*)alloca(current_env_length(e)); + jl_varbinding_t *v = e->vars; int n = 0; - v = e->vars; - while (n < len) { - assert(v != NULL); + while (v != NULL) { rs[n++] = v->right; v->right = 1; v = v->prev; } int issub = subtype_in_env(x, y, e); n = 0; v = e->vars; - while (n < len) { - assert(v != NULL); + while (v != NULL) { v->right = rs[n++]; v = v->prev; } - free(rs); return issub; } @@ -2739,6 +2730,8 @@ static int check_unsat_bound(jl_value_t *t, jl_tvar_t *v, jl_stenv_t *e) JL_NOTS } +static int intersect_var_ccheck_in_env(jl_value_t *xlb, jl_value_t *xub, jl_value_t *ylb, jl_value_t *yub, jl_stenv_t *e, int flip); + static jl_value_t *intersect_var(jl_tvar_t *b, jl_value_t *a, jl_stenv_t *e, int8_t R, int param) { jl_varbinding_t *bb = lookup(e, b); @@ -2750,20 +2743,14 @@ static jl_value_t *intersect_var(jl_tvar_t *b, jl_value_t *a, jl_stenv_t *e, int return R ? intersect(a, bb->lb, e, param) : intersect(bb->lb, a, e, param); if (!jl_is_type(a) && !jl_is_typevar(a)) return set_var_to_const(bb, a, e, R); - jl_savedenv_t se; if (param == 2) { jl_value_t *ub = NULL; JL_GC_PUSH1(&ub); if (!jl_has_free_typevars(a)) { - save_env(e, &se, 1); - int issub = subtype_in_env_existential(bb->lb, a, e); - restore_env(e, &se, 1); - if (issub) { - issub = subtype_in_env_existential(a, bb->ub, e); - restore_env(e, &se, 1); - } - free_env(&se); - if (!issub) { + if (R) flip_offset(e); + int ccheck = intersect_var_ccheck_in_env(bb->lb, bb->ub, a, a, e, !R); + if (R) flip_offset(e); + if (!ccheck) { JL_GC_POP(); return jl_bottom_type; } @@ -2773,6 +2760,7 @@ static jl_value_t *intersect_var(jl_tvar_t *b, jl_value_t *a, jl_stenv_t *e, int e->triangular++; ub = R ? intersect_aside(a, bb->ub, e, bb->depth0) : intersect_aside(bb->ub, a, e, bb->depth0); e->triangular--; + jl_savedenv_t se; save_env(e, &se, 1); int issub = subtype_in_env_existential(bb->lb, ub, e); restore_env(e, &se, 1); @@ -3845,6 +3833,89 @@ static int subtype_by_bounds(jl_value_t *x, jl_value_t *y, jl_stenv_t *e) JL_NOT return compareto_var(x, (jl_tvar_t*)y, e, -1) || compareto_var(y, (jl_tvar_t*)x, e, 1); } +static int intersect_var_ccheck_in_env(jl_value_t *xlb, jl_value_t *xub, jl_value_t *ylb, jl_value_t *yub, jl_stenv_t *e, int flip) +{ + int easy_check1 = xlb == jl_bottom_type || + yub == (jl_value_t *)jl_any_type || + (e->Loffset == 0 && obviously_in_union(yub, xlb)); + int easy_check2 = ylb == jl_bottom_type || + xub == (jl_value_t *)jl_any_type || + (e->Loffset == 0 && obviously_in_union(xub, ylb)); + int nofree1 = 0, nofree2 = 0; + if (!easy_check1) { + nofree1 = !jl_has_free_typevars(xlb) && !jl_has_free_typevars(yub); + if (nofree1 && e->Loffset == 0) { + easy_check1 = jl_subtype(xlb, yub); + if (!easy_check1) + return 0; + } + } + if (!easy_check2) { + nofree2 = !jl_has_free_typevars(ylb) && !jl_has_free_typevars(xub); + if (nofree2 && e->Loffset == 0) { + easy_check2 = jl_subtype(ylb, xub); + if (!easy_check2) + return 0; + } + } + if (easy_check1 && easy_check2) + return 1; + int ccheck = 0; + if ((easy_check1 || nofree1) && (easy_check2 || nofree2)) { + jl_varbinding_t *vars = e->vars; + e->vars = NULL; + ccheck = easy_check1 || subtype_in_env(xlb, yub, e); + if (ccheck && !easy_check2) { + flip_offset(e); + ccheck = subtype_in_env(ylb, xub, e); + flip_offset(e); + } + e->vars = vars; + return ccheck; + } + jl_savedenv_t se; + save_env(e, &se, 1); + // first try normal flip. + if (flip) flip_vars(e); + ccheck = easy_check1 || subtype_in_env(xlb, yub, e); + if (ccheck && !easy_check2) { + flip_offset(e); + ccheck = subtype_in_env(ylb, xub, e); + flip_offset(e); + } + if (flip) flip_vars(e); + if (!ccheck) { + // then try reverse flip. + restore_env(e, &se, 1); + if (!flip) flip_vars(e); + ccheck = easy_check1 || subtype_in_env(xlb, yub, e); + if (ccheck && !easy_check2) { + flip_offset(e); + ccheck = subtype_in_env(ylb, xub, e); + flip_offset(e); + } + if (!flip) flip_vars(e); + } + if (!ccheck) { + // then try existential. + restore_env(e, &se, 1); + if (easy_check1) + ccheck = 1; + else { + ccheck = subtype_in_env_existential(xlb, yub, e); + restore_env(e, &se, 1); + } + if (ccheck && !easy_check2) { + flip_offset(e); + ccheck = subtype_in_env_existential(ylb, xub, e); + flip_offset(e); + restore_env(e, &se, 1); + } + } + free_env(&se); + return ccheck; +} + static int has_typevar_via_env(jl_value_t *x, jl_tvar_t *t, jl_stenv_t *e) { if (e->Loffset == 0) { @@ -3977,14 +4048,8 @@ static jl_value_t *intersect(jl_value_t *x, jl_value_t *y, jl_stenv_t *e, int pa ccheck = 1; } else { - if (R) flip_vars(e); - ccheck = subtype_in_env(xlb, yub, e); - if (ccheck) { - flip_offset(e); - ccheck = subtype_in_env(ylb, xub, e); - flip_offset(e); - } - if (R) flip_vars(e); + // try many subtype check to avoid false `Union{}` + ccheck = intersect_var_ccheck_in_env(xlb, xub, ylb, yub, e, R); } if (R) flip_offset(e); if (!ccheck) diff --git a/test/subtype.jl b/test/subtype.jl index ba7f86bb86a14..979746bd626dc 100644 --- a/test/subtype.jl +++ b/test/subtype.jl @@ -1691,9 +1691,7 @@ CovType{T} = Union{AbstractArray{T,2}, # issue #31703 @testintersect(Pair{<:Any, Ref{Tuple{Ref{Ref{Tuple{Int}}},Ref{Float64}}}}, Pair{T, S} where S<:(Ref{A} where A<:(Tuple{C,Ref{T}} where C<:(Ref{D} where D<:(Ref{E} where E<:Tuple{FF}) where FF<:B)) where B) where T, - Pair{T, Ref{Tuple{Ref{Ref{Tuple{Int}}},Ref{Float64}}}} where T) -# TODO: should be able to get this result -# Pair{Float64, Ref{Tuple{Ref{Ref{Tuple{Int}}},Ref{Float64}}}} + Pair{Float64, Ref{Tuple{Ref{Ref{Tuple{Int}}},Ref{Float64}}}}) module I31703 using Test, LinearAlgebra @@ -1745,8 +1743,7 @@ end Tuple{Type{SA{2, L}}, Type{SA{2, L}}} where L) @testintersect(Tuple{Type{SA{2, L}}, Type{SA{2, 16}}} where L, Tuple{Type{<:SA{N, L}}, Type{<:SA{N, L}}} where {N,L}, - # TODO: this could be narrower - Tuple{Type{SA{2, L}}, Type{SA{2, 16}}} where L) + Tuple{Type{SA{2, 16}}, Type{SA{2, 16}}}) # issue #31993 @testintersect(Tuple{Type{<:AbstractVector{T}}, Int} where T, @@ -1851,9 +1848,9 @@ c32703(::Type{<:Str{C}}, str::Str{C}) where {C<:CSE} = str Tuple{Type{<:Str{C}}, Str{C}} where {C<:CSE}, Union{}) @test c32703(UTF16Str, ASCIIStr()) == 42 -@test_broken typeintersect(Tuple{Vector{Vector{Float32}},Matrix,Matrix}, - Tuple{Vector{V},Matrix{Int},Matrix{S}} where {S, V<:AbstractVector{S}}) == - Tuple{Array{Array{Float32,1},1},Array{Int,2},Array{Float32,2}} +@testintersect(Tuple{Vector{Vector{Float32}},Matrix,Matrix}, + Tuple{Vector{V},Matrix{Int},Matrix{S}} where {S, V<:AbstractVector{S}}, + Tuple{Array{Array{Float32,1},1},Array{Int,2},Array{Float32,2}}) @testintersect(Tuple{Pair{Int, DataType}, Any}, Tuple{Pair{A, B} where B<:Type, Int} where A, @@ -2469,6 +2466,11 @@ end abstract type P47654{A} end @test Wrapper47654{P47654, Vector{Union{P47654,Nothing}}} <: Wrapper47654 +#issue 41561 +@testintersect(Tuple{Vector{VT}, Vector{VT}} where {N1, VT<:AbstractVector{N1}}, + Tuple{Vector{VN} where {N, VN<:AbstractVector{N}}, Vector{Vector{Float64}}}, + Tuple{Vector{Vector{Float64}}, Vector{Vector{Float64}}}) + @testset "known subtype/intersect issue" begin #issue 45874 let S = Pair{Val{P}, AbstractVector{<:Union{P,<:AbstractMatrix{P}}}} where P, @@ -2476,9 +2478,6 @@ abstract type P47654{A} end @test S <: T end - #issue 41561 - @test_broken typeintersect(Tuple{Vector{VT}, Vector{VT}} where {N1, VT<:AbstractVector{N1}}, - Tuple{Vector{VN} where {N, VN<:AbstractVector{N}}, Vector{Vector{Float64}}}) !== Union{} #issue 40865 @test Tuple{Set{Ref{Int}}, Set{Ref{Int}}} <: Tuple{Set{KV}, Set{K}} where {K,KV<:Union{K,Ref{K}}} @test Tuple{Set{Val{Int}}, Set{Val{Int}}} <: Tuple{Set{KV}, Set{K}} where {K,KV<:Union{K,Val{K}}} @@ -2746,3 +2745,15 @@ end Val{Tuple{T,R,S}} where {T,R<:Vector{T},S<:Vector{R}}, Val{Tuple{Int, Vector{Int}, T}} where T<:Vector{Vector{Int}}, ) + +#issue 57429 +@testintersect( + Pair{<:Any, <:Tuple{Int}}, + Pair{N, S} where {N, NTuple{N,Int}<:S<:NTuple{M,Int} where {M}}, + !Union{} +) +@testintersect( + Pair{N, T} where {N,NTuple{N,Int}<:T<:NTuple{N,Int}}, + Pair{N, T} where {N,NTuple{N,Int}<:T<:Tuple{Int,Vararg{Int}}}, + !Union{} +) From ce2548f9320310be16af3e3dbd09f0efeba84df9 Mon Sep 17 00:00:00 2001 From: Gabriel Baraldi Date: Fri, 3 Jan 2025 14:20:00 -0300 Subject: [PATCH 10/56] Make sure we don't promise alignments that are larger than the heap alignment to LLVM (#56938) Fixes https://github.com/JuliaLang/julia/issues/56937 --------- Co-authored-by: Oscar Smith (cherry picked from commit 1e2758e753cf1b1f710492cdb558550b9982266f) --- src/codegen.cpp | 2 ++ src/datatype.c | 2 ++ test/compiler/codegen.jl | 5 +++++ 3 files changed, 9 insertions(+) diff --git a/src/codegen.cpp b/src/codegen.cpp index c75c2ad27e384..cfa7cafe15e24 100644 --- a/src/codegen.cpp +++ b/src/codegen.cpp @@ -8552,6 +8552,8 @@ static jl_llvm_functions_t Type *RT = Arg->getParamStructRetType(); TypeSize sz = DL.getTypeAllocSize(RT); Align al = DL.getPrefTypeAlign(RT); + if (al > MAX_ALIGN) + al = Align(MAX_ALIGN); param.addAttribute(Attribute::NonNull); // The `dereferenceable` below does not imply `nonnull` for non addrspace(0) pointers. param.addDereferenceableAttr(sz); diff --git a/src/datatype.c b/src/datatype.c index 8de401f4dd0f7..67db47e275d74 100644 --- a/src/datatype.c +++ b/src/datatype.c @@ -754,6 +754,8 @@ void jl_compute_field_offsets(jl_datatype_t *st) if (al > alignm) alignm = al; } + if (alignm > MAX_ALIGN) + alignm = MAX_ALIGN; // We cannot guarantee alignments over 16 bytes because that's what our heap is aligned as if (LLT_ALIGN(sz, alignm) > sz) { haspadding = 1; sz = LLT_ALIGN(sz, alignm); diff --git a/test/compiler/codegen.jl b/test/compiler/codegen.jl index 2691a8f4ea156..10b66fda33667 100644 --- a/test/compiler/codegen.jl +++ b/test/compiler/codegen.jl @@ -933,3 +933,8 @@ let end nothing end + +struct Vec56937 x::NTuple{8, VecElement{Int}} end + +x56937 = Ref(Vec56937(ntuple(_->VecElement(1),8))) +@test x56937[].x[1] == VecElement{Int}(1) # shouldn't crash From d453372c1aa68e11441420747da73bcb976e57dd Mon Sep 17 00:00:00 2001 From: Jameson Nash Date: Tue, 11 Mar 2025 15:42:43 -0400 Subject: [PATCH 11/56] fix alignment computation for nested objects (#57722) The alignment of a nested object (in C layouts) is not affected by the alignment of its parent container when computing a field offset (as if it will be allocated at address 0). This can be strongly counter-intuitive (as it implies it should add padding where it does not seem to provide value to the user), but this is required to match the C standard. It also permits users to write custom allocators which happen to provide alignment in excess of that which codegen may assume is guaranteed, and get the behavioral characteristics they intended to specify (without resorting to computing explicit padding). Addresses https://github.com/JuliaLang/julia/issues/57713#issuecomment-2714111074 (Cherry-picked from c9008ffab74ce2ffc13e3e1d18b0b83277487133, with typo fix to typed_loaded memcpy which was already deleted from master) --- doc/src/manual/calling-c-and-fortran-code.md | 24 ++++++++++------ src/cgutils.cpp | 7 +++-- src/datatype.c | 29 +++++++++++++++----- test/core.jl | 7 +++++ 4 files changed, 48 insertions(+), 19 deletions(-) diff --git a/doc/src/manual/calling-c-and-fortran-code.md b/doc/src/manual/calling-c-and-fortran-code.md index 6f4d69b16bc81..2c20c22b33930 100644 --- a/doc/src/manual/calling-c-and-fortran-code.md +++ b/doc/src/manual/calling-c-and-fortran-code.md @@ -547,15 +547,14 @@ is not valid, since the type layout of `T` is not known statically. ### SIMD Values -Note: This feature is currently implemented on 64-bit x86 and AArch64 platforms only. - If a C/C++ routine has an argument or return value that is a native SIMD type, the corresponding Julia type is a homogeneous tuple of `VecElement` that naturally maps to the SIMD type. Specifically: -> * The tuple must be the same size as the SIMD type. For example, a tuple representing an `__m128` -> on x86 must have a size of 16 bytes. -> * The element type of the tuple must be an instance of `VecElement{T}` where `T` is a primitive type that -> is 1, 2, 4 or 8 bytes. +> * The tuple must be the same size and elements as the SIMD type. For example, a tuple +> representing an `__m128` on x86 must have a size of 16 bytes and Float32 elements. +> * The element type of the tuple must be an instance of `VecElement{T}` where `T` is a +> primitive type with a power-of-two number of bytes (e.g. 1, 2, 4, 8, 16, etc) such as +> Int8 or Float64. For instance, consider this C routine that uses AVX intrinsics: @@ -628,6 +627,10 @@ For translating a C argument list to Julia: * `T`, where `T` is a Julia leaf type * argument value will be copied (passed by value) + * `vector T` (or `__attribute__ vector_size`, or a typedef such as `__m128`) + + * `NTuple{N, VecElement{T}}`, where `T` is a primitive Julia type of the correct size + and N is the number of elements in the vector (equal to `vector_size / sizeof T`). * `void*` * depends on how this parameter is used, first translate this to the intended pointer type, then @@ -674,13 +677,16 @@ For translating a C return type to Julia: * `T`, where `T` is one of the primitive types: `char`, `int`, `long`, `short`, `float`, `double`, `complex`, `enum` or any of their `typedef` equivalents - * `T`, where `T` is an equivalent Julia Bits Type (per the table above) - * if `T` is an `enum`, the argument type should be equivalent to `Cint` or `Cuint` + * same as C argument list * argument value will be copied (returned by-value) * `struct T` (including typedef to a struct) - * `T`, where `T` is a Julia Leaf Type + * same as C argument list * argument value will be copied (returned by-value) + + * `vector T` + + * same as C argument list * `void*` * depends on how this parameter is used, first translate this to the intended pointer type, then diff --git a/src/cgutils.cpp b/src/cgutils.cpp index d049327c2bf36..a3eb2df3c7574 100644 --- a/src/cgutils.cpp +++ b/src/cgutils.cpp @@ -1971,7 +1971,7 @@ static jl_cgval_t typed_load(jl_codectx_t &ctx, Value *ptr, Value *idx_0based, j else if (!alignment) alignment = julia_alignment(jltype); if (intcast && Order == AtomicOrdering::NotAtomic) { - emit_memcpy(ctx, intcast, jl_aliasinfo_t::fromTBAA(ctx, ctx.tbaa().tbaa_stack), data, jl_aliasinfo_t::fromTBAA(ctx, tbaa), nb, Align(alignment), intcast->getAlign()); + emit_memcpy(ctx, intcast, jl_aliasinfo_t::fromTBAA(ctx, ctx.tbaa().tbaa_stack), data, jl_aliasinfo_t::fromTBAA(ctx, tbaa), nb, intcast->getAlign(), Align(alignment)); } else { if (!isboxed && jl_is_genericmemoryref_type(jltype)) { @@ -3214,7 +3214,7 @@ static void union_alloca_type(jl_uniontype_t *ut, [&](unsigned idx, jl_datatype_t *jt) { if (!jl_is_datatype_singleton(jt)) { size_t nb1 = jl_datatype_size(jt); - size_t align1 = jl_datatype_align(jt); + size_t align1 = julia_alignment((jl_value_t*)jt); if (nb1 > nbytes) nbytes = nb1; if (align1 > align) @@ -3796,9 +3796,10 @@ static jl_cgval_t emit_new_struct(jl_codectx_t &ctx, jl_value_t *ty, size_t narg // whether we should perform the initialization with the struct as a IR value // or instead initialize the stack buffer with stores + // although we do the former if it is a vector or could be a vector element auto tracked = CountTrackedPointers(lt); bool init_as_value = false; - if (lt->isVectorTy() || jl_is_vecelement_type(ty)) { // maybe also check the size ? + if (lt->isVectorTy() || jl_special_vector_alignment(1, ty) != 0) { init_as_value = true; } else if (tracked.count) { diff --git a/src/datatype.c b/src/datatype.c index 67db47e275d74..bb33aa9e397bc 100644 --- a/src/datatype.c +++ b/src/datatype.c @@ -298,9 +298,10 @@ static jl_datatype_layout_t *jl_get_layout(uint32_t sz, } // Determine if homogeneous tuple with fields of type t will have -// a special alignment beyond normal Julia rules. +// a special alignment and vector-ABI beyond normal rules for aggregates. // Return special alignment if one exists, 0 if normal alignment rules hold. // A non-zero result *must* match the LLVM rules for a vector type . +// Matching the compiler's `__attribute__ vector_size` behavior. // For sake of Ahead-Of-Time (AOT) compilation, this routine has to work // without LLVM being available. unsigned jl_special_vector_alignment(size_t nfields, jl_value_t *t) @@ -315,8 +316,12 @@ unsigned jl_special_vector_alignment(size_t nfields, jl_value_t *t) // motivating use case comes up for Julia, we reject pointers. return 0; size_t elsz = jl_datatype_size(ty); - if (elsz != 1 && elsz != 2 && elsz != 4 && elsz != 8) - // Only handle power-of-two-sized elements (for now) + if (next_power_of_two(elsz) != elsz) + // Only handle power-of-two-sized elements (for now), since other + // lengths may be packed into very complicated arrangements (llvm pads + // extra bits on most platforms when computing alignment but not when + // computing type size, but adds no extra bytes for each element, so + // their effect on offsets are never what you may naturally expect). return 0; size_t size = nfields * elsz; // Use natural alignment for this vector: this matches LLVM and clang. @@ -707,9 +712,9 @@ void jl_compute_field_offsets(jl_datatype_t *st) } else { fsz = sizeof(void*); - if (fsz > MAX_ALIGN) - fsz = MAX_ALIGN; al = fsz; + if (al > MAX_ALIGN) + al = MAX_ALIGN; desc[i].isptr = 1; zeroinit = 1; npointers++; @@ -754,8 +759,6 @@ void jl_compute_field_offsets(jl_datatype_t *st) if (al > alignm) alignm = al; } - if (alignm > MAX_ALIGN) - alignm = MAX_ALIGN; // We cannot guarantee alignments over 16 bytes because that's what our heap is aligned as if (LLT_ALIGN(sz, alignm) > sz) { haspadding = 1; sz = LLT_ALIGN(sz, alignm); @@ -931,6 +934,18 @@ JL_DLLEXPORT jl_datatype_t *jl_new_primitivetype(jl_value_t *name, jl_module_t * jl_emptysvec, jl_emptysvec, jl_emptysvec, 0, 0, 0); uint32_t nbytes = (nbits + 7) / 8; uint32_t alignm = next_power_of_two(nbytes); +# if defined(_CPU_X86_) && !defined(_OS_WINDOWS_) + // datalayout strings are often weird: on 64-bit they usually follow fairly simple rules, + // but on x86 32 bit platforms, sometimes 5 to 8 byte types are + // 32-bit aligned even though the MAX_ALIGN (for types 9+ bytes) is 16 + // (except for f80 which is align 4 on Mingw, Linux, and BSDs--but align 16 on MSVC and Darwin) + // https://llvm.org/doxygen/ARMTargetMachine_8cpp.html#adb29b487708f0dc2a940345b68649270 + // https://llvm.org/doxygen/AArch64TargetMachine_8cpp.html#a003a58caf135efbf7273c5ed84e700d7 + // https://llvm.org/doxygen/X86TargetMachine_8cpp.html#aefdbcd6131ef195da070cef7fdaf0532 + // 32-bit alignment is weird + if (alignm == 8) + alignm = 4; +# endif if (alignm > MAX_ALIGN) alignm = MAX_ALIGN; // memoize isprimitivetype, since it is much easier than checking diff --git a/test/core.jl b/test/core.jl index 9750cc519a746..f525a3fc39e12 100644 --- a/test/core.jl +++ b/test/core.jl @@ -5668,6 +5668,13 @@ let ni128 = sizeof(FP128test) ÷ sizeof(Int), @test reinterpret(UInt128, arr[2].fp) == expected end +# make sure VecElement Tuple has the C alignment and ABI for supported types +primitive type Int24 24 end +@test Base.datatype_alignment(NTuple{10,VecElement{Int16}}) == 32 +@test Base.datatype_alignment(NTuple{10,VecElement{Int24}}) == 4 +@test Base.datatype_alignment(NTuple{10,VecElement{Int64}}) == 128 +@test Base.datatype_alignment(NTuple{10,VecElement{Int128}}) == 256 + # issue #21516 struct T21516 x::Vector{Float64} From 7c7c32563de3e2a7264acb3a40b9a3c42ed7517e Mon Sep 17 00:00:00 2001 From: Ian Butterworth Date: Tue, 25 Mar 2025 08:51:21 -0400 Subject: [PATCH 12/56] Don't free regex objects in exit-time finalizer calls (#57834) Fixes https://github.com/JuliaLang/julia/issues/57817 on 1.11 --- base/regex.jl | 7 ++++++- test/regex.jl | 8 ++++++++ 2 files changed, 14 insertions(+), 1 deletion(-) diff --git a/base/regex.jl b/base/regex.jl index 9d5c146a6e840..2cb49610dc300 100644 --- a/base/regex.jl +++ b/base/regex.jl @@ -39,7 +39,12 @@ mutable struct Regex <: AbstractPattern end re = compile(new(pattern, compile_options, match_options, C_NULL)) finalizer(re) do re - re.regex == C_NULL || PCRE.free_re(re.regex) + # don't free during exit because tasks may still be running and + # using it. Issue #57817 + during_exit = Base._atexit_hooks_finished + if re.regex != C_NULL && !during_exit + PCRE.free_re(re.regex) + end end re end diff --git a/test/regex.jl b/test/regex.jl index e5f1428527512..ca411b26bbacc 100644 --- a/test/regex.jl +++ b/test/regex.jl @@ -245,3 +245,11 @@ end @test match(re, "ababc").match === SubString("ababc", 3:5) end end + +@testset "#57817: Don't free Regex during exit finalizer calls" begin + # this shouldn't segfault + cmd = `$(Base.julia_cmd()) -t2 --startup-file=no -e 're = Regex(""); Threads.@spawn match(re, "", 1, UInt32(0))'` + for i in 1:10 + @test success(pipeline(cmd, stderr=stderr)) + end +end From 2ccc91ad9f90b1463cf1057fa455aa30a868ab8d Mon Sep 17 00:00:00 2001 From: Gabriel Baraldi Date: Tue, 25 Mar 2025 09:55:09 -0300 Subject: [PATCH 13/56] Add malloc fixes to 1.11 branch (#57880) Contains https://github.com/JuliaLang/julia/pull/55223 and https://github.com/JuliaLang/julia/pull/56801 --- src/gc-debug.c | 11 +- src/gc.c | 235 ++++++++++++++++++++-------------------- src/gc.h | 5 - src/genericmemory.c | 5 +- src/julia_internal.h | 2 + src/julia_threads.h | 3 +- src/mtarraylist.c | 4 +- src/support/arraylist.h | 10 +- 8 files changed, 133 insertions(+), 142 deletions(-) diff --git a/src/gc-debug.c b/src/gc-debug.c index 124b7da74dee1..3aa1612572bf6 100644 --- a/src/gc-debug.c +++ b/src/gc-debug.c @@ -1100,13 +1100,14 @@ void gc_stats_big_obj(void) v = v->next; } - mallocarray_t *ma = ptls2->heap.mallocarrays; - while (ma != NULL) { - if (gc_marked(jl_astaggedvalue(ma->a)->bits.gc)) { + void **lst = ptls2->gc_tls.heap.mallocarrays.items; + for (size_t i = 0, l = ptls2->gc_tls.heap.mallocarrays.len; i < l; i++) { + jl_genericmemory_t *m = (jl_genericmemory_t*)((uintptr_t)lst[i] & ~(uintptr_t)1); + uint8_t bits = jl_astaggedvalue(m)->bits.gc; + if (gc_marked(bits)) { nused++; - nbytes += jl_genericmemory_nbytes((jl_genericmemory_t*)ma->a); + nbytes += jl_genericmemory_nbytes(m); } - ma = ma->next; } } diff --git a/src/gc.c b/src/gc.c index e89e16ff187c0..c4c83861f5a52 100644 --- a/src/gc.c +++ b/src/gc.c @@ -6,7 +6,11 @@ #include "julia_atomics.h" #include "julia_gcext.h" #include "julia_assert.h" -#ifdef __GLIBC__ +#include + +#if defined(_OS_DARWIN_) +#include +#else #include // for malloc_trim #endif @@ -1121,17 +1125,8 @@ static void sweep_big(jl_ptls_t ptls, int sweep_full) JL_NOTSAFEPOINT void jl_gc_track_malloced_genericmemory(jl_ptls_t ptls, jl_genericmemory_t *m, int isaligned){ // This is **NOT** a GC safe point. - mallocarray_t *ma; - if (ptls->heap.mafreelist == NULL) { - ma = (mallocarray_t*)malloc_s(sizeof(mallocarray_t)); - } - else { - ma = ptls->heap.mafreelist; - ptls->heap.mafreelist = ma->next; - } - ma->a = (jl_value_t*)((uintptr_t)m | !!isaligned); - ma->next = ptls->heap.mallocarrays; - ptls->heap.mallocarrays = ma; + void *a = (void*)((uintptr_t)m | !!isaligned); + small_arraylist_push(&ptls->heap.mallocarrays, a); } @@ -1143,10 +1138,6 @@ void jl_gc_count_allocd(size_t sz) JL_NOTSAFEPOINT jl_batch_accum_heap_size(ptls, sz); } -void jl_gc_count_freed(size_t sz) JL_NOTSAFEPOINT -{ - jl_batch_accum_free_size(jl_current_task->ptls, sz); -} // Only safe to update the heap inside the GC static void combine_thread_gc_counts(jl_gc_num_t *dest, int update_heap) JL_NOTSAFEPOINT @@ -1222,19 +1213,21 @@ size_t jl_genericmemory_nbytes(jl_genericmemory_t *m) JL_NOTSAFEPOINT } -static void jl_gc_free_memory(jl_value_t *v, int isaligned) JL_NOTSAFEPOINT +static void jl_gc_free_memory(jl_genericmemory_t *v, int isaligned) JL_NOTSAFEPOINT { assert(jl_is_genericmemory(v)); jl_genericmemory_t *m = (jl_genericmemory_t*)v; assert(jl_genericmemory_how(m) == 1 || jl_genericmemory_how(m) == 2); char *d = (char*)m->ptr; + size_t freed_bytes = memory_block_usable_size(d, isaligned); + assert(freed_bytes != 0); if (isaligned) jl_free_aligned(d); else free(d); jl_atomic_store_relaxed(&gc_heap_stats.heap_size, - jl_atomic_load_relaxed(&gc_heap_stats.heap_size) - jl_genericmemory_nbytes(m)); - gc_num.freed += jl_genericmemory_nbytes(m); + jl_atomic_load_relaxed(&gc_heap_stats.heap_size) - freed_bytes); + gc_num.freed += freed_bytes; gc_num.freecall++; } @@ -1245,24 +1238,23 @@ static void sweep_malloced_memory(void) JL_NOTSAFEPOINT for (int t_i = 0; t_i < gc_n_threads; t_i++) { jl_ptls_t ptls2 = gc_all_tls_states[t_i]; if (ptls2 != NULL) { - mallocarray_t *ma = ptls2->heap.mallocarrays; - mallocarray_t **pma = &ptls2->heap.mallocarrays; - while (ma != NULL) { - mallocarray_t *nxt = ma->next; - jl_value_t *a = (jl_value_t*)((uintptr_t)ma->a & ~1); - int bits = jl_astaggedvalue(a)->bits.gc; - if (gc_marked(bits)) { - pma = &ma->next; + size_t n = 0; + size_t l = ptls2->heap.mallocarrays.len; + void **lst = ptls2->heap.mallocarrays.items; + // filter without preserving order + while (n < l) { + jl_genericmemory_t *m = (jl_genericmemory_t*)((uintptr_t)lst[n] & ~1); + if (gc_marked(jl_astaggedvalue(m)->bits.gc)) { + n++; } else { - *pma = nxt; - int isaligned = (uintptr_t)ma->a & 1; - jl_gc_free_memory(a, isaligned); - free(ma); + int isaligned = (uintptr_t)lst[n] & 1; + jl_gc_free_memory(m, isaligned); + l--; + lst[n] = lst[l]; } - gc_time_count_mallocd_memory(bits); - ma = nxt; } + ptls2->heap.mallocarrays.len = l; } } gc_time_mallocd_memory_end(); @@ -3968,8 +3960,7 @@ void jl_init_thread_heap(jl_ptls_t ptls) small_arraylist_new(&heap->live_tasks, 0); for (int i = 0; i < JL_N_STACK_POOLS; i++) small_arraylist_new(&heap->free_stacks[i], 0); - heap->mallocarrays = NULL; - heap->mafreelist = NULL; + small_arraylist_new(&heap->mallocarrays, 0); heap->big_objects = NULL; heap->remset = &heap->_remset[0]; heap->last_remset = &heap->_remset[1]; @@ -4069,58 +4060,44 @@ JL_DLLEXPORT void jl_throw_out_of_memory_error(void) jl_throw(jl_memory_exception); } -// allocation wrappers that track allocation and let collection run +// allocation wrappers that add to gc pressure -JL_DLLEXPORT void *jl_gc_counted_malloc(size_t sz) +JL_DLLEXPORT void *jl_malloc(size_t sz) { - jl_gcframe_t **pgcstack = jl_get_pgcstack(); - jl_task_t *ct = jl_current_task; - void *data = malloc(sz); - if (data != NULL && pgcstack != NULL && ct->world_age) { - jl_ptls_t ptls = ct->ptls; - maybe_collect(ptls); - jl_atomic_store_relaxed(&ptls->gc_num.allocd, - jl_atomic_load_relaxed(&ptls->gc_num.allocd) + sz); - jl_atomic_store_relaxed(&ptls->gc_num.malloc, - jl_atomic_load_relaxed(&ptls->gc_num.malloc) + 1); - jl_batch_accum_heap_size(ptls, sz); - } - return data; + return jl_gc_counted_malloc(sz); } -JL_DLLEXPORT void *jl_gc_counted_calloc(size_t nm, size_t sz) +//_unchecked_calloc does not check for potential overflow of nm*sz +STATIC_INLINE void *_unchecked_calloc(size_t nm, size_t sz) { + size_t nmsz = nm*sz; + return jl_gc_counted_calloc(nmsz, 1); +} + +JL_DLLEXPORT void *jl_calloc(size_t nm, size_t sz) { - jl_gcframe_t **pgcstack = jl_get_pgcstack(); - jl_task_t *ct = jl_current_task; - void *data = calloc(nm, sz); - if (data != NULL && pgcstack != NULL && ct->world_age) { - jl_ptls_t ptls = ct->ptls; - maybe_collect(ptls); - jl_atomic_store_relaxed(&ptls->gc_num.allocd, - jl_atomic_load_relaxed(&ptls->gc_num.allocd) + nm*sz); - jl_atomic_store_relaxed(&ptls->gc_num.malloc, - jl_atomic_load_relaxed(&ptls->gc_num.malloc) + 1); - jl_batch_accum_heap_size(ptls, sz * nm); - } - return data; + if (nm > SSIZE_MAX/sz) + return NULL; + return _unchecked_calloc(nm, sz); } -JL_DLLEXPORT void jl_gc_counted_free_with_size(void *p, size_t sz) +JL_DLLEXPORT void jl_free(void *p) { - jl_gcframe_t **pgcstack = jl_get_pgcstack(); - jl_task_t *ct = jl_current_task; - free(p); - if (pgcstack != NULL && ct->world_age) { - jl_batch_accum_free_size(ct->ptls, sz); + if (p != NULL) { + size_t sz = memory_block_usable_size(p, 0); + free(p); + jl_task_t *ct = jl_get_current_task(); + if (ct != NULL) + jl_batch_accum_free_size(ct->ptls, sz); } } -JL_DLLEXPORT void *jl_gc_counted_realloc_with_old_size(void *p, size_t old, size_t sz) +JL_DLLEXPORT void *jl_realloc(void *p, size_t sz) { - jl_gcframe_t **pgcstack = jl_get_pgcstack(); - jl_task_t *ct = jl_current_task; + size_t old = p ? memory_block_usable_size(p, 0) : 0; void *data = realloc(p, sz); - if (data != NULL && pgcstack != NULL && ct->world_age) { + jl_task_t *ct = jl_get_current_task(); + if (data != NULL && ct != NULL) { + sz = memory_block_usable_size(data, 0); jl_ptls_t ptls = ct->ptls; maybe_collect(ptls); if (!(sz < old)) @@ -4140,63 +4117,80 @@ JL_DLLEXPORT void *jl_gc_counted_realloc_with_old_size(void *p, size_t old, size return data; } -// allocation wrappers that save the size of allocations, to allow using -// jl_gc_counted_* functions with a libc-compatible API. - -JL_DLLEXPORT void *jl_malloc(size_t sz) +JL_DLLEXPORT void *jl_gc_counted_malloc(size_t sz) { - int64_t *p = (int64_t *)jl_gc_counted_malloc(sz + JL_SMALL_BYTE_ALIGNMENT); - if (p == NULL) - return NULL; - p[0] = sz; - return (void *)(p + 2); // assumes JL_SMALL_BYTE_ALIGNMENT == 16 + jl_task_t *ct = jl_current_task; + void *data = malloc(sz); + if (data != NULL && ct != NULL && ct->world_age) { + sz = memory_block_usable_size(data, 0); + jl_ptls_t ptls = ct->ptls; + maybe_collect(ptls); + jl_atomic_store_relaxed(&ptls->gc_num.allocd, + jl_atomic_load_relaxed(&ptls->gc_num.allocd) + sz); + jl_atomic_store_relaxed(&ptls->gc_num.malloc, + jl_atomic_load_relaxed(&ptls->gc_num.malloc) + 1); + jl_batch_accum_heap_size(ptls, sz); + } + return data; } -//_unchecked_calloc does not check for potential overflow of nm*sz -STATIC_INLINE void *_unchecked_calloc(size_t nm, size_t sz) { - size_t nmsz = nm*sz; - int64_t *p = (int64_t *)jl_gc_counted_calloc(nmsz + JL_SMALL_BYTE_ALIGNMENT, 1); - if (p == NULL) - return NULL; - p[0] = nmsz; - return (void *)(p + 2); // assumes JL_SMALL_BYTE_ALIGNMENT == 16 +JL_DLLEXPORT void *jl_gc_counted_calloc(size_t nm, size_t sz) +{ + jl_task_t *ct = jl_current_task; + void *data = calloc(nm, sz); + if (data != NULL && ct != NULL && ct->world_age) { + sz = memory_block_usable_size(data, 0); + jl_ptls_t ptls = ct->ptls; + maybe_collect(ptls); + jl_atomic_store_relaxed(&ptls->gc_num.allocd, + jl_atomic_load_relaxed(&ptls->gc_num.allocd) + sz); + jl_atomic_store_relaxed(&ptls->gc_num.malloc, + jl_atomic_load_relaxed(&ptls->gc_num.malloc) + 1); + jl_batch_accum_heap_size(ptls, sz); + } + return data; } -JL_DLLEXPORT void *jl_calloc(size_t nm, size_t sz) +JL_DLLEXPORT void jl_gc_counted_free_with_size(void *p, size_t sz) { - if (nm > SSIZE_MAX/sz - JL_SMALL_BYTE_ALIGNMENT) - return NULL; - return _unchecked_calloc(nm, sz); + jl_free(p); } -JL_DLLEXPORT void jl_free(void *p) +JL_DLLEXPORT void *jl_gc_counted_realloc_with_old_size(void *p, size_t old, size_t sz) { - if (p != NULL) { - int64_t *pp = (int64_t *)p - 2; - size_t sz = pp[0]; - jl_gc_counted_free_with_size(pp, sz + JL_SMALL_BYTE_ALIGNMENT); - } + return jl_realloc(p, sz); } -JL_DLLEXPORT void *jl_realloc(void *p, size_t sz) +// =========================================================================== // +// malloc wrappers, aligned allocation +// =========================================================================== // + +#if defined(_OS_WINDOWS_) +// helper function based partly on wine msvcrt80+ heap.c +// but with several fixes to improve the correctness of the computation and remove unnecessary parameters +#define SAVED_PTR(x) ((void *)((DWORD_PTR)((char *)x - sizeof(void *)) & \ + ~(sizeof(void *) - 1))) +static size_t _aligned_msize(void *p) { - int64_t *pp; - size_t szold; - if (p == NULL) { - pp = NULL; - szold = 0; - } - else { - pp = (int64_t *)p - 2; - szold = pp[0] + JL_SMALL_BYTE_ALIGNMENT; - } - int64_t *pnew = (int64_t *)jl_gc_counted_realloc_with_old_size(pp, szold, sz + JL_SMALL_BYTE_ALIGNMENT); - if (pnew == NULL) - return NULL; - pnew[0] = sz; - return (void *)(pnew + 2); // assumes JL_SMALL_BYTE_ALIGNMENT == 16 + void *alloc_ptr = *(void**)SAVED_PTR(p); + return _msize(alloc_ptr) - ((char*)p - (char*)alloc_ptr); } +#undef SAVED_PTR +#endif +size_t memory_block_usable_size(void *p, int isaligned) JL_NOTSAFEPOINT +{ +#if defined(_OS_WINDOWS_) + if (isaligned) + return _aligned_msize(p); + else + return _msize(p); +#elif defined(_OS_DARWIN_) + return malloc_size(p); +#else + return malloc_usable_size(p); +#endif +} // allocating blocks for Arrays and Strings JL_DLLEXPORT void *jl_gc_managed_malloc(size_t sz) @@ -4214,12 +4208,13 @@ JL_DLLEXPORT void *jl_gc_managed_malloc(size_t sz) void *b = malloc_cache_align(allocsz); if (b == NULL) jl_throw(jl_memory_exception); - + size_t allocated_bytes = memory_block_usable_size(b, 1); + assert(allocated_bytes >= allocsz); jl_atomic_store_relaxed(&ptls->gc_num.allocd, - jl_atomic_load_relaxed(&ptls->gc_num.allocd) + allocsz); + jl_atomic_load_relaxed(&ptls->gc_num.allocd) + allocated_bytes); jl_atomic_store_relaxed(&ptls->gc_num.malloc, jl_atomic_load_relaxed(&ptls->gc_num.malloc) + 1); - jl_batch_accum_heap_size(ptls, allocsz); + jl_batch_accum_heap_size(ptls, allocated_bytes); #ifdef _OS_WINDOWS_ SetLastError(last_error); #endif diff --git a/src/gc.h b/src/gc.h index 01d8745b2899e..7e4da2bd1900f 100644 --- a/src/gc.h +++ b/src/gc.h @@ -143,11 +143,6 @@ JL_EXTENSION typedef struct _bigval_t { // data structure for tracking malloc'd arrays and genericmemory. -typedef struct _mallocarray_t { - jl_value_t *a; - struct _mallocarray_t *next; -} mallocarray_t; - // pool page metadata typedef struct _jl_gc_pagemeta_t { // next metadata structure in per-thread list diff --git a/src/genericmemory.c b/src/genericmemory.c index b36852d53f9c8..02293867da4df 100644 --- a/src/genericmemory.c +++ b/src/genericmemory.c @@ -165,7 +165,8 @@ JL_DLLEXPORT jl_genericmemory_t *jl_ptr_to_genericmemory(jl_value_t *mtype, void if (own_buffer) { int isaligned = 0; // TODO: allow passing memalign'd buffers jl_gc_track_malloced_genericmemory(ct->ptls, m, isaligned); - jl_gc_count_allocd(nel*elsz); + size_t allocated_bytes = memory_block_usable_size(data, isaligned); + jl_gc_count_allocd(allocated_bytes); } return m; } @@ -208,8 +209,6 @@ JL_DLLEXPORT jl_value_t *jl_genericmemory_to_string(jl_genericmemory_t *m, size_ JL_GC_PUSH1(&o); jl_value_t *str = jl_pchar_to_string((const char*)m->ptr, len); JL_GC_POP(); - if (how == 1) // TODO: we might like to early-call jl_gc_free_memory here instead actually, but hopefully `m` will die soon - jl_gc_count_freed(mlength); return str; } // n.b. how == 0 is always pool-allocated, so the freed bytes are computed from the pool not the object diff --git a/src/julia_internal.h b/src/julia_internal.h index 1c2d071d1a6cd..05a2f1e677d60 100644 --- a/src/julia_internal.h +++ b/src/julia_internal.h @@ -608,6 +608,7 @@ jl_svec_t *jl_perm_symsvec(size_t n, ...); #endif jl_value_t *jl_gc_realloc_string(jl_value_t *s, size_t sz); +JL_DLLEXPORT void *jl_gc_counted_calloc(size_t nm, size_t sz); JL_DLLEXPORT void *jl_gc_counted_malloc(size_t sz); JL_DLLEXPORT void JL_NORETURN jl_throw_out_of_memory_error(void); @@ -618,6 +619,7 @@ JL_DLLEXPORT int64_t jl_gc_sync_total_bytes(int64_t offset) JL_NOTSAFEPOINT; void jl_gc_track_malloced_array(jl_ptls_t ptls, jl_array_t *a) JL_NOTSAFEPOINT; void jl_gc_track_malloced_genericmemory(jl_ptls_t ptls, jl_genericmemory_t *m, int isaligned) JL_NOTSAFEPOINT; size_t jl_genericmemory_nbytes(jl_genericmemory_t *a) JL_NOTSAFEPOINT; +size_t memory_block_usable_size(void *mem, int isaligned) JL_NOTSAFEPOINT; void jl_gc_count_allocd(size_t sz) JL_NOTSAFEPOINT; void jl_gc_count_freed(size_t sz) JL_NOTSAFEPOINT; void jl_gc_run_all_finalizers(jl_task_t *ct); diff --git a/src/julia_threads.h b/src/julia_threads.h index 3a0f7f12bffe5..0ca47cc553c88 100644 --- a/src/julia_threads.h +++ b/src/julia_threads.h @@ -130,8 +130,7 @@ typedef struct { small_arraylist_t live_tasks; // variables for tracking malloc'd arrays - struct _mallocarray_t *mallocarrays; - struct _mallocarray_t *mafreelist; + small_arraylist_t mallocarrays; // variables for tracking big objects struct _bigval_t *big_objects; diff --git a/src/mtarraylist.c b/src/mtarraylist.c index 8bad44797dab4..1bd6810cda8a6 100644 --- a/src/mtarraylist.c +++ b/src/mtarraylist.c @@ -14,8 +14,8 @@ extern "C" { // but there can be any number of observers typedef struct { - _Atomic(uint32_t) len; - uint32_t max; + _Atomic(size_t) len; + size_t max; _Atomic(_Atomic(void*)*) items; _Atomic(void*) _space[SMALL_AL_N_INLINE]; } small_mtarraylist_t; diff --git a/src/support/arraylist.h b/src/support/arraylist.h index 6ad2f0e2f28c9..edad2880dbed2 100644 --- a/src/support/arraylist.h +++ b/src/support/arraylist.h @@ -5,7 +5,7 @@ #define AL_N_INLINE 29 -#define SMALL_AL_N_INLINE 6 +#define SMALL_AL_N_INLINE 5 #ifdef __cplusplus extern "C" { @@ -13,7 +13,7 @@ extern "C" { #include "analyzer_annotations.h" -typedef struct { +typedef struct { // 32 words size_t len; size_t max; void **items; @@ -27,9 +27,9 @@ void arraylist_push(arraylist_t *a, void *elt) JL_NOTSAFEPOINT; void *arraylist_pop(arraylist_t *a) JL_NOTSAFEPOINT; JL_DLLEXPORT void arraylist_grow(arraylist_t *a, size_t n) JL_NOTSAFEPOINT; -typedef struct { - uint32_t len; - uint32_t max; +typedef struct { // 8 words + size_t len; + size_t max; void **items; void *_space[SMALL_AL_N_INLINE]; } small_arraylist_t; From 56909d7f018f662c55bb0a875602dd6c177c1b88 Mon Sep 17 00:00:00 2001 From: Tim Holy Date: Tue, 25 Mar 2025 07:55:21 -0500 Subject: [PATCH 14/56] [backports-release-1.11] Revert "precompile: don't waste memory on useless inferred code" (#57864) This reverts commit bdf8219ee80557ea6035b421b00d91b1174234f2, from #56749 **Note that this PR is made against `backports-release-1.11`.** Rationale: when coverage is on, both the native code and the inferred code might be eliminated, a complete loss of all precompilation results. There are intentions to adopt a new strategy for Julia 1.12, but in the meantime we should revert this change since it is "just" a sysimg size reduction. Affected Julia versions: 1.11.3, 1.11.4 xref https://github.com/timholy/SnoopCompile.jl/pull/413#issuecomment-2743794491 --- base/compiler/effects.jl | 1 - src/codegen.cpp | 8 ++++---- src/staticdata.c | 31 ++----------------------------- 3 files changed, 6 insertions(+), 34 deletions(-) diff --git a/base/compiler/effects.jl b/base/compiler/effects.jl index ece549eda7a6d..166df78f3130c 100644 --- a/base/compiler/effects.jl +++ b/base/compiler/effects.jl @@ -329,7 +329,6 @@ is_inaccessiblemem_or_argmemonly(effects::Effects) = effects.inaccessiblememonly is_consistent_overlay(effects::Effects) = effects.nonoverlayed === CONSISTENT_OVERLAY -# (sync this with codegen.cpp and staticdata.c effects_foldable functions) function encode_effects(e::Effects) return ((e.consistent % UInt32) << 0) | ((e.effect_free % UInt32) << 3) | diff --git a/src/codegen.cpp b/src/codegen.cpp index cfa7cafe15e24..b46a406edd2be 100644 --- a/src/codegen.cpp +++ b/src/codegen.cpp @@ -9679,10 +9679,10 @@ jl_llvm_functions_t jl_emit_codeinst( // Julia-level optimization will never need to see it else if (jl_is_method(def) && // don't delete toplevel code inferred != jl_nothing && // and there is something to delete (test this before calling jl_ir_inlining_cost) - ((!effects_foldable(codeinst->ipo_purity_bits) && // don't delete code we may want for irinterp - (jl_ir_inlining_cost(inferred) == UINT16_MAX) && // don't delete inlineable code - !jl_generating_output()) || // don't delete code when generating a precompile file, trading memory in the short term for avoiding likely duplicating inference work for aotcompile - jl_atomic_load_relaxed(&codeinst->invoke) == jl_fptr_const_return_addr)) { // unless it is constant (although this shouldn't have had code in the first place) + !effects_foldable(codeinst->ipo_purity_bits) && // don't delete code we may want for irinterp + ((jl_ir_inlining_cost(inferred) == UINT16_MAX) || // don't delete inlineable code + jl_atomic_load_relaxed(&codeinst->invoke) == jl_fptr_const_return_addr) && // unless it is constant + !(params.imaging_mode || jl_options.incremental)) { // don't delete code when generating a precompile file jl_atomic_store_release(&codeinst->inferred, jl_nothing); } } diff --git a/src/staticdata.c b/src/staticdata.c index 9d4c60a137058..76bb488731a92 100644 --- a/src/staticdata.c +++ b/src/staticdata.c @@ -725,16 +725,6 @@ static uintptr_t jl_fptr_id(void *fptr) return *(uintptr_t*)pbp; } -static int effects_foldable(uint32_t effects) -{ - // N.B.: This needs to be kept in sync with Core.Compiler.is_foldable(effects, true) - return ((effects & 0x7) == 0) && // is_consistent(effects) - (((effects >> 10) & 0x03) == 0) && // is_noub(effects) - (((effects >> 3) & 0x03) == 0) && // is_effect_free(effects) - ((effects >> 6) & 0x01); // is_terminates(effects) -} - - // `jl_queue_for_serialization` adds items to `serialization_order` #define jl_queue_for_serialization(s, v) jl_queue_for_serialization_((s), (jl_value_t*)(v), 1, 0) static void jl_queue_for_serialization_(jl_serializer_state *s, jl_value_t *v, int recursive, int immediate) JL_GC_DISABLED; @@ -848,25 +838,8 @@ static void jl_insert_into_serialization_queue(jl_serializer_state *s, jl_value_ // TODO: if (ci in ci->defs->cache) record_field_change((jl_value_t**)&ci->next, NULL); } - jl_value_t *inferred = jl_atomic_load_relaxed(&ci->inferred); - if (inferred && inferred != jl_nothing) { // disregard if there is nothing here to delete (e.g. builtins, unspecialized) - if (!is_relocatable_ci(&relocatable_ext_cis, ci)) - record_field_change((jl_value_t**)&ci->inferred, jl_nothing); - else if (jl_is_method(ci->def->def.method) && // don't delete toplevel code - ci->def->def.method->source) { // don't delete code from optimized opaque closures that can't be reconstructed (and builtins) - if (jl_atomic_load_relaxed(&ci->max_world) != ~(size_t)0 || // delete all code that cannot run - jl_atomic_load_relaxed(&ci->invoke) == jl_fptr_const_return) { // delete all code that just returns a constant - record_field_change((jl_value_t**)&ci->inferred, jl_nothing); - } - else if (native_functions && // don't delete any code if making a ji file - (ci->owner == jl_nothing) && // don't delete code for external interpreters - !effects_foldable(ci->ipo_purity_bits) && // don't delete code we may want for irinterp - jl_ir_inlining_cost(inferred) == UINT16_MAX) { // don't delete inlineable code - // delete the code now: if we thought it was worth keeping, it would have been converted to object code - record_field_change((jl_value_t**)&ci->inferred, jl_nothing); - } - } - } + if (jl_atomic_load_relaxed(&ci->inferred) && !is_relocatable_ci(&relocatable_ext_cis, ci)) + record_field_change((jl_value_t**)&ci->inferred, jl_nothing); } if (immediate) // must be things that can be recursively handled, and valid as type parameters From 2e9119dd95578b8b9cb8bcb11ec344c0dfa08d02 Mon Sep 17 00:00:00 2001 From: Tommy Hofmann Date: Fri, 21 Feb 2025 19:41:27 +0100 Subject: [PATCH 15/56] Clarify disabling of tab-completion hinting in the documentation (#57493) (cherry picked from commit e2cc68ced04dbfa4ea2005a4a44e05fe1e6d6336) --- stdlib/REPL/docs/src/index.md | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/stdlib/REPL/docs/src/index.md b/stdlib/REPL/docs/src/index.md index d2a17e3a6b4a3..fdc1be5c5f357 100644 --- a/stdlib/REPL/docs/src/index.md +++ b/stdlib/REPL/docs/src/index.md @@ -341,7 +341,15 @@ mapfoldl mapfoldr When a single complete tab-complete result is available at the end of an input line and 2 or more characters have been typed, a hint of the completion will show in a lighter color. -This can be disabled via `Base.active_repl.options.hint_tab_completes = false`. +This can be disabled via `Base.active_repl.options.hint_tab_completes = false` or by adding +``` +atreplinit() do repl + if VERSION >= v"1.11.0-0" + repl.options.hint_tab_completes = false + end +end +``` +to your `~/.julia/config/startup.jl`. !!! compat "Julia 1.11" Tab-complete hinting was added in Julia 1.11 From 06c808bd678831aaf18238dd6f3680f78263944d Mon Sep 17 00:00:00 2001 From: Ian Butterworth Date: Thu, 27 Mar 2025 18:47:52 -0400 Subject: [PATCH 16/56] fixup "Don't free regex objects in exit-time finalizer calls (#57834)" --- base/regex.jl | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/base/regex.jl b/base/regex.jl index 2cb49610dc300..2b2717a74efc0 100644 --- a/base/regex.jl +++ b/base/regex.jl @@ -40,8 +40,9 @@ mutable struct Regex <: AbstractPattern re = compile(new(pattern, compile_options, match_options, C_NULL)) finalizer(re) do re # don't free during exit because tasks may still be running and - # using it. Issue #57817 - during_exit = Base._atexit_hooks_finished + # using it. Issue #57817. During sysimage creation _atexit_hooks_finished + # is not defined but threads aren't running so just always run + during_exit = @isdefined(_atexit_hooks_finished) && _atexit_hooks_finished if re.regex != C_NULL && !during_exit PCRE.free_re(re.regex) end From 8ca7e1e7eaab620f783e3801f404a10727c059ee Mon Sep 17 00:00:00 2001 From: Gabriel Baraldi Date: Fri, 28 Mar 2025 09:24:34 -0300 Subject: [PATCH 17/56] [backports-1.11] Add passes to `-O1` pipeline to reduce allocations in `reinterpret` (#57732) --- src/pipeline.cpp | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/src/pipeline.cpp b/src/pipeline.cpp index 5c12e3dad0dd7..2df9d0dfd5a31 100644 --- a/src/pipeline.cpp +++ b/src/pipeline.cpp @@ -490,6 +490,13 @@ static void buildScalarOptimizerPipeline(FunctionPassManager &FPM, PassBuilder * FPM.addPass(IRCEPass()); FPM.addPass(InstCombinePass()); FPM.addPass(JumpThreadingPass()); + } else if (O.getSpeedupLevel() >= 1) { + JULIA_PASS(FPM.addPass(AllocOptPass())); + FPM.addPass(SROAPass(SROAOptions::ModifyCFG)); + FPM.addPass(MemCpyOptPass()); + FPM.addPass(SCCPPass()); + FPM.addPass(InstCombinePass()); + FPM.addPass(ADCEPass()); } if (O.getSpeedupLevel() >= 3) { FPM.addPass(GVNPass()); From c28dc8502f3277e474bacbd28a992b8605fb51e7 Mon Sep 17 00:00:00 2001 From: Jishnu Bhattacharya Date: Fri, 28 Mar 2025 19:30:52 +0530 Subject: [PATCH 18/56] Materialize complex Symmetric matrices in eigen (#55348) --- stdlib/LinearAlgebra/src/bunchkaufman.jl | 15 +++++++++------ stdlib/LinearAlgebra/src/symmetriceigen.jl | 1 + stdlib/LinearAlgebra/test/hessenberg.jl | 7 +++++++ stdlib/LinearAlgebra/test/symmetriceigen.jl | 6 ++++++ 4 files changed, 23 insertions(+), 6 deletions(-) diff --git a/stdlib/LinearAlgebra/src/bunchkaufman.jl b/stdlib/LinearAlgebra/src/bunchkaufman.jl index 8d1ded9bf8111..db0d44a1e25a6 100644 --- a/stdlib/LinearAlgebra/src/bunchkaufman.jl +++ b/stdlib/LinearAlgebra/src/bunchkaufman.jl @@ -127,6 +127,9 @@ function bunchkaufman!(A::StridedMatrix{<:BlasFloat}, rook::Bool = false; check: end end +bkcopy_oftype(A, S) = eigencopy_oftype(A, S) +bkcopy_oftype(A::Symmetric{<:Complex}, S) = Symmetric(copytrito!(similar(parent(A), S, size(A)), A.data, A.uplo), sym_uplo(A.uplo)) + """ bunchkaufman(A, rook::Bool=false; check = true) -> S::BunchKaufman @@ -206,7 +209,7 @@ julia> S.L*S.D*S.L' - A[S.p, S.p] ``` """ bunchkaufman(A::AbstractMatrix{T}, rook::Bool=false; check::Bool = true) where {T} = - bunchkaufman!(eigencopy_oftype(A, typeof(sqrt(oneunit(T)))), rook; check = check) + bunchkaufman!(bkcopy_oftype(A, typeof(sqrt(oneunit(T)))), rook; check = check) BunchKaufman{T}(B::BunchKaufman) where {T} = BunchKaufman(convert(Matrix{T}, B.LD), B.ipiv, B.uplo, B.symmetric, B.rook, B.info) @@ -1529,7 +1532,7 @@ function bunchkaufman(A::AbstractMatrix{TS}, rook::Bool = false; check::Bool = true ) where TS <: ClosedScalar{TR} where TR <: ClosedReal - return bunchkaufman!(eigencopy_oftype(A, TS), rook; check) + return bunchkaufman!(bkcopy_oftype(A, TS), rook; check) end function bunchkaufman(A::AbstractMatrix{TS}, @@ -1551,15 +1554,15 @@ function bunchkaufman(A::AbstractMatrix{TS}, # We promote input to BigInt to avoid overflow problems if TA == Nothing if TS <: Integer - M = Rational{BigInt}.(eigencopy_oftype(A, TS)) + M = Rational{BigInt}.(bkcopy_oftype(A, TS)) else - M = Complex{Rational{BigInt}}.(eigencopy_oftype(A, TS)) + M = Complex{Rational{BigInt}}.(bkcopy_oftype(A, TS)) end else if TS <: Integer - M = TA(Rational{BigInt}.(eigencopy_oftype(A, TS)), Symbol(A.uplo)) + M = TA(Rational{BigInt}.(bkcopy_oftype(A, TS)), Symbol(A.uplo)) else - M = TA(Complex{Rational{BigInt}}.(eigencopy_oftype(A, TS)), + M = TA(Complex{Rational{BigInt}}.(bkcopy_oftype(A, TS)), Symbol(A.uplo)) end end diff --git a/stdlib/LinearAlgebra/src/symmetriceigen.jl b/stdlib/LinearAlgebra/src/symmetriceigen.jl index 0c86383685807..e9f43ef640392 100644 --- a/stdlib/LinearAlgebra/src/symmetriceigen.jl +++ b/stdlib/LinearAlgebra/src/symmetriceigen.jl @@ -3,6 +3,7 @@ # preserve HermOrSym wrapper eigencopy_oftype(A::Hermitian, S) = Hermitian(copy_similar(A, S), sym_uplo(A.uplo)) eigencopy_oftype(A::Symmetric, S) = Symmetric(copy_similar(A, S), sym_uplo(A.uplo)) +eigencopy_oftype(A::Symmetric{<:Complex}, S) = copyto!(similar(parent(A), S), A) # Eigensolvers for symmetric and Hermitian matrices eigen!(A::RealHermSymComplexHerm{<:BlasReal,<:StridedMatrix}; sortby::Union{Function,Nothing}=nothing) = diff --git a/stdlib/LinearAlgebra/test/hessenberg.jl b/stdlib/LinearAlgebra/test/hessenberg.jl index 39ae7ec83a5c3..136f741fa5c0e 100644 --- a/stdlib/LinearAlgebra/test/hessenberg.jl +++ b/stdlib/LinearAlgebra/test/hessenberg.jl @@ -250,4 +250,11 @@ end @test axes(S) === (r,r) end +@testset "complex Symmetric" begin + D = diagm(0=>ComplexF64[1,2]) + S = Symmetric(D) + H = hessenberg(S) + @test H.H == D +end + end # module TestHessenberg diff --git a/stdlib/LinearAlgebra/test/symmetriceigen.jl b/stdlib/LinearAlgebra/test/symmetriceigen.jl index b3a5472c511f4..258ccbd2d4591 100644 --- a/stdlib/LinearAlgebra/test/symmetriceigen.jl +++ b/stdlib/LinearAlgebra/test/symmetriceigen.jl @@ -151,4 +151,10 @@ end @test HT * V ≈ V * Diagonal(λ) end +@testset "complex Symmetric" begin + S = Symmetric(rand(ComplexF64,2,2)) + λ, v = eigen(S) + @test S * v ≈ v * Diagonal(λ) +end + end # module TestSymmetricEigen From dec70727fcd327af8e9df7f7c0aabd53ddb9b046 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?C=C3=A9dric=20Belmant?= Date: Mon, 3 Feb 2025 16:00:24 +0100 Subject: [PATCH 19/56] Optimizer: Update SROA def-uses after DCE (#57201) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Fixes https://github.com/JuliaLang/julia/issues/57141. Given the function ```julia julia> function _f() ref = Ref{Any}() ref[] = 3 @assert isdefined(ref, :x) inner = Returns(ref) x = inner() (x, ref[]) end _f (generic function with 1 method) julia> f() = first(_f()) f (generic function with 1 method) ``` Here is before: ```julia julia> @code_typed f() CodeInfo( 1 ─ %1 = %new(Base.RefValue{Any})::Base.RefValue{Any} └── goto #3 2 ─ unreachable 3 ─ return %1 ) => Base.RefValue{Any} ``` Here is after this PR: ```julia julia> @code_typed f() CodeInfo( 1 ─ %1 = %new(Base.RefValue{Any})::Base.RefValue{Any} │ builtin Base.setfield!(%1, :x, 3)::Int64 │ %3 = builtin Main.isdefined(%1, :x)::Bool └── goto #3 if not %3 2 ─ goto #4 3 ─ %6 = invoke Base.AssertionError("isdefined(ref, :x)"::String)::AssertionError │ builtin Base.throw(%6)::Union{} └── unreachable 4 ─ return %1 ) => Base.RefValue{Any} ``` The elimination of `setfield!` was due to a use still being recorded for `ref[]` in the def-use data while DCE eliminated this `getindex` call (by virtue of not using the second tuple element in the result). --------- Co-authored-by: Cédric Belmant Co-authored-by: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com> (cherry picked from commit fea26ddecb8a6c404f0c501228bf17c9b384d686) --- base/compiler/ssair/passes.jl | 4 ++++ test/compiler/irpasses.jl | 12 ++++++++++++ 2 files changed, 16 insertions(+) diff --git a/base/compiler/ssair/passes.jl b/base/compiler/ssair/passes.jl index 3f5943d36938d..a9e020c653aed 100644 --- a/base/compiler/ssair/passes.jl +++ b/base/compiler/ssair/passes.jl @@ -1480,6 +1480,10 @@ function sroa_pass!(ir::IRCode, inlining::Union{Nothing,InliningState}=nothing) used_ssas[x.id] -= 1 end ir = complete(compact) + # remove any use that has been optimized away by the DCE + for (intermediaries, defuse) in values(defuses) + filter!(x -> ir[SSAValue(x.idx)][:stmt] !== nothing, defuse.uses) + end sroa_mutables!(ir, defuses, used_ssas, lazydomtree, inlining) return ir else diff --git a/test/compiler/irpasses.jl b/test/compiler/irpasses.jl index 6d6cd74028594..a370a921f51b2 100644 --- a/test/compiler/irpasses.jl +++ b/test/compiler/irpasses.jl @@ -1841,3 +1841,15 @@ let f = (x)->nothing, mi = Base.method_instance(f, (Base.RefValue{Nothing},)), c ir = Core.Compiler.sroa_pass!(ir, inlining) Core.Compiler.verify_ir(ir) end + +# https://github.com/JuliaLang/julia/issues/57141 +# don't eliminate `setfield!` when the field is to be used +let src = code_typed1(()) do + ref = Ref{Any}() + ref[] = 0 + @assert isdefined(ref, :x) + inner() = ref[] + 1 + (inner(), ref[]) + end + @test count(iscall((src, setfield!)), src.code) == 1 +end From 358337b72a88ad483e62eb65e9d01c53900abb53 Mon Sep 17 00:00:00 2001 From: Neven Sajko <4944410+nsajko@users.noreply.github.com> Date: Tue, 11 Mar 2025 12:17:35 +0100 Subject: [PATCH 20/56] `Base`: `append!`, `resize!`: convert length to `Int` before passing it on (#57585) Reduces the number of invalidations from 512 to 505 on running this code: ```julia struct I <: Integer end Base.Int(::I) = 7 ``` (cherry picked from commit a97137ee079de308599c72e1ed04154dbd3ffc50) --- base/array.jl | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/base/array.jl b/base/array.jl index 7efdd1839b0d8..711c3e9f3bc28 100644 --- a/base/array.jl +++ b/base/array.jl @@ -1320,7 +1320,7 @@ function append! end function append!(a::Vector{T}, items::Union{AbstractVector{<:T},Tuple}) where T items isa Tuple && (items = map(x -> convert(T, x), items)) - n = length(items) + n = Int(length(items))::Int _growend!(a, n) copyto!(a, length(a)-n+1, items, firstindex(items), n) return a @@ -1444,7 +1444,8 @@ julia> a[1:6] 1 ``` """ -function resize!(a::Vector, nl::Integer) +function resize!(a::Vector, nl_::Integer) + nl = Int(nl_)::Int l = length(a) if nl > l _growend!(a, nl-l) From 969bcdec0c1b2726367329481103ee60d765e674 Mon Sep 17 00:00:00 2001 From: Cody Tapscott <84105208+topolarity@users.noreply.github.com> Date: Tue, 11 Mar 2025 15:20:11 -0400 Subject: [PATCH 21/56] Libdl: Improve inference for `string(::LazyLibraryPath)` (#57721) Make this function `--trim` compatible. (cherry picked from commit 8edc2b35fca93a002606219bc0bb4628c5b986fa) --- base/libdl.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/base/libdl.jl b/base/libdl.jl index 199d847572ca4..0b603d944100b 100644 --- a/base/libdl.jl +++ b/base/libdl.jl @@ -334,7 +334,7 @@ struct LazyLibraryPath LazyLibraryPath(pieces::Vector) = new(pieces) end LazyLibraryPath(args...) = LazyLibraryPath(collect(args)) -Base.string(llp::LazyLibraryPath) = joinpath(string.(llp.pieces)...)::String +Base.string(llp::LazyLibraryPath) = joinpath(String[string(p) for p in llp.pieces]) Base.cconvert(::Type{Cstring}, llp::LazyLibraryPath) = Base.cconvert(Cstring, string(llp)) # Define `print` so that we can wrap this in a `LazyString` Base.print(io::IO, llp::LazyLibraryPath) = print(io, string(llp)) From de8ef4657e3cefbaca0bf1a3370b1c687c8678c8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mos=C3=A8=20Giordano?= <765740+giordano@users.noreply.github.com> Date: Sat, 15 Mar 2025 00:56:03 +0000 Subject: [PATCH 22/56] [docs] Clarify that Float16 is supported natively when possible (#57725) Co-authored-by: Jishnu Bhattacharya (cherry picked from commit 3e57a8ac3adbe28e2a9a67e2fed2a1be24375ca5) --- doc/src/manual/integers-and-floating-point-numbers.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/doc/src/manual/integers-and-floating-point-numbers.md b/doc/src/manual/integers-and-floating-point-numbers.md index 4c31871374aa2..3eabccda44cd7 100644 --- a/doc/src/manual/integers-and-floating-point-numbers.md +++ b/doc/src/manual/integers-and-floating-point-numbers.md @@ -334,8 +334,8 @@ julia> typeof(x) Float64 ``` -Half-precision floating-point numbers are also supported ([`Float16`](@ref)), but they are -implemented in software and use [`Float32`](@ref) for calculations. +Half-precision floating-point numbers are also supported ([`Float16`](@ref)) on all platforms, with native instructions used on hardware which supports this number format. Otherwise, operations are implemented in software, and use [`Float32`](@ref) for intermediate calculations. +As an internal implementation detail, this is achieved under the hood by using LLVM's [`half`](https://llvm.org/docs/LangRef.html#half-precision-floating-point-intrinsics) type, which behaves similarly to what the GCC [`-fexcess-precision=16`](https://gcc.gnu.org/onlinedocs/gcc/Optimize-Options.html#index-fexcess-precision) flag does for C/C++ code. ```jldoctest julia> sizeof(Float16(4.)) From ac642ff03c71c1fb7f88f099848d99968391a4e3 Mon Sep 17 00:00:00 2001 From: Neven Sajko <4944410+nsajko@users.noreply.github.com> Date: Mon, 17 Mar 2025 06:05:16 +0100 Subject: [PATCH 23/56] fix special function `::Real` fallback stack overflow (#57790) Fixes #57789 (cherry picked from commit 6817691ecbba3e2a687348c085af1c3d76f020fe) --- base/math.jl | 2 +- test/math.jl | 8 ++++++++ 2 files changed, 9 insertions(+), 1 deletion(-) diff --git a/base/math.jl b/base/math.jl index 9c02b43140aaf..a26f6fc5f4053 100644 --- a/base/math.jl +++ b/base/math.jl @@ -1557,7 +1557,7 @@ for f in (:sin, :cos, :tan, :asin, :atan, :acos, :exponent, :sqrt, :cbrt, :sinpi, :cospi, :sincospi, :tanpi) @eval function ($f)(x::Real) xf = float(x) - x === xf && throw(MethodError($f, (x,))) + xf isa typeof(x) && throw(MethodError($f, (x,))) return ($f)(xf) end @eval $(f)(::Missing) = missing diff --git a/test/math.jl b/test/math.jl index d73c13530f166..3a06db8a22fa0 100644 --- a/test/math.jl +++ b/test/math.jl @@ -1485,6 +1485,14 @@ end @test E^float(n) == Inf end +@testset "special function `::Real` fallback shouldn't recur without bound, issue #57789" begin + mutable struct Issue57789 <: Real end + Base.float(::Issue57789) = Issue57789() + for f ∈ (sin, sinpi, log, exp) + @test_throws MethodError f(Issue57789()) + end +end + # Test that sqrt behaves correctly and doesn't exhibit fp80 double rounding. # This happened on old glibc versions. # Test case from https://sourceware.org/bugzilla/show_bug.cgi?id=14032. From e80ce4b41429053cf07df37697edbc0e5e3b6932 Mon Sep 17 00:00:00 2001 From: Jameson Nash Date: Mon, 17 Mar 2025 16:53:43 -0400 Subject: [PATCH 24/56] stackwalk: fix heuristic termination (#57801) When getting stacktraces on non-X86 platforms, the first frame may not have been set up yet, incorrectly triggering this bad-frame detection logic. This should fix the issue of async unwind failing after only getting 2 frames, if the first frame happens to land in the function header. This is not normally an issue on X86 or non-signals, but also causes no expected issues to be the same logic there too. Fix #52334 After (on arm64-apple-darwin24.3.0): ``` julia> f(1) Warning: detected a stack overflow; program state may be corrupted, so further execution might be unreliable. ERROR: StackOverflowError: Stacktrace: [1] f(x::Int64) @ Main ./REPL[3]:1 [2] g(x::Int64) @ Main ./REPL[4]:1 --- the above 2 lines are repeated 39990 more times --- [79983] f(x::Int64) @ Main ./REPL[3]:1 ``` n.b. This will not fix and is not related to any issues where profiling gets only a single stack frame during profiling of syscalls on Apple AArch64. This fix is specific to the bug where it gets exactly 2 frames. (cherry picked from commit f82917a8ada5a3f4e4ca85408e078a6389c9e94a) --- src/stackwalk.c | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/src/stackwalk.c b/src/stackwalk.c index 0cf7b11d7cb86..d4d87e5f95a35 100644 --- a/src/stackwalk.c +++ b/src/stackwalk.c @@ -97,9 +97,13 @@ static int jl_unw_stepn(bt_cursor_t *cursor, jl_bt_element_t *bt_data, size_t *b } uintptr_t oldsp = thesp; have_more_frames = jl_unw_step(cursor, from_signal_handler, &return_ip, &thesp); - if (oldsp >= thesp && !jl_running_under_rr(0)) { - // The stack pointer is clearly bad, as it must grow downwards. + if ((n < 2 ? oldsp > thesp : oldsp >= thesp) && !jl_running_under_rr(0)) { + // The stack pointer is clearly bad, as it must grow downwards, // But sometimes the external unwinder doesn't check that. + // Except for n==0 when there is no oldsp and n==1 on all platforms but i686/x86_64. + // (on x86, the platform first pushes the new stack frame, then does the + // call, on almost all other platforms, the platform first does the call, + // then the user pushes the link register to the frame). have_more_frames = 0; } if (return_ip == 0) { @@ -131,11 +135,11 @@ static int jl_unw_stepn(bt_cursor_t *cursor, jl_bt_element_t *bt_data, size_t *b // * The way that libunwind handles it in `unw_get_proc_name`: // https://lists.nongnu.org/archive/html/libunwind-devel/2014-06/msg00025.html uintptr_t call_ip = return_ip; + #if defined(_CPU_ARM_) // ARM instruction pointer encoding uses the low bit as a flag for // thumb mode, which must be cleared before further use. (Note not // needed for ARM AArch64.) See // https://github.com/libunwind/libunwind/pull/131 - #ifdef _CPU_ARM_ call_ip &= ~(uintptr_t)0x1; #endif // Now there's two main cases to adjust for: From ae9f94c3810dfc6b9fb36b36a7a1a398eb83d229 Mon Sep 17 00:00:00 2001 From: Neven Sajko <4944410+nsajko@users.noreply.github.com> Date: Thu, 20 Mar 2025 22:02:43 +0100 Subject: [PATCH 25/56] restrict dispatch of some custrom string macros to `String` (#57781) Restricts the dispatch for these macros so that only `String` (literal) arguments are accepted: * `int128_str` * `uint128_str` * `big_str` * `ip_str` from the Sockets stdlib * `dateformat_str` from the Dates stdlib Some of these changes make the code in the sysimage less vulnerable to invalidation. (cherry picked from commit f9365a5ecd336388c0d4f3c987c1c8fde95b4da3) --- base/int.jl | 6 +++--- stdlib/Dates/src/io.jl | 2 +- stdlib/Sockets/src/IPAddr.jl | 2 +- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/base/int.jl b/base/int.jl index 61576d4360835..0c7a0219d8c2a 100644 --- a/base/int.jl +++ b/base/int.jl @@ -647,7 +647,7 @@ ERROR: LoadError: ArgumentError: invalid base 10 digit '.' in "123456789123.4" [...] ``` """ -macro int128_str(s) +macro int128_str(s::String) return parse(Int128, s) end @@ -667,7 +667,7 @@ ERROR: LoadError: ArgumentError: invalid base 10 digit '-' in "-123456789123" [...] ``` """ -macro uint128_str(s) +macro uint128_str(s::String) return parse(UInt128, s) end @@ -700,7 +700,7 @@ ERROR: ArgumentError: invalid number format _ for BigInt or BigFloat depends on the value of the precision at the point when the function is defined, **not** at the precision at the time when the function is called. """ -macro big_str(s) +macro big_str(s::String) message = "invalid number format $s for BigInt or BigFloat" throw_error = :(throw(ArgumentError($message))) if '_' in s diff --git a/stdlib/Dates/src/io.jl b/stdlib/Dates/src/io.jl index 3980ad3a7245f..33e3cf375e7ed 100644 --- a/stdlib/Dates/src/io.jl +++ b/stdlib/Dates/src/io.jl @@ -460,7 +460,7 @@ but creates the DateFormat object once during macro expansion. See [`DateFormat`](@ref) for details about format specifiers. """ -macro dateformat_str(str) +macro dateformat_str(str::String) DateFormat(str) end diff --git a/stdlib/Sockets/src/IPAddr.jl b/stdlib/Sockets/src/IPAddr.jl index d3834a8b8bf73..e324dee712b71 100644 --- a/stdlib/Sockets/src/IPAddr.jl +++ b/stdlib/Sockets/src/IPAddr.jl @@ -286,7 +286,7 @@ julia> @ip_str "2001:db8:0:0:0:0:2:1" ip"2001:db8::2:1" ``` """ -macro ip_str(str) +macro ip_str(str::String) return parse(IPAddr, str) end From 2a153e809261f858afbf467c0a19fe0d5d9461a1 Mon Sep 17 00:00:00 2001 From: Neven Sajko <4944410+nsajko@users.noreply.github.com> Date: Fri, 21 Mar 2025 18:38:20 +0100 Subject: [PATCH 26/56] iobuffer: copyline: type assert `Int` to prevent invalidation (#57848) Should prevent invalidation stemming from `MethodInstance`s for * `readline()` * `readlines()` * `Base.run_fallback_repl(::Bool)` * `Base.repl_main(::Any)` * `Base._start()` In each case the issue is the use of the nonconcretely-typed global variable `stdin::IO`. (cherry picked from commit eed18bdf706b7aab15b12f3ba0588e8fafcd4930) --- base/iobuffer.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/base/iobuffer.jl b/base/iobuffer.jl index fa1a99d3553f8..45d711589276d 100644 --- a/base/iobuffer.jl +++ b/base/iobuffer.jl @@ -615,7 +615,7 @@ function _copyline(out::IO, io::GenericIOBuffer; keep::Bool=false) data = view(io.data, io.ptr:io.size) # note: findfirst + copyto! is much faster than a single loop # except for nout ≲ 20. A single loop is 2x faster for nout=5. - nout = nread = something(findfirst(==(0x0a), data), length(data)) + nout = nread = something(findfirst(==(0x0a), data), length(data))::Int if !keep && nout > 0 && data[nout] == 0x0a nout -= 1 nout > 0 && data[nout] == 0x0d && (nout -= 1) From 9b474fa2a592e0a94b31853b39fc6d60a043db57 Mon Sep 17 00:00:00 2001 From: Oscar Smith Date: Sat, 22 Mar 2025 21:55:11 -0400 Subject: [PATCH 27/56] fix `mod` for mixes of `Signed` and `Unsigned` (#57853) Previously this was just overfowing producing wrong answers (both for the sign convention and just the wrong modulo class) fixes https://github.com/JuliaLang/julia/issues/57851 (cherry picked from commit 056891701e8ec629834def549f565cf80c46ccf9) --- base/int.jl | 10 ++++++++-- test/int.jl | 17 +++++++++++++++++ 2 files changed, 25 insertions(+), 2 deletions(-) diff --git a/base/int.jl b/base/int.jl index 0c7a0219d8c2a..f9cdce44f88dc 100644 --- a/base/int.jl +++ b/base/int.jl @@ -286,8 +286,14 @@ function mod(x::T, y::T) where T<:Integer y == -1 && return T(0) # avoid potential overflow in fld return x - fld(x, y) * y end -mod(x::BitSigned, y::Unsigned) = rem(y + unsigned(rem(x, y)), y) -mod(x::Unsigned, y::Signed) = rem(y + signed(rem(x, y)), y) +function mod(x::BitSigned, y::Unsigned) + remval = rem(x, y) # correct iff remval>=0 + return unsigned(remval + (remval0 so correct iff y>0 or remval==0 + return remval + (!iszero(remval) && y Date: Sun, 23 Mar 2025 11:49:22 -0400 Subject: [PATCH 28/56] REPL: call display on the backend (#57773) (cherry picked from commit c75cf3ff62baf98edefa95e05307a6ea525eb6e3) --- stdlib/REPL/src/REPL.jl | 84 +++++++++++++++++++++++++++------------- stdlib/REPL/test/repl.jl | 2 +- 2 files changed, 59 insertions(+), 27 deletions(-) diff --git a/stdlib/REPL/src/REPL.jl b/stdlib/REPL/src/REPL.jl index 5561b046c77db..2cc844068bc52 100644 --- a/stdlib/REPL/src/REPL.jl +++ b/stdlib/REPL/src/REPL.jl @@ -193,6 +193,22 @@ mutable struct REPLBackend end REPLBackend() = REPLBackend(Channel(1), Channel(1), false) +# A reference to a backend that is not mutable +struct REPLBackendRef + repl_channel::Channel{Any} + response_channel::Channel{Any} +end +REPLBackendRef(backend::REPLBackend) = REPLBackendRef(backend.repl_channel, backend.response_channel) + +function destroy(ref::REPLBackendRef, state::Task) + if istaskfailed(state) + close(ref.repl_channel, TaskFailedException(state)) + close(ref.response_channel, TaskFailedException(state)) + end + close(ref.repl_channel) + close(ref.response_channel) +end + """ softscope(ex) @@ -334,12 +350,23 @@ function repl_backend_loop(backend::REPLBackend, get_module::Function) while true tls = task_local_storage() tls[:SOURCE_PATH] = nothing - ast, show_value = take!(backend.repl_channel) + ast_or_func, show_value = take!(backend.repl_channel) if show_value == -1 # exit flag break end - eval_user_input(ast, backend, get_module()) + if show_value == 2 # 2 indicates a function to be called + f = ast_or_func + try + ret = f() + put!(backend.response_channel, Pair{Any, Bool}(ret, false)) + catch err + put!(backend.response_channel, Pair{Any, Bool}(err, true)) + end + else + ast = ast_or_func + eval_user_input(ast, backend, get_module()) + end end return nothing end @@ -375,7 +402,7 @@ function print_response(repl::AbstractREPL, response, show_value::Bool, have_col repl.waserror = response[2] with_repl_linfo(repl) do io io = IOContext(io, :module => Base.active_module(repl)::Module) - print_response(io, response, show_value, have_color, specialdisplay(repl)) + print_response(io, response, backend(repl), show_value, have_color, specialdisplay(repl)) end return nothing end @@ -392,7 +419,7 @@ function repl_display_error(errio::IO, @nospecialize errval) return nothing end -function print_response(errio::IO, response, show_value::Bool, have_color::Bool, specialdisplay::Union{AbstractDisplay,Nothing}=nothing) +function print_response(errio::IO, response, backend::Union{REPLBackendRef,Nothing}, show_value::Bool, have_color::Bool, specialdisplay::Union{AbstractDisplay,Nothing}=nothing) Base.sigatomic_begin() val, iserr = response while true @@ -404,15 +431,19 @@ function print_response(errio::IO, response, show_value::Bool, have_color::Bool, repl_display_error(errio, val) else if val !== nothing && show_value - try - if specialdisplay === nothing + val2, iserr = if specialdisplay === nothing + # display calls may require being run on the main thread + eval_with_backend(backend) do Base.invokelatest(display, val) - else + end + else + eval_with_backend(backend) do Base.invokelatest(display, specialdisplay, val) end - catch + end + if iserr println(errio, "Error showing value of type ", typeof(val), ":") - rethrow() + throw(val2) end end end @@ -442,21 +473,7 @@ function print_response(errio::IO, response, show_value::Bool, have_color::Bool, nothing end -# A reference to a backend that is not mutable -struct REPLBackendRef - repl_channel::Channel{Any} - response_channel::Channel{Any} -end -REPLBackendRef(backend::REPLBackend) = REPLBackendRef(backend.repl_channel, backend.response_channel) -function destroy(ref::REPLBackendRef, state::Task) - if istaskfailed(state) - close(ref.repl_channel, TaskFailedException(state)) - close(ref.response_channel, TaskFailedException(state)) - end - close(ref.repl_channel) - close(ref.response_channel) -end """ run_repl(repl::AbstractREPL) @@ -977,12 +994,27 @@ find_hist_file() = get(ENV, "JULIA_HISTORY", !isempty(DEPOT_PATH) ? joinpath(DEPOT_PATH[1], "logs", "repl_history.jl") : error("DEPOT_PATH is empty and and ENV[\"JULIA_HISTORY\"] not set.")) -backend(r::AbstractREPL) = r.backendref +backend(r::AbstractREPL) = hasproperty(r, :backendref) ? r.backendref : nothing -function eval_with_backend(ast, backend::REPLBackendRef) - put!(backend.repl_channel, (ast, 1)) + +function eval_with_backend(ast::Expr, backend::REPLBackendRef) + put!(backend.repl_channel, (ast, 1)) # (f, show_value) + return take!(backend.response_channel) # (val, iserr) +end +function eval_with_backend(f, backend::REPLBackendRef) + put!(backend.repl_channel, (f, 2)) # (f, show_value) 2 indicates function (rather than ast) return take!(backend.response_channel) # (val, iserr) end +# if no backend just eval (used by tests) +function eval_with_backend(f, backend::Nothing) + try + ret = f() + return (ret, false) # (val, iserr) + catch err + return (err, true) + end +end + function respond(f, repl, main; pass_empty::Bool = false, suppress_on_semicolon::Bool = true) return function do_respond(s::MIState, buf, ok::Bool) diff --git a/stdlib/REPL/test/repl.jl b/stdlib/REPL/test/repl.jl index debf7e5ad12e4..f83978b43e2a9 100644 --- a/stdlib/REPL/test/repl.jl +++ b/stdlib/REPL/test/repl.jl @@ -924,7 +924,7 @@ function test19864() @eval Base.showerror(io::IO, e::Error19864) = print(io, "correct19864") buf = IOBuffer() fake_response = (Base.ExceptionStack([(exception=Error19864(),backtrace=Ptr{Cvoid}[])]),true) - REPL.print_response(buf, fake_response, false, false, nothing) + REPL.print_response(buf, fake_response, nothing, false, false, nothing) return String(take!(buf)) end @test occursin("correct19864", test19864()) From 2dc33adcdefca1d58bb86b0d1cb9b9915b7c495d Mon Sep 17 00:00:00 2001 From: Neven Sajko <4944410+nsajko@users.noreply.github.com> Date: Tue, 25 Mar 2025 13:56:07 +0100 Subject: [PATCH 29/56] `Base`: `PCRE`: `exec`: type assert `String` after construction (#57868) Should prevent some invalidation in the sysimage. (cherry picked from commit f49f46d240df335233fa49d1b204c7df7de30540) --- base/pcre.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/base/pcre.jl b/base/pcre.jl index 614ffa694af0e..e62d0c384cff5 100644 --- a/base/pcre.jl +++ b/base/pcre.jl @@ -199,7 +199,7 @@ end exec(re, subject::Union{String,SubString{String}}, offset, options, match_data) = _exec(re, subject, offset, options, match_data) exec(re, subject, offset, options, match_data) = - _exec(re, String(subject), offset, options, match_data) + _exec(re, String(subject)::String, offset, options, match_data) function _exec(re, subject, offset, options, match_data) rc = ccall((:pcre2_match_8, PCRE_LIB), Cint, From b8c0a89c6806154ce318e30efe6ec2b71203a1a4 Mon Sep 17 00:00:00 2001 From: Neven Sajko <4944410+nsajko@users.noreply.github.com> Date: Tue, 25 Mar 2025 13:56:37 +0100 Subject: [PATCH 30/56] `Base`: `macro b_str`: restrict argument to `String` (#57863) Should make the sysimage less vulnerable to invalidation. As far as I understand this change can't break any code, because: * the macro definition requires `AbstractString` * the way Julia macros work, the argument is either a literal or an `Expr` * `String` is the only `AbstractString` with literals (cherry picked from commit 87f4d3a344e7efe49fc41870f5e3e3901fca8b00) --- base/strings/io.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/base/strings/io.jl b/base/strings/io.jl index 4ab22637e0eb1..91fe950eba366 100644 --- a/base/strings/io.jl +++ b/base/strings/io.jl @@ -577,7 +577,7 @@ julia> v[2] 0x32 ``` """ -macro b_str(s) +macro b_str(s::String) v = codeunits(unescape_string(s)) QuoteNode(v) end From 118bd2d36263a67f51cc571235509ae9ac553b6d Mon Sep 17 00:00:00 2001 From: Neven Sajko <4944410+nsajko@users.noreply.github.com> Date: Tue, 25 Mar 2025 13:56:52 +0100 Subject: [PATCH 31/56] `Base`: `macro cmd`: restrict argument to `String` (#57862) Should make the sysimage less vulnerable to invalidation. As far as I understand this change can't break any code, because: * the macro definition requires `AbstractString` * the way Julia macros work, the argument is either a literal or an `Expr` * `String` is the only `AbstractString` with literals (cherry picked from commit 7acb2a6aa4299b38cddb52117b21dcdbd1c8268d) --- base/cmd.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/base/cmd.jl b/base/cmd.jl index 84ec52f865e98..93c78b63139c3 100644 --- a/base/cmd.jl +++ b/base/cmd.jl @@ -504,7 +504,7 @@ julia> run(cm) Process(`echo 1`, ProcessExited(0)) ``` """ -macro cmd(str) +macro cmd(str::String) cmd_ex = shell_parse(str, special=shell_special, filename=String(__source__.file))[1] return :(cmd_gen($(esc(cmd_ex)))) end From f661509ebfe79cf61eb58afa79673c8cda3b0e37 Mon Sep 17 00:00:00 2001 From: Diogo Netto <61364108+d-netto@users.noreply.github.com> Date: Fri, 28 Mar 2025 01:56:26 -0300 Subject: [PATCH 32/56] only update fragmentation data for pages that are not lazily freed (#57907) We are including data from lazily freed pages into this metric, which makes it inaccurate. Thanks @qinsoon for spotting it. (cherry picked from commit d6fdbf5212aaf270749138db2e285141e4de1dc6) --- src/gc.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/gc.c b/src/gc.c index c4c83861f5a52..28e7ce3e4e91f 100644 --- a/src/gc.c +++ b/src/gc.c @@ -1542,6 +1542,7 @@ static void gc_sweep_page(gc_page_profiler_serializer_t *s, jl_gc_pool_t *p, jl_ done: if (re_use_page) { + gc_update_page_fragmentation_data(pg); push_lf_back(allocd, pg); } else { @@ -1555,7 +1556,6 @@ static void gc_sweep_page(gc_page_profiler_serializer_t *s, jl_gc_pool_t *p, jl_ } } gc_page_profile_write_to_file(s); - gc_update_page_fragmentation_data(pg); gc_time_count_page(freedall, pg_skpd); jl_ptls_t ptls = gc_all_tls_states[pg->thread_n]; jl_atomic_fetch_add(&ptls->gc_num.pool_live_bytes, GC_PAGE_SZ - GC_PAGE_OFFSET - nfree * osize); From eb3a41130bd4ec011fd8a96c57810f8843cdb140 Mon Sep 17 00:00:00 2001 From: Neven Sajko <4944410+nsajko@users.noreply.github.com> Date: Fri, 28 Mar 2025 12:26:13 +0100 Subject: [PATCH 33/56] `Random`: `show` method for `MersenneTwister`: invalidation resistance (#57913) Avoid using or constructing the vector with nonconcrete element type. Should make the sysimage more resistant to method invalidation. (cherry picked from commit 8e03cb11c8460b14ccb1553cb11343c3f39a6774) --- stdlib/Random/src/RNGs.jl | 23 ++++++++++++++--------- 1 file changed, 14 insertions(+), 9 deletions(-) diff --git a/stdlib/Random/src/RNGs.jl b/stdlib/Random/src/RNGs.jl index 7782de88ba537..2ea2fb3a684df 100644 --- a/stdlib/Random/src/RNGs.jl +++ b/stdlib/Random/src/RNGs.jl @@ -147,21 +147,26 @@ function show(io::IO, rng::MersenneTwister) end print(io, MersenneTwister, "(", repr(rng.seed), ", (") # state - adv = Integer[rng.adv_jump, rng.adv] + sep = ", " + show(io, rng.adv_jump) + print(io, sep) + show(io, rng.adv) if rng.adv_vals != -1 || rng.adv_ints != -1 - if rng.adv_vals == -1 - @assert rng.idxF == MT_CACHE_F - push!(adv, 0, 0) # "(0, 0)" is nicer on the eyes than (-1, 1002) - else - push!(adv, rng.adv_vals, rng.idxF) - end + # "(0, 0)" is nicer on the eyes than (-1, 1002) + s = rng.adv_vals != -1 + print(io, sep) + show(io, s ? rng.adv_vals : zero(rng.adv_vals)) + print(io, sep) + show(io, s ? rng.idxF : zero(rng.idxF)) end if rng.adv_ints != -1 idxI = (length(rng.ints)*16 - rng.idxI) / 8 # 8 represents one Int64 idxI = Int(idxI) # idxI should always be an integer when using public APIs - push!(adv, rng.adv_ints, idxI) + print(io, sep) + show(io, rng.adv_ints) + print(io, sep) + show(io, idxI) end - join(io, adv, ", ") print(io, "))") end From aa8ff5d5074a3bcf732346c7faa7a1328ba8675e Mon Sep 17 00:00:00 2001 From: Neven Sajko <4944410+nsajko@users.noreply.github.com> Date: Sun, 30 Mar 2025 08:55:46 +0200 Subject: [PATCH 34/56] `Base`: shell escaping: inference improvement to prevent invalidation (#57915) (cherry picked from commit 4d2a350870b97059432ac8fa8de92b0b161c335b) --- base/shell.jl | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/base/shell.jl b/base/shell.jl index 9f15550a1aa59..40b24fcf699d1 100644 --- a/base/shell.jl +++ b/base/shell.jl @@ -342,7 +342,7 @@ function shell_escape_csh(io::IO, args::AbstractString...) end shell_escape_csh(args::AbstractString...) = sprint(shell_escape_csh, args...; - sizehint = sum(sizeof.(args)) + length(args) * 3) + sizehint = sum(sizeof, args) + length(args) * 3) """ shell_escape_wincmd(s::AbstractString) @@ -492,4 +492,4 @@ function escape_microsoft_c_args(io::IO, args::AbstractString...) end escape_microsoft_c_args(args::AbstractString...) = sprint(escape_microsoft_c_args, args...; - sizehint = (sum(sizeof.(args)) + 3*length(args))) + sizehint = (sum(sizeof, args) + 3*length(args))) From b75482ba9486862826531e0d8045ed3ce8cc2420 Mon Sep 17 00:00:00 2001 From: Neven Sajko <4944410+nsajko@users.noreply.github.com> Date: Mon, 31 Mar 2025 10:00:17 +0200 Subject: [PATCH 35/56] `_precompilepkgs`: interactive progress display: fix unintended capture (#57932) The variable `str` also exists in one of the enclosing closures. Use a new variable, as was surely intended, instead of capturing and mutating the `str`. Improves the sysimage's resistance to invalidation. (cherry picked from commit fcf492d4b39c2becde6cd5ca3bb63fcbc7a308d3) --- base/precompilation.jl | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/base/precompilation.jl b/base/precompilation.jl index b33b5a14728e4..5b9ddd076c4d1 100644 --- a/base/precompilation.jl +++ b/base/precompilation.jl @@ -811,8 +811,8 @@ function _precompilepkgs(pkgs::Vector{String}, # window between print cycles termwidth = displaysize(io)[2] - 4 if !final_loop - str = sprint(io -> show_progress(io, bar; termwidth, carriagereturn=false); context=io) - print(iostr, Base._truncate_at_width_or_chars(true, str, termwidth), "\n") + s = sprint(io -> show_progress(io, bar; termwidth, carriagereturn=false); context=io) + print(iostr, Base._truncate_at_width_or_chars(true, s, termwidth), "\n") end for pkg_config in pkg_queue_show dep, config = pkg_config From ebdc6366a3fe1efd3edcf25b6a6b00c6f8484bfa Mon Sep 17 00:00:00 2001 From: Ian Butterworth Date: Mon, 31 Mar 2025 08:11:08 -0400 Subject: [PATCH 36/56] REPL: only load stdlibs during precompilation script (#57940) Fixes https://github.com/JuliaLang/julia/issues/57939 Not tested as it's quite involved... requires building a custom sysimage. --- stdlib/REPL/src/precompile.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/stdlib/REPL/src/precompile.jl b/stdlib/REPL/src/precompile.jl index 7c45bc8a0be5b..f5d02b42f0cd6 100644 --- a/stdlib/REPL/src/precompile.jl +++ b/stdlib/REPL/src/precompile.jl @@ -6,7 +6,7 @@ module Precompile import ..REPL # Prepare this staging area with all the loaded packages available for (_pkgid, _mod) in Base.loaded_modules - if !(_pkgid.name in ("Main", "Core", "Base", "REPL")) + if !(_pkgid.name in ("Main", "Core", "Base", "REPL")) && Base.is_stdlib(_pkgid) eval(:(const $(Symbol(_mod)) = $_mod)) end end From 460c78a1d75824c30d8a9843f321046d0613e997 Mon Sep 17 00:00:00 2001 From: Jameson Nash Date: Fri, 14 Feb 2025 10:43:22 -0500 Subject: [PATCH 37/56] lowering: fix has_fcall computation (#57395) Previously didn't handle ccall or cfunction that were assigned to a variable. Required for inlining correctness. Fixes #57023 (cherry picked from commit 57b7d2e0a88d2e4006ad74ec4bd1db5586e2d0bf) --- src/method.c | 8 ++++++-- test/core.jl | 5 +++++ 2 files changed, 11 insertions(+), 2 deletions(-) diff --git a/src/method.c b/src/method.c index 1d4085bd5e71d..b73d698e9aeeb 100644 --- a/src/method.c +++ b/src/method.c @@ -432,8 +432,12 @@ static void jl_code_info_set_ir(jl_code_info_t *li, jl_expr_t *ir) is_flag_stmt = 1; else if (jl_is_expr(st) && ((jl_expr_t*)st)->head == jl_return_sym) jl_array_ptr_set(body, j, jl_new_struct(jl_returnnode_type, jl_exprarg(st, 0))); - else if (jl_is_expr(st) && (((jl_expr_t*)st)->head == jl_foreigncall_sym || ((jl_expr_t*)st)->head == jl_cfunction_sym)) - li->has_fcall = 1; + else { + if (jl_is_expr(st) && ((jl_expr_t*)st)->head == jl_assign_sym) + st = jl_exprarg(st, 1); + if (jl_is_expr(st) && (((jl_expr_t*)st)->head == jl_foreigncall_sym || ((jl_expr_t*)st)->head == jl_cfunction_sym)) + li->has_fcall = 1; + } if (is_flag_stmt) jl_array_uint32_set(li->ssaflags, j, 0); else { diff --git a/test/core.jl b/test/core.jl index f525a3fc39e12..c81bc12e571da 100644 --- a/test/core.jl +++ b/test/core.jl @@ -8158,3 +8158,8 @@ let M = @__MODULE__ end @test Base.unsafe_convert(Ptr{Int}, [1]) !== C_NULL + +myfun57023a(::Type{T}) where {T} = (x = @ccall mycfun()::Ptr{T}; x) +@test only(code_lowered(myfun57023a)).has_fcall +myfun57023b(::Type{T}) where {T} = (x = @cfunction myfun57023a Ptr{T} (Ref{T},); x) +@test only(code_lowered(myfun57023b)).has_fcall From 6c509b3226cc72fdcaef6653405c133c67ba0d60 Mon Sep 17 00:00:00 2001 From: Lilith Orion Hafner Date: Fri, 14 Feb 2025 10:05:01 -0600 Subject: [PATCH 38/56] Make `Pairs` public (#56794) This is the type of slurped keyword args and IMO was already public in 1.10. (cherry picked from commit be574cd1b441afdbc62fb40bfcc0cbec10475ad6) --- base/exports.jl | 1 + 1 file changed, 1 insertion(+) diff --git a/base/exports.jl b/base/exports.jl index a8254d434a1f5..7762eef18313d 100644 --- a/base/exports.jl +++ b/base/exports.jl @@ -1095,6 +1095,7 @@ public ImmutableDict, Lockable, OneTo, + Pairs, LogRange, UUID, From 65d937ad23b44774e65cb436813a37b71d17da60 Mon Sep 17 00:00:00 2001 From: Neven Sajko <4944410+nsajko@users.noreply.github.com> Date: Mon, 3 Mar 2025 09:42:50 +0100 Subject: [PATCH 39/56] `AnnotatedString`: add concrete type asserts to `isvalid`, `ncodeunits` (#57607) The type assertions are valid according to the doc strings of these two functions in the case of `AbstractString`. Should prevent some invalidation on loading user code. Fixes #57606 (cherry picked from commit c4eeabf2f64ddfc133b02be04f8b6557d5f722e9) --- base/strings/annotated.jl | 4 ++-- test/strings/annotated.jl | 3 +++ 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/base/strings/annotated.jl b/base/strings/annotated.jl index c5c330fe0dfcd..a8752565e14d8 100644 --- a/base/strings/annotated.jl +++ b/base/strings/annotated.jl @@ -147,11 +147,11 @@ promote_rule(::Type{<:AnnotatedString}, ::Type{<:AbstractString}) = AnnotatedStr ## AbstractString interface ## -ncodeunits(s::AnnotatedString) = ncodeunits(s.string) +ncodeunits(s::AnnotatedString) = ncodeunits(s.string)::Int codeunits(s::AnnotatedString) = codeunits(s.string) codeunit(s::AnnotatedString) = codeunit(s.string) codeunit(s::AnnotatedString, i::Integer) = codeunit(s.string, i) -isvalid(s::AnnotatedString, i::Integer) = isvalid(s.string, i) +isvalid(s::AnnotatedString, i::Integer) = isvalid(s.string, i)::Bool @propagate_inbounds iterate(s::AnnotatedString, i::Integer=firstindex(s)) = if i <= lastindex(s.string); (s[i], nextind(s, i)) end eltype(::Type{<:AnnotatedString{S}}) where {S} = AnnotatedChar{eltype(S)} diff --git a/test/strings/annotated.jl b/test/strings/annotated.jl index 8d0e54e38e38e..5a58edd2649e1 100644 --- a/test/strings/annotated.jl +++ b/test/strings/annotated.jl @@ -61,6 +61,9 @@ using StyledStrings # see https://github.com/JuliaLang/StyledStrings.jl/issues/6 "AnnotatedString{String}(\"some string\", [(1:4, :thing, 0x01), (6:11, :other, 0x02), (1:11, :all, 0x03)])" @test eval(Meta.parse(repr(str))) == str @test sprint(show, MIME("text/plain"), str) == "\"some string\"" + + @test Bool === Base.infer_return_type(isvalid, Tuple{Base.AnnotatedString, Vararg}) + @test Int === Base.infer_return_type(ncodeunits, Tuple{Base.AnnotatedString}) end @testset "AnnotatedChar" begin From 0819f974b94c0dedd5336655ba17bc9099b88c6c Mon Sep 17 00:00:00 2001 From: Ian Butterworth Date: Tue, 25 Mar 2025 08:59:40 -0400 Subject: [PATCH 40/56] Profile: remove scope from profile macros (#57858) Fixes this, which breaks expectations from the way `@time` doesn't introduce a new scope. ``` julia> using Profile julia> @profile x = 1 1 julia> x ERROR: UndefVarError: `x` not defined in `Main` Suggestion: check for spelling errors or missing imports. ``` (cherry picked from commit d6af199c5d489d5964cddc73425bfdc1a002ddfa) --- stdlib/Profile/src/Allocs.jl | 6 +++--- stdlib/Profile/src/Profile.jl | 8 ++++---- stdlib/Profile/test/runtests.jl | 10 ++++++++++ 3 files changed, 17 insertions(+), 7 deletions(-) diff --git a/stdlib/Profile/src/Allocs.jl b/stdlib/Profile/src/Allocs.jl index bf0a734b55bf8..1ce2610b5d6b7 100644 --- a/stdlib/Profile/src/Allocs.jl +++ b/stdlib/Profile/src/Allocs.jl @@ -79,11 +79,11 @@ end function _prof_expr(expr, opts) quote $start(; $(esc(opts))) - try + Base.@__tryfinally( $(esc(expr)) - finally + , $stop() - end + ) end end diff --git a/stdlib/Profile/src/Profile.jl b/stdlib/Profile/src/Profile.jl index 61acee765acc9..d612619e698f3 100644 --- a/stdlib/Profile/src/Profile.jl +++ b/stdlib/Profile/src/Profile.jl @@ -54,12 +54,12 @@ appended to an internal buffer of backtraces. """ macro profile(ex) return quote - try - start_timer() + start_timer() + Base.@__tryfinally( $(esc(ex)) - finally + , stop_timer() - end + ) end end diff --git a/stdlib/Profile/test/runtests.jl b/stdlib/Profile/test/runtests.jl index 958f1fefb6981..13999be2245ea 100644 --- a/stdlib/Profile/test/runtests.jl +++ b/stdlib/Profile/test/runtests.jl @@ -107,6 +107,16 @@ end @test z == 10 end +@testset "@profile no scope" begin + @profile no_scope_57858_1 = 1 + @test @isdefined no_scope_57858_1 + Profile.clear() + + Profile.Allocs.@profile no_scope_57858_2 = 1 + @test @isdefined no_scope_57858_2 + Profile.Allocs.clear() +end + @testset "setting sample count and delay in init" begin n_, delay_ = Profile.init() n_original = n_ From a22c32cbc799ee55fbb51d2ee0f3d94f8dda3d73 Mon Sep 17 00:00:00 2001 From: Alex Arslan Date: Tue, 7 Jan 2025 21:37:32 -0800 Subject: [PATCH 41/56] Update OpenLibm to 0.8.5 (#56984) This fixes building on FreeBSD AArch64, as there was a regression in OpenLibm 0.8.4; see https://github.com/JuliaMath/openlibm/pull/314. (cherry picked from commit 3c7bc45f14c8a2b70ccf1d92d4418cfaaa112b56) --- deps/checksums/openlibm | 72 +++++++++++++++++--------------- deps/openlibm.version | 6 +-- stdlib/Manifest.toml | 2 +- stdlib/OpenLibm_jll/Project.toml | 2 +- 4 files changed, 43 insertions(+), 39 deletions(-) diff --git a/deps/checksums/openlibm b/deps/checksums/openlibm index 22d35d23ea7aa..cad61fd42cf94 100644 --- a/deps/checksums/openlibm +++ b/deps/checksums/openlibm @@ -1,34 +1,38 @@ -OpenLibm.v0.8.1+4.aarch64-apple-darwin.tar.gz/md5/f7f8947d276e50b58db7530e050062fd -OpenLibm.v0.8.1+4.aarch64-apple-darwin.tar.gz/sha512/9e28c02d1aa98fdff8e637c9d1a577325d76c098bc89837b5bd3a50ec05647ab8379893a7945d570907b82ef9446804a0065403b6ddec8ede4cb9b0acf5b27ea -OpenLibm.v0.8.1+4.aarch64-linux-gnu.tar.gz/md5/bf9e4bc08aa8488319724b9a3011be8b -OpenLibm.v0.8.1+4.aarch64-linux-gnu.tar.gz/sha512/773263ff709fbdbd07cde5049372175f7cf8fefa26a5fae0fdc48990886911e8c9bcfdb8b05158f38621c79a17e445ad73d41cc4186f6d9df84a3e8232a8a17d -OpenLibm.v0.8.1+4.aarch64-linux-musl.tar.gz/md5/eab078c285039562f65f8fc1d8d62fd9 -OpenLibm.v0.8.1+4.aarch64-linux-musl.tar.gz/sha512/c0b818d728f85ef1ed4231dc2a3bc78e95de9186829d12012b168505b6d6505e4732a379c67a5a3c37e40e048bbaadabc00d153383347e9f606fc9731ebb26d5 -OpenLibm.v0.8.1+4.armv6l-linux-gnueabihf.tar.gz/md5/c76f4ca7bbcd276e5769bd73bee00966 -OpenLibm.v0.8.1+4.armv6l-linux-gnueabihf.tar.gz/sha512/0a711684d1289c747ecadeee0fa1c8ca6067727a5ab5d531f7c30f998c8ee04803c6712067426c939f50698c15104724214eaa3953e522a6dc210c39954f2727 -OpenLibm.v0.8.1+4.armv6l-linux-musleabihf.tar.gz/md5/e072d09a671f98bede25cb0bd00a2fd4 -OpenLibm.v0.8.1+4.armv6l-linux-musleabihf.tar.gz/sha512/37a741e5f66ca4dc8c9358376afb562c7d2a1bb1fcbde2c9b555001a4e6faffc0446b5faff33aead192d4b2fc8cd45c8261b06cc40abec73e39dc63da932b8ab -OpenLibm.v0.8.1+4.armv7l-linux-gnueabihf.tar.gz/md5/c76f4ca7bbcd276e5769bd73bee00966 -OpenLibm.v0.8.1+4.armv7l-linux-gnueabihf.tar.gz/sha512/0a711684d1289c747ecadeee0fa1c8ca6067727a5ab5d531f7c30f998c8ee04803c6712067426c939f50698c15104724214eaa3953e522a6dc210c39954f2727 -OpenLibm.v0.8.1+4.armv7l-linux-musleabihf.tar.gz/md5/e072d09a671f98bede25cb0bd00a2fd4 -OpenLibm.v0.8.1+4.armv7l-linux-musleabihf.tar.gz/sha512/37a741e5f66ca4dc8c9358376afb562c7d2a1bb1fcbde2c9b555001a4e6faffc0446b5faff33aead192d4b2fc8cd45c8261b06cc40abec73e39dc63da932b8ab -OpenLibm.v0.8.1+4.i686-linux-gnu.tar.gz/md5/d8602652f0f347a16e39a869eb2ccb83 -OpenLibm.v0.8.1+4.i686-linux-gnu.tar.gz/sha512/b140032c96497c7e6626751b799598bd54f687af3976bc43ac7ddb6f490527dca64fd44a125da2f54d8ca3679ad53d2700d412ec4c2ddcfe7bfbfe719c0cfc05 -OpenLibm.v0.8.1+4.i686-linux-musl.tar.gz/md5/5d20637487e85b529e3901d129b586a7 -OpenLibm.v0.8.1+4.i686-linux-musl.tar.gz/sha512/b83742801cdfee62bf14bf66f4d20e42219899d431ab335c23f2943c00363c82ee2ab1b853ec421eb825dbe65899fc8f3a3c91c3d86c5e4891c60ddc981d0831 -OpenLibm.v0.8.1+4.i686-w64-mingw32.tar.gz/md5/6ba08a1d5b3aa21fa58618f9ea2a9b8d -OpenLibm.v0.8.1+4.i686-w64-mingw32.tar.gz/sha512/63bed0bc519fa87abae157b53f439f8b452720090780f306b62ff802b8f8ddc4b546899aad5b3e91dacdc3439b7a10a36080d34f09f072719f766c3cdb0baa82 -OpenLibm.v0.8.1+4.powerpc64le-linux-gnu.tar.gz/md5/c9c690ff59b202763ee901f22a798d69 -OpenLibm.v0.8.1+4.powerpc64le-linux-gnu.tar.gz/sha512/83a1e37a62dcff357836385f55f9410cf49b10445c8320b62381359557306c97f11773c508e816fb0bbd4de372b6666833e960921959b6dbb4c7c954e230004a -OpenLibm.v0.8.1+4.x86_64-apple-darwin.tar.gz/md5/bbe8f7a039ad3f07baca340112ea2e65 -OpenLibm.v0.8.1+4.x86_64-apple-darwin.tar.gz/sha512/89e578b7e8e56e7152c9f5881fbf51b33833f8e2143126212e60db262de5641573f33dea5b810575a39e21ec4fbaaa307a049d42e06970c7d4e052b97622938a -OpenLibm.v0.8.1+4.x86_64-linux-gnu.tar.gz/md5/94f42c769349c92987ed3bd9f35d96e0 -OpenLibm.v0.8.1+4.x86_64-linux-gnu.tar.gz/sha512/5e901618da26aa6f0f7d05ed1e5c538aea88cadb59b0efc7213203f1714e85aa0b6f0d463f2a4d367d2a8af36e37e7c353fdefbb98599fdc5bc182a6b93e4348 -OpenLibm.v0.8.1+4.x86_64-linux-musl.tar.gz/md5/462b9dfebd341f0c8bb33ba72f99f769 -OpenLibm.v0.8.1+4.x86_64-linux-musl.tar.gz/sha512/df84815a282a065e8fa33aa35ee29166a1119cd776f8812073e55521ca8c94f4bca679206b8a67ef69edbbb6ba6fca520d81626f687ca353a63146c4858ced80 -OpenLibm.v0.8.1+4.x86_64-unknown-freebsd.tar.gz/md5/f3642b29670e6216056a13f5da9e87b8 -OpenLibm.v0.8.1+4.x86_64-unknown-freebsd.tar.gz/sha512/613242d2f24b1dcc4b2bfd6f22ad66e9889f618ee685b50d9fdf33b9f3798fe503fc9e278f291118db70bacd54bd475f12554a4a56c60c369222fd23b3c5ba22 -OpenLibm.v0.8.1+4.x86_64-w64-mingw32.tar.gz/md5/59381a874c86a5ad5f3fb3b206587f64 -OpenLibm.v0.8.1+4.x86_64-w64-mingw32.tar.gz/sha512/3a8dd3ef46f15f78a34bdc37c5e26dcbf8522625457aa7c52dca21cbb967c5e39257216e5fc203ff57c9171b6c0f2e2ee9d6216c43b0254008f0e91318bb5f0e -openlibm-ae2d91698508701c83cab83714d42a1146dccf85.tar.gz/md5/19408d70bf042a109e1c267a53740089 -openlibm-ae2d91698508701c83cab83714d42a1146dccf85.tar.gz/sha512/9597fdcbc4af8369e6eecc3f8e86f251661cc64d236578f3ee8a6b39e77a47951446e1a0fe1151513da153e7ed17bf39aa5a36c32153d0d0400232bed2839e22 +OpenLibm.v0.8.5+0.aarch64-apple-darwin.tar.gz/md5/5fcbd746e90712e396e76dc4e76724d0 +OpenLibm.v0.8.5+0.aarch64-apple-darwin.tar.gz/sha512/f4ac2bc38bdc723384b67119daa2974fb43da34b2e45cea2029ea48f92c84c4cad6dfb43521b09a1e89ddf8c5b8cc22a38fa4b78ba39ac7524fd6bd1ba897aa9 +OpenLibm.v0.8.5+0.aarch64-linux-gnu.tar.gz/md5/4d1b4cd566805b5179c5ecdd060da473 +OpenLibm.v0.8.5+0.aarch64-linux-gnu.tar.gz/sha512/a9fe1a3d2e3898c017eb8615b2f3dbb514995ff041ac964c931c99c60d8cfe4eab7563a9cd65058f42f83c812f33d998573a7c5cc56a2e3960a4657e459ed321 +OpenLibm.v0.8.5+0.aarch64-linux-musl.tar.gz/md5/413be59af62b3ce0ebafeca093e3179e +OpenLibm.v0.8.5+0.aarch64-linux-musl.tar.gz/sha512/7bd76373e047ba854066af61f1c56b2e3a4d28c266228d7b30f596eadbaec52b070548ae60d41840c425ad5d0829c6c0cdaf326f2f160ed7508877ab5ec1a4b1 +OpenLibm.v0.8.5+0.aarch64-unknown-freebsd.tar.gz/md5/80736f9022c695eb1198e0b591a8fa63 +OpenLibm.v0.8.5+0.aarch64-unknown-freebsd.tar.gz/sha512/c633644578265e7ccc259ceb0442457b8c09290b4861b66c86dd6be7b30c4e394e70728142798097d6fe3afcfb4d9d1bd7ef58513fe8eed5684a4fba51bf185a +OpenLibm.v0.8.5+0.armv6l-linux-gnueabihf.tar.gz/md5/8fe0900a318393a290907f016bc654c3 +OpenLibm.v0.8.5+0.armv6l-linux-gnueabihf.tar.gz/sha512/167100a2d46e68462ef9a66915ced881d6358f05337bd38f2f77176f41cfd5be37e3c5226dd5d7d59147bd3e1aa7fb0893c1c81e9516134d3ab663b5752c4969 +OpenLibm.v0.8.5+0.armv6l-linux-musleabihf.tar.gz/md5/e8566719387984604f19dc5f9354a783 +OpenLibm.v0.8.5+0.armv6l-linux-musleabihf.tar.gz/sha512/532dd2b764fa15f7a838fb14cccafd2d4fe8fa4a132ea8394479a719c7aee11442f1b8a18e5d4a26ca820fa696d9d2afc7f5ec63dd96fa3b6763cea72b7026c3 +OpenLibm.v0.8.5+0.armv7l-linux-gnueabihf.tar.gz/md5/8fe0900a318393a290907f016bc654c3 +OpenLibm.v0.8.5+0.armv7l-linux-gnueabihf.tar.gz/sha512/167100a2d46e68462ef9a66915ced881d6358f05337bd38f2f77176f41cfd5be37e3c5226dd5d7d59147bd3e1aa7fb0893c1c81e9516134d3ab663b5752c4969 +OpenLibm.v0.8.5+0.armv7l-linux-musleabihf.tar.gz/md5/e8566719387984604f19dc5f9354a783 +OpenLibm.v0.8.5+0.armv7l-linux-musleabihf.tar.gz/sha512/532dd2b764fa15f7a838fb14cccafd2d4fe8fa4a132ea8394479a719c7aee11442f1b8a18e5d4a26ca820fa696d9d2afc7f5ec63dd96fa3b6763cea72b7026c3 +OpenLibm.v0.8.5+0.i686-linux-gnu.tar.gz/md5/9580d34e69d6067427b9c33db631cfd3 +OpenLibm.v0.8.5+0.i686-linux-gnu.tar.gz/sha512/46934f82791f69ac5f5da0dab7dcc6e3e9a4577c3bb529e9c0519c38f140c7b54517c55ff3579cd4ed4df68f0863e006aa98e51873f1dab452ce9f853996429a +OpenLibm.v0.8.5+0.i686-linux-musl.tar.gz/md5/66bfc9611d04c5d609e7824cb076d24b +OpenLibm.v0.8.5+0.i686-linux-musl.tar.gz/sha512/1bda2395d44c22aba3d1aab2b08ae06f763d3755037d454aa73f8e8134289a1ab5d65862bbc5a17a7a6b9f2918eb87e926b21527ddc4471e2ea20d605ba14e2d +OpenLibm.v0.8.5+0.i686-w64-mingw32.tar.gz/md5/0e97311b2f08b57d79085635f01ccced +OpenLibm.v0.8.5+0.i686-w64-mingw32.tar.gz/sha512/ae061ea406c06969332af58ed6fdfce2825326d771d30274d90775a1709b0361b7ca1dc7e6b0b76b93e4dd7a81d1842510a2c835251ee0a0978d6c839d96070e +OpenLibm.v0.8.5+0.powerpc64le-linux-gnu.tar.gz/md5/8ecfff7db76eee29591a654871e88855 +OpenLibm.v0.8.5+0.powerpc64le-linux-gnu.tar.gz/sha512/af03993b162316dd581f6ba5d1c23bca4c26cb22356ab229f326c42e111acbdf7ef45c9ad05894fe2d68794a63670cf89888653f788192a38b9255ce4bc72e28 +OpenLibm.v0.8.5+0.riscv64-linux-gnu.tar.gz/md5/69e06de135940666791c984941e9c4ad +OpenLibm.v0.8.5+0.riscv64-linux-gnu.tar.gz/sha512/2ac84deb7eb80a6a6237eff6fe861fd2907b3c95d1a76366dea062f3f35228dbc67aa40bd982e646508b4ff7cb6ef029111e2c0325039e60679800d6c6886be5 +OpenLibm.v0.8.5+0.x86_64-apple-darwin.tar.gz/md5/bd671ab9fe01835cab3e42e7cfa790fb +OpenLibm.v0.8.5+0.x86_64-apple-darwin.tar.gz/sha512/8bf2e66df17effc1e8778453904ffc20127f785bf096873289e8fdd8b17069ca844faffbd9f7621b87a7cb0a0051037eb9402360f2a03cf8794fbac8f7719777 +OpenLibm.v0.8.5+0.x86_64-linux-gnu.tar.gz/md5/df7fab134fbce3b625e9a82376f23e79 +OpenLibm.v0.8.5+0.x86_64-linux-gnu.tar.gz/sha512/64d07434e0db79833f84a2225838456eb9532617d377a776b3a534a908b1673bc4f890903f95350e4045e05c29539d993a18ecadeb879761e279ec3947f74390 +OpenLibm.v0.8.5+0.x86_64-linux-musl.tar.gz/md5/ebef6bb7651d116b397e035f39adfb1b +OpenLibm.v0.8.5+0.x86_64-linux-musl.tar.gz/sha512/de9036073e5dba2721b4119ecbbd21a0c9f75b65aff9392b7e88e464da35b97135d62404477441d0dadd3a2f8d49f1082291b35bf4b626fb1096d36d401980bf +OpenLibm.v0.8.5+0.x86_64-unknown-freebsd.tar.gz/md5/1115497539f00a37af18aa6516d52268 +OpenLibm.v0.8.5+0.x86_64-unknown-freebsd.tar.gz/sha512/71a2c06d141b3671fd220f2d88d72e845848b6d2b08a7b3a6c4bb1d5cc27cc450e1e681647bb583e7ed6375d5a70748401e95e61dc95d7808f33a9aa06755337 +OpenLibm.v0.8.5+0.x86_64-w64-mingw32.tar.gz/md5/b6b5335f4c83f7ebf0f74cf753358f00 +OpenLibm.v0.8.5+0.x86_64-w64-mingw32.tar.gz/sha512/e8351ddda305b757f337bb7ea26c441968843b23861676f0bdd7bcf83bb3969af790d4112307d3204eb87fac044dda9be305f349700ebe9ba2bfe3d6df24fde8 +openlibm-db24332879c320606c37f77fea165e6ecb49153c.tar.gz/md5/2375dd448e77e59152442a4b33abda01 +openlibm-db24332879c320606c37f77fea165e6ecb49153c.tar.gz/sha512/36054e7051990d04913f054a0542e2e104273f61308e9a442c2dab3dd392d40c03f264fbeca93c4296218eed85dad71028989a225088254013d752f4407d57ef diff --git a/deps/openlibm.version b/deps/openlibm.version index f35b291260380..16b17504430bc 100644 --- a/deps/openlibm.version +++ b/deps/openlibm.version @@ -2,6 +2,6 @@ OPENLIBM_JLL_NAME := OpenLibm ## source build -OPENLIBM_VER := 0.8.1 -OPENLIBM_BRANCH=v0.8.1 -OPENLIBM_SHA1=ae2d91698508701c83cab83714d42a1146dccf85 +OPENLIBM_VER := 0.8.5 +OPENLIBM_BRANCH=v0.8.5 +OPENLIBM_SHA1=db24332879c320606c37f77fea165e6ecb49153c diff --git a/stdlib/Manifest.toml b/stdlib/Manifest.toml index c34e4424a2c87..79ff7d22bd562 100644 --- a/stdlib/Manifest.toml +++ b/stdlib/Manifest.toml @@ -163,7 +163,7 @@ version = "0.3.26+2" [[deps.OpenLibm_jll]] deps = ["Artifacts", "Libdl"] uuid = "05823500-19ac-5b8b-9628-191a04bc5112" -version = "0.8.1+2" +version = "0.8.5+0" [[deps.PCRE2_jll]] deps = ["Artifacts", "Libdl"] diff --git a/stdlib/OpenLibm_jll/Project.toml b/stdlib/OpenLibm_jll/Project.toml index c5ba7fe77b651..431528ee3f400 100644 --- a/stdlib/OpenLibm_jll/Project.toml +++ b/stdlib/OpenLibm_jll/Project.toml @@ -1,6 +1,6 @@ name = "OpenLibm_jll" uuid = "05823500-19ac-5b8b-9628-191a04bc5112" -version = "0.8.1+4" +version = "0.8.5+0" [deps] Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb" From 618c74e9b624cbd3905ccf9d26278e8ffd93daa8 Mon Sep 17 00:00:00 2001 From: Kristoffer Date: Mon, 31 Mar 2025 15:19:10 +0200 Subject: [PATCH 42/56] bump Pkg to latest v1.11 --- .../Pkg-2eb8ae5b8f421fc77295f9cf382132d39e14d16f.tar.gz/md5 | 1 - .../Pkg-2eb8ae5b8f421fc77295f9cf382132d39e14d16f.tar.gz/sha512 | 1 - .../Pkg-9ca5e30b4c095ffa93812499930c8d703a658cf1.tar.gz/md5 | 1 + .../Pkg-9ca5e30b4c095ffa93812499930c8d703a658cf1.tar.gz/sha512 | 1 + stdlib/Pkg.version | 2 +- 5 files changed, 3 insertions(+), 3 deletions(-) delete mode 100644 deps/checksums/Pkg-2eb8ae5b8f421fc77295f9cf382132d39e14d16f.tar.gz/md5 delete mode 100644 deps/checksums/Pkg-2eb8ae5b8f421fc77295f9cf382132d39e14d16f.tar.gz/sha512 create mode 100644 deps/checksums/Pkg-9ca5e30b4c095ffa93812499930c8d703a658cf1.tar.gz/md5 create mode 100644 deps/checksums/Pkg-9ca5e30b4c095ffa93812499930c8d703a658cf1.tar.gz/sha512 diff --git a/deps/checksums/Pkg-2eb8ae5b8f421fc77295f9cf382132d39e14d16f.tar.gz/md5 b/deps/checksums/Pkg-2eb8ae5b8f421fc77295f9cf382132d39e14d16f.tar.gz/md5 deleted file mode 100644 index 94028daf1ceae..0000000000000 --- a/deps/checksums/Pkg-2eb8ae5b8f421fc77295f9cf382132d39e14d16f.tar.gz/md5 +++ /dev/null @@ -1 +0,0 @@ -04462f4ccf05a569002927e662938857 diff --git a/deps/checksums/Pkg-2eb8ae5b8f421fc77295f9cf382132d39e14d16f.tar.gz/sha512 b/deps/checksums/Pkg-2eb8ae5b8f421fc77295f9cf382132d39e14d16f.tar.gz/sha512 deleted file mode 100644 index 4b719cfd15d33..0000000000000 --- a/deps/checksums/Pkg-2eb8ae5b8f421fc77295f9cf382132d39e14d16f.tar.gz/sha512 +++ /dev/null @@ -1 +0,0 @@ -20d84f39511ab5229e1d2d542e204fe8df016e81bbe2f684c4713d04945d1b8fa89b506031847c1a754368aa6fed48ee8c6cb8f28219fbc210179883803d46bf diff --git a/deps/checksums/Pkg-9ca5e30b4c095ffa93812499930c8d703a658cf1.tar.gz/md5 b/deps/checksums/Pkg-9ca5e30b4c095ffa93812499930c8d703a658cf1.tar.gz/md5 new file mode 100644 index 0000000000000..b3e41de8c745b --- /dev/null +++ b/deps/checksums/Pkg-9ca5e30b4c095ffa93812499930c8d703a658cf1.tar.gz/md5 @@ -0,0 +1 @@ +c5df4a32eb3abe57fd2800c50a212db2 diff --git a/deps/checksums/Pkg-9ca5e30b4c095ffa93812499930c8d703a658cf1.tar.gz/sha512 b/deps/checksums/Pkg-9ca5e30b4c095ffa93812499930c8d703a658cf1.tar.gz/sha512 new file mode 100644 index 0000000000000..95fa1f8ea3d17 --- /dev/null +++ b/deps/checksums/Pkg-9ca5e30b4c095ffa93812499930c8d703a658cf1.tar.gz/sha512 @@ -0,0 +1 @@ +1b38c71a7ed169d8bd5d47536a68ec632df8ecdc7a1bdf29e55912218c52c85579b4adbb60e31cbce5609c2a31fbb14657844047f4eaa3d6ae2f1142d8821f58 diff --git a/stdlib/Pkg.version b/stdlib/Pkg.version index 300d42c186ab0..5708a2e93b7ba 100644 --- a/stdlib/Pkg.version +++ b/stdlib/Pkg.version @@ -1,4 +1,4 @@ PKG_BRANCH = release-1.11 -PKG_SHA1 = 2eb8ae5b8f421fc77295f9cf382132d39e14d16f +PKG_SHA1 = 9ca5e30b4c095ffa93812499930c8d703a658cf1 PKG_GIT_URL := https://github.com/JuliaLang/Pkg.jl.git PKG_TAR_URL = https://api.github.com/repos/JuliaLang/Pkg.jl/tarball/$1 From ee1e5256021adfec713a07ae247ed793df861a52 Mon Sep 17 00:00:00 2001 From: Cody Tapscott <84105208+topolarity@users.noreply.github.com> Date: Mon, 31 Mar 2025 04:03:19 -0400 Subject: [PATCH 43/56] staticdata: Memoize `type_in_worklist` query (#57917) When pre-compiling `stdlib/` this cache has a 91% hit rate, so this seems fairly profitable. It also dramatically improves some pathological cases, a few of which have been hit in the wild (arguably due to inference bugs) Without this PR, this package takes exponentially long to pre-compile: ```julia function BigType(N) (N == 0) && return Nothing T = BigType(N-1) return Pair{T,T} end foo(::Type{T}) where T = T precompile(foo, (Type{BigType(40)},)) ``` For an in-the-wild test case hit by a customer, this reduces pre-compilation time from over an hour to just ~two and a half minutes. Resolves #53331. --- src/staticdata.c | 74 ++++++++++++++++++++++++++++-------------- src/staticdata_utils.c | 70 ++++++++++++++++++++++++--------------- 2 files changed, 93 insertions(+), 51 deletions(-) diff --git a/src/staticdata.c b/src/staticdata.c index 76bb488731a92..02ba108e75c78 100644 --- a/src/staticdata.c +++ b/src/staticdata.c @@ -90,6 +90,22 @@ External links: static const size_t WORLD_AGE_REVALIDATION_SENTINEL = 0x1; +// This structure is used to store hash tables for the memoization +// of queries in staticdata.c (currently only `type_in_worklist`). +typedef struct { + htable_t type_in_worklist; +} jl_query_cache; + +static void init_query_cache(jl_query_cache *cache) +{ + htable_new(&cache->type_in_worklist, 0); +} + +static void destroy_query_cache(jl_query_cache *cache) +{ + htable_free(&cache->type_in_worklist); +} + #include "staticdata_utils.c" #include "precompile_utils.c" @@ -512,6 +528,7 @@ typedef struct { jl_array_t *link_ids_gctags; jl_array_t *link_ids_gvars; jl_array_t *link_ids_external_fnvars; + jl_query_cache *query_cache; jl_ptls_t ptls; // Set (implemented has a hasmap of MethodInstances to themselves) of which MethodInstances have (forward) edges // to other MethodInstances. @@ -658,38 +675,37 @@ static int jl_needs_serialization(jl_serializer_state *s, jl_value_t *v) JL_NOTS return 1; } - -static int caching_tag(jl_value_t *v) JL_NOTSAFEPOINT +static int caching_tag(jl_value_t *v, jl_query_cache *query_cache) JL_NOTSAFEPOINT { if (jl_is_method_instance(v)) { jl_method_instance_t *mi = (jl_method_instance_t*)v; jl_value_t *m = mi->def.value; if (jl_is_method(m) && jl_object_in_image(m)) - return 1 + type_in_worklist(mi->specTypes); + return 1 + type_in_worklist(mi->specTypes, query_cache); } if (jl_is_datatype(v)) { jl_datatype_t *dt = (jl_datatype_t*)v; if (jl_is_tuple_type(dt) ? !dt->isconcretetype : dt->hasfreetypevars) return 0; // aka !is_cacheable from jltypes.c if (jl_object_in_image((jl_value_t*)dt->name)) - return 1 + type_in_worklist(v); + return 1 + type_in_worklist(v, query_cache); } jl_value_t *dtv = jl_typeof(v); if (jl_is_datatype_singleton((jl_datatype_t*)dtv)) { - return 1 - type_in_worklist(dtv); // these are already recached in the datatype in the image + return 1 - type_in_worklist(dtv, query_cache); // these are already recached in the datatype in the image } return 0; } -static int needs_recaching(jl_value_t *v) JL_NOTSAFEPOINT +static int needs_recaching(jl_value_t *v, jl_query_cache *query_cache) JL_NOTSAFEPOINT { - return caching_tag(v) == 2; + return caching_tag(v, query_cache) == 2; } -static int needs_uniquing(jl_value_t *v) JL_NOTSAFEPOINT +static int needs_uniquing(jl_value_t *v, jl_query_cache *query_cache) JL_NOTSAFEPOINT { assert(!jl_object_in_image(v)); - return caching_tag(v) == 1; + return caching_tag(v, query_cache) == 1; } static void record_field_change(jl_value_t **addr, jl_value_t *newval) JL_NOTSAFEPOINT @@ -774,7 +790,7 @@ static void jl_insert_into_serialization_queue(jl_serializer_state *s, jl_value_ jl_datatype_t *dt = (jl_datatype_t*)v; // ensure all type parameters are recached jl_queue_for_serialization_(s, (jl_value_t*)dt->parameters, 1, 1); - if (jl_is_datatype_singleton(dt) && needs_uniquing(dt->instance)) { + if (jl_is_datatype_singleton(dt) && needs_uniquing(dt->instance, s->query_cache)) { assert(jl_needs_serialization(s, dt->instance)); // should be true, since we visited dt // do not visit dt->instance for our template object as it leads to unwanted cycles here // (it may get serialized from elsewhere though) @@ -785,7 +801,7 @@ static void jl_insert_into_serialization_queue(jl_serializer_state *s, jl_value_ if (s->incremental && jl_is_method_instance(v)) { jl_method_instance_t *mi = (jl_method_instance_t*)v; jl_value_t *def = mi->def.value; - if (needs_uniquing(v)) { + if (needs_uniquing(v, s->query_cache)) { // we only need 3 specific fields of this (the rest are not used) jl_queue_for_serialization(s, mi->def.value); jl_queue_for_serialization(s, mi->specTypes); @@ -801,7 +817,7 @@ static void jl_insert_into_serialization_queue(jl_serializer_state *s, jl_value_ record_field_change((jl_value_t**)&mi->cache, NULL); } else { - assert(!needs_recaching(v)); + assert(!needs_recaching(v, s->query_cache)); } // n.b. opaque closures cannot be inspected and relied upon like a // normal method since they can get improperly introduced by generated @@ -947,9 +963,9 @@ static void jl_queue_for_serialization_(jl_serializer_state *s, jl_value_t *v, i // Items that require postorder traversal must visit their children prior to insertion into // the worklist/serialization_order (and also before their first use) if (s->incremental && !immediate) { - if (jl_is_datatype(t) && needs_uniquing(v)) + if (jl_is_datatype(t) && needs_uniquing(v, s->query_cache)) immediate = 1; - if (jl_is_datatype_singleton((jl_datatype_t*)t) && needs_uniquing(v)) + if (jl_is_datatype_singleton((jl_datatype_t*)t) && needs_uniquing(v, s->query_cache)) immediate = 1; } @@ -1113,7 +1129,7 @@ static uintptr_t _backref_id(jl_serializer_state *s, jl_value_t *v, jl_array_t * static void record_uniquing(jl_serializer_state *s, jl_value_t *fld, uintptr_t offset) JL_NOTSAFEPOINT { - if (s->incremental && jl_needs_serialization(s, fld) && needs_uniquing(fld)) { + if (s->incremental && jl_needs_serialization(s, fld) && needs_uniquing(fld, s->query_cache)) { if (jl_is_datatype(fld) || jl_is_datatype_singleton((jl_datatype_t*)jl_typeof(fld))) arraylist_push(&s->uniquing_types, (void*)(uintptr_t)offset); else if (jl_is_method_instance(fld)) @@ -1297,7 +1313,7 @@ static void jl_write_values(jl_serializer_state *s) JL_GC_DISABLED // write header if (object_id_expected) write_uint(f, jl_object_id(v)); - if (s->incremental && jl_needs_serialization(s, (jl_value_t*)t) && needs_uniquing((jl_value_t*)t)) + if (s->incremental && jl_needs_serialization(s, (jl_value_t*)t) && needs_uniquing((jl_value_t*)t, s->query_cache)) arraylist_push(&s->uniquing_types, (void*)(uintptr_t)(ios_pos(f)|1)); if (f == s->const_data) write_uint(s->const_data, ((uintptr_t)t->smalltag << 4) | GC_OLD_MARKED | GC_IN_IMAGE); @@ -1308,7 +1324,7 @@ static void jl_write_values(jl_serializer_state *s) JL_GC_DISABLED layout_table.items[item] = (void*)(reloc_offset | (f == s->const_data)); // store the inverse mapping of `serialization_order` (`id` => object-as-streampos) if (s->incremental) { - if (needs_uniquing(v)) { + if (needs_uniquing(v, s->query_cache)) { if (jl_is_method_instance(v)) { assert(f == s->s); jl_method_instance_t *mi = (jl_method_instance_t*)v; @@ -1329,7 +1345,7 @@ static void jl_write_values(jl_serializer_state *s) JL_GC_DISABLED assert(jl_is_datatype_singleton(t) && "unreachable"); } } - else if (needs_recaching(v)) { + else if (needs_recaching(v, s->query_cache)) { arraylist_push(jl_is_datatype(v) ? &s->fixup_types : &s->fixup_objs, (void*)reloc_offset); } else if (jl_typetagis(v, jl_binding_type)) { @@ -1731,7 +1747,7 @@ static void jl_write_values(jl_serializer_state *s) JL_GC_DISABLED } } void *superidx = ptrhash_get(&serialization_order, dt->super); - if (s->incremental && superidx != HT_NOTFOUND && (char*)superidx - 1 - (char*)HT_NOTFOUND > item && needs_uniquing((jl_value_t*)dt->super)) + if (s->incremental && superidx != HT_NOTFOUND && (char*)superidx - 1 - (char*)HT_NOTFOUND > item && needs_uniquing((jl_value_t*)dt->super, s->query_cache)) arraylist_push(&s->uniquing_super, dt->super); } else if (jl_is_typename(v)) { @@ -2540,7 +2556,8 @@ JL_DLLEXPORT jl_value_t *jl_as_global_root(jl_value_t *val, int insert) static void jl_prepare_serialization_data(jl_array_t *mod_array, jl_array_t *newly_inferred, uint64_t worklist_key, /* outputs */ jl_array_t **extext_methods, jl_array_t **new_ext_cis, - jl_array_t **method_roots_list, jl_array_t **ext_targets, jl_array_t **edges) + jl_array_t **method_roots_list, jl_array_t **ext_targets, jl_array_t **edges, + jl_query_cache *query_cache) { // extext_methods: [method1, ...], worklist-owned "extending external" methods added to functions owned by modules outside the worklist // ext_targets: [invokesig1, callee1, matches1, ...] non-worklist callees of worklist-owned methods @@ -2551,7 +2568,7 @@ static void jl_prepare_serialization_data(jl_array_t *mod_array, jl_array_t *new assert(edges_map == NULL); // Save the inferred code from newly inferred, external methods - *new_ext_cis = queue_external_cis(newly_inferred); + *new_ext_cis = queue_external_cis(newly_inferred, query_cache); // Collect method extensions and edges data JL_GC_PUSH1(&edges_map); @@ -2590,7 +2607,8 @@ static void jl_prepare_serialization_data(jl_array_t *mod_array, jl_array_t *new static void jl_save_system_image_to_stream(ios_t *f, jl_array_t *mod_array, jl_array_t *worklist, jl_array_t *extext_methods, jl_array_t *new_ext_cis, jl_array_t *method_roots_list, - jl_array_t *ext_targets, jl_array_t *edges) JL_GC_DISABLED + jl_array_t *ext_targets, jl_array_t *edges, + jl_query_cache *query_cache) JL_GC_DISABLED { htable_new(&field_replace, 0); // strip metadata and IR when requested @@ -2617,6 +2635,7 @@ static void jl_save_system_image_to_stream(ios_t *f, jl_array_t *mod_array, ios_mem(&gvar_record, 0); ios_mem(&fptr_record, 0); jl_serializer_state s = {0}; + s.query_cache = query_cache; s.incremental = !(worklist == NULL); s.s = &sysimg; s.const_data = &const_data; @@ -2947,12 +2966,15 @@ JL_DLLEXPORT void jl_create_system_image(void **_native_data, jl_array_t *workli int64_t datastartpos = 0; JL_GC_PUSH6(&mod_array, &extext_methods, &new_ext_cis, &method_roots_list, &ext_targets, &edges); + jl_query_cache query_cache; + init_query_cache(&query_cache); + if (worklist) { mod_array = jl_get_loaded_modules(); // __toplevel__ modules loaded in this session (from Base.loaded_modules_array) // Generate _native_data` if (_native_data != NULL) { jl_prepare_serialization_data(mod_array, newly_inferred, jl_worklist_key(worklist), - &extext_methods, &new_ext_cis, NULL, NULL, NULL); + &extext_methods, &new_ext_cis, NULL, NULL, NULL, &query_cache); jl_precompile_toplevel_module = (jl_module_t*)jl_array_ptr_ref(worklist, jl_array_len(worklist)-1); *_native_data = jl_precompile_worklist(worklist, extext_methods, new_ext_cis); jl_precompile_toplevel_module = NULL; @@ -2981,7 +3003,7 @@ JL_DLLEXPORT void jl_create_system_image(void **_native_data, jl_array_t *workli if (worklist) { htable_new(&relocatable_ext_cis, 0); jl_prepare_serialization_data(mod_array, newly_inferred, jl_worklist_key(worklist), - &extext_methods, &new_ext_cis, &method_roots_list, &ext_targets, &edges); + &extext_methods, &new_ext_cis, &method_roots_list, &ext_targets, &edges, &query_cache); if (!emit_split) { write_int32(f, 0); // No clone_targets write_padding(f, LLT_ALIGN(ios_pos(f), JL_CACHE_BYTE_ALIGNMENT) - ios_pos(f)); @@ -2993,7 +3015,7 @@ JL_DLLEXPORT void jl_create_system_image(void **_native_data, jl_array_t *workli } if (_native_data != NULL) native_functions = *_native_data; - jl_save_system_image_to_stream(ff, mod_array, worklist, extext_methods, new_ext_cis, method_roots_list, ext_targets, edges); + jl_save_system_image_to_stream(ff, mod_array, worklist, extext_methods, new_ext_cis, method_roots_list, ext_targets, edges, &query_cache); if (_native_data != NULL) native_functions = NULL; if (worklist) @@ -3024,6 +3046,8 @@ JL_DLLEXPORT void jl_create_system_image(void **_native_data, jl_array_t *workli } } + destroy_query_cache(&query_cache); + JL_GC_POP(); *s = f; if (emit_split) diff --git a/src/staticdata_utils.c b/src/staticdata_utils.c index 3441d38beea74..49e292f8da514 100644 --- a/src/staticdata_utils.c +++ b/src/staticdata_utils.c @@ -104,62 +104,80 @@ JL_DLLEXPORT void jl_push_newly_inferred(jl_value_t* ci) JL_UNLOCK(&newly_inferred_mutex); } - // compute whether a type references something internal to worklist // and thus could not have existed before deserialize // and thus does not need delayed unique-ing -static int type_in_worklist(jl_value_t *v) JL_NOTSAFEPOINT +static int type_in_worklist(jl_value_t *v, jl_query_cache *cache) JL_NOTSAFEPOINT { if (jl_object_in_image(v)) return 0; // fast-path for rejection + + void *cached = HT_NOTFOUND; + if (cache != NULL) + cached = ptrhash_get(&cache->type_in_worklist, v); + + // fast-path for memoized results + if (cached != HT_NOTFOUND) + return cached == v; + + int result = 0; if (jl_is_uniontype(v)) { jl_uniontype_t *u = (jl_uniontype_t*)v; - return type_in_worklist(u->a) || - type_in_worklist(u->b); + result = type_in_worklist(u->a, cache) || + type_in_worklist(u->b, cache); } else if (jl_is_unionall(v)) { jl_unionall_t *ua = (jl_unionall_t*)v; - return type_in_worklist((jl_value_t*)ua->var) || - type_in_worklist(ua->body); + result = type_in_worklist((jl_value_t*)ua->var, cache) || + type_in_worklist(ua->body, cache); } else if (jl_is_typevar(v)) { jl_tvar_t *tv = (jl_tvar_t*)v; - return type_in_worklist(tv->lb) || - type_in_worklist(tv->ub); + result = type_in_worklist(tv->lb, cache) || + type_in_worklist(tv->ub, cache); } else if (jl_is_vararg(v)) { jl_vararg_t *tv = (jl_vararg_t*)v; - if (tv->T && type_in_worklist(tv->T)) - return 1; - if (tv->N && type_in_worklist(tv->N)) - return 1; + result = ((tv->T && type_in_worklist(tv->T, cache)) || + (tv->N && type_in_worklist(tv->N, cache))); } else if (jl_is_datatype(v)) { jl_datatype_t *dt = (jl_datatype_t*)v; - if (!jl_object_in_image((jl_value_t*)dt->name)) - return 1; - jl_svec_t *tt = dt->parameters; - size_t i, l = jl_svec_len(tt); - for (i = 0; i < l; i++) - if (type_in_worklist(jl_tparam(dt, i))) - return 1; + if (!jl_object_in_image((jl_value_t*)dt->name)) { + result = 1; + } + else { + jl_svec_t *tt = dt->parameters; + size_t i, l = jl_svec_len(tt); + for (i = 0; i < l; i++) { + if (type_in_worklist(jl_tparam(dt, i), cache)) { + result = 1; + break; + } + } + } } else { - return type_in_worklist(jl_typeof(v)); + return type_in_worklist(jl_typeof(v), cache); } - return 0; + + // Memoize result + if (cache != NULL) + ptrhash_put(&cache->type_in_worklist, (void*)v, result ? (void*)v : NULL); + + return result; } // When we infer external method instances, ensure they link back to the // package. Otherwise they might be, e.g., for external macros. // Implements Tarjan's SCC (strongly connected components) algorithm, simplified to remove the count variable -static int has_backedge_to_worklist(jl_method_instance_t *mi, htable_t *visited, arraylist_t *stack) +static int has_backedge_to_worklist(jl_method_instance_t *mi, htable_t *visited, arraylist_t *stack, jl_query_cache *query_cache) { jl_module_t *mod = mi->def.module; if (jl_is_method(mod)) mod = ((jl_method_t*)mod)->module; assert(jl_is_module(mod)); - if (jl_atomic_load_relaxed(&mi->precompiled) || !jl_object_in_image((jl_value_t*)mod) || type_in_worklist(mi->specTypes)) { + if (jl_atomic_load_relaxed(&mi->precompiled) || !jl_object_in_image((jl_value_t*)mod) || type_in_worklist(mi->specTypes, query_cache)) { return 1; } if (!mi->backedges) { @@ -182,7 +200,7 @@ static int has_backedge_to_worklist(jl_method_instance_t *mi, htable_t *visited, while (i < n) { jl_method_instance_t *be; i = get_next_edge(mi->backedges, i, NULL, &be); - int child_found = has_backedge_to_worklist(be, visited, stack); + int child_found = has_backedge_to_worklist(be, visited, stack, query_cache); if (child_found == 1 || child_found == 2) { // found what we were looking for, so terminate early found = 1; @@ -225,7 +243,7 @@ static int is_relocatable_ci(htable_t *relocatable_ext_cis, jl_code_instance_t * // from the worklist or explicitly added by a `precompile` statement, and // (4) are the most recently computed result for that method. // These will be preserved in the image. -static jl_array_t *queue_external_cis(jl_array_t *list) +static jl_array_t *queue_external_cis(jl_array_t *list, jl_query_cache *query_cache) { if (list == NULL) return NULL; @@ -246,7 +264,7 @@ static jl_array_t *queue_external_cis(jl_array_t *list) jl_method_instance_t *mi = ci->def; jl_method_t *m = mi->def.method; if (jl_atomic_load_relaxed(&ci->inferred) && jl_is_method(m) && jl_object_in_image((jl_value_t*)m->module)) { - int found = has_backedge_to_worklist(mi, &visited, &stack); + int found = has_backedge_to_worklist(mi, &visited, &stack, query_cache); assert(found == 0 || found == 1 || found == 2); assert(stack.len == 0); if (found == 1 && jl_atomic_load_relaxed(&ci->max_world) == ~(size_t)0) { From 9f0f7f47d271119a8d5781bf626196f9a5374c0e Mon Sep 17 00:00:00 2001 From: Martijn Visser Date: Tue, 25 Mar 2025 16:02:59 +0100 Subject: [PATCH 44/56] Don't error when initializing LibGit2 with CA roots path (#56924) When SSL_CERT_FILE or SSL_CERT_DIR is set, it is [impossible to set this location](https://github.com/libgit2/libgit2/blob/4dcdb64c6844d76776745cdc25071a72c1af84d6/src/libgit2/settings.c#L206-L222) in LibGit2_jll on Apple and Windows because [it isn't built with support for that](https://github.com/JuliaPackaging/Yggdrasil/blob/7123a60a68102ba6cd953e13a4e45845dc37fd82/L/LibGit2/build_tarballs.jl#L67). Until now we've errored out with a message telling users to set JULIA_SSL_CA_ROOTS_PATH to an empty string, which is a somewhat problematic workaround because the Windows environment variables UI doesn't allow empty values, and [setting it to an empty string from PowerShell unsets it](https://discourse.julialang.org/t/how-to-fix-ssl-cert-issues-in-pkg/115495/7?u=visr). This PR changes the behavior to allow this expected error. Variables like SSL_CERT_FILE are for instance [set by the Conda OpenSSL package on environment activation](https://github.com/conda-forge/openssl-feedstock/blob/83b5e2a793bc95d19e6cc2d9d28068f1a6ff6b79/recipe/activate-win.ps1) used by e.g. Python, ensuring many people cannot use Pkg operations that use LibGit2, like `dev Example`, `add Example#master`. See more user reports [on Discourse](https://discourse.julialang.org/search?q=JULIA_SSL_CA_ROOTS_PATH). Together with https://github.com/JuliaLang/NetworkOptions.jl/pull/37 this should improve the experience of users trying out Julia from a Conda environment. This should also be fine to backport. (cherry picked from commit 7fa969ab3ce9c1ab6b8b67969b1b8de04a671094) --- stdlib/LibGit2/src/LibGit2.jl | 16 ++++++---------- stdlib/LibGit2/test/bad_ca_roots.jl | 26 +++++++++++++++----------- 2 files changed, 21 insertions(+), 21 deletions(-) diff --git a/stdlib/LibGit2/src/LibGit2.jl b/stdlib/LibGit2/src/LibGit2.jl index 43b960e8d509d..9dad6f38d2615 100644 --- a/stdlib/LibGit2/src/LibGit2.jl +++ b/stdlib/LibGit2/src/LibGit2.jl @@ -1043,24 +1043,20 @@ function set_ssl_cert_locations(cert_loc) else # files, /dev/null, non-existent paths, etc. cert_file = cert_loc end - ret = @ccall libgit2.git_libgit2_opts( + ret = @ccall libgit2.git_libgit2_opts( Consts.SET_SSL_CERT_LOCATIONS::Cint; cert_file::Cstring, cert_dir::Cstring)::Cint ret >= 0 && return ret + # On macOS and Windows LibGit2_jll is built without a TLS backend that supports + # certificate locations; don't throw on this expected error so we allow certificate + # location environment variables to be set for other purposes. + # We still try doing so to support other LibGit2 builds. err = Error.GitError(ret) err.class == Error.SSL && err.msg == "TLS backend doesn't support certificate locations" || throw(err) - var = nothing - for v in NetworkOptions.CA_ROOTS_VARS - haskey(ENV, v) && (var = v) - end - @assert var !== nothing # otherwise we shouldn't be here - msg = """ - Your Julia is built with a SSL/TLS engine that libgit2 doesn't know how to configure to use a file or directory of certificate authority roots, but your environment specifies one via the $var variable. If you believe your system's root certificates are safe to use, you can `export JULIA_SSL_CA_ROOTS_PATH=""` in your environment to use those instead. - """ - throw(Error.GitError(err.class, err.code, chomp(msg))) + return ret end """ diff --git a/stdlib/LibGit2/test/bad_ca_roots.jl b/stdlib/LibGit2/test/bad_ca_roots.jl index 4882065167bdb..4caed4ed90beb 100644 --- a/stdlib/LibGit2/test/bad_ca_roots.jl +++ b/stdlib/LibGit2/test/bad_ca_roots.jl @@ -12,20 +12,24 @@ const CAN_SET_CA_ROOTS_PATH = !Sys.isapple() && !Sys.iswindows() # Given this is a sub-processed test file, not using @testsets avoids # leaking the report print into the Base test runner report begin # empty CA roots file - # these fail for different reasons on different platforms: - # - on Apple & Windows you cannot set the CA roots path location - # - on Linux & FreeBSD you you can but these are invalid files + # different behavior on different platforms: + # - on Apple & Windows you cannot set the CA roots path location; don't error + # - on Linux & FreeBSD you can but these are invalid files + ENV["JULIA_SSL_CA_ROOTS_PATH"] = "/dev/null" - @test_throws LibGit2.GitError LibGit2.ensure_initialized() + if CAN_SET_CA_ROOTS_PATH + @test_throws LibGit2.GitError LibGit2.ensure_initialized() + else + @test LibGit2.ensure_initialized() === nothing + end + ENV["JULIA_SSL_CA_ROOTS_PATH"] = tempname() - @test_throws LibGit2.GitError LibGit2.ensure_initialized() - # test that it still fails if called a second time - @test_throws LibGit2.GitError LibGit2.ensure_initialized() - if !CAN_SET_CA_ROOTS_PATH - # test that this doesn't work on macOS & Windows - ENV["JULIA_SSL_CA_ROOTS_PATH"] = NetworkOptions.bundled_ca_roots() + if CAN_SET_CA_ROOTS_PATH + @test_throws LibGit2.GitError LibGit2.ensure_initialized() + # test that it still fails if called a second time @test_throws LibGit2.GitError LibGit2.ensure_initialized() - delete!(ENV, "JULIA_SSL_CA_ROOTS_PATH") + else + @test LibGit2.ensure_initialized() === nothing @test LibGit2.ensure_initialized() === nothing end end From d4d0876ce3f069aee5dc21f3b8d3c091e90f4138 Mon Sep 17 00:00:00 2001 From: Neven Sajko <4944410+nsajko@users.noreply.github.com> Date: Tue, 1 Apr 2025 09:05:56 +0200 Subject: [PATCH 45/56] `append_c_digits`: typeassert `Int` to improve inference (#57950) Makes the sysimage more resistant to method invalidation, when defining a new `Integer` subtype with a right bitshift method. (cherry picked from commit 69a22cf4bcaaf54e9bf08f2d4ed9e4e77f0ad1e4) --- base/intfuncs.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/base/intfuncs.jl b/base/intfuncs.jl index f2de94db5589e..2c009ae2a6494 100644 --- a/base/intfuncs.jl +++ b/base/intfuncs.jl @@ -801,7 +801,7 @@ function append_c_digits(olength::Int, digits::Unsigned, buf, pos::Int) while i >= 2 d, c = divrem(digits, 0x64) digits = oftype(digits, d) - @inbounds d100 = _dec_d100[(c % Int) + 1] + @inbounds d100 = _dec_d100[(c % Int)::Int + 1] @inbounds buf[pos + i - 2] = d100 % UInt8 @inbounds buf[pos + i - 1] = (d100 >> 0x8) % UInt8 i -= 2 From 21e7f7a6610bfc3c9df70aa70c01102af065bc96 Mon Sep 17 00:00:00 2001 From: Neven Sajko <4944410+nsajko@users.noreply.github.com> Date: Fri, 4 Apr 2025 04:13:40 +0200 Subject: [PATCH 46/56] fix `nextpow`, `prevpow` for types without `typemax` (#49669) Without this change `prevpow` and `nextpow` fail for, e.g., `BigInt`; incorrectly throwing a `MethodError`. For example, calls like `prevpow(3, big"10")` or `nextpow(3, big"10")` fail. The issue is that the code incorrectly assumes the existence of a `typemax` method. Another issue was a missing promote for the arguments of a `mul_with_overflow` call. Fixes #57906 (cherry picked from commit 3627a85749e4aa8197edb56dd93d1b21fd54dbe8) --- base/intfuncs.jl | 8 +++++--- test/intfuncs.jl | 17 ++++++++++++++++- 2 files changed, 21 insertions(+), 4 deletions(-) diff --git a/base/intfuncs.jl b/base/intfuncs.jl index 2c009ae2a6494..a75bc14e15f26 100644 --- a/base/intfuncs.jl +++ b/base/intfuncs.jl @@ -526,7 +526,8 @@ function nextpow(a::Real, x::Real) n = ceil(Integer,log(a, x)) # round-off error of log can go either direction, so need some checks p = a^(n-1) - x > typemax(p) && throw(DomainError(x,"argument is beyond the range of type of the base")) + hastypemax(typeof(p)) && x > typemax(p) && + throw(DomainError(x,"argument is beyond the range of type of the base")) p >= x && return p wp = a^n wp > p || throw(OverflowError("result is beyond the range of type of the base")) @@ -567,9 +568,10 @@ function prevpow(a::T, x::Real) where T <: Real n = floor(Integer,log(a, x)) # round-off error of log can go either direction, so need some checks p = a^n - x > typemax(p) && throw(DomainError(x,"argument is beyond the range of type of the base")) + hastypemax(typeof(p)) && x > typemax(p) && + throw(DomainError(x,"argument is beyond the range of type of the base")) if a isa Integer - wp, overflow = mul_with_overflow(a, p) + wp, overflow = mul_with_overflow(promote(a, p)...) wp <= x && !overflow && return wp else wp = a^(n+1) diff --git a/test/intfuncs.jl b/test/intfuncs.jl index ed661b2806fb5..17bcd47655828 100644 --- a/test/intfuncs.jl +++ b/test/intfuncs.jl @@ -309,6 +309,14 @@ end end @testset "nextpow/prevpow" begin + fs = (prevpow, nextpow) + types = (Int8, BigInt, BigFloat) + for f ∈ fs, P ∈ types, R ∈ types, p ∈ 1:20, r ∈ 2:5 + q = P(p) + n = R(r) + @test f(r, p) == f(n, q) + end + @test nextpow(2, 3) == 4 @test nextpow(2, 4) == 4 @test nextpow(2, 7) == 8 @@ -322,7 +330,14 @@ end @test prevpow(10, 101.0) === 100 @test prevpow(10.0, 101) === 100.0 @test_throws DomainError prevpow(0, 3) - @test_throws DomainError prevpow(0, 3) + @test_throws DomainError prevpow(3, 0) + + # "argument is beyond the range of type of the base" + @test_throws DomainError prevpow(Int8(3), 243) + @test_throws DomainError nextpow(Int8(3), 243) + + # "result is beyond the range of type of the base" + @test_throws OverflowError nextpow(Int8(3), 82) end @testset "ndigits/ndigits0z" begin From c9a4255be2e06ccad1c941e5b354cfe1728f482c Mon Sep 17 00:00:00 2001 From: Kristoffer Date: Sat, 5 Apr 2025 20:20:04 +0200 Subject: [PATCH 47/56] bump Pkg to latest v1.11 --- .../Pkg-9ca5e30b4c095ffa93812499930c8d703a658cf1.tar.gz/md5 | 1 - .../Pkg-9ca5e30b4c095ffa93812499930c8d703a658cf1.tar.gz/sha512 | 1 - .../Pkg-ec5b551f1c51e79eefce9029785c6a465471f425.tar.gz/md5 | 1 + .../Pkg-ec5b551f1c51e79eefce9029785c6a465471f425.tar.gz/sha512 | 1 + stdlib/Pkg.version | 2 +- 5 files changed, 3 insertions(+), 3 deletions(-) delete mode 100644 deps/checksums/Pkg-9ca5e30b4c095ffa93812499930c8d703a658cf1.tar.gz/md5 delete mode 100644 deps/checksums/Pkg-9ca5e30b4c095ffa93812499930c8d703a658cf1.tar.gz/sha512 create mode 100644 deps/checksums/Pkg-ec5b551f1c51e79eefce9029785c6a465471f425.tar.gz/md5 create mode 100644 deps/checksums/Pkg-ec5b551f1c51e79eefce9029785c6a465471f425.tar.gz/sha512 diff --git a/deps/checksums/Pkg-9ca5e30b4c095ffa93812499930c8d703a658cf1.tar.gz/md5 b/deps/checksums/Pkg-9ca5e30b4c095ffa93812499930c8d703a658cf1.tar.gz/md5 deleted file mode 100644 index b3e41de8c745b..0000000000000 --- a/deps/checksums/Pkg-9ca5e30b4c095ffa93812499930c8d703a658cf1.tar.gz/md5 +++ /dev/null @@ -1 +0,0 @@ -c5df4a32eb3abe57fd2800c50a212db2 diff --git a/deps/checksums/Pkg-9ca5e30b4c095ffa93812499930c8d703a658cf1.tar.gz/sha512 b/deps/checksums/Pkg-9ca5e30b4c095ffa93812499930c8d703a658cf1.tar.gz/sha512 deleted file mode 100644 index 95fa1f8ea3d17..0000000000000 --- a/deps/checksums/Pkg-9ca5e30b4c095ffa93812499930c8d703a658cf1.tar.gz/sha512 +++ /dev/null @@ -1 +0,0 @@ -1b38c71a7ed169d8bd5d47536a68ec632df8ecdc7a1bdf29e55912218c52c85579b4adbb60e31cbce5609c2a31fbb14657844047f4eaa3d6ae2f1142d8821f58 diff --git a/deps/checksums/Pkg-ec5b551f1c51e79eefce9029785c6a465471f425.tar.gz/md5 b/deps/checksums/Pkg-ec5b551f1c51e79eefce9029785c6a465471f425.tar.gz/md5 new file mode 100644 index 0000000000000..4f4e563d2df91 --- /dev/null +++ b/deps/checksums/Pkg-ec5b551f1c51e79eefce9029785c6a465471f425.tar.gz/md5 @@ -0,0 +1 @@ +01c864e88a74e327b7ed423f73b389eb diff --git a/deps/checksums/Pkg-ec5b551f1c51e79eefce9029785c6a465471f425.tar.gz/sha512 b/deps/checksums/Pkg-ec5b551f1c51e79eefce9029785c6a465471f425.tar.gz/sha512 new file mode 100644 index 0000000000000..4a4b8c6140b56 --- /dev/null +++ b/deps/checksums/Pkg-ec5b551f1c51e79eefce9029785c6a465471f425.tar.gz/sha512 @@ -0,0 +1 @@ +986ec32c4aed302b4c2e359c08522c9d1aeaba763c172fd016b694cd1a59409941378de5b0e34848ca4a1828c52028ca776f3d2d6a6cb79838656de2c146dbc1 diff --git a/stdlib/Pkg.version b/stdlib/Pkg.version index 5708a2e93b7ba..b434d24df71a0 100644 --- a/stdlib/Pkg.version +++ b/stdlib/Pkg.version @@ -1,4 +1,4 @@ PKG_BRANCH = release-1.11 -PKG_SHA1 = 9ca5e30b4c095ffa93812499930c8d703a658cf1 +PKG_SHA1 = ec5b551f1c51e79eefce9029785c6a465471f425 PKG_GIT_URL := https://github.com/JuliaLang/Pkg.jl.git PKG_TAR_URL = https://api.github.com/repos/JuliaLang/Pkg.jl/tarball/$1 From b5eaa97c16521b8deabbfe7de9bd3c2de3fbf187 Mon Sep 17 00:00:00 2001 From: Zentrik Date: Wed, 11 Dec 2024 08:31:11 +0000 Subject: [PATCH 48/56] Fix undefined symbol error in version script (#55363) lld 17 and above by default error if symbols listed in the version script are undefined. Julia has a few of these, as some symbols are defined conditionally in Julia (e.g. based on OS), others perhaps have been removed from Julia and other seem to be defined in other libraries. Further the version script is used in linking three times, each time linking together different objects and so having different symbols defined. Adding `-Wl,--undefined-version` is not a great solution as passing that to ld < 2.40 errors and there doesn't seem to be a great way to check if a linker supports this flag. I don't know how to get around these errors for symbols like `_IO_stdin_used` which Julia doesn't define and it seems to matter whether or not they are exported, see https://libc-alpha.sourceware.narkive.com/SevIQmU3/io-stdin-used-stripped-by-version-scripts. So I've converted all undefined symbols into wildcards to work around the error. Fixes #50414, fixes #54533 and replaces #55319. --------- Co-authored-by: Zentrik (cherry picked from commit d269d7d375827a0279dc1fee7bb24c9418f06f03) --- src/julia.expmap.in | 40 ++++++++++++++++++++-------------------- 1 file changed, 20 insertions(+), 20 deletions(-) diff --git a/src/julia.expmap.in b/src/julia.expmap.in index 213d087fdc2ad..3c21f3093ffc9 100644 --- a/src/julia.expmap.in +++ b/src/julia.expmap.in @@ -1,8 +1,8 @@ @JULIA_SHLIB_SYMBOL_VERSION@ { global: pthread*; - __stack_chk_guard; - asprintf; + __stack_chk_*; + asprintf*; bitvector_*; ios_*; arraylist_grow; @@ -10,33 +10,33 @@ jl_*; ijl_*; _jl_mutex_*; - rec_backtrace; + rec_backtrace*; julia_*; - libsupport_init; - localtime_r; - memhash; - memhash32; - memhash32_seed; - memhash_seed; - restore_signals; + libsupport_init*; + localtime_r*; + memhash*; + memhash32*; + memhash32_seed*; + memhash_seed*; + restore_signals*; u8_*; uv_*; - add_library_mapping; + add_library_mapping*; utf8proc_*; - jlbacktrace; - jlbacktracet; - _IO_stdin_used; - _Z24jl_coverage_data_pointerN4llvm9StringRefEi; - _Z22jl_coverage_alloc_lineN4llvm9StringRefEi; - _Z22jl_malloc_data_pointerN4llvm9StringRefEi; + jlbacktrace*; + jlbacktracet*; + _IO_stdin_used*; /* glibc expects this to be exported to detect which version of glibc is being used, see https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=634261#109 for further details */ + _Z24jl_coverage_data_pointerN4llvm9StringRefEi*; + _Z22jl_coverage_alloc_lineN4llvm9StringRefEi*; + _Z22jl_malloc_data_pointerN4llvm9StringRefEi*; _jl_timing_*; LLVMExtra*; JLJIT*; - llvmGetPassPluginInfo; + llvmGetPassPluginInfo*; /* freebsd */ - environ; - __progname; + environ*; + __progname*; local: *; From a71dd056e0e934cb0217768917b6af1c5d5178a1 Mon Sep 17 00:00:00 2001 From: Kristoffer Date: Mon, 7 Apr 2025 15:42:17 +0200 Subject: [PATCH 49/56] Revert "Materialize complex Symmetric matrices in eigen (#55348)" This reverts commit c28dc8502f3277e474bacbd28a992b8605fb51e7. --- stdlib/LinearAlgebra/src/bunchkaufman.jl | 15 ++++++--------- stdlib/LinearAlgebra/src/symmetriceigen.jl | 1 - stdlib/LinearAlgebra/test/hessenberg.jl | 7 ------- stdlib/LinearAlgebra/test/symmetriceigen.jl | 6 ------ 4 files changed, 6 insertions(+), 23 deletions(-) diff --git a/stdlib/LinearAlgebra/src/bunchkaufman.jl b/stdlib/LinearAlgebra/src/bunchkaufman.jl index db0d44a1e25a6..8d1ded9bf8111 100644 --- a/stdlib/LinearAlgebra/src/bunchkaufman.jl +++ b/stdlib/LinearAlgebra/src/bunchkaufman.jl @@ -127,9 +127,6 @@ function bunchkaufman!(A::StridedMatrix{<:BlasFloat}, rook::Bool = false; check: end end -bkcopy_oftype(A, S) = eigencopy_oftype(A, S) -bkcopy_oftype(A::Symmetric{<:Complex}, S) = Symmetric(copytrito!(similar(parent(A), S, size(A)), A.data, A.uplo), sym_uplo(A.uplo)) - """ bunchkaufman(A, rook::Bool=false; check = true) -> S::BunchKaufman @@ -209,7 +206,7 @@ julia> S.L*S.D*S.L' - A[S.p, S.p] ``` """ bunchkaufman(A::AbstractMatrix{T}, rook::Bool=false; check::Bool = true) where {T} = - bunchkaufman!(bkcopy_oftype(A, typeof(sqrt(oneunit(T)))), rook; check = check) + bunchkaufman!(eigencopy_oftype(A, typeof(sqrt(oneunit(T)))), rook; check = check) BunchKaufman{T}(B::BunchKaufman) where {T} = BunchKaufman(convert(Matrix{T}, B.LD), B.ipiv, B.uplo, B.symmetric, B.rook, B.info) @@ -1532,7 +1529,7 @@ function bunchkaufman(A::AbstractMatrix{TS}, rook::Bool = false; check::Bool = true ) where TS <: ClosedScalar{TR} where TR <: ClosedReal - return bunchkaufman!(bkcopy_oftype(A, TS), rook; check) + return bunchkaufman!(eigencopy_oftype(A, TS), rook; check) end function bunchkaufman(A::AbstractMatrix{TS}, @@ -1554,15 +1551,15 @@ function bunchkaufman(A::AbstractMatrix{TS}, # We promote input to BigInt to avoid overflow problems if TA == Nothing if TS <: Integer - M = Rational{BigInt}.(bkcopy_oftype(A, TS)) + M = Rational{BigInt}.(eigencopy_oftype(A, TS)) else - M = Complex{Rational{BigInt}}.(bkcopy_oftype(A, TS)) + M = Complex{Rational{BigInt}}.(eigencopy_oftype(A, TS)) end else if TS <: Integer - M = TA(Rational{BigInt}.(bkcopy_oftype(A, TS)), Symbol(A.uplo)) + M = TA(Rational{BigInt}.(eigencopy_oftype(A, TS)), Symbol(A.uplo)) else - M = TA(Complex{Rational{BigInt}}.(bkcopy_oftype(A, TS)), + M = TA(Complex{Rational{BigInt}}.(eigencopy_oftype(A, TS)), Symbol(A.uplo)) end end diff --git a/stdlib/LinearAlgebra/src/symmetriceigen.jl b/stdlib/LinearAlgebra/src/symmetriceigen.jl index e9f43ef640392..0c86383685807 100644 --- a/stdlib/LinearAlgebra/src/symmetriceigen.jl +++ b/stdlib/LinearAlgebra/src/symmetriceigen.jl @@ -3,7 +3,6 @@ # preserve HermOrSym wrapper eigencopy_oftype(A::Hermitian, S) = Hermitian(copy_similar(A, S), sym_uplo(A.uplo)) eigencopy_oftype(A::Symmetric, S) = Symmetric(copy_similar(A, S), sym_uplo(A.uplo)) -eigencopy_oftype(A::Symmetric{<:Complex}, S) = copyto!(similar(parent(A), S), A) # Eigensolvers for symmetric and Hermitian matrices eigen!(A::RealHermSymComplexHerm{<:BlasReal,<:StridedMatrix}; sortby::Union{Function,Nothing}=nothing) = diff --git a/stdlib/LinearAlgebra/test/hessenberg.jl b/stdlib/LinearAlgebra/test/hessenberg.jl index 136f741fa5c0e..39ae7ec83a5c3 100644 --- a/stdlib/LinearAlgebra/test/hessenberg.jl +++ b/stdlib/LinearAlgebra/test/hessenberg.jl @@ -250,11 +250,4 @@ end @test axes(S) === (r,r) end -@testset "complex Symmetric" begin - D = diagm(0=>ComplexF64[1,2]) - S = Symmetric(D) - H = hessenberg(S) - @test H.H == D -end - end # module TestHessenberg diff --git a/stdlib/LinearAlgebra/test/symmetriceigen.jl b/stdlib/LinearAlgebra/test/symmetriceigen.jl index 258ccbd2d4591..b3a5472c511f4 100644 --- a/stdlib/LinearAlgebra/test/symmetriceigen.jl +++ b/stdlib/LinearAlgebra/test/symmetriceigen.jl @@ -151,10 +151,4 @@ end @test HT * V ≈ V * Diagonal(λ) end -@testset "complex Symmetric" begin - S = Symmetric(rand(ComplexF64,2,2)) - λ, v = eigen(S) - @test S * v ≈ v * Diagonal(λ) -end - end # module TestSymmetricEigen From 99a18f6259b57f8c79c140fb52822d98da662736 Mon Sep 17 00:00:00 2001 From: gbaraldi Date: Mon, 7 Apr 2025 16:06:29 -0400 Subject: [PATCH 50/56] Make llvmpasses test pass in 1.11 backport --- test/llvmpasses/late-lower-gc.ll | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/test/llvmpasses/late-lower-gc.ll b/test/llvmpasses/late-lower-gc.ll index 8ca588f717ee2..62122b2ad4ec9 100644 --- a/test/llvmpasses/late-lower-gc.ll +++ b/test/llvmpasses/late-lower-gc.ll @@ -133,9 +133,9 @@ top: %1 = bitcast {}*** %pgcstack to {}** %current_task = getelementptr inbounds {}*, {}** %1, i64 -12 -; CHECK: %current_task = getelementptr inbounds ptr, ptr %1, i64 -12 - %2 = load float, ptr addrspace(1) %0, align 4, !invariant.load !1 -; CHECK-NEXT: %2 = load float, ptr addrspace(1) %0, align 4, !invariant.load +; OPAQUE: %current_task = getelementptr inbounds ptr, ptr %1, i64 -12 + %2 = load float, float addrspace(1)* %0, align 4, !invariant.load !1 +; OPAQUE-NEXT: %2 = load float, ptr addrspace(1) %0, align 4, !invariant.load ret void } From bedac2caada42b5078eacd4cb9ca9320921afe87 Mon Sep 17 00:00:00 2001 From: Kristoffer Date: Tue, 8 Apr 2025 08:31:26 +0200 Subject: [PATCH 51/56] update allocated codegen test from #55223 --- test/compiler/codegen.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/compiler/codegen.jl b/test/compiler/codegen.jl index 10b66fda33667..1c4f8e969c82b 100644 --- a/test/compiler/codegen.jl +++ b/test/compiler/codegen.jl @@ -407,7 +407,7 @@ function g_dict_hash_alloc() end # Warm up f_dict_hash_alloc(); g_dict_hash_alloc(); -@test (@allocated f_dict_hash_alloc()) == (@allocated g_dict_hash_alloc()) +@test abs((@allocated f_dict_hash_alloc()) / (@allocated g_dict_hash_alloc()) - 1) < 0.1 # less that 10% difference # returning an argument shouldn't alloc a new box @noinline f33829(x) = (global called33829 = true; x) From 4991eb800874210456508227bb29c1d3d3c17fc6 Mon Sep 17 00:00:00 2001 From: N5N3 <2642243996@qq.com> Date: Tue, 8 Apr 2025 14:33:18 +0800 Subject: [PATCH 52/56] typeintersect: fix triangular vars handling outside constructor. (#58018) Fix #57852. The 'e->triangle' branch doesn't make sense for variables outside the constructor. Let pkgeval tell us if `constraintkind` based branches are suitable for handling them. (The second commit is needed to fix some stack overflow regression.) (cherry picked from commit ec424d47ff8414a3666dce40d5977aabb509da0f) --- src/subtype.c | 15 +++++++-------- test/subtype.jl | 15 +++++++++++++-- 2 files changed, 20 insertions(+), 10 deletions(-) diff --git a/src/subtype.c b/src/subtype.c index 8bb7a2070c23c..1745e5b9ec11d 100644 --- a/src/subtype.c +++ b/src/subtype.c @@ -1382,7 +1382,7 @@ static int subtype(jl_value_t *x, jl_value_t *y, jl_stenv_t *e, int param) x = pick_union_element(x, e, 0); } if (jl_is_uniontype(y)) { - if (x == ((jl_uniontype_t*)y)->a || x == ((jl_uniontype_t*)y)->b) + if (obviously_in_union(y, x)) return 1; if (jl_is_unionall(x)) return subtype_unionall(y, (jl_unionall_t*)x, e, 0, param); @@ -2528,9 +2528,6 @@ static jl_value_t *intersect_aside(jl_value_t *x, jl_value_t *y, jl_stenv_t *e, static jl_value_t *intersect_union(jl_value_t *x, jl_uniontype_t *u, jl_stenv_t *e, int8_t R, int param) { - // band-aid for #56040 - if (!jl_is_uniontype(x) && obviously_in_union((jl_value_t *)u, x)) - return x; int no_free = !jl_has_free_typevars(x) && !jl_has_free_typevars((jl_value_t*)u); if (param == 2 || no_free) { jl_value_t *a=NULL, *b=NULL; @@ -2667,7 +2664,7 @@ static void set_bound(jl_value_t **bound, jl_value_t *val, jl_tvar_t *v, jl_sten // subtype, treating all vars as existential static int subtype_in_env_existential(jl_value_t *x, jl_value_t *y, jl_stenv_t *e) { - if (x == jl_bottom_type || y == (jl_value_t*)jl_any_type) + if (x == jl_bottom_type || y == (jl_value_t*)jl_any_type || obviously_in_union(y, x)) return 1; int8_t *rs = (int8_t*)alloca(current_env_length(e)); jl_varbinding_t *v = e->vars; @@ -2790,7 +2787,7 @@ static jl_value_t *intersect_var(jl_tvar_t *b, jl_value_t *a, jl_stenv_t *e, int jl_value_t *ub = R ? intersect_aside(a, bb->ub, e, bb->depth0) : intersect_aside(bb->ub, a, e, bb->depth0); if (ub == jl_bottom_type) return jl_bottom_type; - if (bb->constraintkind == 1 || e->triangular) { + if (bb->constraintkind == 1 || (e->triangular && param == 1)) { if (e->triangular && check_unsat_bound(ub, b, e)) return jl_bottom_type; set_bound(&bb->ub, ub, b, e); @@ -4105,12 +4102,14 @@ static jl_value_t *intersect(jl_value_t *x, jl_value_t *y, jl_stenv_t *e, int pa if (jl_subtype(y, x)) return y; } if (jl_is_uniontype(x)) { - if (y == ((jl_uniontype_t*)x)->a || y == ((jl_uniontype_t*)x)->b) + if (obviously_in_union(x, y)) return y; + if (jl_is_uniontype(y) && obviously_in_union(y, x)) + return x; return intersect_union(y, (jl_uniontype_t*)x, e, 0, param); } if (jl_is_uniontype(y)) { - if (x == ((jl_uniontype_t*)y)->a || x == ((jl_uniontype_t*)y)->b) + if (obviously_in_union(y, x)) return x; if (jl_is_unionall(x) && (jl_has_free_typevars(x) || jl_has_free_typevars(y))) return intersect_unionall(y, (jl_unionall_t*)x, e, 0, param); diff --git a/test/subtype.jl b/test/subtype.jl index 979746bd626dc..d186262a6e1ba 100644 --- a/test/subtype.jl +++ b/test/subtype.jl @@ -2087,8 +2087,7 @@ let A = Tuple{Any, Type{Ref{_A}} where _A}, I = typeintersect(A, B) @test I != Union{} @test Tuple{Type{Ref{Integer}}, Type{Ref{Integer}}} <: I - # TODO: this intersection result seems too wide (I == B) ? - @test_broken !<:(Tuple{Type{Int}, Type{Int}}, I) + @test !<:(Tuple{Type{Int}, Type{Int}}, I) end @testintersect(Tuple{Type{T}, T} where T<:(Tuple{Vararg{_A, _B}} where _B where _A), @@ -2757,3 +2756,15 @@ end Pair{N, T} where {N,NTuple{N,Int}<:T<:Tuple{Int,Vararg{Int}}}, !Union{} ) + +#issue 57852 +@testintersect( + Tuple{Type{T}, Type{<:F}, Type{<:F}} where {T, F<:Union{String, T}}, + Tuple{Type{Complex{T}} where T, Type{Complex{T}} where T, Type{String}}, + Tuple{Type{Complex{T}}, Type{Complex{T}}, Type{String}} where T +) +@testintersect( + Tuple{Type{T}, Type{<:Union{F, Nothing}}, Type{<:Union{F, Nothing}}} where {T, F<:Union{String, T}}, + Tuple{Type{Complex{T}} where T, Type{Complex{T}} where T, Type{String}}, + Tuple{Type{Complex{T}}, Type{Complex{T}}, Type{String}} where T +) From 88568a87847446afcf5ff457013638e6752d8b74 Mon Sep 17 00:00:00 2001 From: Kristoffer Date: Wed, 9 Apr 2025 10:50:21 +0200 Subject: [PATCH 53/56] bump Pkg to latest v1.11 --- .../Pkg-5b3ff389aa74714cd28e7add2732b097a01ce764.tar.gz/md5 | 1 + .../Pkg-5b3ff389aa74714cd28e7add2732b097a01ce764.tar.gz/sha512 | 1 + .../Pkg-ec5b551f1c51e79eefce9029785c6a465471f425.tar.gz/md5 | 1 - .../Pkg-ec5b551f1c51e79eefce9029785c6a465471f425.tar.gz/sha512 | 1 - stdlib/Pkg.version | 2 +- 5 files changed, 3 insertions(+), 3 deletions(-) create mode 100644 deps/checksums/Pkg-5b3ff389aa74714cd28e7add2732b097a01ce764.tar.gz/md5 create mode 100644 deps/checksums/Pkg-5b3ff389aa74714cd28e7add2732b097a01ce764.tar.gz/sha512 delete mode 100644 deps/checksums/Pkg-ec5b551f1c51e79eefce9029785c6a465471f425.tar.gz/md5 delete mode 100644 deps/checksums/Pkg-ec5b551f1c51e79eefce9029785c6a465471f425.tar.gz/sha512 diff --git a/deps/checksums/Pkg-5b3ff389aa74714cd28e7add2732b097a01ce764.tar.gz/md5 b/deps/checksums/Pkg-5b3ff389aa74714cd28e7add2732b097a01ce764.tar.gz/md5 new file mode 100644 index 0000000000000..5944ec8a69cb8 --- /dev/null +++ b/deps/checksums/Pkg-5b3ff389aa74714cd28e7add2732b097a01ce764.tar.gz/md5 @@ -0,0 +1 @@ +b5b6cc2e7a1b6401d102f51abb4ae4d5 diff --git a/deps/checksums/Pkg-5b3ff389aa74714cd28e7add2732b097a01ce764.tar.gz/sha512 b/deps/checksums/Pkg-5b3ff389aa74714cd28e7add2732b097a01ce764.tar.gz/sha512 new file mode 100644 index 0000000000000..8c1662757038d --- /dev/null +++ b/deps/checksums/Pkg-5b3ff389aa74714cd28e7add2732b097a01ce764.tar.gz/sha512 @@ -0,0 +1 @@ +2a58eab12df4070a2a002c6e52fbf49e6c445fb973dc044e30332052cfb6089de12525c8ce2f3f5dd5651e0305477fbbf6b8e063c78a6ddc96c52254f5364c5a diff --git a/deps/checksums/Pkg-ec5b551f1c51e79eefce9029785c6a465471f425.tar.gz/md5 b/deps/checksums/Pkg-ec5b551f1c51e79eefce9029785c6a465471f425.tar.gz/md5 deleted file mode 100644 index 4f4e563d2df91..0000000000000 --- a/deps/checksums/Pkg-ec5b551f1c51e79eefce9029785c6a465471f425.tar.gz/md5 +++ /dev/null @@ -1 +0,0 @@ -01c864e88a74e327b7ed423f73b389eb diff --git a/deps/checksums/Pkg-ec5b551f1c51e79eefce9029785c6a465471f425.tar.gz/sha512 b/deps/checksums/Pkg-ec5b551f1c51e79eefce9029785c6a465471f425.tar.gz/sha512 deleted file mode 100644 index 4a4b8c6140b56..0000000000000 --- a/deps/checksums/Pkg-ec5b551f1c51e79eefce9029785c6a465471f425.tar.gz/sha512 +++ /dev/null @@ -1 +0,0 @@ -986ec32c4aed302b4c2e359c08522c9d1aeaba763c172fd016b694cd1a59409941378de5b0e34848ca4a1828c52028ca776f3d2d6a6cb79838656de2c146dbc1 diff --git a/stdlib/Pkg.version b/stdlib/Pkg.version index b434d24df71a0..e454ed89c0a72 100644 --- a/stdlib/Pkg.version +++ b/stdlib/Pkg.version @@ -1,4 +1,4 @@ PKG_BRANCH = release-1.11 -PKG_SHA1 = ec5b551f1c51e79eefce9029785c6a465471f425 +PKG_SHA1 = 5b3ff389aa74714cd28e7add2732b097a01ce764 PKG_GIT_URL := https://github.com/JuliaLang/Pkg.jl.git PKG_TAR_URL = https://api.github.com/repos/JuliaLang/Pkg.jl/tarball/$1 From 897983609713ea98cd371ae86b534517922810c2 Mon Sep 17 00:00:00 2001 From: Gabriel Baraldi Date: Thu, 10 Apr 2025 07:04:32 -0300 Subject: [PATCH 54/56] Add bfloat LLVM fix to 1.11 (#57874) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Mosè Giordano --- deps/checksums/clang | 216 ++++++++-------- deps/checksums/lld | 214 ++++++++-------- deps/checksums/llvm | 436 ++++++++++++++++---------------- deps/clang.version | 2 +- deps/lld.version | 2 +- deps/llvm-tools.version | 4 +- deps/llvm.version | 6 +- src/julia.expmap.in | 4 +- stdlib/LLD_jll/Project.toml | 2 +- stdlib/Manifest.toml | 4 +- stdlib/libLLVM_jll/Project.toml | 2 +- 11 files changed, 445 insertions(+), 447 deletions(-) diff --git a/deps/checksums/clang b/deps/checksums/clang index f27067bf6cb85..423d72d5c2794 100644 --- a/deps/checksums/clang +++ b/deps/checksums/clang @@ -1,108 +1,108 @@ -Clang.v16.0.6+4.aarch64-apple-darwin-llvm_version+16.asserts.tar.gz/md5/669e6bc49ff1715e259ea4d60dd3f0b5 -Clang.v16.0.6+4.aarch64-apple-darwin-llvm_version+16.asserts.tar.gz/sha512/e81c11d4d3c5a96a646a535362dc7f18d1be25b11304faf65b002ca68255c57e067f3022d53e3ae19e2319b1267e71da66bbb8afc0be53632c558bf08aa47f52 -Clang.v16.0.6+4.aarch64-apple-darwin-llvm_version+16.tar.gz/md5/22e32a15d23de5a4b5fa01f56c48e8b3 -Clang.v16.0.6+4.aarch64-apple-darwin-llvm_version+16.tar.gz/sha512/4228e5a66f21058d181b67e4b959f84aceb2195e90af0f28908c537e42b72b32cbd3e813e9261476597ba04d76549cedf6b5aa72eddf6cda63a34df00106a8c5 -Clang.v16.0.6+4.aarch64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/2defb4a5181b381201a6d16c6711e89b -Clang.v16.0.6+4.aarch64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/3386402e8fcfd1c0f6d154cd8b966f308759e13919a38d148a1ad3539e046330982eefaff074f7ab454cd1d396cb92d992dda6589fa73e00fdcb237ec1cfc843 -Clang.v16.0.6+4.aarch64-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/f96d1684861a5b78ec1ce22c68659907 -Clang.v16.0.6+4.aarch64-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/09327b84e86cf117a0e492d39b531690c700f4dbd3e1469ecd3d269fa5e788c173d62f972d474194999a12a3cf88e3151cc07ac418511207c8d2494c4e493f41 -Clang.v16.0.6+4.aarch64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/dd27b64b1c8a4b66647de4dda29e76bb -Clang.v16.0.6+4.aarch64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/1fc68f4c2132eca09bb8cf9d51a1d6c223c4c705de181d973dbc5d818222da1a68eb4dc8f944750c0a715ddd73e61e7da6a4aa44c8a682bb549f0bcfe83a4044 -Clang.v16.0.6+4.aarch64-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/e343df2dcacf98d7366ea9d3206f8655 -Clang.v16.0.6+4.aarch64-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/75ad869bd6ff350c37300ed6f0ceb2815023a8132c3025eb6992f33728b3c67556a503a05613a36bb6f3be39d06256bf51ba2b710f68ac2ed18004e2cd4ed133 -Clang.v16.0.6+4.aarch64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/md5/71f7ffde41325bf4946fb71429e641c9 -Clang.v16.0.6+4.aarch64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/sha512/bbeedf07ee304016c23b57b30bb9e3d9de6186805c38ada808c2f742d61b0650a40626333fe452d2491ff758a07e4ff7e438e9bb66b6a93627381ee5a772e2e5 -Clang.v16.0.6+4.aarch64-linux-musl-cxx03-llvm_version+16.tar.gz/md5/02a5e1d72a7707c4a8dff484f7b06127 -Clang.v16.0.6+4.aarch64-linux-musl-cxx03-llvm_version+16.tar.gz/sha512/591265593d59938744b7753ccff22622bcef5dac9779228ec599db0da250e39082a4dcdbf76cab6c4b79e3b9b8dcc458a426d410c70f739678e4abbd02dbcf42 -Clang.v16.0.6+4.aarch64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/md5/6e23a222df648d83a871a9e70092be22 -Clang.v16.0.6+4.aarch64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/sha512/2ab4e861762ebd9c6e269b8cb10b3238cc0535620956ce63da0b34dd2faf4a925622ee879807ca6af6ff808fdd7f8a1d69dcfbdd499da2cb9d35daf4111b5406 -Clang.v16.0.6+4.aarch64-linux-musl-cxx11-llvm_version+16.tar.gz/md5/a9a8572068bb9ba3d4fff517e4141158 -Clang.v16.0.6+4.aarch64-linux-musl-cxx11-llvm_version+16.tar.gz/sha512/addc84d7245b000e13fd128856fe7125c9cd7d66b943867b17623d73f77634638e7a4d5417ddbd441204fe0e7c26c6668d661e7f336d8e83af93f37ea92c7ce9 -Clang.v16.0.6+4.armv6l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/82466ead7526e9f7e676d5281618592b -Clang.v16.0.6+4.armv6l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/6dc81a93532d7c039e115173de8d6dd28cb1dbc39a41426eb477d3c9172baa5ba0a30e1a5d4db74a9793a32fb19c691daf99794a6339d47b250ab4ea9a042dfb -Clang.v16.0.6+4.armv6l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/md5/9add4c5f6f4649baecdeb16ce8429c64 -Clang.v16.0.6+4.armv6l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/sha512/48276bd860514c27458c2d02ec047c6eabc7364c2b6f429abc081ac78bdd2ad4c9536c501029818676d8d7b1347e900f39ad58a01ba75a1cd8c14ccb78ba995c -Clang.v16.0.6+4.armv6l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/4a4a38af087d005b713348ac1290fd2f -Clang.v16.0.6+4.armv6l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/380975fdecfe0a33b71dcadaa652402764f08af0bd5d9d2cffbedc34a9acc7b5a5e2c92169f35bfd7427d9a431002bbcb4381d0662c58c2d46db9e5709d0c8ae -Clang.v16.0.6+4.armv6l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/md5/602d51818dbe23cc36ddc60083ebcbb0 -Clang.v16.0.6+4.armv6l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/sha512/4593cc80d9ff046961f7f68c30502429ef7b270556b4153c5e47945e8032100470d74e9c9b62c34dd97fc9c81001615b10c31b171bfef2c67c1cd0574d0d2c95 -Clang.v16.0.6+4.armv6l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/e7aba5ab085a0893c4b46a4a8f0d963b -Clang.v16.0.6+4.armv6l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/690b7623af2ca8c1be696b80ac42aa99ec006a5c96a2560250425bcc1c41ceec31d1e6396174ef5fa071ea1d6ecc19bfce9f5606cfaba2176ecb0993e2beb901 -Clang.v16.0.6+4.armv6l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/md5/6544aa4614c5f95fa26194b4812a2ab3 -Clang.v16.0.6+4.armv6l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/sha512/4b4c5aa1449416d807cbb9546c31bba655f413f6f5cffd26b20ad53d452ada64235342c430aae5ac1faaa52496bcd097d6b7ec6027b9f6dcb6ea5cb6d0c77a0d -Clang.v16.0.6+4.armv6l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/296309f5d25708e632866c688b5abce6 -Clang.v16.0.6+4.armv6l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/29082d6a4b1c9f0d2ab650fe0fd3e9d2085ad7225ea7c4cb7dc38ee8dfc03189a5c7b060af75022f81cca17aa71e3ff96b67255398d06db77a429b2cd0bc2017 -Clang.v16.0.6+4.armv6l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/md5/de7837fe7342a448586a5a176bd98549 -Clang.v16.0.6+4.armv6l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/sha512/194df7bbf67fa70bf78baffecfe5438307804743a4093a5bc123cafc8085d61be9f48c5c1bda47d5b9ca65e7614119c3a235c2ddb1d311623ac92135ebcc3f0d -Clang.v16.0.6+4.armv7l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/71036efacbec706ea6bb4124ac42aa14 -Clang.v16.0.6+4.armv7l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/f4f98648e8708b5053b7086d823651a1fd8df5333a0ea571f9a39f7cc4449ad19abf0556bf756d4e12ab5cbadca771f36bdece6087cf45e4377da9f572e4b4ed -Clang.v16.0.6+4.armv7l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/md5/52374b994418675552d0004c4c304329 -Clang.v16.0.6+4.armv7l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/sha512/51385ef025b1c3d06ed4db078d6458a92d3826b733051e1513c94908e9475b2a27d0a9d5df8ee3f442ac009d1bac4597c0338ed0cb06e2ec5e9d6267ad9c1be3 -Clang.v16.0.6+4.armv7l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/4fbd519b4be6fc20180bfc770b38e1a8 -Clang.v16.0.6+4.armv7l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/7807b20b344186aa0fa54cebcab4371995f8d3a4e6fb1ae43fcceffd7d20be227f43346f6408375ecbfc40244be7d0cca690ba2000a8715deab19b729e2cf28f -Clang.v16.0.6+4.armv7l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/md5/3017cea85ad3f416ad0ad1131562ca38 -Clang.v16.0.6+4.armv7l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/sha512/0ad5f18a3d33d849af2055ea833764c2d77d81fc5a33d41987fb4c89ac9eaa647da10d32b3a3c86317e60bfc4af431e855ba0bc2e5ccd0800950ccb77bc0e03e -Clang.v16.0.6+4.armv7l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/e06e17cd995cb424628d02e0a40b7110 -Clang.v16.0.6+4.armv7l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/e0466a2cbf651684ad51ee9f2a34f10b12c0f114ab795b0b16c8f18d944d956101a913e7762ddca36bfb146c5930d1e8b6a6a8508517e44276fd4e21663118d9 -Clang.v16.0.6+4.armv7l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/md5/3a3357bc382a3e32f98ac557f47ee626 -Clang.v16.0.6+4.armv7l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/sha512/bcc34b8ed6f3876c5f11b87f4779cc6106aa54055886c55d2f8d0ba420ddd5e498907b44b2fafcec1efd4cc9b513f26e09163cddefad60a1d07493b6a3c3d0ef -Clang.v16.0.6+4.armv7l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/2a938d18681235edbfb6ebb1868246f4 -Clang.v16.0.6+4.armv7l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/6df520c1443b1750d5cb397389bde9478510042cdacead6420c08db9e80d69957a93e17c9918a83bf6c3b46d5b7fab71ba7efd52da641619ae3308ae510e9a54 -Clang.v16.0.6+4.armv7l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/md5/304f130084074e3e4ac5d37f1c1bea57 -Clang.v16.0.6+4.armv7l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/sha512/bf893e5ab3f572e1db081b484ffcddd7dc2f6c15060099a76ef00685885d8f71b9196272c5b973014f2492cd7f94cf1e3c32b9222e97d4b580baae9235539a29 -Clang.v16.0.6+4.i686-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/c1f5add69bea21e906485c0267345084 -Clang.v16.0.6+4.i686-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/72b08d5001e713505a3185dc179bf1d2614e77518ad6439f92e6df69b6b328e48ba449865fdda20f5cd4a10482dd8c07398e28ffcec7ca29216c12170e34825b -Clang.v16.0.6+4.i686-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/c58327d44901fb4c51bd98639be97dcd -Clang.v16.0.6+4.i686-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/21d92e946dd96e32000ab114b29db233d41e3731a6ebac9d9c876cc8e7b225be570d3751f74c98a0747121638fc6d6e63c3c3e8734cfd53a3c056dc4aec9f96a -Clang.v16.0.6+4.i686-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/d8c025b9240ed4c8742ea8381b975d2c -Clang.v16.0.6+4.i686-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/2631a139162c4acdf990054eef55e68fcd83608ee708a85589a82bb4b4a2e0a0e91dfca6f4b7c2aad9b4fed61fedca9237c6f55cd1cb91a9d9bfa1c279b3cabb -Clang.v16.0.6+4.i686-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/62f5a0d34e3e39ff0832f5566e77b43e -Clang.v16.0.6+4.i686-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/911c9e5a545500dac325faddbdbf33983862ebf2d2b55baf07f8003ce045710d15dc386f65c6a1c01a1c3500b831030ea686953b86631d1870ea4c6016784928 -Clang.v16.0.6+4.i686-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/md5/aca138da6dbb96b923c3b444760901be -Clang.v16.0.6+4.i686-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/sha512/21768ce38c29c012b36037ed7d5232b53c388d6fdfee81f13f7b04e4168957b2d8477b821452b8f602455899c779cd5d32e69a213fdaaa25e4e83d1e3c9621fd -Clang.v16.0.6+4.i686-w64-mingw32-cxx03-llvm_version+16.tar.gz/md5/10de75baa15af9f99a0a936a7c1fdcd0 -Clang.v16.0.6+4.i686-w64-mingw32-cxx03-llvm_version+16.tar.gz/sha512/686db38e54436b2816ca658cdd17b7f8de3c71d4f5bcca629968d5c2a11b91b55269aa506f8ba4a4f059f482804d7c622cdd92dbef445e2377f2cd1c6fe7265a -Clang.v16.0.6+4.i686-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/md5/c1f92df83f99e7d920da36b470e39a4d -Clang.v16.0.6+4.i686-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/sha512/8f67d8fc779ee738ceba20389bd68560696e94497b0455b3894027bb9773ea0f4933cac6a3c4d10fd7a391d934cff0487722be509f37654736a23c3b4f3d2dde -Clang.v16.0.6+4.i686-w64-mingw32-cxx11-llvm_version+16.tar.gz/md5/660393c8f29f5127bb32f5b1135028db -Clang.v16.0.6+4.i686-w64-mingw32-cxx11-llvm_version+16.tar.gz/sha512/a4366e839d1d4fbba30fa6599cc7cdee4d32474abb6ae5fa499e83546543917e9737ff38994bc7a9421d4fa88b8c466a50a49196482c2ddd4ab0b8a3f7556903 -Clang.v16.0.6+4.powerpc64le-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/1689b18599e772b79c2bdd09bbf8f8fa -Clang.v16.0.6+4.powerpc64le-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/d7a74189addfe6ab7fca0dd7408b8b0476e3befe1cac65150a3558c6cd1cbb4b919c5f079fc892dee46b6776bad8d3251799ebb7d76d7fcaa4ef45830a551adc -Clang.v16.0.6+4.powerpc64le-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/33c06a9914fea54f71d3a546583e43d1 -Clang.v16.0.6+4.powerpc64le-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/bcfbb536df4b0929a3cba2b6366d7cf0b3362c3eabd7f1e94f774a617f5134a26f3e4c41c44896c7a3e2f6c734b7efd2301de34d9883f6e2d42619d7fb9281bb -Clang.v16.0.6+4.powerpc64le-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/bd983991a186c350303e1108534ab713 -Clang.v16.0.6+4.powerpc64le-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/7b96d52d66fe1bf4d967022067d5336b016947c120df7c892c03fa5b1b95a5fdbe24f220c13afc76ee25142c15aaa70000c11dab2b7e5db1445b0c73a7d3eaf5 -Clang.v16.0.6+4.powerpc64le-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/1add4ae2faa3bf120b29a7d80b173b2b -Clang.v16.0.6+4.powerpc64le-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/7996347224e4b973a1174e253d022784b5a6e7fd7813d7ed47a0dccc3728bbe0432d94a89ced9e406e2ff5860d4b1646a40ec889f5dc1aec264f13608bb05661 -Clang.v16.0.6+4.x86_64-apple-darwin-llvm_version+16.asserts.tar.gz/md5/fd02d184d64e04010a5a31c1a9dd9d43 -Clang.v16.0.6+4.x86_64-apple-darwin-llvm_version+16.asserts.tar.gz/sha512/56d4be2fa7f0d2f1a6d17014ac4a8a6b302a542464c733c4637b1a3bbfc2bcf42755783445ba0f272d9bbbfb9f755eedb46d3ade8252136d9f3c4f328aac78d8 -Clang.v16.0.6+4.x86_64-apple-darwin-llvm_version+16.tar.gz/md5/8977be77d1e9c9fd7d4c509fd20e96d5 -Clang.v16.0.6+4.x86_64-apple-darwin-llvm_version+16.tar.gz/sha512/852290b61a1489f9251471d9863bdec6bbf179c325df6dd5acfc77937cd3cdecf0c988cc9eb02ce3ac5a5b7a44eb1c72ecb66f8cdd27b4f5b7bda237aa1ab1c2 -Clang.v16.0.6+4.x86_64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/e28a61211a0ff79356ce55126f934f6c -Clang.v16.0.6+4.x86_64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/4a842bc9758d3ffba3143aabc4f4c91f5a73531565d7ed0a53191996b3e157c0cd0117bf5f9deb28a226f1bbd2a5c5bc880fb58d79673db2661d95baa73463fc -Clang.v16.0.6+4.x86_64-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/31647f7142d211ce00910f806b203193 -Clang.v16.0.6+4.x86_64-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/15e10f67a5276aad4ac27fa6134b10b917b4e3dbeb19e615cf2691edc045029ece958a0208e347cab7c50fe0125e7b5cff97a0f73b5f05fc29dd9f4bbd439917 -Clang.v16.0.6+4.x86_64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/143114515a5460f569ab2b2bbb6f38a6 -Clang.v16.0.6+4.x86_64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/4cbb239fae8d8677165a3ecf8b43a5583eb053bd6861fc16db0090574c3e588b07af9b195ab615d02836e28f069341d29540863578f3455c76a109aa81888672 -Clang.v16.0.6+4.x86_64-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/bb7c9cedba80462c3414aafe3abe1960 -Clang.v16.0.6+4.x86_64-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/faaade14199c876784ecdb7a6a60a937591a6cc8ecef58a2cbcd52b7f94a9f282bb3a9ef51e1956081f1898bdfe6a63e3bbf1da677331888e164d25cb270690e -Clang.v16.0.6+4.x86_64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/md5/477eac2f9d86be87ac488141acda2e5b -Clang.v16.0.6+4.x86_64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/sha512/205a2bde47551dd09d5eb8bed193f1b64b18d423464c5bf7379553576d88fd33c23b6d43c4ad37587373fe41d7a3f1c3e0921efa7013dce1f314e88c6c3641a0 -Clang.v16.0.6+4.x86_64-linux-musl-cxx03-llvm_version+16.tar.gz/md5/e885ef6dc19efc4160eac81e99f9a220 -Clang.v16.0.6+4.x86_64-linux-musl-cxx03-llvm_version+16.tar.gz/sha512/30f6ab9e0c4b1f1ac8b1429f0e3b8d222b371c4c1198332d11268930cf425d3660cfda0fcddf0d2ba57afb74ebee1c39c0a3e92aaf1fb7564c33c053e58fa872 -Clang.v16.0.6+4.x86_64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/md5/d962d03f5a979124cde704add0e2a801 -Clang.v16.0.6+4.x86_64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/sha512/d677f1abff6c06411327ab78bd5276a6f880c3eb5e3ef32dcb02fbd64efe6751d24fb6bee0a45498a0e38f678a922ac95813da0ba025d5363f7a20c9dec44155 -Clang.v16.0.6+4.x86_64-linux-musl-cxx11-llvm_version+16.tar.gz/md5/4ea0a8e61ee8058982a1a4df1b30c001 -Clang.v16.0.6+4.x86_64-linux-musl-cxx11-llvm_version+16.tar.gz/sha512/ce95b6798901a84116542bf8566f520dccd5aacb4af8f8c7542abec62dc3c1d7136e6aa8922c5c2f2f61103730e7629e507acbff670b6f59ee62aa1f9a3d6e7f -Clang.v16.0.6+4.x86_64-unknown-freebsd-llvm_version+16.asserts.tar.gz/md5/03304c40a1e4727b9db5052e59ae5884 -Clang.v16.0.6+4.x86_64-unknown-freebsd-llvm_version+16.asserts.tar.gz/sha512/70467c23ab0a25c490803f78de10ae10b0afafcb76b77fd3ec325c4fecfcf03463c2b0a1842a7657f57c668811f4854776328e9af28227587f8268bb79363440 -Clang.v16.0.6+4.x86_64-unknown-freebsd-llvm_version+16.tar.gz/md5/461da00bc30e1dad361dce9ef79e0e42 -Clang.v16.0.6+4.x86_64-unknown-freebsd-llvm_version+16.tar.gz/sha512/51bc60c08fb0df8a565c88563642ef4a9ed4f8bb956a18f12ff570b673f69a26a2c8e8775c785a753727586336f276c42ce25385e7a813e227a93d2b532378e1 -Clang.v16.0.6+4.x86_64-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/md5/3e6d5b7230676a2c149524cba960706c -Clang.v16.0.6+4.x86_64-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/sha512/906d17378d957138de5f54bf0c8e8bda505a299d79c8b34b3db5113d2f9f732535ec464abbd198504f2a73c905f9209491ba30616e99258162c5045eb8e722d1 -Clang.v16.0.6+4.x86_64-w64-mingw32-cxx03-llvm_version+16.tar.gz/md5/a2c0cc701b90f580700a6d60186db8f0 -Clang.v16.0.6+4.x86_64-w64-mingw32-cxx03-llvm_version+16.tar.gz/sha512/e85533953837ed4caa6c429ce4228fa85e8b667c0212211755ea9be0029149d6e08f19b1d02cf5e69134250f1aa8918630b1623ad1ae2cd0b0e8535ee769c9cb -Clang.v16.0.6+4.x86_64-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/md5/5de809c792f82069cd68693e90ae8521 -Clang.v16.0.6+4.x86_64-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/sha512/b62502667136444890b85e589e3dd19153d71d23f9e989baa0cf83af09022b7ea042e6da5eff9094e50f0ba8200cbfc7a20ca76b89c251d0b887a0a970b28e65 -Clang.v16.0.6+4.x86_64-w64-mingw32-cxx11-llvm_version+16.tar.gz/md5/4b4c3064a5e613e2ac2d558a29d34a42 -Clang.v16.0.6+4.x86_64-w64-mingw32-cxx11-llvm_version+16.tar.gz/sha512/93739f9b85ae4d345c7522ca8ce8edb1c699d16756bec7fbbe44d5d3429a5c9ed2bd587c4ccf57df8a1758b8e52be009448db86e1de372fea02e3ab2a0221837 +Clang.v16.0.6+5.aarch64-apple-darwin-llvm_version+16.asserts.tar.gz/md5/17c6ed8ca18dae5189ab9970758cb01c +Clang.v16.0.6+5.aarch64-apple-darwin-llvm_version+16.asserts.tar.gz/sha512/43dad346fe2300ac2d081e7919699aed0231b9f8aa49c6f367005eba0ad4f17d9929d1d4aef69ebf1c352bf0df8fd4c58213ddb94b3cc9ccfc4ce271d3e13adc +Clang.v16.0.6+5.aarch64-apple-darwin-llvm_version+16.tar.gz/md5/982134372c10f17f10502e026c67d39f +Clang.v16.0.6+5.aarch64-apple-darwin-llvm_version+16.tar.gz/sha512/ae96d67108ab7290c268f9e7a7af5b26f6fe1a22a8433afb97d2dd0436e9632ed3d78932f8edeabbf853c5d335f39960f9195c84da6654f31644bf81a2508455 +Clang.v16.0.6+5.aarch64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/32a4b1efd3396137bd38c90eb30d3bb4 +Clang.v16.0.6+5.aarch64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/48e0efab3ec6080ee6b5f1bfe85fe3fd36232f046a2ca0880fb8c5651f959a5b8ba0e8f465686a4d10e0a3992aa634beac4eccff508955b5569db333074bc761 +Clang.v16.0.6+5.aarch64-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/2967ff061c1ffcd4ff605a70d7d2980e +Clang.v16.0.6+5.aarch64-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/17040d6f032b176181a32aa3de0c5ebdd8d421ad4183f3fb7030911d68addb922b3638cda2feec9d3015a76a7e0c14697953e7892ba823e3dd8cf887f341bae8 +Clang.v16.0.6+5.aarch64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/0be1ad594046dc4bc2ced433afcd73a8 +Clang.v16.0.6+5.aarch64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/b5cb23f61ae93dcf4b91c714eca340fedfd0fec5954e17cc96d6c42e3be009a32a8f8f8b61ce4933de5527f0bf03098c8378724d31feb4c7904c848da82bf120 +Clang.v16.0.6+5.aarch64-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/701ecc38f727c3d9b4c76266038dd6b7 +Clang.v16.0.6+5.aarch64-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/6bf24ff08aebd082d432e15478a1f63ba6c8a82ce4978d27b96e1dc784fd8720b46821ecb4a78ab1bede9f678166b63617d9e02d7be8cd5665fdf5a19bc51c0b +Clang.v16.0.6+5.aarch64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/md5/f2ad50df56d14937f087e756006a9f0a +Clang.v16.0.6+5.aarch64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/sha512/9590dff74393bd41e9d1e7831b92618d13fb304b0461158d4feece02484e9fbf7496add2bee5a1b8bead5d307faf1481e4de977ee860cdd7a7dd1c69207a42ee +Clang.v16.0.6+5.aarch64-linux-musl-cxx03-llvm_version+16.tar.gz/md5/72180bfe9adf7d1a60aec488306090ea +Clang.v16.0.6+5.aarch64-linux-musl-cxx03-llvm_version+16.tar.gz/sha512/d1cbe9177d824b2a71986f691b409b556ceb2c623e970bc3b831f34437fd999c93345f249ff6c38c734c1f74b0974a1b695eb494d17bd227c46589a774c8083e +Clang.v16.0.6+5.aarch64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/md5/bcf46656cff9f8a7b1c26abdfd22eacb +Clang.v16.0.6+5.aarch64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/sha512/21dfd9ef6f7fa6caa418dfc22fe4015010655272265e7229c324e17ca6bd1994dfc9ddf45a32c8e392efddeecefcf63942b455f4bdb6cf7837a1a54b9ce3bc11 +Clang.v16.0.6+5.aarch64-linux-musl-cxx11-llvm_version+16.tar.gz/md5/31368ecadcd6f3e20bf55f4f717420f8 +Clang.v16.0.6+5.aarch64-linux-musl-cxx11-llvm_version+16.tar.gz/sha512/48e64ab1b646cdc7b0d8f2951c1317c784a0300d75e991993b5fe447c4cb74d14f2f4d10050d9bb17b13a75ee8a921fd50b291223aec5c44161923ccbc7378d9 +Clang.v16.0.6+5.armv6l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/a62158a6a986996ee9b429943dfd23dc +Clang.v16.0.6+5.armv6l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/a4354866f4504705223021057970112615a7083a8142a4742f7853db21dac98a603b244d8609e920d985c73631bf694bc6e833e77faa5c99ad206a73db26406b +Clang.v16.0.6+5.armv6l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/md5/69b8a1040cb29526e634e4a351b0dbc8 +Clang.v16.0.6+5.armv6l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/sha512/f791c713e565e3dc9288e7fa2096195127dce27eeff212504f07f9d82a6f06aa3424054ff0db9a0d488160d339cd831a95a63b68bfcf25fa238c323dcce4a47a +Clang.v16.0.6+5.armv6l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/97d4c36ab1e3b5be120d94e94b6b860d +Clang.v16.0.6+5.armv6l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/84377f517f13913041a1e6985adccbc9c92312304e72aa35313ff9d12f2153014b82b59ad00f5fb258960bf9a575def83ff3c6433d7da1463a990a101cb096eb +Clang.v16.0.6+5.armv6l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/md5/41e92d38276443309745b3f04f8452f4 +Clang.v16.0.6+5.armv6l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/sha512/a5f15f2ce2d921c9ed552897c15896349af4c753f9b73475d4870fb85756a0a0aefa3043fa930415576e01826797e6ab896fc25030ddbfd1e713c5a7aa2f91d1 +Clang.v16.0.6+5.armv6l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/da66c4c3792f23b6ec013627dc542a11 +Clang.v16.0.6+5.armv6l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/a75431cb6608cdbf38b106714040383567ea3861189795bb42d2ee27dc6dda2ce701aede2e90fd86a2308415ecdc26e5960213f1942f51407cc7489c24696699 +Clang.v16.0.6+5.armv6l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/md5/129dd5586dd48661c9c80eb4457b497e +Clang.v16.0.6+5.armv6l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/sha512/59328c14cf4cbc4fa5db236402bc73eeda9bac56664cee98fbe82a3d54b7718930214c5a356bf6190e1216be0c4f813b7e77b27fc25a7808bcae21f622184faa +Clang.v16.0.6+5.armv6l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/147c8e718d106a14b53db4baaf5339c7 +Clang.v16.0.6+5.armv6l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/3526732cb729f8d2b86535f823975798a2f9dbf8d677791dcf9d59b8a3ba4f4c92358f101045a17932e640e80ae47e068f9f4ae181b8ba362897c3d6a73a9210 +Clang.v16.0.6+5.armv6l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/md5/51bf85afe07065b8e8bf00f7da83b3d7 +Clang.v16.0.6+5.armv6l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/sha512/0bd71055c7f9fb3e8fa44a6cd50769012cee74c52868f5fe65b2d45c0aa6686773c0b21482b463ed05e2eaa2c2060f8512f8313c6e31bf34cd605eb5c4a3c554 +Clang.v16.0.6+5.armv7l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/04ada79eb35ba0281aeff6a6a9537734 +Clang.v16.0.6+5.armv7l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/ecd7daea8f3f02257760beab813387fa1567326c3ba3d0ab959b6d2de599b136e180f4ee79ef13f348197f7dbcd4f872a5ca0b089c0b3d83ceafc9174b917bdd +Clang.v16.0.6+5.armv7l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/md5/bbcc7032262fa73705b09b97c0d7f99e +Clang.v16.0.6+5.armv7l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/sha512/552b85a72a36138cea7d9a1d16879b160cb177ff9fa1d32db80328cc74d4637c165ee6a585f3caa0f029b6f39f9173232655c22a2ad479eb9b804b9bec47c7e0 +Clang.v16.0.6+5.armv7l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/a140cfd33720a4d4c2c91195413f629b +Clang.v16.0.6+5.armv7l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/e2488d556a3a9c1967f6eb026fd796ce3dfa2c7b76aeb61e32901c6081a314b3781b388d00db797af08af8bd74c90d3e3de1bd85a80450f5a0a3e7cc413e993f +Clang.v16.0.6+5.armv7l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/md5/0ef374100354a81d7f78160eedaf0f4f +Clang.v16.0.6+5.armv7l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/sha512/cbe69496d44f6d0416624094b815d1a0f4cf49aeb1dbf3542497e017d265f72b6609d0d3f7f3a2d756dab6ed4aab3d75144e34255ec8e12a1d03116dfc572123 +Clang.v16.0.6+5.armv7l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/41d9445d1c35bed5f934187bc450cd76 +Clang.v16.0.6+5.armv7l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/d049ea262f7738bb210378ea736a2395e1905922ceb0e363e3806522f89b730c79f5a928c2445469320e7fc30358b93877e7788e8cce686a0a2ff0c1504e44a6 +Clang.v16.0.6+5.armv7l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/md5/f4d5f08bfe22e34e3c6baa547a0e9efe +Clang.v16.0.6+5.armv7l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/sha512/4926a6deffc8e229463de5651bfdcb133b21f0eaa1c1575a012b49e613316de842a2f02d85fa9a21721eae16bba8893a42cf2ee4218d82617e9cf47e8ecc6ecf +Clang.v16.0.6+5.armv7l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/47156ebb94d690cc07614224fbb6b822 +Clang.v16.0.6+5.armv7l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/38f78c8d15d771f61fcc632526167f9d0c9e3d6d516f37ad6519e2f90441dd5395af2bddeba2fc4ea02a24c282024e3457efd982aa15d9e0cf9b0da678480d24 +Clang.v16.0.6+5.armv7l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/md5/e1d783d16dfc064048a891cb37447306 +Clang.v16.0.6+5.armv7l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/sha512/55cf1c742515f09b8257bc86d975025637aa811d646b99ddb2d1392a691d170ca30e997a9338695eb240b1e7c0d74a4042304fe5c3fb764749b2ec534086211b +Clang.v16.0.6+5.i686-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/991404cf95a7a685d157dc2fb1b5fcb5 +Clang.v16.0.6+5.i686-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/dd88acb9f7eed91d2bdf1cf9c908b15e30f1859bbbdda3bd71ca980a960d974bf8570f9fb17b081d53e7808beff916d9143cf803b4604bc44f9494952b557a0c +Clang.v16.0.6+5.i686-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/5bd3b71fc67441a6b8f951f3fe705876 +Clang.v16.0.6+5.i686-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/e08d826835e47c24b405497e2d350b86007a535d876ac3f79bdd032d70b1342316f44fe82afccb6f744cb6f5ea6f8115b114328dfcf17959a20336ed29febd21 +Clang.v16.0.6+5.i686-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/eef4665c24c4e15f3373acc857cf94b8 +Clang.v16.0.6+5.i686-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/94898df1ff8e1cbd312ac068cba10441eb0c24fb32f0aa71a4553fd40ad4ed02eae247f30eae93d77088af487ab5d83620192e8e013cd7a49684d576a31f9f1f +Clang.v16.0.6+5.i686-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/6b8cf0008ff33abd61a6b5c44bc0546c +Clang.v16.0.6+5.i686-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/4d0b4639e1bf74c4282c291183ca8493b5f11efa85efd7499e4c1da367086ca3a27be5596255307adb049a5fba39fd285e03316d5f772624a0646c451d55116b +Clang.v16.0.6+5.i686-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/md5/5fa65469e652c80b0db6b4c6be0674f6 +Clang.v16.0.6+5.i686-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/sha512/abe9e5f4d554e282b88a93b82db8810ad356c842a776fe8bd11f603d2b4ffb35aa048416413b20bf00a559b1ca7a25943ee5aecd0a98c62a0bfa9a01dfcf09af +Clang.v16.0.6+5.i686-w64-mingw32-cxx03-llvm_version+16.tar.gz/md5/cc3a64834cdca7c3d6b7d4a302bc8d67 +Clang.v16.0.6+5.i686-w64-mingw32-cxx03-llvm_version+16.tar.gz/sha512/e3514509705b80db2f2be1567e2df01911c440ff134513df4f554e8fe83216c614b7eb68a420f3ce734053158d158cc600708538cd7c3050ffd12e892e8ed697 +Clang.v16.0.6+5.i686-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/md5/51abe7a0a735858bc2b21afb4ec70771 +Clang.v16.0.6+5.i686-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/sha512/acc56bf7345a859c7d38d889dff9a351610f3357682bafdc9025072fa33de75455c91478e14102db388f51452f0ad193d73e6ef3287c741dc3dea4131dba4b60 +Clang.v16.0.6+5.i686-w64-mingw32-cxx11-llvm_version+16.tar.gz/md5/4de50238873e88db72c0a4df927a4401 +Clang.v16.0.6+5.i686-w64-mingw32-cxx11-llvm_version+16.tar.gz/sha512/35e271415dc71cd9cfd27d55a9cb03b97044097f8da163bd18a08f56a4707f240b84118343275468bfe884f33d80ba5748088f726d1ed66d6a507f695b60925b +Clang.v16.0.6+5.powerpc64le-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/321f01397280d9f3fc0d8f1bf9fced99 +Clang.v16.0.6+5.powerpc64le-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/d15f117ffa97c4abc45f48c87123e44f18ca98cd8839bfe3e699a67f963f178735b327d5f4906470b670ef2002ef4dd93e776c02922c0550ecd7ce33cc907372 +Clang.v16.0.6+5.powerpc64le-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/adbb7dc4c9631baebe1dc0dc11c997fe +Clang.v16.0.6+5.powerpc64le-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/41658a01208b9efdf9fd8989be5d15954edfe1c2b220630b320c11fe2ea72eaa624c1cbcb23fde1fd640540405da2227aa5ba49115be0eb0659fd5e777ba46d7 +Clang.v16.0.6+5.powerpc64le-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/a6f5321c08231b128f59c0c0efe3aea0 +Clang.v16.0.6+5.powerpc64le-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/dd9193ec0f229350648495913e22629f185b2afe112038bc1355e492ba8d2abca6860da7bfe8f7135801b8779561457a5f8c6c201e9d9d65d4f0acca93049a87 +Clang.v16.0.6+5.powerpc64le-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/815418e57097b7cb608c1413e45d40dd +Clang.v16.0.6+5.powerpc64le-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/103238241b4a75b390796302d75ca38b7fd34341809b365f3b9b17aef63edec757f98447c5f349752a6ce1119c0ae2ec24008ddf1773e1f99ef1fd573fe55789 +Clang.v16.0.6+5.x86_64-apple-darwin-llvm_version+16.asserts.tar.gz/md5/8e022f5d451d67154f45dffdf18af70d +Clang.v16.0.6+5.x86_64-apple-darwin-llvm_version+16.asserts.tar.gz/sha512/c27c76c5520af465f8039837ed48f964c6154a0c9ec0dbd951161e2200856c60b4deca39a4c2002a12696510ddff9a7f78c828578b5ef055f42b7b25a45ae30b +Clang.v16.0.6+5.x86_64-apple-darwin-llvm_version+16.tar.gz/md5/4c618c131e0ad4c48e03842d62878a53 +Clang.v16.0.6+5.x86_64-apple-darwin-llvm_version+16.tar.gz/sha512/1f42efdac7cb18105fdb72d4bb33767bd2107520f185182707d419bd144a0a6ec099bda697a357f315130e468557758ebd7e72a8d4af3ec4ea03cea09f95c99e +Clang.v16.0.6+5.x86_64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/7cb976f5d756bfd5fd829eac38735c5e +Clang.v16.0.6+5.x86_64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/25cdea63048471ed45fa75555dc01bdc0984c4e3745aa23546321e5e7f064255b0b8d8f9ce79d52c632c3f499acc6581e496b7e77c5be4b3c6417fc19ae21011 +Clang.v16.0.6+5.x86_64-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/dcb60200049cc185d4b078f1fdab244c +Clang.v16.0.6+5.x86_64-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/2a729a82eca30eda99778c992315e620d81df4d6ebb96fe57fb78f19b8718e8965d449a11cfa9cd4db115f952fc36e2d948a5b9a38421d107622c24fbe7bc5df +Clang.v16.0.6+5.x86_64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/76182bb590d61f92b3a9cbd163403aef +Clang.v16.0.6+5.x86_64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/b3d7b0189725916a7d2b6a33347e5b77dda3446a263c6b71debe5787aac5ecb5475f319920dcfe01c5c317f5c8726ae6dbb57ff36ea5bce5fb060110bb6a69d5 +Clang.v16.0.6+5.x86_64-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/bb1577c3448919fd190dcaea0e0b11cf +Clang.v16.0.6+5.x86_64-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/1c6b16f2ef954bec3db2a581dc7898c97e7c2b8902b97ead4a88f7e97f2040ec0ce44d86dc217f8ad7593bb39ee78ae77f415f858669a46fff08c81f164502de +Clang.v16.0.6+5.x86_64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/md5/e0a86e11d40a9d2912cf7ed5bf979e93 +Clang.v16.0.6+5.x86_64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/sha512/35fa54e339f15a0777a585313229d95c9a86f4b40b713993ed1f36e66ad912e2ee3c03a8c2607d1936e2935296d33d395c624a4413952a44de335fde43d40898 +Clang.v16.0.6+5.x86_64-linux-musl-cxx03-llvm_version+16.tar.gz/md5/c647039a1c55140ef63a1361cc270636 +Clang.v16.0.6+5.x86_64-linux-musl-cxx03-llvm_version+16.tar.gz/sha512/4e1900993fcbc4c139e20b516563c6abf85d95d4672e247fb59929d21188885e4a9d51b2977635f0aa14ebe11ec8bf9fe9a1a97058f4d8203036eafb2a8571cf +Clang.v16.0.6+5.x86_64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/md5/6885729c0db819c27871575dda3d420f +Clang.v16.0.6+5.x86_64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/sha512/ac18d5c4018f3cd7cbc3509dc48a7cc7ef8a4c2fa21283e0c89aedf51e25e71d27c4aaf54c97e1769eca73b93d62847c56b7d28afada35574a5c1f0d66cef667 +Clang.v16.0.6+5.x86_64-linux-musl-cxx11-llvm_version+16.tar.gz/md5/0dc0189a91a5f13163904b9d6962d798 +Clang.v16.0.6+5.x86_64-linux-musl-cxx11-llvm_version+16.tar.gz/sha512/09a5ec84f6c6945c3f734f0fa62984e3abe7a3b06f912c172e3457a3c7aeba3f3203f2582e46cd1dc92cfd48c0002515cdb1221add8bbd5f370f2b96f833116d +Clang.v16.0.6+5.x86_64-unknown-freebsd-llvm_version+16.asserts.tar.gz/md5/3bcdc781f9f2a2dfc00d724f20738dc9 +Clang.v16.0.6+5.x86_64-unknown-freebsd-llvm_version+16.asserts.tar.gz/sha512/a12fca76610b49839b734b3f216c8bcda7ce0a001efc39a867ca6e6cfc7036d6cd26d7d8e5105afa0676150896210469a5fd1f1a6f439c28ba55e5b2a5feeabf +Clang.v16.0.6+5.x86_64-unknown-freebsd-llvm_version+16.tar.gz/md5/0b03810477c2594cf6b8b8fae0f1e4d4 +Clang.v16.0.6+5.x86_64-unknown-freebsd-llvm_version+16.tar.gz/sha512/eb66843e04beb48c8e8d34e36694e812f38bc79f6d5045a49eaeffe17553c4a7cad2f98239aa966d8a1dda94214e5290f5e69b64e5be6e0c7055db7a71082614 +Clang.v16.0.6+5.x86_64-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/md5/2aa905ac6dbc98453b875b919c01acf2 +Clang.v16.0.6+5.x86_64-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/sha512/4bf73b4ad4e47f3fad3a876db2acc35a0405d6bf861d14de088dff061a0db6565e3e7aef131361ee923c75e6207c9b5b8c8a29c80d43720b637e340d26af2e74 +Clang.v16.0.6+5.x86_64-w64-mingw32-cxx03-llvm_version+16.tar.gz/md5/f04ddf88ad84fb4ed11537efc095270d +Clang.v16.0.6+5.x86_64-w64-mingw32-cxx03-llvm_version+16.tar.gz/sha512/5d59175e63ef63abc0b8a5b702178eb39dfd0c3b5b827ed84b6c0e9738bad43748c7fab8ba66a1381f8e474e4edd56d8bcc7bc3faf39fa6ea95fc0c297d33ccd +Clang.v16.0.6+5.x86_64-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/md5/37776b1815b67037c63a5fec7b0eae0f +Clang.v16.0.6+5.x86_64-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/sha512/4b27e36febe54451bd58b934ce47e11039e68f5fd888a61e3c6891208137ec928ed93d7c024e5be6f92adc3d4d7b90881ae63ba17c5c3fbe3b57bfa5258d478a +Clang.v16.0.6+5.x86_64-w64-mingw32-cxx11-llvm_version+16.tar.gz/md5/c4ac58305270560a52f64b0e01de3d93 +Clang.v16.0.6+5.x86_64-w64-mingw32-cxx11-llvm_version+16.tar.gz/sha512/2e74777625d4e33bc0fe983a44a79983437820bdd9d018874e1ae944cc49c9694f1b851a2dca6bf3dfce0c1d76ad37910d7b3bf86293c3592b01bf5a29896b77 diff --git a/deps/checksums/lld b/deps/checksums/lld index c703c2c2d041f..3f0d5de515917 100644 --- a/deps/checksums/lld +++ b/deps/checksums/lld @@ -1,108 +1,106 @@ -LLD.v16.0.6+4.aarch64-apple-darwin-llvm_version+16.asserts.tar.gz/md5/0e1fb589a6f0d95c4952c141fcc6edca -LLD.v16.0.6+4.aarch64-apple-darwin-llvm_version+16.asserts.tar.gz/sha512/f6f3bf38d9263c26f25191fbf8ac867167afdb700055f5fe34a06a1759fe2fb39a716760839d91e55a8149ff96a0821386aae8e5e0d4953e8a4cf9e7e627c4eb -LLD.v16.0.6+4.aarch64-apple-darwin-llvm_version+16.tar.gz/md5/4526e34074b99a330b0bd1cf2f1bbab7 -LLD.v16.0.6+4.aarch64-apple-darwin-llvm_version+16.tar.gz/sha512/24ce4daf534084bb20f123bfe6c85cd2f706f552262d831de34dd393d1466e8cd905812f9f1dbfeb394401508240a66a397c006cc7bb067d6a6baf73dee168ee -LLD.v16.0.6+4.aarch64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/ad127f66681d145045e47076d8d8e962 -LLD.v16.0.6+4.aarch64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/b63aec7e18f3c92b9f098779fe04f2bde454f981b2d39ac688ed6bb5ed9f1d78a00f8f5607bcf57bfa2b7c7e85f02ed405802642c9567acbc64a3dc5a430f226 -LLD.v16.0.6+4.aarch64-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/83945b3b814c496fbb0d7351877a0fb1 -LLD.v16.0.6+4.aarch64-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/3243f222dfc7dca9878606caf1593b5776c6066ffac25a195b9624b532fd5cdf5576faccb26db802c36f2d9bc3c84cfc62a83c77449d0056e190af1ccd0239bb -LLD.v16.0.6+4.aarch64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/aa335fce63e6cbcc7018c56d7ef16a78 -LLD.v16.0.6+4.aarch64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/8d82a46d9f2e428a745687bff5b183bf91b1850c1e815aac56209c5a8817dbdc8d26fd0012917b5a14476ad8ec6ac450e01238da9024637b76be2899a1ca04ff -LLD.v16.0.6+4.aarch64-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/56cc8663e0390eda08d05a491a172c71 -LLD.v16.0.6+4.aarch64-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/dc056292c94b2a0619eb49f94521912c5f3cfbb9cb00bbd7b701a8c6a172e50dcbee719bdb43622a0c8fb32404d742efb416dea6922a3799af9ca7dda0400fa6 -LLD.v16.0.6+4.aarch64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/md5/19f4bddcbb68108301580a16b4cef32f -LLD.v16.0.6+4.aarch64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/sha512/1694c0d7cc63680f7c04b22a5d842acf3f48568e682a1a7acf29529ffe9d6ca027c33f9ae5cf4cdb1b703d28f30a654bd1f4e0586eee49ddf64bfb40c8a9206c -LLD.v16.0.6+4.aarch64-linux-musl-cxx03-llvm_version+16.tar.gz/md5/eedfa092b0f4a2867cdb5bd4102a27d9 -LLD.v16.0.6+4.aarch64-linux-musl-cxx03-llvm_version+16.tar.gz/sha512/dd895f9c5d4c76186c7d2172f56e1052f2b8926466fd0deb725683ab4d98b85b695b7d571f076bc6eda679747946ffa380e1c23f497ed8cf1fdbde89132ec653 -LLD.v16.0.6+4.aarch64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/md5/d46f65ed03a071779bd5277040905721 -LLD.v16.0.6+4.aarch64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/sha512/1b3bf0d64ab0481b11f6776a249c252622b23f125eaef733dec4473ced554ba6b876632c0e4855d0f93a9e4eab06cbbfff8fe568661f569a08263543d8ccd930 -LLD.v16.0.6+4.aarch64-linux-musl-cxx11-llvm_version+16.tar.gz/md5/05ae31c675789b5b87bf800e971e8886 -LLD.v16.0.6+4.aarch64-linux-musl-cxx11-llvm_version+16.tar.gz/sha512/02342bb5a5c78f7c876bb75dd0c9b7140b4e41878203469a573c190baa2be82ce64101bffb93524b24444a69e15fa6eabda8f7f006e934595e52c97d4865faa9 -LLD.v16.0.6+4.armv6l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/46ecafa64b02b6a72cbf33000728e023 -LLD.v16.0.6+4.armv6l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/72df77be62ede0737f2c9bbf58fe617ce8358ce3f08e3d3b9fbf8aa29c0ab4db4eb49e426fa43156d05f9f8c83b974594026029e67bf8a8fddf6ab33b1c2126b -LLD.v16.0.6+4.armv6l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/md5/ea36fa4169f9862db75bb1ff19b45645 -LLD.v16.0.6+4.armv6l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/sha512/7795affc068e64a5c3b68e9d0a773d21acec68eb2a4fb28c791938c993d0f0f8e9b1ce8b16cab3f25a48c2d7b8097449831f2e6340af4b47c59f9c35636e23b6 -LLD.v16.0.6+4.armv6l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/ba2e078e52583ff43f3b840e3a144726 -LLD.v16.0.6+4.armv6l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/0af8ea82206204ed515bb6c222d2b51a16b360858a1a4c9db7b3749cab79e08a9b0a91b54b389a19f0b40586d0f0ab3665fd2df415a90aa401728d592c9a5716 -LLD.v16.0.6+4.armv6l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/md5/4f6c8a05367f8e70f6247f667737bc79 -LLD.v16.0.6+4.armv6l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/sha512/f5ddaa2c14dd6fe85456701d60f279bbb30f2d9c63948ec3212a2fe15670be11ca8db815c914cdd069cdc469e3ad37d848220c7d5e1feff5ab6913a94be22d17 -LLD.v16.0.6+4.armv6l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/758f27b74dea4231ca5ad4bb1eb812f8 -LLD.v16.0.6+4.armv6l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/6f378dc8ab2a4b0f59a8107ddf6ef10ececdb03d616b6ba1741dc9ad0b7d96a8d506b45b1f3129c6f58b9ad8b3f97d300cea246c6687bedbe2b2abaec5738e95 -LLD.v16.0.6+4.armv6l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/md5/7491cd8edcbd4933e0e897b2378e4f96 -LLD.v16.0.6+4.armv6l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/sha512/ebfda1800a564de252c1e0bfa8ba505589cb15a137a731df927449714379c64478d51d08f973f59d29274eac66a205dfcb96d809b4ac431e4618d68068ff02c7 -LLD.v16.0.6+4.armv6l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/23303f8b1baa11890f92ce44a1210706 -LLD.v16.0.6+4.armv6l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/45f5f696f0b4cdd3491c8601d24576628ac9ddea992ed0ea969d38389f50b547835b2b74b7df0b3710b8b1048ee11665c9dc40f6ba71aca428dffc81ce716b11 -LLD.v16.0.6+4.armv6l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/md5/d46db7e7e1c7aded195d6eedb280f21b -LLD.v16.0.6+4.armv6l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/sha512/8cc4958e9cd55ce3180b17fe171446fe222ce38c76778e77a34998eeb3f3fea3de09fb2590c2f4c2a1015575c1f5e1a37356695ccba0041f8381a2e4389563a3 -LLD.v16.0.6+4.armv7l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/6892dea9c18297dfe41710092abb1d01 -LLD.v16.0.6+4.armv7l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/c7841b05942dc5edef6002e02452651d74e85ae4f8b575505e9955949efb47ccb8447a9157b52c88686c4334842fecf415912e228c58a2632002a4d1e72af0b8 -LLD.v16.0.6+4.armv7l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/md5/35525045309d318400241205333f366f -LLD.v16.0.6+4.armv7l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/sha512/a7176919817fd94c0ea39c4efd53f494958441a53c5ca18e0932f77b66a5a5aa7b2b4801ff776deb45161b6e099b5b626a83eab5258e9648307c8010b2baac09 -LLD.v16.0.6+4.armv7l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/087b8f9b88ddfd488e196d6e1b966e45 -LLD.v16.0.6+4.armv7l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/68cef6e1f29d18e92ae70cf9c6c4e21c96b4ab86993f58f7addff16281debd50051dad828bf18b2ebe297d03ea1efe16b8fec3daf9f8cc33dd6124e77db28134 -LLD.v16.0.6+4.armv7l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/md5/5594492322eba79eea3141e29a71fc28 -LLD.v16.0.6+4.armv7l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/sha512/3745179518285c1e30ec4c554c6ecb630943985796e62713d85de79ff0d4585d790bdcd1d2ba50ad12333671e7bf45dcea09f7cdf84bbb25440348203f4f512e -LLD.v16.0.6+4.armv7l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/c751963cf072766374881f79cc5de719 -LLD.v16.0.6+4.armv7l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/22d351e65de75276969c1bd9f78f8873878ac21035311fc138bb399c250e45d3c689bda1d13b00f0a1c1a93afe90292be749a0184acfba5bf2a17a2f9aab0c60 -LLD.v16.0.6+4.armv7l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/md5/03fd8f5ec6894645206d1e8e1f2939ce -LLD.v16.0.6+4.armv7l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/sha512/025a12586a3370d1e604daecb5eaaf6b3300fa8c57d68fb09cc39e0fa5c353160be2c1493fcbbc7df28a6c345c46731d77422a282cef7b8a90d0df12739326fc -LLD.v16.0.6+4.armv7l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/5ff5a4efb63282ba6e08663070c030e3 -LLD.v16.0.6+4.armv7l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/16bc7d275079d10ba197910bd194edd4d67ba29bb8d86b110cf71658b10abef83c9ff37d5ee366a015302966382705f79c77c810ef9e37e8ab25c3e5be09c78e -LLD.v16.0.6+4.armv7l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/md5/e92652c998ce524305d1af766f12b273 -LLD.v16.0.6+4.armv7l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/sha512/a451ee76668601477459a474265d390a777a7a985ef976fa430766369d378ec71c32fcdcc8f99066fb6fcec8c56fa0154126d9f2d03d4d19b393508f8e0641d1 -LLD.v16.0.6+4.i686-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/ed523fd79f3f2b42d1f8e752346906bd -LLD.v16.0.6+4.i686-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/34053f32db29857315eee9dfcae9067bfd517c42e761ee3e56218a9439725955a673756eb593ab2aec3d0b1eabadf0e4011f4a72fd1e14938a6bed0cd6592cf3 -LLD.v16.0.6+4.i686-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/6c6f042e199db6e7fcb6fc9d877e9d4e -LLD.v16.0.6+4.i686-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/b884c46cd26b9312a7e07e3684806a42263635dd63c3127be7ea8c0ad3c76c7de4fe089da73f58306d65689116c7e83de73fb06533b322ba5eacdcf02241140f -LLD.v16.0.6+4.i686-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/d2516d66916580f58cd2d79bd3372faa -LLD.v16.0.6+4.i686-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/0204064425018cc2b08d0f8bceb5f73f7823f3494b9200fce64de600c653cd28f9b65634a45d50e9fa1ba5b19d2182d3f599425e69ee38dd08effe065e5db2fc -LLD.v16.0.6+4.i686-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/5f27602a98ef1a642fd1cf49141b92ac -LLD.v16.0.6+4.i686-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/267a0c91b1c9c44fd4bbcad09a7db13c94288368f45763f11796e575eedddf5218a17405eb737647c552c2c62aaa5761ca069f0063bb7aaed9c2c3d82f13f1d0 -LLD.v16.0.6+4.i686-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/md5/07104f4a51ade84b7e2d218cb2e10c5f -LLD.v16.0.6+4.i686-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/sha512/a22de36fcedfdb03f0d73c8bb12a1d4541d76a4b1af5d15c6b6f943b691c26cdb86003581b98d57bdcebf746d901e15c2c2e404fd0569846c7e12107d0280622 -LLD.v16.0.6+4.i686-w64-mingw32-cxx03-llvm_version+16.tar.gz/md5/f0e7f72818dde68f5b0ca858ce1370ba -LLD.v16.0.6+4.i686-w64-mingw32-cxx03-llvm_version+16.tar.gz/sha512/a6d010fcefb5a20cdeb328b2bf259b7c380598b488c00c4cd11dc5b3040457829e31979da0e7529b5a613257af6b95e666bbfa5c0ddd6baf97dccb507ca823f3 -LLD.v16.0.6+4.i686-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/md5/2d81caa1f5e04e1b99d1e64c204ecf3a -LLD.v16.0.6+4.i686-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/sha512/bcd5d9442aeaab69390b36f5c3be112dcf753fe57c9bbc36cfec35a7e17151860c421bd5bb30846fb4d4eb690b5de1d85f589c4f1b951e50838fbb2a2216fc97 -LLD.v16.0.6+4.i686-w64-mingw32-cxx11-llvm_version+16.tar.gz/md5/eda482cc028138e1a3999a637abe8a25 -LLD.v16.0.6+4.i686-w64-mingw32-cxx11-llvm_version+16.tar.gz/sha512/19cbb8fdf828f3f38a91c8e33c4c29bf21901fb344020e03903591c13c22fe4093bf0c78a07288d1edbfe2e4a7044510125ca5007f6eb0e9da506bc72240501a -LLD.v16.0.6+4.powerpc64le-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/cbbe928d4453ad9b2ef7852a79a77be3 -LLD.v16.0.6+4.powerpc64le-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/31e85d5d253ea24740ff0f1b784a4eb425fa8a39e5c816f7d62eaa8fa68b38cdf4d4dbcf25136bf4aeacd35600ebce52aca535251af64c41709b9993162aa97e -LLD.v16.0.6+4.powerpc64le-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/9ff5f80c86c0ac582af93811d51237cc -LLD.v16.0.6+4.powerpc64le-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/ad97304983ff2b5307ca9dc41d642bc5fb20be47f93629b92d977fa6f9b989f7234360c9b8cae07f8bdc800fc3b3f9b9970f15bc2b552dbb62072a12e7e716d3 -LLD.v16.0.6+4.powerpc64le-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/f3d9c3944080a14bbb728e672958f9b6 -LLD.v16.0.6+4.powerpc64le-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/c741c0f11212773eb8a98b43ecdd67a86ca58afba5c1a35055f96ee688f2d1b7d7ebdaa7532131497b3b943f22c4985eaa9330b7efbc7f663b230f65ab80e2ac -LLD.v16.0.6+4.powerpc64le-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/99a5bd1365d968249130a0823e29cae9 -LLD.v16.0.6+4.powerpc64le-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/018f80627982006ae5ee21251929a57e9cd69fbb575ab47a831a889f8b87769357144385ddd575a7943c11221bd5c59e02fd7ba861c4bb40940531dae8735c8a -LLD.v16.0.6+4.x86_64-apple-darwin-llvm_version+16.asserts.tar.gz/md5/063171318971a85982d02b597c1ecbca -LLD.v16.0.6+4.x86_64-apple-darwin-llvm_version+16.asserts.tar.gz/sha512/4bdeddbe74994aeccb8a24fe0255271fbb453e1e06daf2f34389770fd9b5ed71c88e50833ffcb44a052b886c8aaf38dcc5b90ee590d85a8479fc574cfaf142c9 -LLD.v16.0.6+4.x86_64-apple-darwin-llvm_version+16.tar.gz/md5/5bb545b987ab4ef00b7d04fa70c493a9 -LLD.v16.0.6+4.x86_64-apple-darwin-llvm_version+16.tar.gz/sha512/5adeebca1e5923c0121117f5cc08eaef3c798212c22b929019ada92fe545401a27ebabad6680470a720cc9a9d2421cb1cb24c4e524ee4b6d9e6cc453f78f2bcc -LLD.v16.0.6+4.x86_64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/c9508e437190c2448a0561905910c92b -LLD.v16.0.6+4.x86_64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/a07a4dd7ea2bf59cc3afeabc488fe1b8f729cd8eb6572421b94693c6efd8e7163113aa5d392767e4eec9083fe6e667240dfbe49ea7de9f1ac7051ab478af5435 -LLD.v16.0.6+4.x86_64-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/ea8ab6c04ddefdaec0a1273db6f20700 -LLD.v16.0.6+4.x86_64-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/c2ec35d58a115796aecdc37f967539d70138af22ea738b7e28d7427cc556a4729bd57e8971189e3291d5c739b4f55f4607680125bb9dbb6a8289185a1464c126 -LLD.v16.0.6+4.x86_64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/6747ca50400f608985d8e571c876b2a5 -LLD.v16.0.6+4.x86_64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/3df9f8a361290f7a78cc20588cccbb22dd2eda1d9709568eb468008a345594270fd7df6c5c7b22bb5bd6c8338fccb508b7ec1b7e1dd855092bac2b25a954c3c5 -LLD.v16.0.6+4.x86_64-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/38171d910690cebc8e6caf53ccae16dc -LLD.v16.0.6+4.x86_64-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/d6073f4cdfa7b291ce7cff44d4978b0258c0a81f95e563f9db9fa946be64e7611cc164859aeed55929b174fd9536bbc213a41605c12cbafc1cff91c38c9cc26b -LLD.v16.0.6+4.x86_64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/md5/7f8f893ae41c0bb12c84f60d6c9e9dc6 -LLD.v16.0.6+4.x86_64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/sha512/0a80b6e351f4efe79796fec98adfaca0b206783b38333056d35be1d6077a09b6fb00ea0e33daf3bec9261b31b1c024d545e5047507567caa925c9abd52660ff6 -LLD.v16.0.6+4.x86_64-linux-musl-cxx03-llvm_version+16.tar.gz/md5/7a7db99f2d12c8b73eda81d06116bebb -LLD.v16.0.6+4.x86_64-linux-musl-cxx03-llvm_version+16.tar.gz/sha512/09e99cd7cb0200296c6efc313be2c36635ac490f5d4100c62e830dfb40d5064d38430435ea9df7e49dcb1490f4d31fbbaaf706f21eebc0e3c78765db7e376ded -LLD.v16.0.6+4.x86_64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/md5/674055d6ff38ba166f9721647841fcbf -LLD.v16.0.6+4.x86_64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/sha512/5ff89cceff288ca9df2ba35a8acc08e75204c200a2204c6d5f2ffadadd1440c18398ed70c4f6a0133cb58fcdd5d95e4f67f03ce4faa4661c9d9e4965b1c9b38e -LLD.v16.0.6+4.x86_64-linux-musl-cxx11-llvm_version+16.tar.gz/md5/a30fbc6a5fa69f879d04e47a94e0b07d -LLD.v16.0.6+4.x86_64-linux-musl-cxx11-llvm_version+16.tar.gz/sha512/394db6aed33be75b7783aa0c1f98b678f0f96cb16946dadd1c143cd4b0378707d37fd0b35a4a9687de91ea293635142e9c433befe9be7fc2899612d48b94ae8f -LLD.v16.0.6+4.x86_64-unknown-freebsd-llvm_version+16.asserts.tar.gz/md5/ff14d881b50746ff4be6642233091bc4 -LLD.v16.0.6+4.x86_64-unknown-freebsd-llvm_version+16.asserts.tar.gz/sha512/6918a29cabcf3d4fa598cfc8390e534be63c049f8c69157629a0e02488f09b461fcf7cab5e0678b38b4c5be6d80a45a70b434889a7d1740100edadd3a32dbcb9 -LLD.v16.0.6+4.x86_64-unknown-freebsd-llvm_version+16.tar.gz/md5/2ec3ef1bea40aa16de080605f082b616 -LLD.v16.0.6+4.x86_64-unknown-freebsd-llvm_version+16.tar.gz/sha512/1d69b07dd179b1e146c4df8879beadd26ac5ba2c1fe0052bd5c40f0788f274c9c2e4e53a53703d95298fa889d2470197411c867247284de48834e7440a0c7977 -LLD.v16.0.6+4.x86_64-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/md5/21e359427a484e7876f4b9d9145b0273 -LLD.v16.0.6+4.x86_64-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/sha512/d1da7c1740f1c7ac07247b554f7cc76a64aa03200b44e41d1a10d66458caaa466099eb82d8d33327ec77eb784a5be91454c17d20c2fbefe049a128a2bf0956f5 -LLD.v16.0.6+4.x86_64-w64-mingw32-cxx03-llvm_version+16.tar.gz/md5/f2975d69c12e91660a84df715f971130 -LLD.v16.0.6+4.x86_64-w64-mingw32-cxx03-llvm_version+16.tar.gz/sha512/8fe4bfd7c692c66d871f2f0c67a8450076d7639addd2874cf6068427462a8656da96fe7c91bc93e5f0cb016ee3908e1b70c5212311f65ca7f0dc64f1f921e2ef -LLD.v16.0.6+4.x86_64-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/md5/1e9103f812fe163e2fc6c868da4fd9ba -LLD.v16.0.6+4.x86_64-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/sha512/e75bbedd72cb5f0337dac014d78d1276992a6f1d6c8832d16bd58ef83b2cd8602d023b45e1235e96ccdd13300e4b67c28f0a17cc0b9ff1ccb89263105a9a66db -LLD.v16.0.6+4.x86_64-w64-mingw32-cxx11-llvm_version+16.tar.gz/md5/b664032e83cddee3d1157f8c670ebe5f -LLD.v16.0.6+4.x86_64-w64-mingw32-cxx11-llvm_version+16.tar.gz/sha512/d7c36b0aa74b5d36446bb0aab413e4e12f042532d15e55eb79a807efabb93e590538cfedf7e3a6abe33da3f2326d631c2a041da2e00dc4051934fed17aed0c4e +LLD.v16.0.6+5.aarch64-apple-darwin-llvm_version+16.tar.gz/md5/4526e34074b99a330b0bd1cf2f1bbab7 +LLD.v16.0.6+5.aarch64-apple-darwin-llvm_version+16.tar.gz/sha512/24ce4daf534084bb20f123bfe6c85cd2f706f552262d831de34dd393d1466e8cd905812f9f1dbfeb394401508240a66a397c006cc7bb067d6a6baf73dee168ee +LLD.v16.0.6+5.aarch64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/ad127f66681d145045e47076d8d8e962 +LLD.v16.0.6+5.aarch64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/b63aec7e18f3c92b9f098779fe04f2bde454f981b2d39ac688ed6bb5ed9f1d78a00f8f5607bcf57bfa2b7c7e85f02ed405802642c9567acbc64a3dc5a430f226 +LLD.v16.0.6+5.aarch64-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/83945b3b814c496fbb0d7351877a0fb1 +LLD.v16.0.6+5.aarch64-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/3243f222dfc7dca9878606caf1593b5776c6066ffac25a195b9624b532fd5cdf5576faccb26db802c36f2d9bc3c84cfc62a83c77449d0056e190af1ccd0239bb +LLD.v16.0.6+5.aarch64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/aa335fce63e6cbcc7018c56d7ef16a78 +LLD.v16.0.6+5.aarch64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/8d82a46d9f2e428a745687bff5b183bf91b1850c1e815aac56209c5a8817dbdc8d26fd0012917b5a14476ad8ec6ac450e01238da9024637b76be2899a1ca04ff +LLD.v16.0.6+5.aarch64-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/56cc8663e0390eda08d05a491a172c71 +LLD.v16.0.6+5.aarch64-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/dc056292c94b2a0619eb49f94521912c5f3cfbb9cb00bbd7b701a8c6a172e50dcbee719bdb43622a0c8fb32404d742efb416dea6922a3799af9ca7dda0400fa6 +LLD.v16.0.6+5.aarch64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/md5/19f4bddcbb68108301580a16b4cef32f +LLD.v16.0.6+5.aarch64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/sha512/1694c0d7cc63680f7c04b22a5d842acf3f48568e682a1a7acf29529ffe9d6ca027c33f9ae5cf4cdb1b703d28f30a654bd1f4e0586eee49ddf64bfb40c8a9206c +LLD.v16.0.6+5.aarch64-linux-musl-cxx03-llvm_version+16.tar.gz/md5/eedfa092b0f4a2867cdb5bd4102a27d9 +LLD.v16.0.6+5.aarch64-linux-musl-cxx03-llvm_version+16.tar.gz/sha512/dd895f9c5d4c76186c7d2172f56e1052f2b8926466fd0deb725683ab4d98b85b695b7d571f076bc6eda679747946ffa380e1c23f497ed8cf1fdbde89132ec653 +LLD.v16.0.6+5.aarch64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/md5/d46f65ed03a071779bd5277040905721 +LLD.v16.0.6+5.aarch64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/sha512/1b3bf0d64ab0481b11f6776a249c252622b23f125eaef733dec4473ced554ba6b876632c0e4855d0f93a9e4eab06cbbfff8fe568661f569a08263543d8ccd930 +LLD.v16.0.6+5.aarch64-linux-musl-cxx11-llvm_version+16.tar.gz/md5/05ae31c675789b5b87bf800e971e8886 +LLD.v16.0.6+5.aarch64-linux-musl-cxx11-llvm_version+16.tar.gz/sha512/02342bb5a5c78f7c876bb75dd0c9b7140b4e41878203469a573c190baa2be82ce64101bffb93524b24444a69e15fa6eabda8f7f006e934595e52c97d4865faa9 +LLD.v16.0.6+5.armv6l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/46ecafa64b02b6a72cbf33000728e023 +LLD.v16.0.6+5.armv6l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/72df77be62ede0737f2c9bbf58fe617ce8358ce3f08e3d3b9fbf8aa29c0ab4db4eb49e426fa43156d05f9f8c83b974594026029e67bf8a8fddf6ab33b1c2126b +LLD.v16.0.6+5.armv6l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/md5/ea36fa4169f9862db75bb1ff19b45645 +LLD.v16.0.6+5.armv6l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/sha512/7795affc068e64a5c3b68e9d0a773d21acec68eb2a4fb28c791938c993d0f0f8e9b1ce8b16cab3f25a48c2d7b8097449831f2e6340af4b47c59f9c35636e23b6 +LLD.v16.0.6+5.armv6l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/ba2e078e52583ff43f3b840e3a144726 +LLD.v16.0.6+5.armv6l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/0af8ea82206204ed515bb6c222d2b51a16b360858a1a4c9db7b3749cab79e08a9b0a91b54b389a19f0b40586d0f0ab3665fd2df415a90aa401728d592c9a5716 +LLD.v16.0.6+5.armv6l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/md5/4f6c8a05367f8e70f6247f667737bc79 +LLD.v16.0.6+5.armv6l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/sha512/f5ddaa2c14dd6fe85456701d60f279bbb30f2d9c63948ec3212a2fe15670be11ca8db815c914cdd069cdc469e3ad37d848220c7d5e1feff5ab6913a94be22d17 +LLD.v16.0.6+5.armv6l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/758f27b74dea4231ca5ad4bb1eb812f8 +LLD.v16.0.6+5.armv6l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/6f378dc8ab2a4b0f59a8107ddf6ef10ececdb03d616b6ba1741dc9ad0b7d96a8d506b45b1f3129c6f58b9ad8b3f97d300cea246c6687bedbe2b2abaec5738e95 +LLD.v16.0.6+5.armv6l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/md5/7491cd8edcbd4933e0e897b2378e4f96 +LLD.v16.0.6+5.armv6l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/sha512/ebfda1800a564de252c1e0bfa8ba505589cb15a137a731df927449714379c64478d51d08f973f59d29274eac66a205dfcb96d809b4ac431e4618d68068ff02c7 +LLD.v16.0.6+5.armv6l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/23303f8b1baa11890f92ce44a1210706 +LLD.v16.0.6+5.armv6l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/45f5f696f0b4cdd3491c8601d24576628ac9ddea992ed0ea969d38389f50b547835b2b74b7df0b3710b8b1048ee11665c9dc40f6ba71aca428dffc81ce716b11 +LLD.v16.0.6+5.armv6l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/md5/d46db7e7e1c7aded195d6eedb280f21b +LLD.v16.0.6+5.armv6l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/sha512/8cc4958e9cd55ce3180b17fe171446fe222ce38c76778e77a34998eeb3f3fea3de09fb2590c2f4c2a1015575c1f5e1a37356695ccba0041f8381a2e4389563a3 +LLD.v16.0.6+5.armv7l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/6892dea9c18297dfe41710092abb1d01 +LLD.v16.0.6+5.armv7l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/c7841b05942dc5edef6002e02452651d74e85ae4f8b575505e9955949efb47ccb8447a9157b52c88686c4334842fecf415912e228c58a2632002a4d1e72af0b8 +LLD.v16.0.6+5.armv7l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/md5/35525045309d318400241205333f366f +LLD.v16.0.6+5.armv7l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/sha512/a7176919817fd94c0ea39c4efd53f494958441a53c5ca18e0932f77b66a5a5aa7b2b4801ff776deb45161b6e099b5b626a83eab5258e9648307c8010b2baac09 +LLD.v16.0.6+5.armv7l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/087b8f9b88ddfd488e196d6e1b966e45 +LLD.v16.0.6+5.armv7l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/68cef6e1f29d18e92ae70cf9c6c4e21c96b4ab86993f58f7addff16281debd50051dad828bf18b2ebe297d03ea1efe16b8fec3daf9f8cc33dd6124e77db28134 +LLD.v16.0.6+5.armv7l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/md5/5594492322eba79eea3141e29a71fc28 +LLD.v16.0.6+5.armv7l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/sha512/3745179518285c1e30ec4c554c6ecb630943985796e62713d85de79ff0d4585d790bdcd1d2ba50ad12333671e7bf45dcea09f7cdf84bbb25440348203f4f512e +LLD.v16.0.6+5.armv7l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/c751963cf072766374881f79cc5de719 +LLD.v16.0.6+5.armv7l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/22d351e65de75276969c1bd9f78f8873878ac21035311fc138bb399c250e45d3c689bda1d13b00f0a1c1a93afe90292be749a0184acfba5bf2a17a2f9aab0c60 +LLD.v16.0.6+5.armv7l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/md5/03fd8f5ec6894645206d1e8e1f2939ce +LLD.v16.0.6+5.armv7l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/sha512/025a12586a3370d1e604daecb5eaaf6b3300fa8c57d68fb09cc39e0fa5c353160be2c1493fcbbc7df28a6c345c46731d77422a282cef7b8a90d0df12739326fc +LLD.v16.0.6+5.armv7l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/5ff5a4efb63282ba6e08663070c030e3 +LLD.v16.0.6+5.armv7l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/16bc7d275079d10ba197910bd194edd4d67ba29bb8d86b110cf71658b10abef83c9ff37d5ee366a015302966382705f79c77c810ef9e37e8ab25c3e5be09c78e +LLD.v16.0.6+5.armv7l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/md5/e92652c998ce524305d1af766f12b273 +LLD.v16.0.6+5.armv7l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/sha512/a451ee76668601477459a474265d390a777a7a985ef976fa430766369d378ec71c32fcdcc8f99066fb6fcec8c56fa0154126d9f2d03d4d19b393508f8e0641d1 +LLD.v16.0.6+5.i686-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/ed523fd79f3f2b42d1f8e752346906bd +LLD.v16.0.6+5.i686-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/34053f32db29857315eee9dfcae9067bfd517c42e761ee3e56218a9439725955a673756eb593ab2aec3d0b1eabadf0e4011f4a72fd1e14938a6bed0cd6592cf3 +LLD.v16.0.6+5.i686-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/6c6f042e199db6e7fcb6fc9d877e9d4e +LLD.v16.0.6+5.i686-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/b884c46cd26b9312a7e07e3684806a42263635dd63c3127be7ea8c0ad3c76c7de4fe089da73f58306d65689116c7e83de73fb06533b322ba5eacdcf02241140f +LLD.v16.0.6+5.i686-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/d2516d66916580f58cd2d79bd3372faa +LLD.v16.0.6+5.i686-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/0204064425018cc2b08d0f8bceb5f73f7823f3494b9200fce64de600c653cd28f9b65634a45d50e9fa1ba5b19d2182d3f599425e69ee38dd08effe065e5db2fc +LLD.v16.0.6+5.i686-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/5f27602a98ef1a642fd1cf49141b92ac +LLD.v16.0.6+5.i686-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/267a0c91b1c9c44fd4bbcad09a7db13c94288368f45763f11796e575eedddf5218a17405eb737647c552c2c62aaa5761ca069f0063bb7aaed9c2c3d82f13f1d0 +LLD.v16.0.6+5.i686-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/md5/07104f4a51ade84b7e2d218cb2e10c5f +LLD.v16.0.6+5.i686-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/sha512/a22de36fcedfdb03f0d73c8bb12a1d4541d76a4b1af5d15c6b6f943b691c26cdb86003581b98d57bdcebf746d901e15c2c2e404fd0569846c7e12107d0280622 +LLD.v16.0.6+5.i686-w64-mingw32-cxx03-llvm_version+16.tar.gz/md5/f0e7f72818dde68f5b0ca858ce1370ba +LLD.v16.0.6+5.i686-w64-mingw32-cxx03-llvm_version+16.tar.gz/sha512/a6d010fcefb5a20cdeb328b2bf259b7c380598b488c00c4cd11dc5b3040457829e31979da0e7529b5a613257af6b95e666bbfa5c0ddd6baf97dccb507ca823f3 +LLD.v16.0.6+5.i686-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/md5/2d81caa1f5e04e1b99d1e64c204ecf3a +LLD.v16.0.6+5.i686-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/sha512/bcd5d9442aeaab69390b36f5c3be112dcf753fe57c9bbc36cfec35a7e17151860c421bd5bb30846fb4d4eb690b5de1d85f589c4f1b951e50838fbb2a2216fc97 +LLD.v16.0.6+5.i686-w64-mingw32-cxx11-llvm_version+16.tar.gz/md5/eda482cc028138e1a3999a637abe8a25 +LLD.v16.0.6+5.i686-w64-mingw32-cxx11-llvm_version+16.tar.gz/sha512/19cbb8fdf828f3f38a91c8e33c4c29bf21901fb344020e03903591c13c22fe4093bf0c78a07288d1edbfe2e4a7044510125ca5007f6eb0e9da506bc72240501a +LLD.v16.0.6+5.powerpc64le-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/cbbe928d4453ad9b2ef7852a79a77be3 +LLD.v16.0.6+5.powerpc64le-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/31e85d5d253ea24740ff0f1b784a4eb425fa8a39e5c816f7d62eaa8fa68b38cdf4d4dbcf25136bf4aeacd35600ebce52aca535251af64c41709b9993162aa97e +LLD.v16.0.6+5.powerpc64le-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/9ff5f80c86c0ac582af93811d51237cc +LLD.v16.0.6+5.powerpc64le-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/ad97304983ff2b5307ca9dc41d642bc5fb20be47f93629b92d977fa6f9b989f7234360c9b8cae07f8bdc800fc3b3f9b9970f15bc2b552dbb62072a12e7e716d3 +LLD.v16.0.6+5.powerpc64le-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/f3d9c3944080a14bbb728e672958f9b6 +LLD.v16.0.6+5.powerpc64le-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/c741c0f11212773eb8a98b43ecdd67a86ca58afba5c1a35055f96ee688f2d1b7d7ebdaa7532131497b3b943f22c4985eaa9330b7efbc7f663b230f65ab80e2ac +LLD.v16.0.6+5.powerpc64le-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/99a5bd1365d968249130a0823e29cae9 +LLD.v16.0.6+5.powerpc64le-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/018f80627982006ae5ee21251929a57e9cd69fbb575ab47a831a889f8b87769357144385ddd575a7943c11221bd5c59e02fd7ba861c4bb40940531dae8735c8a +LLD.v16.0.6+5.x86_64-apple-darwin-llvm_version+16.asserts.tar.gz/md5/063171318971a85982d02b597c1ecbca +LLD.v16.0.6+5.x86_64-apple-darwin-llvm_version+16.asserts.tar.gz/sha512/4bdeddbe74994aeccb8a24fe0255271fbb453e1e06daf2f34389770fd9b5ed71c88e50833ffcb44a052b886c8aaf38dcc5b90ee590d85a8479fc574cfaf142c9 +LLD.v16.0.6+5.x86_64-apple-darwin-llvm_version+16.tar.gz/md5/5bb545b987ab4ef00b7d04fa70c493a9 +LLD.v16.0.6+5.x86_64-apple-darwin-llvm_version+16.tar.gz/sha512/5adeebca1e5923c0121117f5cc08eaef3c798212c22b929019ada92fe545401a27ebabad6680470a720cc9a9d2421cb1cb24c4e524ee4b6d9e6cc453f78f2bcc +LLD.v16.0.6+5.x86_64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/c9508e437190c2448a0561905910c92b +LLD.v16.0.6+5.x86_64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/a07a4dd7ea2bf59cc3afeabc488fe1b8f729cd8eb6572421b94693c6efd8e7163113aa5d392767e4eec9083fe6e667240dfbe49ea7de9f1ac7051ab478af5435 +LLD.v16.0.6+5.x86_64-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/ea8ab6c04ddefdaec0a1273db6f20700 +LLD.v16.0.6+5.x86_64-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/c2ec35d58a115796aecdc37f967539d70138af22ea738b7e28d7427cc556a4729bd57e8971189e3291d5c739b4f55f4607680125bb9dbb6a8289185a1464c126 +LLD.v16.0.6+5.x86_64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/6747ca50400f608985d8e571c876b2a5 +LLD.v16.0.6+5.x86_64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/3df9f8a361290f7a78cc20588cccbb22dd2eda1d9709568eb468008a345594270fd7df6c5c7b22bb5bd6c8338fccb508b7ec1b7e1dd855092bac2b25a954c3c5 +LLD.v16.0.6+5.x86_64-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/38171d910690cebc8e6caf53ccae16dc +LLD.v16.0.6+5.x86_64-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/d6073f4cdfa7b291ce7cff44d4978b0258c0a81f95e563f9db9fa946be64e7611cc164859aeed55929b174fd9536bbc213a41605c12cbafc1cff91c38c9cc26b +LLD.v16.0.6+5.x86_64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/md5/7f8f893ae41c0bb12c84f60d6c9e9dc6 +LLD.v16.0.6+5.x86_64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/sha512/0a80b6e351f4efe79796fec98adfaca0b206783b38333056d35be1d6077a09b6fb00ea0e33daf3bec9261b31b1c024d545e5047507567caa925c9abd52660ff6 +LLD.v16.0.6+5.x86_64-linux-musl-cxx03-llvm_version+16.tar.gz/md5/7a7db99f2d12c8b73eda81d06116bebb +LLD.v16.0.6+5.x86_64-linux-musl-cxx03-llvm_version+16.tar.gz/sha512/09e99cd7cb0200296c6efc313be2c36635ac490f5d4100c62e830dfb40d5064d38430435ea9df7e49dcb1490f4d31fbbaaf706f21eebc0e3c78765db7e376ded +LLD.v16.0.6+5.x86_64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/md5/674055d6ff38ba166f9721647841fcbf +LLD.v16.0.6+5.x86_64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/sha512/5ff89cceff288ca9df2ba35a8acc08e75204c200a2204c6d5f2ffadadd1440c18398ed70c4f6a0133cb58fcdd5d95e4f67f03ce4faa4661c9d9e4965b1c9b38e +LLD.v16.0.6+5.x86_64-linux-musl-cxx11-llvm_version+16.tar.gz/md5/a30fbc6a5fa69f879d04e47a94e0b07d +LLD.v16.0.6+5.x86_64-linux-musl-cxx11-llvm_version+16.tar.gz/sha512/394db6aed33be75b7783aa0c1f98b678f0f96cb16946dadd1c143cd4b0378707d37fd0b35a4a9687de91ea293635142e9c433befe9be7fc2899612d48b94ae8f +LLD.v16.0.6+5.x86_64-unknown-freebsd-llvm_version+16.asserts.tar.gz/md5/ff14d881b50746ff4be6642233091bc4 +LLD.v16.0.6+5.x86_64-unknown-freebsd-llvm_version+16.asserts.tar.gz/sha512/6918a29cabcf3d4fa598cfc8390e534be63c049f8c69157629a0e02488f09b461fcf7cab5e0678b38b4c5be6d80a45a70b434889a7d1740100edadd3a32dbcb9 +LLD.v16.0.6+5.x86_64-unknown-freebsd-llvm_version+16.tar.gz/md5/2ec3ef1bea40aa16de080605f082b616 +LLD.v16.0.6+5.x86_64-unknown-freebsd-llvm_version+16.tar.gz/sha512/1d69b07dd179b1e146c4df8879beadd26ac5ba2c1fe0052bd5c40f0788f274c9c2e4e53a53703d95298fa889d2470197411c867247284de48834e7440a0c7977 +LLD.v16.0.6+5.x86_64-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/md5/21e359427a484e7876f4b9d9145b0273 +LLD.v16.0.6+5.x86_64-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/sha512/d1da7c1740f1c7ac07247b554f7cc76a64aa03200b44e41d1a10d66458caaa466099eb82d8d33327ec77eb784a5be91454c17d20c2fbefe049a128a2bf0956f5 +LLD.v16.0.6+5.x86_64-w64-mingw32-cxx03-llvm_version+16.tar.gz/md5/f2975d69c12e91660a84df715f971130 +LLD.v16.0.6+5.x86_64-w64-mingw32-cxx03-llvm_version+16.tar.gz/sha512/8fe4bfd7c692c66d871f2f0c67a8450076d7639addd2874cf6068427462a8656da96fe7c91bc93e5f0cb016ee3908e1b70c5212311f65ca7f0dc64f1f921e2ef +LLD.v16.0.6+5.x86_64-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/md5/1e9103f812fe163e2fc6c868da4fd9ba +LLD.v16.0.6+5.x86_64-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/sha512/e75bbedd72cb5f0337dac014d78d1276992a6f1d6c8832d16bd58ef83b2cd8602d023b45e1235e96ccdd13300e4b67c28f0a17cc0b9ff1ccb89263105a9a66db +LLD.v16.0.6+5.x86_64-w64-mingw32-cxx11-llvm_version+16.tar.gz/md5/b664032e83cddee3d1157f8c670ebe5f +LLD.v16.0.6+5.x86_64-w64-mingw32-cxx11-llvm_version+16.tar.gz/sha512/d7c36b0aa74b5d36446bb0aab413e4e12f042532d15e55eb79a807efabb93e590538cfedf7e3a6abe33da3f2326d631c2a041da2e00dc4051934fed17aed0c4e diff --git a/deps/checksums/llvm b/deps/checksums/llvm index f54ddc7379b6e..50dfa9bb9cfc7 100644 --- a/deps/checksums/llvm +++ b/deps/checksums/llvm @@ -1,111 +1,111 @@ -LLVM.v16.0.6+4.aarch64-apple-darwin-llvm_version+16.asserts.tar.gz/md5/a01c365e50cb49bbb9ad7c63320afaea -LLVM.v16.0.6+4.aarch64-apple-darwin-llvm_version+16.asserts.tar.gz/sha512/b53adde91d5e21c734a85056e779f26f85b6fe084fa89b679e3d211c1209d14d0b7db627f9ed9692edae31554d76d8e1e85cc34737c4b29273c2a8ee908347e2 -LLVM.v16.0.6+4.aarch64-apple-darwin-llvm_version+16.tar.gz/md5/536058393999e62a2829b5a2b1e85f66 -LLVM.v16.0.6+4.aarch64-apple-darwin-llvm_version+16.tar.gz/sha512/e9d1f6280da11ad3cd956cd4f9520f344a2657c65833ea2c88844cad7005ac7e5ba16f607623ff80d03b7b362752102366d8c5928abe827187f74669b80d56ad -LLVM.v16.0.6+4.aarch64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/e923316d8d68df6ed6fbd8deb7aad6e7 -LLVM.v16.0.6+4.aarch64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/9fc91d10805660a46bf10084c04a9bc53bc540f390ea3d88cd4614a9328d0f3b386862190ffcebe09331dc0324649c052a50326c44be2477062d1573f2ad3b09 -LLVM.v16.0.6+4.aarch64-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/5b600b39079942129b78474ddbc32fa1 -LLVM.v16.0.6+4.aarch64-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/ae46cd569e408b4365f8e953aa1f7cce1f735872d032c71f4a6cfaa53e4d67829bb5a6c8f2c99cebc0eb224b02bba4c24771faeb79c6b99e641d11f5c83d31c2 -LLVM.v16.0.6+4.aarch64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/6f0980a7d08783cacb5613752b04d41b -LLVM.v16.0.6+4.aarch64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/d45e5be28d6c786582bf79b3fa65d67eec12b2f792a408b32be91d76452bbf95255b6e60019b6f1af409dee4bd95120ac1c6fcf3e139613a774e684f4ab6595a -LLVM.v16.0.6+4.aarch64-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/e25c9371e8d59d69dcd8009a892bbe38 -LLVM.v16.0.6+4.aarch64-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/0c67ec6ad0e31b98f1e13883ee2436a4eee61ce5cf53da01df3d12b670e7fe9d6ae408d2dbf622604fe95fe0ae14bb0240c1882616ff1d6c2bbfe8045077a90e -LLVM.v16.0.6+4.aarch64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/md5/039f50bf67a682eaa9d69474f5980302 -LLVM.v16.0.6+4.aarch64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/sha512/03a77ca15883b7e7535f606566d782af8b5706b5d2eda5caf33a3484baaba1f657b65d3e5be9bc40050f0a61521977839da8ef4008f4593296fe318cb3772377 -LLVM.v16.0.6+4.aarch64-linux-musl-cxx03-llvm_version+16.tar.gz/md5/30b471f0630f67245effe1481ad1ba6d -LLVM.v16.0.6+4.aarch64-linux-musl-cxx03-llvm_version+16.tar.gz/sha512/ba7c039b13915ed7b374a75c81578ddd5a8d569cd1022fd39cd40f089c39463d97c3306668ef072becae38171aea44713e27c4d34f4893c671f12ed08824939d -LLVM.v16.0.6+4.aarch64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/md5/38110539776130f9fb2bdbdb1b6a4598 -LLVM.v16.0.6+4.aarch64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/sha512/d8dc28c542ff6a07083e60feb8d7b731cc1b3b0a55ca332200b62e8b0218c2db30af6a5870923db70ba4f47a35f245a6b82504ea1af410e9a43dde03f41981d8 -LLVM.v16.0.6+4.aarch64-linux-musl-cxx11-llvm_version+16.tar.gz/md5/7916ed51676598067620090a9744e110 -LLVM.v16.0.6+4.aarch64-linux-musl-cxx11-llvm_version+16.tar.gz/sha512/46d9be864409108b2c87fac4b87582637fc10d96382ba265a008cf6edcb046f10c5d4e0de4f8f824c2dcfb32fdbacf05dd13928ea9905e3e338f7aa4d5f5fc4a -LLVM.v16.0.6+4.armv6l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/9c51e4d7f15a1a7662d8acb674cb809b -LLVM.v16.0.6+4.armv6l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/e72918bc0af4806cd68f199decaadcc892a70dd9dd4f1cc23f59d361b3e01c7f3542ae295ea954fc8aa7d0121cdde2d06d53616d3196a532b1b9f45f9665ab9e -LLVM.v16.0.6+4.armv6l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/md5/10ed73102caf2bbd27766c292b939f89 -LLVM.v16.0.6+4.armv6l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/sha512/9f08eefe7c0027d7c84955160cf6bd25527688598c6191f9822c12c6558f534567f0c61e4f1397e62202c02f4c8cb61eb0094c343cdcaaad5221d90f147be210 -LLVM.v16.0.6+4.armv6l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/b4fc948b8532d6add7177b77b89feccb -LLVM.v16.0.6+4.armv6l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/6a7c022e4ad205112a1c4665e28286672ed0460925d1e55fca04af9afb6a6a5fcac4e641ae0c1040181d81b1762b2a2ce05cdc532725d5da0702a44668bb8893 -LLVM.v16.0.6+4.armv6l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/md5/7b795c94a4f3dd8d79c5c4a85ecdc8e7 -LLVM.v16.0.6+4.armv6l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/sha512/bd6cb0c2f2ee25823fd9ad9ef931d7d1518c5315db70c33ddb959fece0fbdd1eb030630a5c63dc9f9e50b1bcf1cae9c2f7d24585f9de100e6fc56c4a4b6f7a06 -LLVM.v16.0.6+4.armv6l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/9812ca2eb64521bfd052821824227598 -LLVM.v16.0.6+4.armv6l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/f939353f3fc667fab78b1083365c51bb15eb218bada2e061900bcd16550db5ed6765569ac9990e91294f030c04787228fed14324e2f192ffec26c6dfe851c9a3 -LLVM.v16.0.6+4.armv6l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/md5/cc4e38e0a6cb55e16935f70e2e9035a9 -LLVM.v16.0.6+4.armv6l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/sha512/297d7268808ab95317d576301f81fa52db3d8f9e91e7a2fa554e87afc21bf195fb904a585c39b4e83c7ede6a2ab64efcdeb929cc109894c3caaa7de9cfd41ae1 -LLVM.v16.0.6+4.armv6l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/40459a6691760b6c5a986221bb1d3c7e -LLVM.v16.0.6+4.armv6l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/4b3e4bfeb1e1ddddec786d50a018588d6eb6c2b97fb6e68e1c24026f51aab59229cb8a389be075da5abf3fa50ea7fa36b870ef17c374e97d8e85377abf4846ec -LLVM.v16.0.6+4.armv6l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/md5/07958dcb7b13ee0fba1379d729fae641 -LLVM.v16.0.6+4.armv6l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/sha512/358c454d66b48846888fd696c64ca0d154bf9df81c27859169e6b3274fa9aafbd49935309e976761a4d95c3f2b80481834ce9691d08a2a456c20be15f92319e7 -LLVM.v16.0.6+4.armv7l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/53572cb82b955197819eabdc1164073a -LLVM.v16.0.6+4.armv7l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/cd7da353ddbb1a18305a3b4b20bdaa92f60bc3bac1fdab32878cf53e921b8782f4e87bbfb55a7c7076ce927c42f02d86c890f8b82498eb41d58e2702efb0e044 -LLVM.v16.0.6+4.armv7l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/md5/7420d73f14f4124c79e6477e72ecce25 -LLVM.v16.0.6+4.armv7l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/sha512/992f5ecb3c9b162946bc16e8ce680bc56e5ee5b928e05600b87620554b9f7a22998a03e7380171d659b25790b8408ff656649e9c0cb7a8f91625ca38b0b4cb2d -LLVM.v16.0.6+4.armv7l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/c52e1f13d082a786e02b9a28a5192ad1 -LLVM.v16.0.6+4.armv7l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/fcb6e45b4627b6e62cdfaa9bb333863f99ac4b629082fffcad62f223711e1c36c72be497a6905b74f99f259213eabade3cd7d9b2d95ef6c77049380b46476a4d -LLVM.v16.0.6+4.armv7l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/md5/abe229cb1c155815bbf39735fa2395bc -LLVM.v16.0.6+4.armv7l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/sha512/41ce4c5dda1d85818387a8c0b8061290ecb630b243542b9d8f9f28d5c4364b010ec9dad682a5c62859165d61664b1f43b5343a79bb7afccb79de0746ba4eb0ba -LLVM.v16.0.6+4.armv7l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/7f78b28890669a0140ef864153edf179 -LLVM.v16.0.6+4.armv7l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/f610aeeb183e6c85e0e50d0a2b483b16d11cce83a237e70ab1297914062d78288dffe14f0a63e03dc8680c5bfc096b9e66a2fa6620833648896535c221640202 -LLVM.v16.0.6+4.armv7l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/md5/106d266049c26933d4398ddd9c7e3af9 -LLVM.v16.0.6+4.armv7l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/sha512/fff0928621c86fc50283ed5e929f88ac6191822d2af8280a61a08628d099203002b9a43c69df96d85de36efc364c7dd317e0db48d9e25699440e2279fed4789d -LLVM.v16.0.6+4.armv7l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/47e42e23351ddc592ed7e4c0acec01bd -LLVM.v16.0.6+4.armv7l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/90f9e8b3f54373ee738115e9105b0ac94f298c574d96f8698ca72cb917181d82146c9f7dcde4468022b36cb2767a194d643e0c044af0397922b13b28bf2f6177 -LLVM.v16.0.6+4.armv7l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/md5/29923410db87d76d9a86362713378f3e -LLVM.v16.0.6+4.armv7l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/sha512/c1cf57dc3a3da5b16d14b80fec560c2886fc619addff07d388469aebf04b625d700d89aea52f6f0d50767dc2a4e426b017743fd66ebc15185fecd65904267b8c -LLVM.v16.0.6+4.i686-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/540a5a6a7b785271e5354abb505868c5 -LLVM.v16.0.6+4.i686-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/61807c0e2f0cd25a234db25d171aa078c09d70d683ee874de79ea647c52a5875b8802853051b0f47a12809ddfc88e868cfda6551b789ba1633093fdd325ebe6a -LLVM.v16.0.6+4.i686-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/7195f5e0bb86694fe6c6708510806a11 -LLVM.v16.0.6+4.i686-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/ea058346b3a600ca5fd3496d0a7f8ce7634a97eeedacc5013e458088462d82762eb92f8d82e6355bfebe4befe397cf0970fb8ec0005f8a80a4e8396b24f7205d -LLVM.v16.0.6+4.i686-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/c59ab62f38a937f322326472a6faf6d8 -LLVM.v16.0.6+4.i686-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/54e6b32c0c3599804d44cfebc2d772a00130c3f41403b9211d16bf36112b9de9070fb3f663d09d239c4392daf4238b939cca1267369277a74bb7d176e841d732 -LLVM.v16.0.6+4.i686-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/b5e5b32c0573a376ed4eb76473f98cae -LLVM.v16.0.6+4.i686-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/9f2fb572354d13b6444bd7ce786de90e8b394ecc6b69bce537b9636f3e6906971da317c6ac5a1da4a9ddb4a879060fde75aba5c96059cef5338cafdea78b47b4 -LLVM.v16.0.6+4.i686-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/md5/f4f58134ca48a8485d70ac135a7b8cbf -LLVM.v16.0.6+4.i686-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/sha512/84d3ff5c4d62c56b0fcdce4d9f6c83a5b079d182ac3dd6521ed4df3fa7e8f370cf4c0a3ca284f25a034525141094ec422e3383951c35c8fcfec97339fe477fb6 -LLVM.v16.0.6+4.i686-w64-mingw32-cxx03-llvm_version+16.tar.gz/md5/f797f871fc6c676da2c8006f2b2f1863 -LLVM.v16.0.6+4.i686-w64-mingw32-cxx03-llvm_version+16.tar.gz/sha512/a7b74a8e4d3f0ec5a76b2fb96ad3131c4847eaa46209667cd1dcc6e60c05fed3a584e9f302a05169a04088674529d2fec4deda5a9174735dbc21f98a681375b1 -LLVM.v16.0.6+4.i686-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/md5/445e297dcd1aa83d9f7d29cca4f5e3fc -LLVM.v16.0.6+4.i686-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/sha512/b90c9c7daf05b9afe7d8725c97491efe7e401f055614061ed894f140eb24c2f02f542daa15a4506037eec09a777070fefdec2e6594f1eb34af3eb113954b9543 -LLVM.v16.0.6+4.i686-w64-mingw32-cxx11-llvm_version+16.tar.gz/md5/401ea6f6290a5fffdf4cf55a72b41655 -LLVM.v16.0.6+4.i686-w64-mingw32-cxx11-llvm_version+16.tar.gz/sha512/87349bc4dc337f86e192068b82acc374bce467af8b1ec696fa5b9a98f174647ca8a7aaa98e48bb7ed308d2dd8dff459c8af622f7f2f9761898779879a7069de2 -LLVM.v16.0.6+4.powerpc64le-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/977e40f66ead0070ee1b10c16b4821c4 -LLVM.v16.0.6+4.powerpc64le-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/de1431693f04469f280b512874836a03ada21d0dda05070e8486043999380fb73bddfcd15d1ba98cbb173bce90b2b69589064c02551785a868dc34b45a9dd17a -LLVM.v16.0.6+4.powerpc64le-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/e74514de403eed67e4fbb647426a0fc0 -LLVM.v16.0.6+4.powerpc64le-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/3994895cbb78320048ac330cfd29700ef71ee48081a1eea4c881bee7e307c95caf8fa74be02f8dbc39a5a73b47e7498ede7e42b0c432fb263984f5122a6922d8 -LLVM.v16.0.6+4.powerpc64le-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/2fa81725e463088df57dbfe286319e77 -LLVM.v16.0.6+4.powerpc64le-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/c3d58b6537674ac8b4a3281df3204a7ca6071c8acff7aa54fcd506e898ce872dde81147e955a708fd2ac3ddad31c4d7809c7bb152574e19bbdb72dfed2a75221 -LLVM.v16.0.6+4.powerpc64le-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/397ae293e48777f768c2e98f9e6c558a -LLVM.v16.0.6+4.powerpc64le-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/526536b102e0650b3fda0c8f59639a3d97b8fd72c75c4a066da0955637cbaa5f331d4c1e5e11af48cbaaa813a274f6dbc360f75da9de357a14762703290a1fbe -LLVM.v16.0.6+4.x86_64-apple-darwin-llvm_version+16.asserts.tar.gz/md5/3524c7e60e752ba00e982730e76fa40f -LLVM.v16.0.6+4.x86_64-apple-darwin-llvm_version+16.asserts.tar.gz/sha512/39d5dd8905e51ec8fddd4c29142e1923f6379eeec6e5ce9e52ecafcebbc1642bb06bc912259082ece485071c32f35d56ecd1c19af270794d54a1e0a52b28ac2b -LLVM.v16.0.6+4.x86_64-apple-darwin-llvm_version+16.tar.gz/md5/b7e92004bf50eb5634b0134a41acd80c -LLVM.v16.0.6+4.x86_64-apple-darwin-llvm_version+16.tar.gz/sha512/ecf7dc9f70b74879ad067de733fe482e058231b76a2c220d0eed055f4967b0a9ae5d3e572b03bc20916beafe29f40a404c0e03ae18398ee8f7f95801b085e536 -LLVM.v16.0.6+4.x86_64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/8356012f5f046bf0c931ddbb600e18cb -LLVM.v16.0.6+4.x86_64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/e9324a4bb5342c65dc978425c2da2c61baf1999dff9d30163576699b5be347217bf8750ded3f5a80c166f65ef94c150ee58e7f708791a41f045c2d9d10ed9f67 -LLVM.v16.0.6+4.x86_64-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/f28b04fbb4f1781d36d4bf0d667737f6 -LLVM.v16.0.6+4.x86_64-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/62a6cff9bd8a73a17f8fe851cf4ad69fe70b12a3688323f3d5e169b942b8d2b5a7a2b1a6583a23e0d0c98fc9631b77cf0a21078999d45086f4620f08c0906782 -LLVM.v16.0.6+4.x86_64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/ed5489b9b7d1c2fa7632c91630079c88 -LLVM.v16.0.6+4.x86_64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/ac27506410deb7ff4046def2bf277315e11a7cbf503631d62a749bee50fd09c4cfdd21ee7621f2232ecdac20c7be8b87dfa2125832aff8bb5cd65b7f9e7ae875 -LLVM.v16.0.6+4.x86_64-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/c99551c46f7ae080f3d881247d83ad2a -LLVM.v16.0.6+4.x86_64-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/35b8df0053c904ff31db74d5d2b65fda7585b30753a6a96bb0237fc72e51cc39503fa93a0bfefe453941b047f82fa5aa08429ae1431b1590ef7bb358326485e1 -LLVM.v16.0.6+4.x86_64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/md5/1cdb2a5b49fe2a096d094ebfb5f298e1 -LLVM.v16.0.6+4.x86_64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/sha512/8919a3d2ccf821ad313bdae173db7519d627a6006804cd695e9836fd25ac2b4db5a4c3ba4faa673b89b33ccbc0c23f2b37ef4759f167ceba9a5564275840029b -LLVM.v16.0.6+4.x86_64-linux-musl-cxx03-llvm_version+16.tar.gz/md5/74e55203c31cafee26add48f1016796e -LLVM.v16.0.6+4.x86_64-linux-musl-cxx03-llvm_version+16.tar.gz/sha512/2fd6a34c49fb4c62e8104b91d34c01fef8cb79ecb076bd0c6e325db46a77b79652a741b9e9a4fbff454e7810b3b4352d62eee098b0a155496bec79add7f9ed5c -LLVM.v16.0.6+4.x86_64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/md5/2ba719127a88be8d60251d0b324c4aed -LLVM.v16.0.6+4.x86_64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/sha512/f117558f61da9a2ded579ed0f44151a6480f001aac9c082e3fc6fcb0737d400f97a3e9aa66a311ad6cd7a0b9c53dc2c37be7a0f1d7bad7b742ace2d80f20fed5 -LLVM.v16.0.6+4.x86_64-linux-musl-cxx11-llvm_version+16.tar.gz/md5/4bd2592a0f027b04599b35fe79dcc2de -LLVM.v16.0.6+4.x86_64-linux-musl-cxx11-llvm_version+16.tar.gz/sha512/6240c9f909a222b7c6f51b388d1b49be5ecb51e9a5c17bbf3aab53782e5de23c3e60877208fb0117d46306b9d3a1527ce8debf3790e5e66255938465c11d7570 -LLVM.v16.0.6+4.x86_64-unknown-freebsd-llvm_version+16.asserts.tar.gz/md5/1f161fb77f9b880a8d825e60b83a288c -LLVM.v16.0.6+4.x86_64-unknown-freebsd-llvm_version+16.asserts.tar.gz/sha512/0913c1033dd51c79db2169ea3a40a0809eea49c04e59aac7502a86cb561d7a1a2d61a903b77f92d7fbcf1f26bd9e9e956e3c88124792e9a0d8400fd7cfb593e2 -LLVM.v16.0.6+4.x86_64-unknown-freebsd-llvm_version+16.tar.gz/md5/78e5ea646651847d21af1a710b709660 -LLVM.v16.0.6+4.x86_64-unknown-freebsd-llvm_version+16.tar.gz/sha512/c8789f8fc1b8695f1dc1e49fe8d8512b5a1b23554d651479c39dd64570e3fe141018b5d168fedc5a6f5141a2e71a65dc30f87376374f8f549981e326c87ab39f -LLVM.v16.0.6+4.x86_64-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/md5/8bec2b0452f7c87fc98ed9ccc103759f -LLVM.v16.0.6+4.x86_64-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/sha512/adb89f7904850c31c42f8326fc67fc0331d652d02546368e1db0242fc940074ccdf569b065d77d4803e1ad6cc39ed3353caddf4d0f8cbd92db7d9e95c5564bc4 -LLVM.v16.0.6+4.x86_64-w64-mingw32-cxx03-llvm_version+16.tar.gz/md5/2765a9d83b62b29719f3c5ee63370565 -LLVM.v16.0.6+4.x86_64-w64-mingw32-cxx03-llvm_version+16.tar.gz/sha512/4e67a737e953b9147dd143d5d7b6ab6a3bf5811510664be41dc9a1572f89d75d97c4c2b334fc4c60320a8552845444ba3f12230e9843edc63884264db7d6e3bb -LLVM.v16.0.6+4.x86_64-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/md5/4e9a5587cbc5926224ae0d4a36c581ff -LLVM.v16.0.6+4.x86_64-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/sha512/247c989e3843fc4da54f4c133a96d5bcfc111b84801f52b1b322b548d667657a932e94fb7e0778d1d0151d8c5cc1d0a21d3aec555254bb4d8c8bd37593554ed0 -LLVM.v16.0.6+4.x86_64-w64-mingw32-cxx11-llvm_version+16.tar.gz/md5/8a71fcf24c6758307f0491ccd29e99ae -LLVM.v16.0.6+4.x86_64-w64-mingw32-cxx11-llvm_version+16.tar.gz/sha512/cbe1131e1202e15ffead552a8176c1a86e03556c9d85c6fcf886d0f32bdf31898e3d588e2d6e5723e89267b98cf111abf1bf90b1c6ec6879b7ef8c87d52a7e6f +LLVM.v16.0.6+5.aarch64-apple-darwin-llvm_version+16.asserts.tar.gz/md5/bd48e9a0689534d7761c9c96e5a2ef4f +LLVM.v16.0.6+5.aarch64-apple-darwin-llvm_version+16.asserts.tar.gz/sha512/dd1958dc4d67e60e6dac03711ab3690fd2a6a996cb62798761c35de41dbacae04dccadec0781c7f3fd4366512667b7d8c1503d9c107279bc91a38a98b84cd429 +LLVM.v16.0.6+5.aarch64-apple-darwin-llvm_version+16.tar.gz/md5/31ba7b1b88b0f70fce5305ef908506f0 +LLVM.v16.0.6+5.aarch64-apple-darwin-llvm_version+16.tar.gz/sha512/02504294f79981d30576c29257950fb7ab2971ac6aaeb1ec832e41133dc0f4d1f27f31bf66492ce2e3d6c5a6185ce9e244ad7dbd14b202f235460701fb9f67ba +LLVM.v16.0.6+5.aarch64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/ae85c428284084f83f60374cf3f91fc4 +LLVM.v16.0.6+5.aarch64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/549efdb6f23169d7c606f4405365aaf0b4889f0a677646efa0926896939127143953f9a3a9f50e02feef4665843c2b9d3e918c1ded6904b864c9a4a652c6308e +LLVM.v16.0.6+5.aarch64-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/c1717340b74ba3ef5d00c496bdfcf5a9 +LLVM.v16.0.6+5.aarch64-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/c185726e730aec363643089d2e7238046ebb9b5626fb7c0049e5458b29a4233dc705ce01bbc520d272a158bdd6b27fe4ec0809947c6c8fcbefc2357c28a371fa +LLVM.v16.0.6+5.aarch64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/af115f49b35d5fd20e55c1ff5bc46e5c +LLVM.v16.0.6+5.aarch64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/c7f027378054c3098a0c75e1cfffec648e79111db2e9fc29a91accb3196229c74c1744d5a766629e87cb697ed0652e6773ffb5cd9350893b9ab06102a65c0cdf +LLVM.v16.0.6+5.aarch64-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/0a31cc6ca9ff9984928598836b2ae149 +LLVM.v16.0.6+5.aarch64-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/768b7be845e1bae2e61426fca5e28710a747004938b64802fdbd2d3bdd8f9c2caa8f85b5a493ed759bbc0c08cbd5bb7f520f53d622f4f4a620db2c011a8ce7f7 +LLVM.v16.0.6+5.aarch64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/md5/c8da20fb1d352c291dc4158d85ae6581 +LLVM.v16.0.6+5.aarch64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/sha512/2a922886473b4723c63cbaa1eb2631de4bba0e20c3b6db46ba549bcac9071ae75ab2325a05504daf4d3405f7ac6571d1a6c3d23ddbd16f5155df661ae1973122 +LLVM.v16.0.6+5.aarch64-linux-musl-cxx03-llvm_version+16.tar.gz/md5/fa21d209af95247f806d0a8e55738cd3 +LLVM.v16.0.6+5.aarch64-linux-musl-cxx03-llvm_version+16.tar.gz/sha512/8357d945355dfb667e4160bce0c1b8c6cd7609ce87bc3d86bebe06b491c1ac9c3e853a9d1d858237aef04c8898b2a28f8df49cdae09e9c929a8bc0a944026ad3 +LLVM.v16.0.6+5.aarch64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/md5/094490752ebd42b49ecc16398dec7d20 +LLVM.v16.0.6+5.aarch64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/sha512/7de6c61e794a4406193ee4ab88953b92c2a19415b7ddf60189c67f2fcf6d132f74cb6c4db7738d4072938f7e2f620fb9d1ba8b6ce2f742afc172b311c8f68027 +LLVM.v16.0.6+5.aarch64-linux-musl-cxx11-llvm_version+16.tar.gz/md5/1f83b73679727dc3fe497301b2fb0b76 +LLVM.v16.0.6+5.aarch64-linux-musl-cxx11-llvm_version+16.tar.gz/sha512/245dfd750618b83d57acd2eb397555db6398a9ccff22f1f714bc05aee8369a8be766d2d519dd1bb54a4eb84b4c7639ed1cc2eb31e62c8ce0fd43cf983b9d6a63 +LLVM.v16.0.6+5.armv6l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/5b2f15123af18e4d8d7077e8f5057454 +LLVM.v16.0.6+5.armv6l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/483e817316477eae6985911b3a25cd03d252fd7f6c18421070bb1d24aaef09fc8c7a87d32c1dd86890d37e6720d4219b519dc376bbc7a32772e451e10fe3ea88 +LLVM.v16.0.6+5.armv6l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/md5/787cda220835cd2533789902125ad578 +LLVM.v16.0.6+5.armv6l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/sha512/214d44ce6895d6ccdfe6493eaaed5a7bb205a2d48d91e31a210520661b33938b3947bb9c34f6b738f5ffd25c09820ea683f0c45b9eb32e2627ca32f5f17e51cb +LLVM.v16.0.6+5.armv6l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/97b8fd979282d1bfbfbe84d7adbb3e16 +LLVM.v16.0.6+5.armv6l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/228a50128b2518a60638ce44101124bdb2dc2d153a085598c4133ae19ec053ed4ce09279e63d0959cac7519691d5db299f3c22b154c8cbcd8dd0caa2b476730b +LLVM.v16.0.6+5.armv6l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/md5/e1aa03b8e6091f8c9ff07f6011db8a70 +LLVM.v16.0.6+5.armv6l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/sha512/afe0c7eea1bed98339175d0e2d231e3e6e6b5b7db512ef842e8df3f386b5e0f3df6e7299a13760703e62ab3d612944d7ef508e1ed72831d4a3a63a1e91154680 +LLVM.v16.0.6+5.armv6l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/88c640a1d913f5567575d674f1df6912 +LLVM.v16.0.6+5.armv6l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/1d0c4838404760bf761641e0cf8f012b66f6cd63a2e163b3070e823fb3aab85f2e45e42ebf2990e2f6ad23b9e33f19da59a4392b647b764d315e62e52452f378 +LLVM.v16.0.6+5.armv6l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/md5/e3d790ff7a2381508e34d38011b9e4bd +LLVM.v16.0.6+5.armv6l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/sha512/19e653d9e407da1450296dc75049ad332a3b85deb19136154c68b2d3fc8863cd174ff3f4721937e6774808c0b93bac5ecb89e90b97c603db31da4d02d972ff0d +LLVM.v16.0.6+5.armv6l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/bf0809291b148412c1dcc28d6fd340e2 +LLVM.v16.0.6+5.armv6l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/203187100ff15c0c14bb68a1d000f81756a6440f565ebb91f14bb58844df8913a869cbaf269e3744184676d16b6849e9adf35ef0aca92e01c64321019e3443fe +LLVM.v16.0.6+5.armv6l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/md5/888c31d6c254d47d0f16fe4e9f5bae25 +LLVM.v16.0.6+5.armv6l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/sha512/f91202868584bee9f88aace7f988d28b05a0f0fba00552bed113eca01c8b1d97742f9dba88caab1efb79e1b9bc040640a5a915a0a5625d0bf00310f18d291641 +LLVM.v16.0.6+5.armv7l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/8b0b5d7bd1dc930c28f3bd93233db044 +LLVM.v16.0.6+5.armv7l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/e5fcbba9760ed8f8e9af10ba9430c63f6df0e302b315bb90f99298da3d8679434210cf3f8d8f0515fbac4126ca2f673e5595af16822224e94e44043a854de5d4 +LLVM.v16.0.6+5.armv7l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/md5/89a6b49f7c10886eb4f1430a43dd9653 +LLVM.v16.0.6+5.armv7l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/sha512/53c5734bce7f2b2252a86fe07d759c3fd481c01abda0a7a6364866b11da22374e52afe0652a2562e4d20de2bf5e9c784b481d9383b32ddbbf6431ba2b57a4ed2 +LLVM.v16.0.6+5.armv7l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/bf6afcec8bf58b33ffce0c02bb03b811 +LLVM.v16.0.6+5.armv7l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/430dcee32d9e5f2c097b569faa947e0398682a00f32468e1cb6abca07f0d687b26e3e70f7859f26136ab372efc3b00db555cd08365723fe3287eb58ed0099674 +LLVM.v16.0.6+5.armv7l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/md5/ee139fcc644d75ea6df7847bdb63c056 +LLVM.v16.0.6+5.armv7l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/sha512/a3e34fa7e2bc0d92fb70f009e4fbc70af852f9abee50bbc12526443da96794808891965f1b5dc7c8bd2bb7826a4bdcad69356ed53cc97ada2598c8162af7fb89 +LLVM.v16.0.6+5.armv7l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/ffde0c0f3c2194e3b3d9edeeef16a506 +LLVM.v16.0.6+5.armv7l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/1f84ffe983a78b3df27e8ab0ac8d7fcc383c4f377c4de03e06eefaa0541ca546e0d8355b24aef06b16378113b904b9d55fdc487a5f6e48a8e1dd7aed3f165d5e +LLVM.v16.0.6+5.armv7l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/md5/50dc598124bf33c0d0b91189e3d6f563 +LLVM.v16.0.6+5.armv7l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/sha512/4b59553fb6127af3a4bf12b2f1a839e028d9d1db4ee4aab92ca491c6f703af40c692523ce9f952ee4b10e5f9cf26c432f94956e9df4bc6649575ac096e3eef99 +LLVM.v16.0.6+5.armv7l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/73dd4b35fbe39a834b18bbf7c22101f3 +LLVM.v16.0.6+5.armv7l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/ec52bae2e9a8c6d75f2f71aa4414a4faea528e80269045178fb4f28ad64b7f6cec5d1d24093e013e822c924a1e1f629e5baae4e1bf2cd34a9f6ae58624a592a9 +LLVM.v16.0.6+5.armv7l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/md5/7db4e772d579c3a5b387593c3496c4f7 +LLVM.v16.0.6+5.armv7l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/sha512/ccfe236ff4061c91137157bf1b70b6802764cb9edc19e1408c49d2791c50f7b03119ab7282c08c6c300ce3e7b49a94f983bfcb83413060b4a76f2bb48d7ccd8c +LLVM.v16.0.6+5.i686-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/4ad2b48a723df13ae20fdd7516f45bc0 +LLVM.v16.0.6+5.i686-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/5f7fc70d327e88434e3876e609e1cd95d77449f60a6bfe1076197af8c6b3b103c564f8108a0490f48fdfe76e6f5c87b38d1bff8b28c600b31805064849c1d055 +LLVM.v16.0.6+5.i686-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/1632a7f6d49d305530c3172ae2a01366 +LLVM.v16.0.6+5.i686-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/064240ee9efbb25b1d42af914c600fcddb381f47cb29ce70bf0ecf956a89277248eb536f7583b6f68b3d6e3a869df0f6dbda8bfa3871736bb438de405c12ee72 +LLVM.v16.0.6+5.i686-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/b9cdd49e8ac138134e4eaa5a2a10ff80 +LLVM.v16.0.6+5.i686-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/cb490b96926a9387a1b2c9d9e9371054eaad8bef46229a2ce689f5dd70b8c926db5a35665206d035fd7a0bd74b273b72ff4564540fdbf0f530f7468d7fb55695 +LLVM.v16.0.6+5.i686-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/f5f87727a29b6cf1fdd432dfb637a7c1 +LLVM.v16.0.6+5.i686-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/16e0371ea67d33f6c4a3d065f810c7d42f4273c81ba26d392ff06bb8185efdf46776fc35a80ae7329145a29b93a0dcc84e109268fcdc9a1836fd43ca6ac80c03 +LLVM.v16.0.6+5.i686-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/md5/dda703c07d2186dc63afef935634ab31 +LLVM.v16.0.6+5.i686-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/sha512/47303695417029764cd2423b8169fb9a5d1c3cf9e6d6f63e45368c5929c58f109ae5030217639a4b67bd93ae59d97d6353dba7960a62bfe9fb93d2bb50027e10 +LLVM.v16.0.6+5.i686-w64-mingw32-cxx03-llvm_version+16.tar.gz/md5/e12f9a13e93f0f5fc68101b6744c6ef7 +LLVM.v16.0.6+5.i686-w64-mingw32-cxx03-llvm_version+16.tar.gz/sha512/1a689cac06c2ac7039eab39be1c41f6030b70db7a3fd21d587d7c193cf16c71cba0c02b4ebc920ceb54c3d8396d0ed9579e2dd7fc213f59048613db855bced9d +LLVM.v16.0.6+5.i686-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/md5/47da6fa85c128a0472d36791dafa06b0 +LLVM.v16.0.6+5.i686-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/sha512/9337d69d6301ce4dfdce7c09a79ff0438115d970354df1e39a0b3f2b603dcfd101c76956f021dd832f7df121059d99a1517b6fbbefef904860ff09db200ccb59 +LLVM.v16.0.6+5.i686-w64-mingw32-cxx11-llvm_version+16.tar.gz/md5/2f8f12546aa2c2945a052e3cfbbb264e +LLVM.v16.0.6+5.i686-w64-mingw32-cxx11-llvm_version+16.tar.gz/sha512/759468edcaa10fb7855933b64eb00330ef78d12134a5fd0259f46af3e49fa7f24c41c351ee1dedbb340282960fc0ae47b4dfe8c432c633e6bf7c781ef04d8197 +LLVM.v16.0.6+5.powerpc64le-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/afd6748b4780da4e291901ca740d45b9 +LLVM.v16.0.6+5.powerpc64le-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/6cfb9c361beb792d149ef342e84bea1eb08bdff1137bb560190da9b755c9c9af4b59744e63933c6d53955968967d46ee171ba55c2a50b0098c117cdf9ff7bd14 +LLVM.v16.0.6+5.powerpc64le-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/cfb7d9dc801bbb6ce21c45b13970841b +LLVM.v16.0.6+5.powerpc64le-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/316b45c8eb140c9cf3be5f3f1158de60bc5a95a254549d9d5803b4e4b80efa3146b306b0be65a0a19f2381a660ce7958a37a402766e8e4e86207cf645aa1503a +LLVM.v16.0.6+5.powerpc64le-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/3758eb22d0d2e96d8cc5e9e7e2bd5141 +LLVM.v16.0.6+5.powerpc64le-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/25e8722a7351669692ea9e9a8635d58f222f6fd24c2dcf59566032cbb58648dbdda166417614530cad6f4ea0f815b9039b3f36aec27207fd619a18e60f743be2 +LLVM.v16.0.6+5.powerpc64le-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/7e5174e23233264ccee26e69674d09b6 +LLVM.v16.0.6+5.powerpc64le-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/a31df78bad16b2f3cd92aed7f7fc18034fd9e65f663ea93459814a29997a255a18364217a418bb2d82638fdde0ccd99ce6898a6aec1de0119d74c00773bd4e33 +LLVM.v16.0.6+5.x86_64-apple-darwin-llvm_version+16.asserts.tar.gz/md5/b59e1a499c041269466ee2a57bb1fe8f +LLVM.v16.0.6+5.x86_64-apple-darwin-llvm_version+16.asserts.tar.gz/sha512/feff049f2e15a0555ec632547b703eb890e939cfb98a944f422373e79010751a567f8f084e934647f4622eabd6b99eb3fe969d49a6c5ddd9167544d869238e13 +LLVM.v16.0.6+5.x86_64-apple-darwin-llvm_version+16.tar.gz/md5/5e52f44105bd7f1bb411a765238566e7 +LLVM.v16.0.6+5.x86_64-apple-darwin-llvm_version+16.tar.gz/sha512/75922f5d1c92f9d71686056fef735abe7c68349312c8f1a5ac51c930047d30f4fc5419a3fccd89553135b6a3cef70d0d9a6d76839a0c40db8505d55a41ede220 +LLVM.v16.0.6+5.x86_64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/51ff77e575a037779dcea9c70afd0054 +LLVM.v16.0.6+5.x86_64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/4eed4f5199a9a0765e64e33919a1c84cf6a0cd266d75ef28d36838c804e812f5c00146d3610cb36ad0e3feb1d6b09470a1779479030048f07cf3bd0e9f27557c +LLVM.v16.0.6+5.x86_64-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/cfef41224043b74a20385896e55e562d +LLVM.v16.0.6+5.x86_64-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/5546516bef077490a3750dfa0804578f9befafd43dbb3a85d954313302726ebc4ae5499a7fb4d64e5d74afbc4a6b191b0e03ef66ebd8b7a24bd6621d9895324b +LLVM.v16.0.6+5.x86_64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/b364639d993d5b363e270f0a164cdf67 +LLVM.v16.0.6+5.x86_64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/5418b1fa39360c79ed41767ad68f8f183a9ab7f60410cab7f63181b4b1388189e8cb5aea42ca8edc78fd82b2d85c3d7b00f4b5fb7a8cca8060ba2cbf01ccad73 +LLVM.v16.0.6+5.x86_64-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/1b5c6c9fa0dc49e7036c95e0613745c4 +LLVM.v16.0.6+5.x86_64-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/d9c08f52b840722737f296ba48836c920fcea2f605b05ad2cf5e152632dd1fa833dbf7487f568a5a46c461436bd38383887be5cae90a7d06f95f7ae45df250b2 +LLVM.v16.0.6+5.x86_64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/md5/46f5d73c93929cfc61830f8fa1b4ebc4 +LLVM.v16.0.6+5.x86_64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/sha512/f567bc1f4cfc47d41e753ecfdf8989ca490dd42250492732e67cedd78da5f4a9d6726a412fba7ca9fb9e68208a8dc737031b603ea313fb98469fb1a94e454722 +LLVM.v16.0.6+5.x86_64-linux-musl-cxx03-llvm_version+16.tar.gz/md5/2057ec2f2864763f1909bf99e9d0dab0 +LLVM.v16.0.6+5.x86_64-linux-musl-cxx03-llvm_version+16.tar.gz/sha512/955a9ee538dbc305aeafefaeb14da9d6b69036ff5d076d5f379aeb0acb4a43d169376f2df435d03131aaaf314f16a3d485ee52c1bd9ec2bcbf48cec041935594 +LLVM.v16.0.6+5.x86_64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/md5/790a5e41ff9e6eccf5d0e81de6b44858 +LLVM.v16.0.6+5.x86_64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/sha512/0b6929b09012d45ecd89bab7f904745d69313fcb53254e80ed3d9955978a14e7c6dfccca79ac5969bdfd9d0024682765e3b5ad6e9a1437f882c84b44a97b12e8 +LLVM.v16.0.6+5.x86_64-linux-musl-cxx11-llvm_version+16.tar.gz/md5/bb53988c9b48a21f20f6548454fa3892 +LLVM.v16.0.6+5.x86_64-linux-musl-cxx11-llvm_version+16.tar.gz/sha512/437f78afb9b9b58845222e299ce999be447a3e3be153f7e18fbf642464e331efa911cc5714fff350b67a96f271d347e03c191617c6a4ff5478bd8cf70a21335d +LLVM.v16.0.6+5.x86_64-unknown-freebsd-llvm_version+16.asserts.tar.gz/md5/2b40db504b6a77986858bfcfd53fb738 +LLVM.v16.0.6+5.x86_64-unknown-freebsd-llvm_version+16.asserts.tar.gz/sha512/5562183cff3dc24f00bd72b7f678decd3e7e249c33d2f4a1fb6e980f17d029223612fd478c1a687562bebdde1d6582d904e26042d7a53c7a0fa29030a466c5d9 +LLVM.v16.0.6+5.x86_64-unknown-freebsd-llvm_version+16.tar.gz/md5/e8752a6676bc446827886e67dfdc6687 +LLVM.v16.0.6+5.x86_64-unknown-freebsd-llvm_version+16.tar.gz/sha512/421aafdc4fb0b7964cda378b937bb8ab3c997b80625aa7dc487ea7eb851d67c24dee13e473df21f58a363cf5977a4089dc42732a4b4c5d5fdb27452ba4ad743f +LLVM.v16.0.6+5.x86_64-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/md5/19f7d44603e261fd9bccaf47102ba9fc +LLVM.v16.0.6+5.x86_64-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/sha512/a9c9600a6f3dba9b4b660c8f0ee35f84ccfa6151cf97dea32553b120f771f2cd53d11e8bf82d1e717029b50c78df2563e115b0f979064343c5127db77cf01873 +LLVM.v16.0.6+5.x86_64-w64-mingw32-cxx03-llvm_version+16.tar.gz/md5/0de19a3f6585e8621ea017ab518f7ac2 +LLVM.v16.0.6+5.x86_64-w64-mingw32-cxx03-llvm_version+16.tar.gz/sha512/879fa58a18af1913cdd05ae75195f4b3339842a4b31958fec10057b8c3e96c130364c143d81305f8403bf1915dd0ab16c9676d79636e93414f81592a82d24565 +LLVM.v16.0.6+5.x86_64-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/md5/0c591aba83cb18d99f5264d8a1b2275a +LLVM.v16.0.6+5.x86_64-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/sha512/c7fe3c5c3a1adee6d5453c6e248afa26504c84d301971354d8c05d3e5760f7dbf5a48483d2a8f2d4a446daa96a2a9a42a9d17be4ca105cfb824276203ad70393 +LLVM.v16.0.6+5.x86_64-w64-mingw32-cxx11-llvm_version+16.tar.gz/md5/ca65507d2a7e1b3eaa4255267741228a +LLVM.v16.0.6+5.x86_64-w64-mingw32-cxx11-llvm_version+16.tar.gz/sha512/996846e92fd26df45d9ddd351e4b6155e7cf9d433f789a263429b881c4948cf795e844f7d80a99c45a7e69480169c449b73321ad84a21a45cb0e010fb82fb3da LLVMLibUnwind.v12.0.1+0.aarch64-apple-darwin.tar.gz/md5/b95ad4844e649bf46db43683b55b9f4f LLVMLibUnwind.v12.0.1+0.aarch64-apple-darwin.tar.gz/sha512/15e0996aebe6db91fe58121001aa7ea4b23685ead3c26b5d89afae34b535e34b4e801a971f4854d8e1a1fbc805cece06272470622eef863e225358113a127913 LLVMLibUnwind.v12.0.1+0.aarch64-linux-gnu.tar.gz/md5/6d8783dc9b86c9884e0877f0d8ac4167 @@ -138,115 +138,115 @@ LLVMLibUnwind.v12.0.1+0.x86_64-unknown-freebsd.tar.gz/md5/54ac594b4c8e7f261034a8 LLVMLibUnwind.v12.0.1+0.x86_64-unknown-freebsd.tar.gz/sha512/a43756afd92081e6dd7244d162862fc318b41ca110a5e8be6e4ee2d8fdfd8fb0f79961ae55e48913e055779791bd1c0ecd34fd59281fb66b3c4f24a1f44128f0 LLVMLibUnwind.v12.0.1+0.x86_64-w64-mingw32.tar.gz/md5/83cf8fc2a085a73b8af4245a82b7d32f LLVMLibUnwind.v12.0.1+0.x86_64-w64-mingw32.tar.gz/sha512/297a5c7b33bd3f57878871eccb3b9879ea5549639523a1b9db356b710cafb232906a74d668315340d60ba0c5087d3400f14ab92c3704e32e062e6b546abf7df6 -libLLVM.v16.0.6+4.aarch64-apple-darwin-llvm_version+16.asserts.tar.gz/md5/bcdb469da04c788fb81a723ed285d268 -libLLVM.v16.0.6+4.aarch64-apple-darwin-llvm_version+16.asserts.tar.gz/sha512/d44eec8843f4b22fb8319e1a6e138f96795d82000a8f90f8157455e6a08c4706d2a2704a70ba96c33226bed6fdd27ac52da6a78c5f2eefddd98f8911fcaa966f -libLLVM.v16.0.6+4.aarch64-apple-darwin-llvm_version+16.tar.gz/md5/237d2d1a2fc596e502502ecf35a23623 -libLLVM.v16.0.6+4.aarch64-apple-darwin-llvm_version+16.tar.gz/sha512/9619bc2c0cb38cf38a53624a0a6f2711154d409178d7d9e510babef007c7eda33a9ffa4e5ae29c56bd52c77a230c4fa74f1730150232ebf0491736ede5805c85 -libLLVM.v16.0.6+4.aarch64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/2963b428aa281238a11df94715ccc7ab -libLLVM.v16.0.6+4.aarch64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/04f34b768de43175f7b453e5e5d4516b1f42f42fae04be511a01fa865e7a778b4044e0d0cacec4c8efffbcd7b462a1b61c3c7a796c7c8ee474085b40d59e9e9b -libLLVM.v16.0.6+4.aarch64-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/bad975489e45f75190a930e2adffdc5b -libLLVM.v16.0.6+4.aarch64-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/48cb7d77d85d9ba6826105e3707914f773e1b54412b0165da407f9248ad1b9f262c477a11b0d2fd2efbc638e9fe20102b3a6ad4e51d8169ecde0a8ded863be26 -libLLVM.v16.0.6+4.aarch64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/e47e1d4be6d503f069dad542c04f2391 -libLLVM.v16.0.6+4.aarch64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/d6e98a2effa12796f305a90e401ddff5f29df7203d017fa08c681ef0b91a807f5dcecc63ec8a690c25a664c6a02bb55a205e238eb6696dd421888ce771fd7ffe -libLLVM.v16.0.6+4.aarch64-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/9289127a28c909e8e7d5f3c44a20b4ba -libLLVM.v16.0.6+4.aarch64-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/5c253a38b9b06f227123fc3d7d9f2f55ca7445169f6c6f0ed73dce1b369039da6edee91a69cff88d6dda1651989685570c7fb40e2e196b0cc73e40a3e68df2b8 -libLLVM.v16.0.6+4.aarch64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/md5/9219850cd1c29f480f7ac7545fcbaf50 -libLLVM.v16.0.6+4.aarch64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/sha512/42ac83c9ddda05b0ff83159bbd72190daf05d6573f715ea7d2e0c015365ee81471069e43b2a58be4ffe340139f4ef5902c543820920537d0918f15ad9510bead -libLLVM.v16.0.6+4.aarch64-linux-musl-cxx03-llvm_version+16.tar.gz/md5/1ec5846ddedf6c8a57bc3b5633df9626 -libLLVM.v16.0.6+4.aarch64-linux-musl-cxx03-llvm_version+16.tar.gz/sha512/a40b5b13f3ceb0a261e7fc28209334a6ee4fd7d9490535810b1471f7dee1a5ff6f80fa98c4adbe3f56a6fdc10f2b2b22d835b974ef8bec4909aaaff4a87f1bcb -libLLVM.v16.0.6+4.aarch64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/md5/1f65b8354b9235b442400560acd0e7c3 -libLLVM.v16.0.6+4.aarch64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/sha512/c2b82578425e2a378cef3a1028b1a55492d3ef8aa4e2509ef06ba30475b95d1896764a3745de4eb905711f57b9ac7fb451d5d5f44afc5c95c9a0526a08197f97 -libLLVM.v16.0.6+4.aarch64-linux-musl-cxx11-llvm_version+16.tar.gz/md5/57b2b92268a1bd13f042cb8cc4f652a7 -libLLVM.v16.0.6+4.aarch64-linux-musl-cxx11-llvm_version+16.tar.gz/sha512/187a925182cefa8eaf42b9b4df42e9b5999deb27d864887ef65ba97fb09b1f6fbac1b0c7675aef0df91dce5b51adf35493bb6edf1d5049a73d1b76eac26144f9 -libLLVM.v16.0.6+4.armv6l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/04bd3427ebb23c98f580ab27b8b73809 -libLLVM.v16.0.6+4.armv6l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/fa2fc5bfcb2ddd555ef173e95bcde24320cd5e54af7dc3e24f2ba6828753cb52f2c59381191d5b14a76ce53634203c40d126d533afcd1b620b718a75e38a51a8 -libLLVM.v16.0.6+4.armv6l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/md5/c4e68d1829702b7cde26bae87817273c -libLLVM.v16.0.6+4.armv6l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/sha512/4f656cd0b95f7bbb17acb49ef125c46e4d3d9e3336db5dbe80322e5089fad53248172acbae068b35ea82204839a11309336c8296e672c2d0b4aa8778bcc003fa -libLLVM.v16.0.6+4.armv6l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/9372fa9a23ad5efe86fa002834cd8b71 -libLLVM.v16.0.6+4.armv6l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/6eacf49a32264fc88d5a034a96c6621e0ff9e5ebcfece0c702718c4d2027adb02ecce4a11096755010052ee4b61f99216f0c3f4bc3e31ef643dd6eae028220fb -libLLVM.v16.0.6+4.armv6l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/md5/535eae6a95d4d6be3be3b69eb180b4d6 -libLLVM.v16.0.6+4.armv6l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/sha512/df9820469c84d9c354dac9ac8ebddee3df878602ce2abbced63e77dd0f67e7e12929003e4c62def63be5b8cb90337707535bbebcca5fe1c730bafd90523fdf3d -libLLVM.v16.0.6+4.armv6l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/b82947eae6dff1fb15445b7dfd98c0db -libLLVM.v16.0.6+4.armv6l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/a314e0297f60e55952960889445f4a9347782d8416644cbbabffef2af08cb1c9e59940a6f59b09627aba8783287749489d94ac2614aef4bd7f58b572bce146ad -libLLVM.v16.0.6+4.armv6l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/md5/78457fbe2cb70afc8db031808080c732 -libLLVM.v16.0.6+4.armv6l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/sha512/6ffb4628c4f2ec4651d0605709a67a5d5b86f1fdbd27a47551adef9b95d402c6bf0cee916f06f8d07de82cddb7e3b9fd5a557f98197e0c5431296917f6294dce -libLLVM.v16.0.6+4.armv6l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/72725d8f28c4e22596e8181e632b3d87 -libLLVM.v16.0.6+4.armv6l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/90dcfbefbc58529616f64d7b1add5d8cb4a2e01406f7897aec64003e6c73b822be50c63cb8c2c9805d73cb3e7cd729846a39b6813d4f11872489c88d298249db -libLLVM.v16.0.6+4.armv6l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/md5/494f84c84942b12d0bf26e4d2e8e946f -libLLVM.v16.0.6+4.armv6l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/sha512/b5e1f1e2be533e7e5cbfb2dcec3ed573e4d6a7ada20442ee29122a2ff4d79246f140b7381eb33d56c436f893a65626a949474fc7d1a33502e40b857aeb5c01b0 -libLLVM.v16.0.6+4.armv7l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/6f7e0ad54d6bc43bd539a3026c2dc564 -libLLVM.v16.0.6+4.armv7l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/c9a4b83795605d0550c8ed065e94df2523a45ff451b6cc894300b642cccc2778b9134e77a609ba62aaa838761c5b1572bd90436dfc96dab02319808036358a59 -libLLVM.v16.0.6+4.armv7l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/md5/e2ace2d6f83a72208f4475c6b19bac4f -libLLVM.v16.0.6+4.armv7l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/sha512/83b537561732308f126efc2b62433b3a0410d6e33834e2593dfdd029c1f874287c4c4c005564f64ded7b7127f839522d24626077f260b0a79cd9be64f9773d32 -libLLVM.v16.0.6+4.armv7l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/3f92c8b09401190a5b5d7699b3e6e5e8 -libLLVM.v16.0.6+4.armv7l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/460e99bf7735ea4dde2adaced43c66c9e91a515e13a516775fee0a02a75d1c1270ff7390d2632af683912ffbef4e142e9d55e8870c3307fbdb4261515ccd1447 -libLLVM.v16.0.6+4.armv7l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/md5/dfc28578d1a2eaa0fb95dee5763024e2 -libLLVM.v16.0.6+4.armv7l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/sha512/9188d85d365c65cdfc487ab354e7593193efa3be09b5dc95701cb6244ba276409aa52ae0dbd3907be1b6e156a7d0506c6fa2ba8b60035b774d7ca5451233b287 -libLLVM.v16.0.6+4.armv7l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/8a8f929967e0d26152f145d93a79a4fd -libLLVM.v16.0.6+4.armv7l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/9d474211b4ec025a56fe2a77bb78e6865fe14235620accc5110a4170a672295419bab55c750d2f7fc0fa1cbecbfa959e07126b8355c95231658446697f489b58 -libLLVM.v16.0.6+4.armv7l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/md5/a8f7ff725142e3de01b6d76ac20fad71 -libLLVM.v16.0.6+4.armv7l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/sha512/f29e03f0d7cd5610972c5b1538fa5714484641ce1281871d9f960f026ae9107076cfb9c45ad6bc5cd65f85cac395d978222c95600f4c91556f9386a84ce3088a -libLLVM.v16.0.6+4.armv7l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/f641a49cd631ade07e66c46c30c66570 -libLLVM.v16.0.6+4.armv7l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/2081495e58ea755f43b76cc4ebc1d09e726f26893e2642b036165f75d417184e2038f97ccbe537f431aead46f8151036cfd4afe96a32192395e48fada13c83aa -libLLVM.v16.0.6+4.armv7l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/md5/51b06c324130d8e8935bbd8a0b5a5740 -libLLVM.v16.0.6+4.armv7l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/sha512/4150ad22761ed19493338d6d155e8c5ecdddf979b212f0fc6cae5ee3722ab4b6b0d4b0493778c665b81f2d4468e43589745b14b270b32953dfe71631d59ea4f5 -libLLVM.v16.0.6+4.i686-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/ed66dbfebe14efcdcc1b71ff3a491fff -libLLVM.v16.0.6+4.i686-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/550db082a181cc53e5336f13cdc34c469f9d5934caf2fde41935068fd7bddc74102b822181d7cfb38848e7409e38975b100bdc2a96c112df335fd91ca326a90b -libLLVM.v16.0.6+4.i686-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/703841665078d4061bb8f6839c49546f -libLLVM.v16.0.6+4.i686-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/c48786852da4b367356fc87703ec2dc4efbe9bbd66a16a1edff2f60f009ecac9fd95c54fd5de2e0a56ff8c59bcbf24df2609080c245aa8da166806a55f9868ec -libLLVM.v16.0.6+4.i686-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/8d8bc21967705c1310219f9f91699a3f -libLLVM.v16.0.6+4.i686-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/52c44373d708f80409a1a83271effef97dffcb4828bf6d7094119378bc625cf3a2f3f7af649a590dc827fd2859ec3d302287cd235b65cbac9d1273ff241aed8b -libLLVM.v16.0.6+4.i686-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/59ca3888cdbf9ff4b55d7a1092bbaba3 -libLLVM.v16.0.6+4.i686-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/8b30cc6eecbb496bfdaf2b9c81d5f0a08ae1c02f2433e1bf9dfcbb936d438e12c2a0de99014f325d76dddfda9b833207f615fbcd1d9a25cfc393593c32478621 -libLLVM.v16.0.6+4.i686-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/md5/9298b06192d36c20b56f76348122eec7 -libLLVM.v16.0.6+4.i686-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/sha512/ed173f7e0e7663f2186a519cc53429ad326958773a2211dfaff15ac20326617bf85c1233019b5ee996071b1158353ceea307c6ef2f6f617b81771a69072d3c49 -libLLVM.v16.0.6+4.i686-w64-mingw32-cxx03-llvm_version+16.tar.gz/md5/b267df02f127fbe710a75ce1b24ec70b -libLLVM.v16.0.6+4.i686-w64-mingw32-cxx03-llvm_version+16.tar.gz/sha512/4d78a547ef718810b4e5f2ff81e1edce7492808218e3313587afbc25d59877a2529df3405a9000eb254f88c59822da5a00e764153143b9f7418b0f4adc46c5c9 -libLLVM.v16.0.6+4.i686-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/md5/8719ff4479ca28614a530a97540be161 -libLLVM.v16.0.6+4.i686-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/sha512/d913eb261dabe4074566cb4620d7559613ac539b5f4fa5bde8db5d93c0c729ed5c59d177972f283a449a24df0ec76548ac7db26f8e162d7f08619e9bbfdc11cc -libLLVM.v16.0.6+4.i686-w64-mingw32-cxx11-llvm_version+16.tar.gz/md5/f3c3cbbaa2fe0289815dd022608721c3 -libLLVM.v16.0.6+4.i686-w64-mingw32-cxx11-llvm_version+16.tar.gz/sha512/951adf71911a4b4ec8ad2342c6d4e27797874499e10b8467b56cda5d36496130e72db7e8cda58f0512e04d94c1c144bd66d076451f6048c4c399a9af162202ea -libLLVM.v16.0.6+4.powerpc64le-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/f9ee9ffa905583656c3405f553667e06 -libLLVM.v16.0.6+4.powerpc64le-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/91a96e8b8eba7d6505d6bdb28af993c7f8724a61c0d7179228035cd631535e5307880884249947f481a82b4f6a37f91c3cc15025383c7ce7302c010eb1130f99 -libLLVM.v16.0.6+4.powerpc64le-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/d80972a0609c688f0a1064cb995e84ff -libLLVM.v16.0.6+4.powerpc64le-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/136c5f35ad7c41080472bac15f1a433134468f6b512d4ab7d41408da1d27a3aa6b0e5a6480ec185e4a1eee84ab222231f4de21fae7f852a324dfc702a80afd25 -libLLVM.v16.0.6+4.powerpc64le-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/cc16d38262b9f3e1057d50bc57739ea0 -libLLVM.v16.0.6+4.powerpc64le-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/c62bcbde36850de855fe7c0e010a2a403c8b923da1c1bbc8384410e356c112186d1dc874f664260a8e819b0bde8a457746a32a1fc988b103e1277cf00912000f -libLLVM.v16.0.6+4.powerpc64le-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/70b7a3e70f0f6566e34dcfba524d3ae7 -libLLVM.v16.0.6+4.powerpc64le-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/ae211588739af26ce61f2503adfc9e9711ecb1db5b8ff9072086accbfa55de8ba2086fd09d766d2de15ab3fa6a6a2790be363f20f03b146bd81764a8c6651506 -libLLVM.v16.0.6+4.x86_64-apple-darwin-llvm_version+16.asserts.tar.gz/md5/f2e71e81105619177a8d007f6ad8e9a6 -libLLVM.v16.0.6+4.x86_64-apple-darwin-llvm_version+16.asserts.tar.gz/sha512/dd4f6ee07f69ebd2f49da99d3de3b4394d0520fae6e506fdf4a028e3602c147b0a725f02b0e4712e6568815a460876cfcc05aa453e10ca30f9378925ca12b1d7 -libLLVM.v16.0.6+4.x86_64-apple-darwin-llvm_version+16.tar.gz/md5/fd64aaf12cac1e97a2d6c6a8a73b6bdc -libLLVM.v16.0.6+4.x86_64-apple-darwin-llvm_version+16.tar.gz/sha512/8917408e6f023de7d1f05027d389d9aac7f77623506e9d621487f601e3bc53053b99510266d31840985a380082e7af578c29c400a6dbccc31165bb90bf55bc41 -libLLVM.v16.0.6+4.x86_64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/d05a0f7df67d362e0c48e6a81a7efa73 -libLLVM.v16.0.6+4.x86_64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/8a8adf8b13b02af3ac4ab29e314f689089359b35ac088cf30e0ae8d4d3cc24ca7d63ab908ecc18b6617935a01909e4eae2cdc392b6c7ee69fa0f3cbadff41349 -libLLVM.v16.0.6+4.x86_64-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/d84ad34377aceaafcfb2922141b06790 -libLLVM.v16.0.6+4.x86_64-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/785bf236810f8c9ff0a6477c978059c136e936150e97bf2c45ec23b23accc0aa2df28442cb456d64f31350d1c49811fa4997029fd9f1044890284be494d68500 -libLLVM.v16.0.6+4.x86_64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/275083a9fb3c2cf281f64f08c840249b -libLLVM.v16.0.6+4.x86_64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/01598d993a34faa33948d5a56a91401e100018b154112431c4b124e6e5356afa89870699006a6a4358d1bee1bc8155a1c96efba1c62a6fbcbf796087e1334f41 -libLLVM.v16.0.6+4.x86_64-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/a7e0e0734e86acf47998c94441922a68 -libLLVM.v16.0.6+4.x86_64-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/a96b8e9fa2f34711c7826c4a8615d326fba3b6857ee77b9bf6120dfb3f64638da54fe50c7d6b2fac5aed77755da8d2529ae45daee7f1182b04f8248a34d02f9e -libLLVM.v16.0.6+4.x86_64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/md5/359b3ec71148c1467f3c763e90b5a7ce -libLLVM.v16.0.6+4.x86_64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/sha512/673dca9861ec87cc349678fad4b29489cda2a2f8ed02eb87baa893055e9574a0457c69bcacb17a8b3899a380dd43c44cd9632fd6e60bfc26625ceaa8ddf56385 -libLLVM.v16.0.6+4.x86_64-linux-musl-cxx03-llvm_version+16.tar.gz/md5/118c299f09ffd7946ab66844e056c9c4 -libLLVM.v16.0.6+4.x86_64-linux-musl-cxx03-llvm_version+16.tar.gz/sha512/880df9edee1f67ad1c68b504f03dcac492809aa1252589634300441b469cb84e9697771fd0c516ce25da5223814303b0c1d2bea48342d2b42bdda028272e9cbe -libLLVM.v16.0.6+4.x86_64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/md5/ecb34de28c31cdcab980c45d2c90faca -libLLVM.v16.0.6+4.x86_64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/sha512/bfb6cbb1ef7a712cb36c7d26de346b3bd7d10f3bbc8fa412b23e7332d2eb432a1bbec338cf92d7899d29036915871ecf70148468ef06dfe0042f5ae547505b1f -libLLVM.v16.0.6+4.x86_64-linux-musl-cxx11-llvm_version+16.tar.gz/md5/eff0891d113de03516e229eb0d9d9c33 -libLLVM.v16.0.6+4.x86_64-linux-musl-cxx11-llvm_version+16.tar.gz/sha512/078df9260d75354eeab5c6213e3ae926aa4050bc5c3f8691fffa4ce83e32648fefaa78bc67ee3d76a42dc4bad432ffc132e0733d15fe5f85a60f344fd51be639 -libLLVM.v16.0.6+4.x86_64-unknown-freebsd-llvm_version+16.asserts.tar.gz/md5/b28f51c7f01699b1b7488d3c9b7afaa1 -libLLVM.v16.0.6+4.x86_64-unknown-freebsd-llvm_version+16.asserts.tar.gz/sha512/297895fcbfd2b46e62e9e685eb08aa7710177a753ee7d6f3211dccd790f2677c9c57f8738785c35368c43dcedabb374ec57c7dd54110e0f153b0b8cc4b40bd5c -libLLVM.v16.0.6+4.x86_64-unknown-freebsd-llvm_version+16.tar.gz/md5/3822dc96d157aa849a5c73bafe221b19 -libLLVM.v16.0.6+4.x86_64-unknown-freebsd-llvm_version+16.tar.gz/sha512/a74d9ca78fa7daab47a9a0191356803ce98c8f3d7180073a949fe491d4364f148ff3fdc35d4960dff8ff7f6ecb65b31a471b171c7cab32e89b8252827b059775 -libLLVM.v16.0.6+4.x86_64-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/md5/ab93b1ece593bf2fd37902d7cfcb26b9 -libLLVM.v16.0.6+4.x86_64-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/sha512/3ee486621ec970ba991162a7ac80bc75be46b528a277d256b385a15c96018077862d0708eaa36234530d47d2f83fa934dc7993d4aa32cee0b2885e1c45cb16ab -libLLVM.v16.0.6+4.x86_64-w64-mingw32-cxx03-llvm_version+16.tar.gz/md5/22a246271f82a70c9a72d8387fa340ea -libLLVM.v16.0.6+4.x86_64-w64-mingw32-cxx03-llvm_version+16.tar.gz/sha512/f61f51bb3b7c9d253dcb40ca6a478ac44a6c47bb1f81fc7f562ee682d16081b2307695fb4feb0f3ca495fb8349aafd2b659a4f82b395f7d82e02dc909354b780 -libLLVM.v16.0.6+4.x86_64-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/md5/f642a67480e79f269e3bbfe7b3ceed33 -libLLVM.v16.0.6+4.x86_64-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/sha512/45930e3ae3bf3922c8b3096474cbe22035432e80d2b0f4ccbd424c69e874a76acf4a724e055a5ef73ce40ae00ee6ede60b210b8847c30239a6ec242550a3e464 -libLLVM.v16.0.6+4.x86_64-w64-mingw32-cxx11-llvm_version+16.tar.gz/md5/344f2a9d2b85a6c527fd6fa024d6763e -libLLVM.v16.0.6+4.x86_64-w64-mingw32-cxx11-llvm_version+16.tar.gz/sha512/73909c58087568d8654d48ed5fc952289d8b3a4e26e956e9220cf254b8fb2c4b6630ebc9258502a6c3b67ed3cfe0cbe3a92ee3d346b228d842af03f0a42794c7 -llvm-julia-16.0.6-2.tar.gz/md5/f05607b71ac8d1e7c30430d2a9efa0a6 -llvm-julia-16.0.6-2.tar.gz/sha512/5f2f88b4673b13780fa819c78cb27fc5dab77c2976768ae4f7863b904c911e39fc18ee85d212e512a7c60081c74efd1fa2e7142b78002982533b7326ff808f24 +libLLVM.v16.0.6+5.aarch64-apple-darwin-llvm_version+16.asserts.tar.gz/md5/b65a03cd9f05b01269705d39e0323fe1 +libLLVM.v16.0.6+5.aarch64-apple-darwin-llvm_version+16.asserts.tar.gz/sha512/4b871af800fdbb65c63d6388bac2163d3ca73a24aef19c4adc6d1331e1926b0eabbfe83ec67b3136aba8016157f55a07606f290fde87549a6d5e654ad19fc079 +libLLVM.v16.0.6+5.aarch64-apple-darwin-llvm_version+16.tar.gz/md5/dc33b7f0e24a21e21076798e282d6e12 +libLLVM.v16.0.6+5.aarch64-apple-darwin-llvm_version+16.tar.gz/sha512/0450d3ccfd8228845aa7fb963be89e39689cdf71fdf8f4517aacbf67734659149ec39061c54932e5f598ae87f33ce5cf6f4e2c774e00978df5111ceafd833f54 +libLLVM.v16.0.6+5.aarch64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/21dc2a0c8275e5e8548e0b6f64c56398 +libLLVM.v16.0.6+5.aarch64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/0409642363afdc211ec37421d03a38d2a31839f27c1256bf40c761c1ebf9126680b376c284b15932125ddb2135b4ea45c1b811da1669580fc4219d0d8ee15e05 +libLLVM.v16.0.6+5.aarch64-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/156e99361d1b5188757ab61449c3c1df +libLLVM.v16.0.6+5.aarch64-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/53404ae7668f5a421cb1969e86b50f8526bd89dee5c9a3b9ee7173c48542f89197f880b25974e84b0abe7770eeda3b2053fc4404f431a0298fa1c67c9cb7c794 +libLLVM.v16.0.6+5.aarch64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/8c47c1aba3682105b78f78e668593b9c +libLLVM.v16.0.6+5.aarch64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/3b9a5c3b3214ff999378551280d9de2a501705cbf4991b2ff83182ee3a27ad9b289937513b782f3c2355b7903fc63d64486d98ce9fb3b69fcba09093cb6d35e4 +libLLVM.v16.0.6+5.aarch64-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/dc8d8437ce44aeebf302603f86fbc523 +libLLVM.v16.0.6+5.aarch64-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/7a8d606d34028351acdccd6eee1bf3e140b7f81925ca84cb3a08e8a56944c31de81dfd98b0f9ec4534e94bb38f725a98be6af204b7903d8483681b611c888e82 +libLLVM.v16.0.6+5.aarch64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/md5/d7547f2f191db71e8d4edd3d008384d9 +libLLVM.v16.0.6+5.aarch64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/sha512/597cd6e3f853de3ef372f662cd12c180361d86a7510e3cc4cec6cee32e5ba44f95415b9be77f426ec1a09b5b6466cc1874f0599699786a7dd3baab728f19a6e1 +libLLVM.v16.0.6+5.aarch64-linux-musl-cxx03-llvm_version+16.tar.gz/md5/f5f93cb749e579e697e0e0ee36b2ee29 +libLLVM.v16.0.6+5.aarch64-linux-musl-cxx03-llvm_version+16.tar.gz/sha512/5ab431b7848bc81ee3e6181d49f9e1abac15df9a9eb7f86735d83f4947e6229ef910d2066488d83a0d28464114580487c63102c146c727027d9f2a0b8967c9aa +libLLVM.v16.0.6+5.aarch64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/md5/021e6a41792612a787ae4ddd16e6c8f4 +libLLVM.v16.0.6+5.aarch64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/sha512/b26e094004f5f9f1ec2cd8ba835ec9ca977dff2f63682ec8c8e4fe0825712508d87bd70328a46d7642106fc9f1ea072ddaaf30a40b7424d5b088c6be58b3de4f +libLLVM.v16.0.6+5.aarch64-linux-musl-cxx11-llvm_version+16.tar.gz/md5/fb5a91917816f884f34062cac9ebc644 +libLLVM.v16.0.6+5.aarch64-linux-musl-cxx11-llvm_version+16.tar.gz/sha512/ddbcc1774fce3f0c00721a98ca1e81488759de9d9f4ea2e95128cd05c8a5298a9be08f215d3fb13a218fc42ed3ee5c890a895551f06281f10a0b732052d8850f +libLLVM.v16.0.6+5.armv6l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/33f2111dc67e58d4044c68ad5b426d68 +libLLVM.v16.0.6+5.armv6l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/5173e96e22fac54da6b935ee45c03c6ff73c6ae6e11952fc15ca6f91c20752e6049c77538f9866e85eb0d8694a5518144e294338558755e944940a246f83a50e +libLLVM.v16.0.6+5.armv6l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/md5/40fe62fd45d9e53466134a78eff82bf3 +libLLVM.v16.0.6+5.armv6l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/sha512/aec50173270dd9835140c9e68bc46cdbeae3886191c08423b5541736ddb03817d2ed3d3db331b11688303cb6b7219508e88531cdf40b62381f8250f8440e69fa +libLLVM.v16.0.6+5.armv6l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/579d8dc03c6abcbe2f27bb826bc36990 +libLLVM.v16.0.6+5.armv6l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/972c08b306dfa86cc5329630404a56b7c49f5324c8a0406b4f6bae2259e0ad5459e99d265700f5a5561eda6c2c36bae323bf259417f64bc5bc1a94bd6c0e3987 +libLLVM.v16.0.6+5.armv6l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/md5/6584eb2b6abf91d0c83a9584d0a01141 +libLLVM.v16.0.6+5.armv6l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/sha512/39e523adf40c7edb92221febbb02db2ec4f46f86454a26a4eb5bab6e2cb3eb8eb93639c64d7cd6ab815dff16590fad4578e132dbfe4d730df33edd5a20932e60 +libLLVM.v16.0.6+5.armv6l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/e4419e27b89068a9637de21e7d98128e +libLLVM.v16.0.6+5.armv6l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/8c51da1bdf31b0008d1eaa72a62821f4ff746f7ac49435734ee24cb1503d23e4df48d86bda3bfe6dfdd4b9f3c1b9c03a08697a895e11ef115aabc322cf94bcd2 +libLLVM.v16.0.6+5.armv6l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/md5/bfbe1aa7cd6ff601d2ebbb8a688fcc10 +libLLVM.v16.0.6+5.armv6l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/sha512/1ec053bef1f59e2795b2c273f3e829c5b549f7722d634f39af61638b5ddb9790053770072814d7a9da9b9bdfe012db780b8df430b0080de7e76c74f2d1b5730e +libLLVM.v16.0.6+5.armv6l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/bde0cd20ba626d877a00b2883ffd09fa +libLLVM.v16.0.6+5.armv6l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/c23fe2f7e5917aeb705c39821a053778085ace86af98c3d9288f677ca9c203af6222ab28539762a3e125a344441d95478d640a166e6e12b197be4e96860b89df +libLLVM.v16.0.6+5.armv6l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/md5/2150120dccf7462c59ca92f213764607 +libLLVM.v16.0.6+5.armv6l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/sha512/c33f4380746318c18d0ca57634774eda51ab6171ff18414cbf069efb9a7ae816d378d4e35d89e52a29e167a185a033f6681414cf8e973976b37923f0a0c17575 +libLLVM.v16.0.6+5.armv7l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/bbea53fc9cd0e12a83e3eeca20056632 +libLLVM.v16.0.6+5.armv7l-linux-gnueabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/43df0b341f9ff53672370e52b16425e4a886882281794c32474a78eac34e1b51ed80dac5b8fbc0e29deb48eb23f4b133b4f4fac7f901c576d89bfbcdd181cd38 +libLLVM.v16.0.6+5.armv7l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/md5/d21f214425e1beba4cf64aed671b2764 +libLLVM.v16.0.6+5.armv7l-linux-gnueabihf-cxx03-llvm_version+16.tar.gz/sha512/80b21c6b382012bfd81d891fb6d1da702bba56218aae4964e042119527d3ed5af3bbd312f8945330c4534364d828281a82b3a62898c4da240192e5ca8e560c8b +libLLVM.v16.0.6+5.armv7l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/97359779230fefb414f7f14604d9f0e7 +libLLVM.v16.0.6+5.armv7l-linux-gnueabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/9d3d2f6495d2289c2db80a96805b0cfb2b741151d5996caf9a4478944f30305ec40b6dee9be48d4da3a827483e5677c0071a61a914c6e220f30671627c8c2cf5 +libLLVM.v16.0.6+5.armv7l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/md5/2f062929b35f3136a932950670dde327 +libLLVM.v16.0.6+5.armv7l-linux-gnueabihf-cxx11-llvm_version+16.tar.gz/sha512/05f72e45790e991ba42dc3452095c4e5c6e8211bed3909c6331b2afc76880806b7a3482a17bda3cb99450108ae471361f26b05e0a2c401e16d4f3ffc42d5713d +libLLVM.v16.0.6+5.armv7l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/md5/002a9156a9ba8a4674fbec151e4106d8 +libLLVM.v16.0.6+5.armv7l-linux-musleabihf-cxx03-llvm_version+16.asserts.tar.gz/sha512/9958d56b33cc2fd49e7163527e66ae5b56093a0e54279612ae6f29b4b538175350d3fc5075dc88334f20582e31f4358f092b3400cba891156b44086b56299101 +libLLVM.v16.0.6+5.armv7l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/md5/44396ba708965efd60b891dca24c1fa1 +libLLVM.v16.0.6+5.armv7l-linux-musleabihf-cxx03-llvm_version+16.tar.gz/sha512/ba6e8a15380b4230fd5ef7fb0b569e76de295a8a2cab4141999d88bd8bc0e7b9f36c9b75fe9103a980b5c3fe4b007ab63f5500fc572db341e346f6bc8f5ce585 +libLLVM.v16.0.6+5.armv7l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/md5/852baee50567e6ead11b1b7c14228329 +libLLVM.v16.0.6+5.armv7l-linux-musleabihf-cxx11-llvm_version+16.asserts.tar.gz/sha512/5da7ae9309643a113d576b3aa7f8e24e29871af3f17da1af804f41ecdbd473d24e6230e42723b15299fa41c8c24b76e76eeb7dbd5505403e2a126f4ff878a458 +libLLVM.v16.0.6+5.armv7l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/md5/3fe78c6177f191742763e05f0c18dace +libLLVM.v16.0.6+5.armv7l-linux-musleabihf-cxx11-llvm_version+16.tar.gz/sha512/5e2c82b4b3a6e32fcf0194fe786fb87aaae51ed37c6a2a142e3a3ef26ab451ac443df65f0968e59bcc2c0b55c9e0f944d2f083fdb22c55ebefb8b898f01857e2 +libLLVM.v16.0.6+5.i686-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/6aa57c6a30a55b01f588b13280022f2c +libLLVM.v16.0.6+5.i686-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/e86a6ce52ab9cec084b140a8ba31cd4ad8fea0067c394ae3e36ed886545ff5c282d00f03f132f5320e92eeaccdb11bc8d83145ef90881672695eb9c9d2706571 +libLLVM.v16.0.6+5.i686-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/4418f2e581ef5b1fed8fc8e28ea92656 +libLLVM.v16.0.6+5.i686-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/1ef3ff64bc2338252fe696e4af43c61df01d82106095c892b0e37579a506e2db3dd32553aaece0c2275c1e07aba2eca8a393225dbe002ba134c418de54d6ca34 +libLLVM.v16.0.6+5.i686-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/bb7d8951c0b2a4a90f28e7239cb572fa +libLLVM.v16.0.6+5.i686-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/17354be08d9ebbb1f859b63afd906caafd1e55feda7093707d8e5218dd0bd84e95ff9b575aa7a4efea9c9ed7d4ab2bc49a470b6950ffe34196124e1732010db6 +libLLVM.v16.0.6+5.i686-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/f81446b407e848dc40451f489d29255f +libLLVM.v16.0.6+5.i686-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/9d9844c40bd7297c18570d6757db371d656b44568b26c6d8c54331c7a27c8a38a077e80090ed6ae8ca6737ed08f98b037aad83cd57f5e46691112b6c7d256607 +libLLVM.v16.0.6+5.i686-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/md5/690c99872180001f1e91f783986b972e +libLLVM.v16.0.6+5.i686-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/sha512/f1ad9b4f700fff786fde2fb6560b0ba31979d83d56bbf4ef80ca492d2c23b8d781d8af30f04446a470f56e2833aad0e07494e2ae67eccf1270b8ca093adea116 +libLLVM.v16.0.6+5.i686-w64-mingw32-cxx03-llvm_version+16.tar.gz/md5/cd8fd367f43b45313b2e54257e8485e4 +libLLVM.v16.0.6+5.i686-w64-mingw32-cxx03-llvm_version+16.tar.gz/sha512/305b69b6667597bb7fff838cc478cf8599021173dea4d0504044f9616ded576763050e1699b3cc14f0a1968b33ad6af9e7fcdd03076e1db0bd95f18981c28753 +libLLVM.v16.0.6+5.i686-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/md5/e41c93e32c56067da5b6c7479a9a7165 +libLLVM.v16.0.6+5.i686-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/sha512/da6e3203a58f9a690f91a425466918e2b8ce585545a85489eecef7c3a2ade4aba1ac8f93a8a6fcb39b998be809355aedfd882f9dea47a9628449738f549529f5 +libLLVM.v16.0.6+5.i686-w64-mingw32-cxx11-llvm_version+16.tar.gz/md5/42ac7b1f08c825198611d9c934d1ee23 +libLLVM.v16.0.6+5.i686-w64-mingw32-cxx11-llvm_version+16.tar.gz/sha512/c4f76978a8d22408e821e7932c37c59f1d2e171688b5aa57ae69f25094ee10cd79482f919ffd9cc8bfe5f613e4a1c8eee964d80558912f1ffac9421d307bbba5 +libLLVM.v16.0.6+5.powerpc64le-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/b8e7d594d6bd933072ecf80e3bb58f9c +libLLVM.v16.0.6+5.powerpc64le-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/8ad811ade5ac16788456f33ef57a90ce9c5aa197321574099a05ede9144009d0d22b3107fb33f934e292fd7bcbcb120f94f54b783a05e7834afda9c1292e3cf2 +libLLVM.v16.0.6+5.powerpc64le-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/4d5386c541928781cd25d45bf93f28ca +libLLVM.v16.0.6+5.powerpc64le-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/b6698c10652ab9dea491f7f74db077b9c85a19790d3c0de8cab3b1d68b944153e500ae33e3a24d9a774069f48302a5eb9c002fc48d7d9a36e6fb488801ff5c16 +libLLVM.v16.0.6+5.powerpc64le-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/6e3b1d9e6a59306ca136db7356024950 +libLLVM.v16.0.6+5.powerpc64le-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/454bf9338899e86475a7892858554db55717fbbad7a70838aabd2d34bcf6eb735f22662e9f56aaf850c66f81df8057f2e9cc1a1fd0aacab7a893c8d26efdbe13 +libLLVM.v16.0.6+5.powerpc64le-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/60b6ebb51120a0f28b548a2d373f3da8 +libLLVM.v16.0.6+5.powerpc64le-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/0d9166a1a6c9e2590f61ae9b0f5fa46dbcce0757af09f1d1c3c47d3e7a75a64026f641b213b38ba6f15bc28958e719adb01fca187af1414739c5d9e422e79b64 +libLLVM.v16.0.6+5.x86_64-apple-darwin-llvm_version+16.asserts.tar.gz/md5/534349c6c985ffb4d92ff87d14ec769a +libLLVM.v16.0.6+5.x86_64-apple-darwin-llvm_version+16.asserts.tar.gz/sha512/97be984919a912dfe241b3fb85e4c16a80995f4bcae7f144d1c3d3cc942ede9f502cb5f6569bfd99f62b309ff936a063d1495787dc986155642f5289e7a7a986 +libLLVM.v16.0.6+5.x86_64-apple-darwin-llvm_version+16.tar.gz/md5/c5239f27b0b9f61d499be07401996cb1 +libLLVM.v16.0.6+5.x86_64-apple-darwin-llvm_version+16.tar.gz/sha512/d26be2323798a3474d50e2092a07f6d2523f25c39db1cead0450f860d7918da0d9cfe315a1069e6877bcd3fa2597ee3b53c3c0346eed4ef0bea588d740fdca64 +libLLVM.v16.0.6+5.x86_64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/md5/8b4c831576f8f52e4d5e7f10b9409ddc +libLLVM.v16.0.6+5.x86_64-linux-gnu-cxx03-llvm_version+16.asserts.tar.gz/sha512/a4e0ab7bfa2f481dbe8d20bdbc7ecd9cdfb66da18b4eae3ca92820a3f906e2d5e3247296ec5a85e52e30add7c417c4c7be1264dd49c0df1748d4e2116649ea38 +libLLVM.v16.0.6+5.x86_64-linux-gnu-cxx03-llvm_version+16.tar.gz/md5/fa4d4cf5fd2a0e7154651759490e4e9e +libLLVM.v16.0.6+5.x86_64-linux-gnu-cxx03-llvm_version+16.tar.gz/sha512/a905c618d3bdb5dafb7494742b7803c82956bdcef9ea926bd5209125042d16bcf7c9e907383d6283f8a9ebf712faca40676e9182eeac664a5ebfb62e0a7efb10 +libLLVM.v16.0.6+5.x86_64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/md5/b7ddde905045fbe2ef022817593f6da6 +libLLVM.v16.0.6+5.x86_64-linux-gnu-cxx11-llvm_version+16.asserts.tar.gz/sha512/33d86bf1f8c5272954648ad86362ae33ba3a872f0eb97ea8be340fcb3f2576d986d4f6b748b96081e519d4b6db8a8d827fbf75c5491d95a5a18831b3aeeba3d8 +libLLVM.v16.0.6+5.x86_64-linux-gnu-cxx11-llvm_version+16.tar.gz/md5/a28a25c7daf024a2b2e52f31eb98a775 +libLLVM.v16.0.6+5.x86_64-linux-gnu-cxx11-llvm_version+16.tar.gz/sha512/3406107292f02f6375293d34ca7e8adb3ecb7d951334b25a39d8105c6d025e382af40050c35cdc6091657a16cf4fa635d23384b16d800b87ac26f3c7682d008a +libLLVM.v16.0.6+5.x86_64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/md5/3b3790da4411cda6e2215a81d45b7e09 +libLLVM.v16.0.6+5.x86_64-linux-musl-cxx03-llvm_version+16.asserts.tar.gz/sha512/aad5b208952e92712f9b5134a1bee53c4d35bc520b4bf68639f7f4d084391fb6ca2960ca14057da224a48e6d25df3cf617ec0b658fe514dfe90aa67f6b51e19d +libLLVM.v16.0.6+5.x86_64-linux-musl-cxx03-llvm_version+16.tar.gz/md5/72b13ef3ffd513c67b16b296717b4ebb +libLLVM.v16.0.6+5.x86_64-linux-musl-cxx03-llvm_version+16.tar.gz/sha512/63e5427a32f13fe761912a9312aac18bd990d1a237126ad84cbf470180468e9fd11e681b8e6118aff37bb510683f414596d090d7397f3ca8817c64cd0f01f07c +libLLVM.v16.0.6+5.x86_64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/md5/4e60b080716bdd3095479ae803318bcb +libLLVM.v16.0.6+5.x86_64-linux-musl-cxx11-llvm_version+16.asserts.tar.gz/sha512/0bfe1acce368e13aea5aed12a1a5709a48ca760b196d14acf38d7dbd5a44dc02a153a711a14d778b7830f386d1cb490a0766bf7543a0d3250e5b6148a2fde265 +libLLVM.v16.0.6+5.x86_64-linux-musl-cxx11-llvm_version+16.tar.gz/md5/2763e0464f55e9f6cc8275a0b93e3586 +libLLVM.v16.0.6+5.x86_64-linux-musl-cxx11-llvm_version+16.tar.gz/sha512/1a508e2cd2c8d7a879e4235a545aabfd2b1ef7a1b9a8d90f1306a625a4ae612dae3fee7feb892fe14200a57f7be14a68d7c9c30fd495fc4411d2b7ccdbafe3c7 +libLLVM.v16.0.6+5.x86_64-unknown-freebsd-llvm_version+16.asserts.tar.gz/md5/a0fcd5121dbd574a12fccf8263c139da +libLLVM.v16.0.6+5.x86_64-unknown-freebsd-llvm_version+16.asserts.tar.gz/sha512/8c8bd0956f437a7383972e5d316adf3d0c420b40bf6de43db9797cf6005028edc3f7c64f3e84254e3313e8279d2b969362e5bf53646d148b772b608224fd8e4e +libLLVM.v16.0.6+5.x86_64-unknown-freebsd-llvm_version+16.tar.gz/md5/5128bd872c5bc47bbc31973561f2df61 +libLLVM.v16.0.6+5.x86_64-unknown-freebsd-llvm_version+16.tar.gz/sha512/9cdc7a7cf96f22aa2d6c3fabbcda418a915fb13c1069657e6272921d43c8213635be17a6bade65f18446fff1bef8316f9bef2eea54d11b8a1d70fe248394ba5c +libLLVM.v16.0.6+5.x86_64-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/md5/df3386f6092837fe97ec1320f6e08fe3 +libLLVM.v16.0.6+5.x86_64-w64-mingw32-cxx03-llvm_version+16.asserts.tar.gz/sha512/600f64be80a8345568ec91fdcb25977a27379c34bc31b2c0af6a79b85b9cfcb55b71260dd1a7169e5c7cacee65a4a5905eaa4559951037dc7eca172c76ff2a22 +libLLVM.v16.0.6+5.x86_64-w64-mingw32-cxx03-llvm_version+16.tar.gz/md5/791c3966f9b2251517cb0dd59d5bf0a4 +libLLVM.v16.0.6+5.x86_64-w64-mingw32-cxx03-llvm_version+16.tar.gz/sha512/8bb4f1017575cfc036fa9e8a40e5e86c91f565d2c0242e77078017ce25facab13d0850ce4737fb24d88bc0238a980fc86777a3467516ab77dccb8a677d219e47 +libLLVM.v16.0.6+5.x86_64-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/md5/ae9f60e3b3bf663e9f954af3e535f349 +libLLVM.v16.0.6+5.x86_64-w64-mingw32-cxx11-llvm_version+16.asserts.tar.gz/sha512/a7186f12a35bf6db0ee0d18f222eb238c94fc7c6980eb9557172d232d034b1a14ace05812323ae55d1f6901f4fcaae4eb11970516a3e3cad5d648e6913550e31 +libLLVM.v16.0.6+5.x86_64-w64-mingw32-cxx11-llvm_version+16.tar.gz/md5/e5aca0453eb7e407e8e6c4b605765625 +libLLVM.v16.0.6+5.x86_64-w64-mingw32-cxx11-llvm_version+16.tar.gz/sha512/803b4f9b39c08c3241f8ae824b4314c89719e6b71a98b5587798ef5fe8380ae803ab91bf0fade37ef752af4f2b6de1dedac297d3b7d7abbf1507151429d51f55 +llvm-julia-16.0.6-3.tar.gz/md5/f05607b71ac8d1e7c30430d2a9efa0a6 +llvm-julia-16.0.6-3.tar.gz/sha512/5f2f88b4673b13780fa819c78cb27fc5dab77c2976768ae4f7863b904c911e39fc18ee85d212e512a7c60081c74efd1fa2e7142b78002982533b7326ff808f24 llvmunwind-12.0.1.tar.xz/md5/4ec327cee517fdb1f6a20e83748e2c7b llvmunwind-12.0.1.tar.xz/sha512/847b6ba03010a43f4fdbfdc49bf16d18fd18474d01584712e651b11191814bf7c1cf53475021d9ee447ed78413202b4ed97973d7bdd851d3e49f8d06f55a7af4 diff --git a/deps/clang.version b/deps/clang.version index a950bc32aca6b..db148cfc1ad50 100644 --- a/deps/clang.version +++ b/deps/clang.version @@ -1,4 +1,4 @@ ## jll artifact # Clang (paired with LLVM, only here as a JLL download) CLANG_JLL_NAME := Clang -CLANG_JLL_VER := 16.0.6+4 +CLANG_JLL_VER := 16.0.6+5 diff --git a/deps/lld.version b/deps/lld.version index 949577bdacae2..6043f47eeaaf2 100644 --- a/deps/lld.version +++ b/deps/lld.version @@ -1,3 +1,3 @@ ## jll artifact LLD_JLL_NAME := LLD -LLD_JLL_VER := 16.0.6+4 +LLD_JLL_VER := 16.0.6+5 diff --git a/deps/llvm-tools.version b/deps/llvm-tools.version index 8191c8742dcbb..3d97fc5c27e59 100644 --- a/deps/llvm-tools.version +++ b/deps/llvm-tools.version @@ -1,5 +1,5 @@ ## jll artifact # LLVM_tools (downloads LLVM_jll to get things like `lit` and `opt`) LLVM_TOOLS_JLL_NAME := LLVM -LLVM_TOOLS_JLL_VER := 16.0.6+4 -LLVM_TOOLS_ASSERT_JLL_VER := 16.0.6+4 +LLVM_TOOLS_JLL_VER := 16.0.6+5 +LLVM_TOOLS_ASSERT_JLL_VER := 16.0.6+5 diff --git a/deps/llvm.version b/deps/llvm.version index 7e74cf2e4fd65..21cc1b10f33e2 100644 --- a/deps/llvm.version +++ b/deps/llvm.version @@ -2,14 +2,14 @@ ## jll artifact LLVM_JLL_NAME := libLLVM -LLVM_ASSERT_JLL_VER := 16.0.6+4 +LLVM_ASSERT_JLL_VER := 16.0.6+5 ## source build # Version number of LLVM LLVM_VER := 16.0.6 # Git branch name in `LLVM_GIT_URL` repository -LLVM_BRANCH=julia-16.0.6-2 +LLVM_BRANCH=julia-16.0.6-3 # Git ref in `LLVM_GIT_URL` repository -LLVM_SHA1=julia-16.0.6-2 +LLVM_SHA1=julia-16.0.6-3 ## Following options are used to automatically fetch patchset from Julia's fork. This is ## useful if you want to build an external LLVM while still applying Julia's patches. diff --git a/src/julia.expmap.in b/src/julia.expmap.in index 3c21f3093ffc9..b28a714e75f69 100644 --- a/src/julia.expmap.in +++ b/src/julia.expmap.in @@ -5,8 +5,8 @@ asprintf*; bitvector_*; ios_*; - arraylist_grow; - small_arraylist_grow; + arraylist_*; + small_arraylist_*; jl_*; ijl_*; _jl_mutex_*; diff --git a/stdlib/LLD_jll/Project.toml b/stdlib/LLD_jll/Project.toml index fccea03ebd80e..c51c06609a33b 100644 --- a/stdlib/LLD_jll/Project.toml +++ b/stdlib/LLD_jll/Project.toml @@ -1,6 +1,6 @@ name = "LLD_jll" uuid = "d55e3150-da41-5e91-b323-ecfd1eec6109" -version = "16.0.6+4" +version = "16.0.6+5" [deps] Zlib_jll = "83775a58-1f1d-513f-b197-d71354ab007a" diff --git a/stdlib/Manifest.toml b/stdlib/Manifest.toml index 79ff7d22bd562..5ad675ac21510 100644 --- a/stdlib/Manifest.toml +++ b/stdlib/Manifest.toml @@ -68,7 +68,7 @@ version = "1.11.0" [[deps.LLD_jll]] deps = ["Artifacts", "Libdl", "Zlib_jll", "libLLVM_jll"] uuid = "d55e3150-da41-5e91-b323-ecfd1eec6109" -version = "16.0.6+4" +version = "16.0.6+5" [[deps.LLVMLibUnwind_jll]] deps = ["Artifacts", "Libdl"] @@ -276,7 +276,7 @@ version = "2.2.5+0" [[deps.libLLVM_jll]] deps = ["Artifacts", "Libdl"] uuid = "8f36deef-c2a5-5394-99ed-8e07531fb29a" -version = "16.0.6+4" +version = "16.0.6+5" [[deps.libblastrampoline_jll]] deps = ["Artifacts", "Libdl"] diff --git a/stdlib/libLLVM_jll/Project.toml b/stdlib/libLLVM_jll/Project.toml index 3decbf5f81512..eddbeda0a6288 100644 --- a/stdlib/libLLVM_jll/Project.toml +++ b/stdlib/libLLVM_jll/Project.toml @@ -1,6 +1,6 @@ name = "libLLVM_jll" uuid = "8f36deef-c2a5-5394-99ed-8e07531fb29a" -version = "16.0.6+4" +version = "16.0.6+5" [deps] Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb" From 8063884bbfeb768cd4864752d9ebdf69e3cb8f2b Mon Sep 17 00:00:00 2001 From: Kristoffer Date: Thu, 10 Apr 2025 14:02:36 +0200 Subject: [PATCH 55/56] Revert "power uses Float64 exponents for integers (#53967)" This reverts commit 237ad1a1e73170e0efdcf4601c28413b10613e00. --- base/math.jl | 52 +++++++++------------------------------- base/special/exp.jl | 2 +- test/compiler/codegen.jl | 2 +- test/math.jl | 19 --------------- 4 files changed, 13 insertions(+), 62 deletions(-) diff --git a/base/math.jl b/base/math.jl index a26f6fc5f4053..ab88d25e647ee 100644 --- a/base/math.jl +++ b/base/math.jl @@ -1140,10 +1140,6 @@ function modf(x::T) where T<:IEEEFloat return (rx, ix) end -@inline function use_power_by_squaring(n::Integer) - -2^12 <= n <= 3 * 2^13 -end - # @constprop aggressive to help the compiler see the switch between the integer and float # variants for callers with constant `y` @constprop :aggressive function ^(x::Float64, y::Float64) @@ -1156,33 +1152,24 @@ end y = sign(y)*0x1.8p62 end yint = unsafe_trunc(Int64, y) # This is actually safe since julia freezes the result - yisint = y == yint - if yisint - yint == 0 && return 1.0 - use_power_by_squaring(yint) && return @noinline pow_body(x, yint) - end - 2*xu==0 && return abs(y)*Inf*(!(y>0)) # if x === +0.0 or -0.0 (Inf * false === 0.0) - s = 1 - if x < 0 - !yisint && throw_exp_domainerror(x) # y isn't an integer - s = ifelse(isodd(yint), -1, 1) - end - !isfinite(x) && return copysign(x,s)*(y>0 || isnan(x)) # x is inf or NaN - return copysign(pow_body(abs(x), y), s) -end - -@assume_effects :foldable @noinline function pow_body(x::Float64, y::Float64) - xu = reinterpret(UInt64, x) + y == yint && return @noinline x^yint + 2*xu==0 && return abs(y)*Inf*(!(y>0)) # if x==0 + x<0 && throw_exp_domainerror(x) # |y| is small enough that y isn't an integer + !isfinite(x) && return x*(y>0 || isnan(x)) # x is inf or NaN if xu < (UInt64(1)<<52) # x is subnormal xu = reinterpret(UInt64, x * 0x1p52) # normalize x xu &= ~sign_mask(Float64) xu -= UInt64(52) << 52 # mess with the exponent end + return pow_body(xu, y) +end + +@inline function pow_body(xu::UInt64, y::Float64) logxhi,logxlo = _log_ext(xu) xyhi, xylo = two_mul(logxhi,y) xylo = muladd(logxlo, y, xylo) hi = xyhi+xylo - return @inline Base.Math.exp_impl(hi, xylo-(hi-xyhi), Val(:ℯ)) + return Base.Math.exp_impl(hi, xylo-(hi-xyhi), Val(:ℯ)) end @constprop :aggressive function ^(x::T, y::T) where T <: Union{Float16, Float32} @@ -1206,29 +1193,12 @@ end return T(exp2(log2(abs(widen(x))) * y)) end +# compensated power by squaring @constprop :aggressive @inline function ^(x::Float64, n::Integer) - x^clamp(n, Int64) -end -@constprop :aggressive @inline function ^(x::Float64, n::Int64) n == 0 && return one(x) - if use_power_by_squaring(n) - return pow_body(x, n) - else - s = ifelse(x < 0 && isodd(n), -1.0, 1.0) - x = abs(x) - y = float(n) - if y == n - return copysign(pow_body(x, y), s) - else - n2 = n % 1024 - y = float(n - n2) - return pow_body(x, y) * copysign(pow_body(x, n2), s) - end - end + return pow_body(x, n) end -# compensated power by squaring -# this method is only reliable for -2^20 < n < 2^20 (cf. #53881 #53886) @assume_effects :terminates_locally @noinline function pow_body(x::Float64, n::Integer) y = 1.0 xnlo = ynlo = 0.0 diff --git a/base/special/exp.jl b/base/special/exp.jl index 38d7509807aed..32de6b9be296d 100644 --- a/base/special/exp.jl +++ b/base/special/exp.jl @@ -252,7 +252,7 @@ end twopk = (k + UInt64(53)) << 52 return reinterpret(T, twopk + reinterpret(UInt64, small_part))*0x1p-53 end - k == 1024 && return (small_part * 2.0) * 2.0^1023 + #k == 1024 && return (small_part * 2.0) * 2.0^1023 end twopk = Int64(k) << 52 return reinterpret(T, twopk + reinterpret(Int64, small_part)) diff --git a/test/compiler/codegen.jl b/test/compiler/codegen.jl index 1c4f8e969c82b..e63ea5588cad9 100644 --- a/test/compiler/codegen.jl +++ b/test/compiler/codegen.jl @@ -866,7 +866,7 @@ if Sys.ARCH === :x86_64 foo52079() = Core.Intrinsics.have_fma(Float64) if foo52079() == true let io = IOBuffer() - code_native(io,Base.Math.exp_impl,(Float64,Float64,Val{:ℯ}), dump_module=false) + code_native(io,^,(Float64,Float64), dump_module=false) str = String(take!(io)) @test !occursin("fma_emulated", str) @test occursin("vfmadd", str) diff --git a/test/math.jl b/test/math.jl index 3a06db8a22fa0..ff105cbee37ef 100644 --- a/test/math.jl +++ b/test/math.jl @@ -1464,25 +1464,6 @@ end # two cases where we have observed > 1 ULP in the past @test 0.0013653274095082324^-97.60372292227069 == 4.088393948750035e279 @test 8.758520413376658e-5^70.55863059215994 == 5.052076767078296e-287 - - # issue #53881 - c53881 = 2.2844135865398217e222 # check correctness within 2 ULPs - @test prevfloat(1.0) ^ -Int64(2)^62 ≈ c53881 atol=2eps(c53881) - @test 2.0 ^ typemin(Int) == 0.0 - @test (-1.0) ^ typemin(Int) == 1.0 - Z = Int64(2) - E = prevfloat(1.0) - @test E ^ (-Z^54) ≈ 7.38905609893065 - @test E ^ (-Z^62) ≈ 2.2844135865231613e222 - @test E ^ (-Z^63) == Inf - @test abs(E ^ (Z^62-1) * E ^ (-Z^62+1) - 1) <= eps(1.0) - n, x = -1065564664, 0.9999997040311492 - @test abs(x^n - Float64(big(x)^n)) / eps(x^n) == 0 # ULPs - @test E ^ (big(2)^100 + 1) == 0 - @test E ^ 6705320061009595392 == nextfloat(0.0) - n = Int64(1024 / log2(E)) - @test E^n == Inf - @test E^float(n) == Inf end @testset "special function `::Real` fallback shouldn't recur without bound, issue #57789" begin From eccd25aedbae2191cd8103cc26cf6bc2e64cf35c Mon Sep 17 00:00:00 2001 From: Kristoffer Date: Thu, 10 Apr 2025 15:47:33 +0200 Subject: [PATCH 56/56] Revert "fix `mod` for mixes of `Signed` and `Unsigned` (#57853)" This reverts commit 9b474fa2a592e0a94b31853b39fc6d60a043db57. --- base/int.jl | 10 ++-------- test/int.jl | 17 ----------------- 2 files changed, 2 insertions(+), 25 deletions(-) diff --git a/base/int.jl b/base/int.jl index f9cdce44f88dc..0c7a0219d8c2a 100644 --- a/base/int.jl +++ b/base/int.jl @@ -286,14 +286,8 @@ function mod(x::T, y::T) where T<:Integer y == -1 && return T(0) # avoid potential overflow in fld return x - fld(x, y) * y end -function mod(x::BitSigned, y::Unsigned) - remval = rem(x, y) # correct iff remval>=0 - return unsigned(remval + (remval0 so correct iff y>0 or remval==0 - return remval + (!iszero(remval) && y