Refactor TBAA hierarchy creating both immutable and mutable union selectors.

Author: gbaraldi

Compiler/test/codegen.jl

@@ -1047,3 +1047,22 @@ f57872() = (Core.isdefinedglobal(@__MODULE__, Base.compilerbarrier(:const, :x578
 @noinline f_mutateany(@nospecialize x) = x[] = 1
 g_mutateany() = (y = Ref(0); f_mutateany(y); y[])
 @test g_mutateany() === 1
+
+# 58470 tbaa for unionselbyte for mut and immut
+
+mutable struct Wrapper58470
+    x::Union{Nothing,Int}
+end
+
+function findsomething58470(dict, inds)
+    default = Wrapper58470(nothing)
+    for i in inds
+        x = get(dict, i, default).x
+        if !isnothing(x)
+            return x
+        end
+    end
+    return nothing
+end
+
+@test occursin("tindex_ptr", get_llvm(findsomething58470, Tuple{Dict{Int64, Wrapper58470}, Vector{Int}}))

src/cgutils.cpp

@@ -3131,7 +3131,8 @@ static jl_cgval_t emit_getfield_knownidx(jl_codectx_t &ctx, const jl_cgval_t &st
             bool isptr = (union_max == 0);
             assert(!isptr && fsz < jl_field_size(jt, idx)); (void)isptr;
             Value *ptindex = emit_ptrgep(ctx, addr, fsz1);
-            return emit_unionload(ctx, addr, ptindex, jfty, fsz, al, tbaa, false, union_max, strct.tbaa);
+            auto tindex_tbaa = jl_is_mutable(strct.typ) ? ctx.tbaa().tbaa_mutable_unionselbyte : ctx.tbaa().tbaa_immut_unionselbyte;
+            return emit_unionload(ctx, addr, ptindex, jfty, fsz, al, tbaa, false, union_max, tindex_tbaa);
         }
         else if (jfty == (jl_value_t*)jl_bool_type) {
             unsigned align = jl_field_align(jt, idx);
@@ -3166,7 +3167,8 @@ static jl_cgval_t emit_getfield_knownidx(jl_codectx_t &ctx, const jl_cgval_t &st
             assert(!isptr && fsz < jl_field_size(jt, idx)); (void)isptr;
             size_t fsz1 = jl_field_size(jt, idx) - 1;
             Value *ptindex = emit_ptrgep(ctx, staddr, byte_offset + fsz1);
-            auto val = emit_unionload(ctx, addr, ptindex, jfty, fsz, al, tbaa, !jl_field_isconst(jt, idx), union_max, strct.tbaa);
+            auto tindex_tbaa = jl_is_mutable(strct.typ) ? ctx.tbaa().tbaa_mutable_unionselbyte : ctx.tbaa().tbaa_immut_unionselbyte;
+            auto val = emit_unionload(ctx, addr, ptindex, jfty, fsz, al, tbaa, !jl_field_isconst(jt, idx), union_max, tindex_tbaa);
             if (val.V && val.V != addr) {
                 setNameWithField(ctx.emission_context, val.V, get_objname, jt, idx, Twine());
             }
@@ -4141,7 +4143,7 @@ static jl_cgval_t emit_setfield(jl_codectx_t &ctx,
         size_t fsz1 = jl_field_size(sty, idx0) - 1;
         Value *ptindex = emit_ptrgep(ctx, addr, fsz1);
         setNameWithField(ctx.emission_context, ptindex, get_objname, sty, idx0, Twine(".tindex_ptr"));
-        return union_store(ctx, addr, ptindex, rhs, cmp, jfty, tbaa, ctx.tbaa().tbaa_unionselbyte,
+        return union_store(ctx, addr, ptindex, rhs, cmp, jfty, tbaa, ctx.tbaa().tbaa_mutable_unionselbyte,
             Order, FailOrder,
             needlock, issetfield, isreplacefield, isswapfield, ismodifyfield, issetfieldonce,
             modifyop, fname);
@@ -4325,7 +4327,7 @@ static jl_cgval_t emit_new_struct(jl_codectx_t &ctx, jl_value_t *ty, size_t narg
                     }
                     else {
                         Value *ptindex = emit_ptrgep(ctx, strct, offs + fsz1);
-                        jl_aliasinfo_t ai = jl_aliasinfo_t::fromTBAA(ctx, ctx.tbaa().tbaa_unionselbyte);
+                        jl_aliasinfo_t ai = jl_aliasinfo_t::fromTBAA(ctx, ctx.tbaa().tbaa_immut_unionselbyte);
                         ai.decorateInst(ctx.builder.CreateAlignedStore(tindex, ptindex, Align(1)));
                         if (!rhs_union.isghost)
                             emit_unionmove(ctx, dest, ctx.tbaa().tbaa_stack, fval_info, nullptr);
@@ -4409,7 +4411,8 @@ static jl_cgval_t emit_new_struct(jl_codectx_t &ctx, jl_value_t *ty, size_t narg
         undef_derived_strct(ctx, strct, sty, strctinfo.tbaa);
         for (size_t i = nargs; i < nf; i++) {
             if (!jl_field_isptr(sty, i) && jl_is_uniontype(jl_field_type(sty, i))) {
-                jl_aliasinfo_t ai = jl_aliasinfo_t::fromTBAA(ctx, ctx.tbaa().tbaa_unionselbyte);
+                auto tindex_tbaa = jl_is_mutable(sty) ? ctx.tbaa().tbaa_mutable_unionselbyte : ctx.tbaa().tbaa_immut_unionselbyte;
+                jl_aliasinfo_t ai = jl_aliasinfo_t::fromTBAA(ctx, tindex_tbaa);
                 ai.decorateInst(ctx.builder.CreateAlignedStore(
                         ConstantInt::get(getInt8Ty(ctx.builder.getContext()), 0),
                         emit_ptrgep(ctx, strct, jl_field_offset(sty, i) + jl_field_size(sty, i) - 1),

src/codegen.cpp

@@ -331,11 +331,12 @@ struct jl_tbaacache_t {
     // LLVM should have enough info for alias analysis of non-gcframe stack slot
     // this is mainly a place holder for `jl_cgval_t::tbaa`
     MDNode *tbaa_stack;      // stack slot
-    MDNode *tbaa_unionselbyte;   // a selector byte in isbits Union struct fields
+    MDNode *tbaa_immut_unionselbyte;   // a selector byte in isbits Union struct fields
     MDNode *tbaa_data;       // Any user data that `pointerset/ref` are allowed to alias
     MDNode *tbaa_binding;        // jl_binding_t::value
     MDNode *tbaa_value;          // jl_value_t, that is not jl_array_t or jl_genericmemory_t
     MDNode *tbaa_mutab;              // mutable type
+    MDNode *tbaa_mutable_unionselbyte;   // a selector byte in mutable isbits Union struct fields
     MDNode *tbaa_datatype;               // datatype
     MDNode *tbaa_immut;              // immutable type
     MDNode *tbaa_ptrarraybuf;    // Data in an array of boxed values
@@ -351,8 +352,8 @@ struct jl_tbaacache_t {
     bool initialized;
 
     jl_tbaacache_t(): tbaa_root(nullptr), tbaa_gcframe(nullptr), tbaa_stack(nullptr),
-                    tbaa_unionselbyte(nullptr), tbaa_data(nullptr), tbaa_binding(nullptr),
-                    tbaa_value(nullptr), tbaa_mutab(nullptr), tbaa_datatype(nullptr),
+                    tbaa_immut_unionselbyte(nullptr), tbaa_data(nullptr), tbaa_binding(nullptr),
+                    tbaa_value(nullptr), tbaa_mutab(nullptr),tbaa_mutable_unionselbyte(nullptr), tbaa_datatype(nullptr),
                     tbaa_immut(nullptr), tbaa_ptrarraybuf(nullptr), tbaa_arraybuf(nullptr),
                     tbaa_array(nullptr), tbaa_arrayptr(nullptr), tbaa_arraysize(nullptr),
                     tbaa_arrayselbyte(nullptr), tbaa_memoryptr(nullptr), tbaa_memorylen(nullptr), tbaa_memoryown(nullptr),
@@ -376,7 +377,6 @@ struct jl_tbaacache_t {
         tbaa_gcframe = tbaa_make_child(mbuilder, "jtbaa_gcframe").first;
         MDNode *tbaa_stack_scalar;
         std::tie(tbaa_stack, tbaa_stack_scalar) = tbaa_make_child(mbuilder, "jtbaa_stack");
-        tbaa_unionselbyte = tbaa_make_child(mbuilder, "jtbaa_unionselbyte", tbaa_stack_scalar).first;
         MDNode *tbaa_data_scalar;
         std::tie(tbaa_data, tbaa_data_scalar) = tbaa_make_child(mbuilder, "jtbaa_data");
         tbaa_binding = tbaa_make_child(mbuilder, "jtbaa_binding", tbaa_data_scalar).first;
@@ -386,8 +386,11 @@ struct jl_tbaacache_t {
         MDNode *tbaa_mutab_scalar;
         std::tie(tbaa_mutab, tbaa_mutab_scalar) =
             tbaa_make_child(mbuilder, "jtbaa_mutab", tbaa_value_scalar);
+        MDNode *tbaa_immut_scalar;
         tbaa_datatype = tbaa_make_child(mbuilder, "jtbaa_datatype", tbaa_mutab_scalar).first;
-        tbaa_immut = tbaa_make_child(mbuilder, "jtbaa_immut", tbaa_value_scalar).first;
+        tbaa_mutable_unionselbyte = tbaa_make_child(mbuilder, "jtbaa_mut_unionselbyte", tbaa_mutab_scalar).first;
+        std::tie(tbaa_immut, tbaa_immut_scalar) = tbaa_make_child(mbuilder, "jtbaa_immut", tbaa_value_scalar);
+        tbaa_immut_unionselbyte = tbaa_make_child(mbuilder, "jtbaa_immut_unionselbyte", tbaa_immut_scalar).first;
         tbaa_arraybuf = tbaa_make_child(mbuilder, "jtbaa_arraybuf", tbaa_data_scalar).first;
         tbaa_ptrarraybuf = tbaa_make_child(mbuilder, "jtbaa_ptrarraybuf", tbaa_data_scalar).first;
         MDNode *tbaa_array_scalar;