Merge branch 'master' into useaffinity

Author: tkf

base/compiler/optimize.jl

@@ -384,7 +384,7 @@ end
 
 """
     finish(interp::AbstractInterpreter, opt::OptimizationState,
-           params::OptimizationParams, ir::IRCode, result) -> analyzed::Union{Nothing,ConstAPI}
+           params::OptimizationParams, ir::IRCode, caller::InferenceResult) -> analyzed::Union{Nothing,ConstAPI}
 
 Post process information derived by Julia-level optimizations for later uses:
 - computes "purity", i.e. side-effect-freeness
@@ -394,16 +394,18 @@ In a case when the purity is proven, `finish` can return `ConstAPI` object wrapp
 value so that the runtime system will use the constant calling convention for the method calls.
 """
 function finish(interp::AbstractInterpreter, opt::OptimizationState,
-                params::OptimizationParams, ir::IRCode, @nospecialize(result))
+                params::OptimizationParams, ir::IRCode, caller::InferenceResult)
     (; src, linfo) = opt
     (; def, specTypes) = linfo
 
     analyzed = nothing # `ConstAPI` if this call can use constant calling convention
     force_noinline = _any(@nospecialize(x) -> isexpr(x, :meta) && x.args[1] === :noinline, ir.meta)
 
     # compute inlining and other related optimizations
-    wresult = isa(result, InterConditional) ? widenconditional(result) : result
-    if (isa(wresult, Const) || isconstType(wresult))
+    result = caller.result
+    @assert !(result isa LimitedAccuracy)
+    result = isa(result, InterConditional) ? widenconditional(result) : result
+    if (isa(result, Const) || isconstType(result))
         proven_pure = false
         # must be proven pure to use constant calling convention;
         # otherwise we might skip throwing errors (issue #20704)
@@ -437,14 +439,14 @@ function finish(interp::AbstractInterpreter, opt::OptimizationState,
             # Still set pure flag to make sure `inference` tests pass
             # and to possibly enable more optimization in the future
             src.pure = true
-            if isa(wresult, Const)
-                val = wresult.val
+            if isa(result, Const)
+                val = result.val
                 if is_inlineable_constant(val)
                     analyzed = ConstAPI(val)
                 end
             else
-                @assert isconstType(wresult)
-                analyzed = ConstAPI(wresult.parameters[1])
+                @assert isconstType(result)
+                analyzed = ConstAPI(result.parameters[1])
             end
             force_noinline || (src.inlineable = true)
         end
@@ -501,9 +503,10 @@ function finish(interp::AbstractInterpreter, opt::OptimizationState,
 end
 
 # run the optimization work
-function optimize(interp::AbstractInterpreter, opt::OptimizationState, params::OptimizationParams, @nospecialize(result))
+function optimize(interp::AbstractInterpreter, opt::OptimizationState,
+                  params::OptimizationParams, caller::InferenceResult)
     @timeit "optimizer" ir = run_passes(opt.src, opt)
-    return finish(interp, opt, params, ir, result)
+    return finish(interp, opt, params, ir, caller)
 end
 
 function run_passes(ci::CodeInfo, sv::OptimizationState)

base/compiler/typeinfer.jl

@@ -250,9 +250,7 @@ function _typeinf(interp::AbstractInterpreter, frame::InferenceState)
     for (caller, _, _) in results
         opt = caller.src
         if opt isa OptimizationState # implies `may_optimize(interp) === true`
-            result_type = caller.result
-            @assert !(result_type isa LimitedAccuracy)
-            analyzed = optimize(interp, opt, OptimizationParams(interp), result_type)
+            analyzed = optimize(interp, opt, OptimizationParams(interp), caller)
             if isa(analyzed, ConstAPI)
                 # XXX: The work in ir_to_codeinf! is essentially wasted. The only reason
                 # we're doing it is so that code_llvm can return the code

stdlib/LinearAlgebra/src/triangular.jl

@@ -1485,7 +1485,7 @@ end
 function ldiv!(xA::Union{UpperTriangular,UnitUpperTriangular}, B::UpperTriangular)
     return UpperTriangular(ldiv!(xA, triu!(B.data)))
 end
-function ldiv!(xA::Union{LowerTriangular,UnitLowerTriangular}, B::UpperTriangular)
+function ldiv!(xA::Union{LowerTriangular,UnitLowerTriangular}, B::LowerTriangular)
     return LowerTriangular(ldiv!(xA, tril!(B.data)))
 end
 

stdlib/LinearAlgebra/test/triangular.jl

@@ -376,7 +376,8 @@ for elty1 in (Float32, Float64, BigFloat, ComplexF32, ComplexF64, Complex{BigFlo
                 @test_throws DimensionMismatch A2'  * offsizeA
                 @test_throws DimensionMismatch A2   * offsizeA
                 if (uplo1 == uplo2 && elty1 == elty2 != Int && t1 != UnitLowerTriangular && t1 != UnitUpperTriangular)
-                    @test rdiv!(copy(A1), copy(A2)) ≈ A1/A2 ≈ Matrix(A1)/Matrix(A2)
+                    @test rdiv!(copy(A1), copy(A2))::t1 ≈ A1/A2 ≈ Matrix(A1)/Matrix(A2)
+                    @test ldiv!(copy(A2), copy(A1))::t1 ≈ A2\A1 ≈ Matrix(A2)\Matrix(A1)
                 end
                 if (uplo1 != uplo2 && elty1 == elty2 != Int && t2 != UnitLowerTriangular && t2 != UnitUpperTriangular)
                     @test lmul!(adjoint(copy(A1)), copy(A2)) ≈ A1'*A2 ≈ Matrix(A1)'*Matrix(A2)