Merge branch 'master' into hr/create_expr_cache

Author: ranocha

Makefile

@@ -459,8 +459,9 @@ endif
 
 
 exe:
-	# run Inno Setup to compile installer
-	$(call spawn,$(JULIAHOME)/dist-extras/inno/iscc.exe /DAppVersion=$(JULIA_VERSION) /DSourceDir="$(call cygpath_w,$(BUILDROOT)/julia-$(JULIA_COMMIT))" /DRepoDir="$(call cygpath_w,$(JULIAHOME))" /F"$(JULIA_BINARYDIST_FILENAME)" /O"$(call cygpath_w,$(BUILDROOT))" $(INNO_ARGS) $(call cygpath_w,$(JULIAHOME)/contrib/windows/build-installer.iss))
+	# run Inno Setup to compile installer.
+	# Note that we disable MSYS2 path munging, as it interferes with the `/` options:
+	MSYS2_ARG_CONV_EXCL='*' $(call spawn,$(JULIAHOME)/dist-extras/inno/iscc.exe /DAppVersion=$(JULIA_VERSION) /DSourceDir="$(call cygpath_w,$(BUILDROOT)/julia-$(JULIA_COMMIT))" /DRepoDir="$(call cygpath_w,$(JULIAHOME))" /F"$(JULIA_BINARYDIST_FILENAME)" /O"$(call cygpath_w,$(BUILDROOT))" $(INNO_ARGS) $(call cygpath_w,$(JULIAHOME)/contrib/windows/build-installer.iss))
 	chmod a+x "$(BUILDROOT)/$(JULIA_BINARYDIST_FILENAME).exe"
 
 app:
@@ -585,7 +586,7 @@ win-extras:
 	cd $(JULIAHOME)/dist-extras && \
 	$(JLDOWNLOAD) https://www.jrsoftware.org/download.php/is.exe && \
 	chmod a+x is.exe && \
-	$(call spawn, $(JULIAHOME)/dist-extras/is.exe /DIR="$(call cygpath_w,$(JULIAHOME)/dist-extras/inno)" /PORTABLE=1 /CURRENTUSER /VERYSILENT)
+	MSYS2_ARG_CONV_EXCL='*' $(call spawn, $(JULIAHOME)/dist-extras/is.exe /DIR="$(call cygpath_w,$(JULIAHOME)/dist-extras/inno)" /PORTABLE=1 /CURRENTUSER /VERYSILENT)
 
 # various statistics about the build that may interest the user
 ifeq ($(USE_SYSTEM_LLVM), 1)

base/abstractarray.jl

@@ -3473,8 +3473,9 @@ function circshift!(a::AbstractVector, shift::Integer)
     n == 0 && return
     shift = mod(shift, n)
     shift == 0 && return
-    reverse!(a, 1, shift)
-    reverse!(a, shift+1, length(a))
+    l = lastindex(a)
+    reverse!(a, firstindex(a), l-shift)
+    reverse!(a, l-shift+1, lastindex(a))
     reverse!(a)
     return a
 end

base/compiler/abstractinterpretation.jl

@@ -2240,7 +2240,9 @@ end
 
 function abstract_eval_phi(interp::AbstractInterpreter, phi::PhiNode, vtypes::Union{VarTable, Nothing}, sv::Union{InferenceState, IRCode})
     rt = Union{}
-    for val in phi.values
+    for i in 1:length(phi.values)
+        isassigned(phi.values, i) || continue
+        val = phi.values[i]
         rt = tmerge(typeinf_lattice(interp), rt, abstract_eval_special_value(interp, val, vtypes, sv))
     end
     return rt

base/compiler/ssair/inlining.jl

@@ -699,18 +699,6 @@ function batch_inline!(todo::Vector{Pair{Int, Any}}, ir::IRCode, linetable::Vect
                     compact.active_result_bb -= 1
                     refinish = true
                 end
-                # It is possible for GlobalRefs and Exprs to be in argument position
-                # at this point in the IR, though in that case they are required
-                # to be effect-free. However, we must still move them out of argument
-                # position, since `Argument` is allowed in PhiNodes, but `GlobalRef`
-                # and `Expr` are not, so a substitution could anger the verifier.
-                for aidx in 1:length(argexprs)
-                    aexpr = argexprs[aidx]
-                    if isa(aexpr, Expr) || isa(aexpr, GlobalRef)
-                        ninst = effect_free(NewInstruction(aexpr, argextype(aexpr, compact), compact.result[idx][:line]))
-                        argexprs[aidx] = insert_node_here!(compact, ninst)
-                    end
-                end
                 if isa(item, InliningTodo)
                     compact.ssa_rename[old_idx] = ir_inline_item!(compact, idx, argexprs, linetable, item, boundscheck, state.todo_bbs)
                 elseif isa(item, UnionSplit)

base/compiler/ssair/irinterp.jl

@@ -134,11 +134,16 @@ function concrete_eval_invoke(interp::AbstractInterpreter, ir::IRCode, mi_cache,
     return nothing
 end
 
+function abstract_eval_phi_stmt(interp::AbstractInterpreter, phi::PhiNode, ir::IRCode, id::Int, dt::LazyDomtree)
+    return abstract_eval_phi(interp, phi, nothing, ir)
+end
+
 function reprocess_instruction!(interp::AbstractInterpreter, ir::IRCode, mi::MethodInstance,
                                 mi_cache,
                                 tpdum::TwoPhaseDefUseMap, idx::Int, bb::Union{Int, Nothing},
                                 @nospecialize(inst), @nospecialize(typ),
-                                phi_revisit::BitSet)
+                                phi_revisit::BitSet,
+                                dt::LazyDomtree)
     function update_phi!(from::Int, to::Int)
         if length(ir.cfg.blocks[to].preds) == 0
             return
@@ -181,7 +186,7 @@ function reprocess_instruction!(interp::AbstractInterpreter, ir::IRCode, mi::Met
         if isa(inst, Expr) || isa(inst, PhiNode)
             if isa(inst, PhiNode) || inst.head === :call || inst.head === :foreigncall || inst.head === :new
                 if isa(inst, PhiNode)
-                    rt = abstract_eval_phi(interp, inst, nothing, ir)
+                    rt = abstract_eval_phi_stmt(interp, inst, ir, idx, dt)
                 else
                     (;rt, effects) = abstract_eval_statement_expr(interp, inst, nothing, ir, mi)
                     # All other effects already guaranteed effect free by construction
@@ -243,6 +248,7 @@ function _ir_abstract_constant_propagation(interp::AbstractInterpreter, mi_cache
     all_rets = Int[]
 
     tpdum = TwoPhaseDefUseMap(length(ir.stmts))
+    dt = LazyDomtree(ir)
 
     """
         process_terminator!
@@ -303,7 +309,7 @@ function _ir_abstract_constant_propagation(interp::AbstractInterpreter, mi_cache
                 delete!(ssa_refined, idx)
             end
             if any_refined && reprocess_instruction!(interp, ir, mi, mi_cache,
-                    tpdum, idx, bb, inst, typ, ssa_refined)
+                    tpdum, idx, bb, inst, typ, ssa_refined, dt)
                 push!(ssa_refined, idx)
             end
             if idx == lstmt && process_terminator!(ip, bb, idx)
@@ -370,7 +376,7 @@ function _ir_abstract_constant_propagation(interp::AbstractInterpreter, mi_cache
         inst = ir.stmts[idx][:inst]
         typ = ir.stmts[idx][:type]
         if reprocess_instruction!(interp, ir, mi, mi_cache,
-                tpdum, idx, nothing, inst, typ, ssa_refined)
+                tpdum, idx, nothing, inst, typ, ssa_refined, dt)
             append!(stmt_ip, tpdum[idx])
         end
     end

base/compiler/ssair/verify.jl

@@ -2,7 +2,7 @@
 
 function maybe_show_ir(ir::IRCode)
     if isdefined(Core, :Main)
-        Core.Main.Base.display(ir)
+        invokelatest(Core.Main.Base.display, ir)
     end
 end
 

base/compiler/typelimits.jl

@@ -433,6 +433,8 @@ function tmerge(lattice::ConditionalsLattice, @nospecialize(typea), @nospecializ
         end
         return Bool
     end
+    typea = widenconditional(typea)
+    typeb = widenconditional(typeb)
     return tmerge(widenlattice(lattice), typea, typeb)
 end
 
@@ -471,8 +473,9 @@ end
 
 function tmerge(lattice::PartialsLattice, @nospecialize(typea), @nospecialize(typeb))
     # type-lattice for Const and PartialStruct wrappers
-    if ((isa(typea, PartialStruct) || isa(typea, Const)) &&
-        (isa(typeb, PartialStruct) || isa(typeb, Const)))
+    acp = isa(typea, Const) || isa(typea, PartialStruct)
+    bcp = isa(typeb, Const) || isa(typeb, PartialStruct)
+    if acp && bcp
         aty = widenconst(typea)
         bty = widenconst(typeb)
         if aty === bty
@@ -521,22 +524,40 @@ function tmerge(lattice::PartialsLattice, @nospecialize(typea), @nospecialize(ty
             return anyrefine ? PartialStruct(aty, fields) : aty
         end
     end
+    # Don't widen const here - external AbstractInterpreter might insert lattice
+    # layers between us and `ConstsLattice`.
+    isa(typea, PartialStruct) && (typea = widenconst(typea))
+    isa(typeb, PartialStruct) && (typeb = widenconst(typeb))
 
     # type-lattice for PartialOpaque wrapper
-    if isa(typea, PartialOpaque) && isa(typeb, PartialOpaque) && widenconst(typea) == widenconst(typeb)
-        if !(typea.source === typeb.source &&
-             typea.parent === typeb.parent)
-            return widenconst(typea)
+    apo = isa(typea, PartialOpaque)
+    bpo = isa(typeb, PartialOpaque)
+    if apo && bpo
+        aty = widenconst(typea)
+        bty = widenconst(typeb)
+        if aty == bty
+            if !(typea.source === typeb.source &&
+                typea.parent === typeb.parent)
+                return widenconst(typea)
+            end
+            return PartialOpaque(typea.typ, tmerge(typea.env, typeb.env),
+                typea.parent, typea.source)
         end
-        return PartialOpaque(typea.typ, tmerge(typea.env, typeb.env),
-            typea.parent, typea.source)
+        typea = aty
+        typeb = bty
+    elseif apo
+        typea = widenconst(typea)
+    elseif bpo
+        typeb = widenconst(typeb)
     end
 
-    # no special type-inference lattice, join the types
-    typea, typeb = widenconst(typea), widenconst(typeb)
-    @assert isa(typea, Type); @assert isa(typeb, Type)
+    return tmerge(widenlattice(lattice), typea, typeb)
+end
 
-    return tmerge(JLTypeLattice(), typea, typeb)
+function tmerge(lattice::ConstsLattice, @nospecialize(typea), @nospecialize(typeb))
+    # the equality of the constants can be checked here, but the equivalent check is usually
+    # done by `tmerge_fast_path` at earlier lattice stage
+    return tmerge(widenlattice(lattice), widenconst(typea), widenconst(typeb))
 end
 
 function tmerge(::JLTypeLattice, @nospecialize(typea::Type), @nospecialize(typeb::Type))

base/logging.jl

@@ -671,7 +671,7 @@ function handle_message(logger::SimpleLogger, level::LogLevel, message, _module,
         remaining > 0 || return
     end
     buf = IOBuffer()
-    stream = logger.stream
+    stream::IO = logger.stream
     if !(isopen(stream)::Bool)
         stream = stderr
     end

deps/checksums/SparseArrays-1bae96dc8f9a8ca8b7879eef4cf71e186598e982.tar.gz/md5

@@ -0,0 +1 @@
+88144ed473b0ca6154ec55a8977c281c

deps/checksums/SparseArrays-1bae96dc8f9a8ca8b7879eef4cf71e186598e982.tar.gz/sha512

@@ -0,0 +1 @@
+1c8c27f6b74c60dedecd6dd58de6b4b400bf3b942104e3ba7319a10a111ebbab0be03f98f072c073f43ca454d187674737dd34c1c9acb92adf3c8b76b3c400ac

deps/checksums/SparseArrays-91814c1e84421a9c43b2776fc9dc96ec25104ac8.tar.gz/md5

@@ -1,7 +1,7 @@
 SuiteSparse-5.10.1.tar.gz/md5/68bb912f3cf3d2b01f30ebafef690302
 SuiteSparse-5.10.1.tar.gz/sha512/8f85c6d63b76cba95707dfa732c51200df7794cb4c2599dbd92100475747b8d02b05089a47096e85c60b89bc852a8e768e0670f24902a82d29494a80ccf2bb5f
-SuiteSparse-ed89e0fe3d8908cede058f42f872ba60159af0a6.tar.gz/md5/3019404c83511b5aab962559c2924072
-SuiteSparse-ed89e0fe3d8908cede058f42f872ba60159af0a6.tar.gz/sha512/06fa991da05376ee7e55a30f6fa29ab60ed2cec79818e217290e0e256233ee321fb25a764cbe834c3e94755b02d5326c93c8f1b686c53da28023778787e6d57f
+SuiteSparse-e8285dd13a6d5b5cf52d8124793fc4d622d07554.tar.gz/md5/46541001073d1c3c85e18d910f8308f3
+SuiteSparse-e8285dd13a6d5b5cf52d8124793fc4d622d07554.tar.gz/sha512/f7470a447b934ca9315e216a07b97e363f11bc93186f9aa057b20b2d05092c58ae4f1b733de362de4a0730861c00be4ca5588d0b3ba65f018c1798b9122b9672
 SuiteSparse.v5.10.1+0.aarch64-apple-darwin.tar.gz/md5/b9392f8e71c0c40d37489e7b2071c5ad
 SuiteSparse.v5.10.1+0.aarch64-apple-darwin.tar.gz/sha512/109d67cb009e3b2931b94d63cbdaaee29d60dc190b731ebe3737181cd48d913b8a1333043c67be8179c73e4d3ae32ed1361ab4e34312c0f42e4b29f8a7afda3e
 SuiteSparse.v5.10.1+0.aarch64-linux-gnu.tar.gz/md5/1b2651ede4a74cd57f65505a65093314

deps/checksums/SparseArrays-91814c1e84421a9c43b2776fc9dc96ec25104ac8.tar.gz/sha512

@@ -1366,6 +1366,7 @@ static void jl_collect_backedges(jl_array_t *edges, jl_array_t *ext_targets)
     jl_value_t *invokeTypes;
     jl_method_instance_t *c;
     size_t i;
+    size_t world = jl_get_world_counter();
     void **table = edges_map.table;    // edges is caller => callees
     size_t table_size = edges_map.size;
     for (i = 0; i < table_size; i += 2) {
@@ -1408,15 +1409,28 @@ static void jl_collect_backedges(jl_array_t *edges, jl_array_t *ext_targets)
                         size_t min_valid = 0;
                         size_t max_valid = ~(size_t)0;
                         int ambig = 0;
-                        jl_value_t *matches = jl_matching_methods((jl_tupletype_t*)sig, jl_nothing, -1, 0, jl_atomic_load_acquire(&jl_world_counter), &min_valid, &max_valid, &ambig);
-                        if (matches == jl_false) {
-                            valid = 0;
-                            break;
-                        }
-                        size_t k;
-                        for (k = 0; k < jl_array_len(matches); k++) {
-                            jl_method_match_t *match = (jl_method_match_t *)jl_array_ptr_ref(matches, k);
-                            jl_array_ptr_set(matches, k, match->method);
+                        jl_value_t *matches;
+                        if (mode == 2 && callee && jl_is_method_instance(callee) && jl_is_type(sig)) {
+                            // invoke, use subtyping
+                            jl_methtable_t *mt = jl_method_get_table(((jl_method_instance_t*)callee)->def.method);
+                            size_t min_world, max_world;
+                            matches = jl_gf_invoke_lookup_worlds(sig, (jl_value_t*)mt, world, &min_world, &max_world);
+                            if (matches == jl_nothing) {
+                                valid = 0;
+                                break;
+                            }
+                            matches = (jl_value_t*)((jl_method_match_t*)matches)->method;
+                        } else {
+                            matches = jl_matching_methods((jl_tupletype_t*)sig, jl_nothing, -1, 0, jl_atomic_load_acquire(&jl_world_counter), &min_valid, &max_valid, &ambig);
+                            if (matches == jl_false) {
+                                valid = 0;
+                                break;
+                            }
+                            size_t k;
+                            for (k = 0; k < jl_array_len(matches); k++) {
+                                jl_method_match_t *match = (jl_method_match_t *)jl_array_ptr_ref(matches, k);
+                                jl_array_ptr_set(matches, k, match->method);
+                            }
                         }
                         jl_array_ptr_1d_push(ext_targets, mode == 1 ? NULL : sig);
                         jl_array_ptr_1d_push(ext_targets, callee);
@@ -2542,8 +2556,10 @@ static void jl_verify_edges(jl_array_t *targets, jl_array_t **pvalids)
     jl_array_t *valids = jl_alloc_array_1d(jl_array_uint8_type, l);
     memset(jl_array_data(valids), 1, l);
     jl_value_t *loctag = NULL, *matches = NULL;
-    JL_GC_PUSH2(&loctag, &matches);
+    jl_methtable_t *mt = NULL;
+    JL_GC_PUSH3(&loctag, &matches, &mt);
     *pvalids = valids;
+    size_t world = jl_get_world_counter();
     for (i = 0; i < l; i++) {
         jl_value_t *invokesig = jl_array_ptr_ref(targets, i * 3);
         jl_value_t *callee = jl_array_ptr_ref(targets, i * 3 + 1);
@@ -2555,33 +2571,43 @@ static void jl_verify_edges(jl_array_t *targets, jl_array_t **pvalids)
         else {
             sig = callee == NULL ? invokesig : callee;
         }
-        jl_array_t *expected = (jl_array_t*)jl_array_ptr_ref(targets, i * 3 + 2);
-        assert(jl_is_array(expected));
+        jl_value_t *expected = jl_array_ptr_ref(targets, i * 3 + 2);
         int valid = 1;
         size_t min_valid = 0;
         size_t max_valid = ~(size_t)0;
         int ambig = 0;
-        // TODO: possibly need to included ambiguities too (for the optimizer correctness)?
-        matches = jl_matching_methods((jl_tupletype_t*)sig, jl_nothing, -1, 0, jl_atomic_load_acquire(&jl_world_counter), &min_valid, &max_valid, &ambig);
-        if (matches == jl_false || jl_array_len(matches) != jl_array_len(expected)) {
-            valid = 0;
-        }
-        else {
-            size_t j, k, l = jl_array_len(expected);
-            for (k = 0; k < jl_array_len(matches); k++) {
-                jl_method_match_t *match = (jl_method_match_t*)jl_array_ptr_ref(matches, k);
-                jl_method_t *m = match->method;
-                for (j = 0; j < l; j++) {
-                    if (m == (jl_method_t*)jl_array_ptr_ref(expected, j))
+        int use_invoke = invokesig == NULL || callee == NULL ? 0 : 1;
+        if (!use_invoke) {
+            // TODO: possibly need to included ambiguities too (for the optimizer correctness)?
+            matches = jl_matching_methods((jl_tupletype_t*)sig, jl_nothing, -1, 0, jl_atomic_load_acquire(&jl_world_counter), &min_valid, &max_valid, &ambig);
+            if (matches == jl_false || jl_array_len(matches) != jl_array_len(expected)) {
+                valid = 0;
+            }
+            else {
+                assert(jl_is_array(expected));
+                size_t j, k, l = jl_array_len(expected);
+                for (k = 0; k < jl_array_len(matches); k++) {
+                    jl_method_match_t *match = (jl_method_match_t*)jl_array_ptr_ref(matches, k);
+                    jl_method_t *m = match->method;
+                    for (j = 0; j < l; j++) {
+                        if (m == (jl_method_t*)jl_array_ptr_ref(expected, j))
+                            break;
+                    }
+                    if (j == l) {
+                        // intersection has a new method or a method was
+                        // deleted--this is now probably no good, just invalidate
+                        // everything about it now
+                        valid = 0;
                         break;
+                    }
                 }
-                if (j == l) {
-                    // intersection has a new method or a method was
-                    // deleted--this is now probably no good, just invalidate
-                    // everything about it now
-                    valid = 0;
-                    break;
-                }
+            }
+        } else {
+            mt = jl_method_get_table(((jl_method_instance_t*)callee)->def.method);
+            size_t min_world, max_world;
+            matches = jl_gf_invoke_lookup_worlds(invokesig, (jl_value_t*)mt, world, &min_world, &max_world);
+            if (matches == jl_nothing || expected != (jl_value_t*)((jl_method_match_t*)matches)->method) {
+                valid = 0;
             }
         }
         jl_array_uint8_set(valids, i, valid);
@@ -2593,7 +2619,7 @@ static void jl_verify_edges(jl_array_t *targets, jl_array_t **pvalids)
             jl_array_ptr_1d_push(_jl_debug_method_invalidation, loctag);
             loctag = jl_box_uint64(jl_worklist_key(serializer_worklist));
             jl_array_ptr_1d_push(_jl_debug_method_invalidation, loctag);
-            if (matches != jl_false) {
+            if (!use_invoke && matches != jl_false) {
                 // setdiff!(matches, expected)
                 size_t j, k, ins = 0;
                 for (j = 0; j < jl_array_len(matches); j++) {

deps/checksums/suitesparse

@@ -1738,8 +1738,9 @@ static void NOINLINE gc_mark_stack_resize(jl_gc_mark_cache_t *gc_cache, jl_gc_ma
     jl_gc_mark_data_t *old_data = gc_cache->data_stack;
     void **pc_stack = sp->pc_start;
     size_t stack_size = (char*)sp->pc_end - (char*)pc_stack;
+    ptrdiff_t datadiff = (char*)sp->data - (char*)old_data;
     gc_cache->data_stack = (jl_gc_mark_data_t *)realloc_s(old_data, stack_size * 2 * sizeof(jl_gc_mark_data_t));
-    sp->data = (jl_gc_mark_data_t *)(((char*)sp->data) + (((char*)gc_cache->data_stack) - ((char*)old_data)));
+    sp->data = (jl_gc_mark_data_t *)((char*)gc_cache->data_stack + datadiff);
 
     sp->pc_start = gc_cache->pc_stack = (void**)realloc_s(pc_stack, stack_size * 2 * sizeof(void*));
     gc_cache->pc_stack_end = sp->pc_end = sp->pc_start + stack_size * 2;