codegen: fix alignment of source in typed_load from a unsafe_load (#57845)

vtjnash · KristofferC · commit dd47fcbbdb9e · 2025-03-22T13:08:51.000+01:00
The unsafe_load code tries to reuse some of the logic from safe loads, but needs to be careful to override the parts that are not safe with slower versions of them. Similar to the typo-fix from ec3c02a on v1.11-backports. Seen in the IR for code_llvm(optimize=false, raw=true, unsafe_load, (Ptr{Tuple{UInt128}},)) causing LightBSON to fail. Fix ancapdev/LightBSON.jl#37 (cherry picked from commit 36b046d)
diff --git a/src/ccall.cpp b/src/ccall.cpp
@@ -547,7 +547,7 @@ static Value *julia_to_native(
     Align align(julia_alignment(jlto));
     Value *slot = emit_static_alloca(ctx, to, align);
     setName(ctx.emission_context, slot, "native_convert_buffer");
-    emit_unbox_store(ctx, jvinfo, slot, ctx.tbaa().tbaa_stack, align);
+    emit_unbox_store(ctx, jvinfo, slot, ctx.tbaa().tbaa_stack, align, align);
     return slot;
 }
 
diff --git a/src/cgutils.cpp b/src/cgutils.cpp
@@ -301,7 +301,7 @@ static Value *emit_pointer_from_objref(jl_codectx_t &ctx, Value *V)
 }
 
 static Value *emit_unbox(jl_codectx_t &ctx, Type *to, const jl_cgval_t &x, jl_value_t *jt);
-static void emit_unbox_store(jl_codectx_t &ctx, const jl_cgval_t &x, Value* dest, MDNode *tbaa_dest, Align alignment, bool isVolatile=false);
+static void emit_unbox_store(jl_codectx_t &ctx, const jl_cgval_t &x, Value* dest, MDNode *tbaa_dest, MaybeAlign align_src, Align align_dst, bool isVolatile=false);
 
 static bool type_is_permalloc(jl_value_t *typ)
 {
@@ -1090,7 +1090,7 @@ static void split_value_into(jl_codectx_t &ctx, const jl_cgval_t &x, Align align
         return;
     }
     if (inline_roots_ptr == nullptr) {
-        emit_unbox_store(ctx, x, dst, ctx.tbaa().tbaa_stack, align_dst, isVolatileStore);
+        emit_unbox_store(ctx, x, dst, ctx.tbaa().tbaa_stack, align_src, align_dst, isVolatileStore);
         return;
     }
     Value *src = data_pointer(ctx, value_to_pointer(ctx, x));
@@ -1152,7 +1152,7 @@ static void split_value_into(jl_codectx_t &ctx, const jl_cgval_t &x, Align align
         return;
     }
     if (inline_roots.empty()) {
-        emit_unbox_store(ctx, x, dst, ctx.tbaa().tbaa_stack, align_dst);
+        emit_unbox_store(ctx, x, dst, ctx.tbaa().tbaa_stack, align_src, align_dst, false);
         return;
     }
     Value *src = data_pointer(ctx, value_to_pointer(ctx, x));
@@ -2351,7 +2351,7 @@ static jl_cgval_t typed_store(jl_codectx_t &ctx,
             r = boxed(ctx, rhs);
         }
         else if (intcast) {
-            emit_unbox_store(ctx, rhs, intcast, ctx.tbaa().tbaa_stack, intcast->getAlign());
+            emit_unbox_store(ctx, rhs, intcast, ctx.tbaa().tbaa_stack, MaybeAlign(), intcast->getAlign());
             r = ctx.builder.CreateLoad(realelty, intcast);
         }
         else if (aliasscope || Order != AtomicOrdering::NotAtomic || (tracked_pointers && rhs.inline_roots.empty())) {
@@ -2389,7 +2389,7 @@ static jl_cgval_t typed_store(jl_codectx_t &ctx,
         }
         else {
             assert(Order == AtomicOrdering::NotAtomic && !isboxed && rhs.typ == jltype);
-            emit_unbox_store(ctx, rhs, ptr, tbaa, Align(alignment));
+            emit_unbox_store(ctx, rhs, ptr, tbaa, MaybeAlign(), Align(alignment));
         }
     }
     else if (isswapfield) {
@@ -2438,7 +2438,7 @@ static jl_cgval_t typed_store(jl_codectx_t &ctx,
                 }
                 cmp = update_julia_type(ctx, cmp, jltype);
                 if (intcast) {
-                    emit_unbox_store(ctx, cmp, intcast, ctx.tbaa().tbaa_stack, intcast->getAlign());
+                    emit_unbox_store(ctx, cmp, intcast, ctx.tbaa().tbaa_stack, MaybeAlign(), intcast->getAlign());
                     Compare = ctx.builder.CreateLoad(realelty, intcast);
                 }
                 else {
@@ -2509,7 +2509,7 @@ static jl_cgval_t typed_store(jl_codectx_t &ctx,
                 r = boxed(ctx, rhs);
             }
             else if (intcast) {
-                emit_unbox_store(ctx, rhs, intcast, ctx.tbaa().tbaa_stack, intcast->getAlign());
+                emit_unbox_store(ctx, rhs, intcast, ctx.tbaa().tbaa_stack, MaybeAlign(), intcast->getAlign());
                 r = ctx.builder.CreateLoad(realelty, intcast);
                 if (!tracked_pointers) // oldval is a slot, so put the oldval back
                     ctx.builder.CreateStore(realCompare, intcast);
@@ -2556,7 +2556,7 @@ static jl_cgval_t typed_store(jl_codectx_t &ctx,
             }
             else {
                 assert(!isboxed && rhs.typ == jltype);
-                emit_unbox_store(ctx, rhs, ptr, tbaa, Align(alignment));
+                emit_unbox_store(ctx, rhs, ptr, tbaa, MaybeAlign(), Align(alignment));
             }
             ctx.builder.CreateBr(DoneBB);
             instr = load;
@@ -3352,9 +3352,10 @@ static void init_bits_value(jl_codectx_t &ctx, Value *newv, Value *v, MDNode *tb
 static void init_bits_cgval(jl_codectx_t &ctx, Value *newv, const jl_cgval_t &v)
 {
     MDNode *tbaa = jl_is_mutable(v.typ) ? ctx.tbaa().tbaa_mutab : ctx.tbaa().tbaa_immut;
-    Align newv_align{std::max(julia_alignment(v.typ), (unsigned)sizeof(void*))};
+    unsigned alignment = julia_alignment(v.typ);
+    unsigned newv_align = std::max(alignment, (unsigned)sizeof(void*));
     newv = maybe_decay_tracked(ctx, newv);
-    emit_unbox_store(ctx, v, newv, tbaa, newv_align);
+    emit_unbox_store(ctx, v, newv, tbaa, Align(alignment), Align(newv_align));
 }
 
 static jl_value_t *static_constant_instance(const llvm::DataLayout &DL, Constant *constant, jl_value_t *jt)
@@ -3808,7 +3809,7 @@ static void emit_unionmove(jl_codectx_t &ctx, Value *dest, MDNode *tbaa_dst, con
         if (jl_is_pointerfree(typ)) {
             emit_guarded_test(ctx, skip, nullptr, [&] {
                 unsigned alignment = julia_alignment(typ);
-                emit_unbox_store(ctx, mark_julia_const(ctx, src.constant), dest, tbaa_dst, Align(alignment), isVolatile);
+                emit_unbox_store(ctx, mark_julia_const(ctx, src.constant), dest, tbaa_dst, Align(alignment), Align(alignment), isVolatile);
                 return nullptr;
             });
         }
@@ -3818,7 +3819,7 @@ static void emit_unionmove(jl_codectx_t &ctx, Value *dest, MDNode *tbaa_dst, con
         if (jl_is_pointerfree(src.typ)) {
             emit_guarded_test(ctx, skip, nullptr, [&] {
                 unsigned alignment = julia_alignment(src.typ);
-                emit_unbox_store(ctx, src, dest, tbaa_dst, Align(alignment), isVolatile);
+                emit_unbox_store(ctx, src, dest, tbaa_dst, Align(alignment), Align(alignment), isVolatile);
                 return nullptr;
             });
         }
@@ -4273,6 +4274,8 @@ static jl_cgval_t emit_new_struct(jl_codectx_t &ctx, jl_value_t *ty, size_t narg
                     }
                 }
                 else {
+                    Align align_dst(jl_field_align(sty, i));
+                    Align align_src(julia_alignment(jtype));
                     if (field_promotable) {
                         fval_info.V->replaceAllUsesWith(dest);
                         cast<Instruction>(fval_info.V)->eraseFromParent();
@@ -4281,10 +4284,10 @@ static jl_cgval_t emit_new_struct(jl_codectx_t &ctx, jl_value_t *ty, size_t narg
                         fval = emit_unbox(ctx, fty, fval_info, jtype);
                     }
                     else if (!roots.empty()) {
-                        split_value_into(ctx, fval_info, Align(julia_alignment(jtype)), dest, Align(jl_field_align(sty, i)), jl_aliasinfo_t::fromTBAA(ctx, ctx.tbaa().tbaa_stack), roots);
+                        split_value_into(ctx, fval_info, align_src, dest, align_dst, jl_aliasinfo_t::fromTBAA(ctx, ctx.tbaa().tbaa_stack), roots);
                     }
                     else {
-                        emit_unbox_store(ctx, fval_info, dest, ctx.tbaa().tbaa_stack, Align(jl_field_align(sty, i)));
+                        emit_unbox_store(ctx, fval_info, dest, ctx.tbaa().tbaa_stack, align_src, align_dst);
                     }
                 }
                 if (init_as_value) {
diff --git a/src/codegen.cpp b/src/codegen.cpp
@@ -5731,7 +5731,7 @@ static void emit_vi_assignment_unboxed(jl_codectx_t &ctx, jl_varinfo_t &vi, Valu
                 if (vi.inline_roots)
                     split_value_into(ctx, rval_info, align, vi.value.V, align, jl_aliasinfo_t::fromTBAA(ctx, tbaa), vi.inline_roots, jl_aliasinfo_t::fromTBAA(ctx, ctx.tbaa().tbaa_gcframe), vi.isVolatile);
                 else
-                    emit_unbox_store(ctx, rval_info, vi.value.V, tbaa, align, vi.isVolatile);
+                    emit_unbox_store(ctx, rval_info, vi.value.V, tbaa, align, align, vi.isVolatile);
             }
         }
     }
@@ -6947,7 +6947,7 @@ static void emit_specsig_to_specsig(
             split_value_into(ctx, gf_retval, align, sret, align, jl_aliasinfo_t::fromTBAA(ctx, ctx.tbaa().tbaa_stack), roots, jl_aliasinfo_t::fromTBAA(ctx, ctx.tbaa().tbaa_gcframe));
         }
         else {
-            emit_unbox_store(ctx, gf_retval, sret, ctx.tbaa().tbaa_stack, align);
+            emit_unbox_store(ctx, gf_retval, sret, ctx.tbaa().tbaa_stack, align, align);
         }
         ctx.builder.CreateRetVoid();
         break;
@@ -8713,11 +8713,12 @@ static jl_llvm_functions_t
             ++AI; // both specsig (derived) and fptr1 (box) pass this argument as a distinct argument
             // Load closure world
             Value *worldaddr = emit_ptrgep(ctx, oc_this, offsetof(jl_opaque_closure_t, world));
+            Align alignof_ptr(ctx.types().alignof_ptr);
             jl_cgval_t closure_world = typed_load(ctx, worldaddr, NULL, (jl_value_t*)jl_long_type,
-                nullptr, nullptr, false, AtomicOrdering::NotAtomic, false, ctx.types().alignof_ptr.value());
+                nullptr, nullptr, false, AtomicOrdering::NotAtomic, false, alignof_ptr.value());
             assert(ctx.world_age_at_entry == nullptr);
             ctx.world_age_at_entry = closure_world.V; // The tls world in a OC is the world of the closure
-            emit_unbox_store(ctx, closure_world, world_age_field, ctx.tbaa().tbaa_gcframe, ctx.types().alignof_ptr);
+            emit_unbox_store(ctx, closure_world, world_age_field, ctx.tbaa().tbaa_gcframe, alignof_ptr, alignof_ptr);
 
             if (s == jl_unused_sym || vi.value.constant)
                 continue;
@@ -9475,7 +9476,7 @@ static jl_llvm_functions_t
                             if (tracked)
                                 split_value_into(ctx, typedval, align, dest, align, jl_aliasinfo_t::fromTBAA(ctx, ctx.tbaa().tbaa_stack), mayberoots);
                             else
-                                emit_unbox_store(ctx, typedval, dest, ctx.tbaa().tbaa_stack, align);
+                                emit_unbox_store(ctx, typedval, dest, ctx.tbaa().tbaa_stack, align, align);
                         }
                         return mayberoots;
                     });
@@ -9510,8 +9511,10 @@ static jl_llvm_functions_t
                     else {
                         if (VN)
                             V = Constant::getNullValue(ctx.types().T_prjlvalue);
-                        if (dest)
-                            emit_unbox_store(ctx, val, dest, ctx.tbaa().tbaa_stack, Align(julia_alignment(val.typ)));
+                        if (dest) {
+                            Align align(julia_alignment(val.typ));
+                            emit_unbox_store(ctx, val, dest, ctx.tbaa().tbaa_stack, align, align);
+                        }
                         RTindex = ConstantInt::get(getInt8Ty(ctx.builder.getContext()), tindex);
                     }
                 }
diff --git a/src/intrinsics.cpp b/src/intrinsics.cpp
@@ -495,7 +495,7 @@ static Value *emit_unbox(jl_codectx_t &ctx, Type *to, const jl_cgval_t &x, jl_va
 }
 
 // emit code to store a raw value into a destination
-static void emit_unbox_store(jl_codectx_t &ctx, const jl_cgval_t &x, Value *dest, MDNode *tbaa_dest, Align alignment, bool isVolatile)
+static void emit_unbox_store(jl_codectx_t &ctx, const jl_cgval_t &x, Value *dest, MDNode *tbaa_dest, MaybeAlign align_src, Align align_dst, bool isVolatile)
 {
     if (x.isghost) {
         // this can happen when a branch yielding a different type ends
@@ -507,22 +507,22 @@ static void emit_unbox_store(jl_codectx_t &ctx, const jl_cgval_t &x, Value *dest
     auto dest_ai = jl_aliasinfo_t::fromTBAA(ctx, tbaa_dest);
 
     if (!x.inline_roots.empty()) {
-        recombine_value(ctx, x, dest, dest_ai, alignment, isVolatile);
+        recombine_value(ctx, x, dest, dest_ai, align_dst, isVolatile);
         return;
     }
 
     if (!x.ispointer()) { // already unboxed, but sometimes need conversion (e.g. f32 -> i32)
         assert(x.V);
         Value *unboxed = zext_struct(ctx, x.V);
-        StoreInst *store = ctx.builder.CreateAlignedStore(unboxed, dest, alignment);
+        StoreInst *store = ctx.builder.CreateAlignedStore(unboxed, dest, align_dst);
         store->setVolatile(isVolatile);
         dest_ai.decorateInst(store);
         return;
     }
 
     Value *src = data_pointer(ctx, x);
     auto src_ai = jl_aliasinfo_t::fromTBAA(ctx, x.tbaa);
-    emit_memcpy(ctx, dest, dest_ai, src, src_ai, jl_datatype_size(x.typ), Align(alignment), Align(julia_alignment(x.typ)), isVolatile);
+    emit_memcpy(ctx, dest, dest_ai, src, src_ai, jl_datatype_size(x.typ), Align(align_dst), align_src ? *align_src : Align(julia_alignment(x.typ)), isVolatile);
 }
 
 static jl_datatype_t *staticeval_bitstype(const jl_cgval_t &targ)

Original file line number	Diff line number	Diff line change
`@@ -547,7 +547,7 @@ static Value *julia_to_native(`
`547`	`547`	`Align align(julia_alignment(jlto));`
`548`	`548`	`Value *slot = emit_static_alloca(ctx, to, align);`
`549`	`549`	`setName(ctx.emission_context, slot, "native_convert_buffer");`
`550`		`- emit_unbox_store(ctx, jvinfo, slot, ctx.tbaa().tbaa_stack, align);`
	`550`	`+ emit_unbox_store(ctx, jvinfo, slot, ctx.tbaa().tbaa_stack, align, align);`
`551`	`551`	`return slot;`
`552`	`552`	`}`
`553`	`553`
Original file line number	Diff line number	Diff line change
`@@ -301,7 +301,7 @@ static Value emit_pointer_from_objref(jl_codectx_t &ctx, Value V)`
`301`	`301`	`}`
`302`	`302`
`303`	`303`	`static Value emit_unbox(jl_codectx_t &ctx, Type to, const jl_cgval_t &x, jl_value_t *jt);`
`304`		`-static void emit_unbox_store(jl_codectx_t &ctx, const jl_cgval_t &x, Value* dest, MDNode *tbaa_dest, Align alignment, bool isVolatile=false);`
	`304`	`+static void emit_unbox_store(jl_codectx_t &ctx, const jl_cgval_t &x, Value* dest, MDNode *tbaa_dest, MaybeAlign align_src, Align align_dst, bool isVolatile=false);`
`305`	`305`
`306`	`306`	`static bool type_is_permalloc(jl_value_t *typ)`
`307`	`307`	`{`
`@@ -1090,7 +1090,7 @@ static void split_value_into(jl_codectx_t &ctx, const jl_cgval_t &x, Align align`
`1090`	`1090`	`return;`
`1091`	`1091`	`}`
`1092`	`1092`	`if (inline_roots_ptr == nullptr) {`
`1093`		`- emit_unbox_store(ctx, x, dst, ctx.tbaa().tbaa_stack, align_dst, isVolatileStore);`
	`1093`	`+ emit_unbox_store(ctx, x, dst, ctx.tbaa().tbaa_stack, align_src, align_dst, isVolatileStore);`
`1094`	`1094`	`return;`
`1095`	`1095`	`}`
`1096`	`1096`	`Value *src = data_pointer(ctx, value_to_pointer(ctx, x));`
`@@ -1152,7 +1152,7 @@ static void split_value_into(jl_codectx_t &ctx, const jl_cgval_t &x, Align align`
`1152`	`1152`	`return;`
`1153`	`1153`	`}`
`1154`	`1154`	`if (inline_roots.empty()) {`
`1155`		`- emit_unbox_store(ctx, x, dst, ctx.tbaa().tbaa_stack, align_dst);`
	`1155`	`+ emit_unbox_store(ctx, x, dst, ctx.tbaa().tbaa_stack, align_src, align_dst, false);`
`1156`	`1156`	`return;`
`1157`	`1157`	`}`
`1158`	`1158`	`Value *src = data_pointer(ctx, value_to_pointer(ctx, x));`
`@@ -2351,7 +2351,7 @@ static jl_cgval_t typed_store(jl_codectx_t &ctx,`
`2351`	`2351`	`r = boxed(ctx, rhs);`
`2352`	`2352`	`}`
`2353`	`2353`	`else if (intcast) {`
`2354`		`- emit_unbox_store(ctx, rhs, intcast, ctx.tbaa().tbaa_stack, intcast->getAlign());`
	`2354`	`+ emit_unbox_store(ctx, rhs, intcast, ctx.tbaa().tbaa_stack, MaybeAlign(), intcast->getAlign());`
`2355`	`2355`	`r = ctx.builder.CreateLoad(realelty, intcast);`
`2356`	`2356`	`}`
`2357`	`2357`	`else if (aliasscope \|\| Order != AtomicOrdering::NotAtomic \|\| (tracked_pointers && rhs.inline_roots.empty())) {`
`@@ -2389,7 +2389,7 @@ static jl_cgval_t typed_store(jl_codectx_t &ctx,`
`2389`	`2389`	`}`
`2390`	`2390`	`else {`
`2391`	`2391`	`assert(Order == AtomicOrdering::NotAtomic && !isboxed && rhs.typ == jltype);`
`2392`		`- emit_unbox_store(ctx, rhs, ptr, tbaa, Align(alignment));`
	`2392`	`+ emit_unbox_store(ctx, rhs, ptr, tbaa, MaybeAlign(), Align(alignment));`
`2393`	`2393`	`}`
`2394`	`2394`	`}`
`2395`	`2395`	`else if (isswapfield) {`
`@@ -2438,7 +2438,7 @@ static jl_cgval_t typed_store(jl_codectx_t &ctx,`
`2438`	`2438`	`}`
`2439`	`2439`	`cmp = update_julia_type(ctx, cmp, jltype);`
`2440`	`2440`	`if (intcast) {`
`2441`		`- emit_unbox_store(ctx, cmp, intcast, ctx.tbaa().tbaa_stack, intcast->getAlign());`
	`2441`	`+ emit_unbox_store(ctx, cmp, intcast, ctx.tbaa().tbaa_stack, MaybeAlign(), intcast->getAlign());`
`2442`	`2442`	`Compare = ctx.builder.CreateLoad(realelty, intcast);`
`2443`	`2443`	`}`
`2444`	`2444`	`else {`
`@@ -2509,7 +2509,7 @@ static jl_cgval_t typed_store(jl_codectx_t &ctx,`
`2509`	`2509`	`r = boxed(ctx, rhs);`
`2510`	`2510`	`}`
`2511`	`2511`	`else if (intcast) {`
`2512`		`- emit_unbox_store(ctx, rhs, intcast, ctx.tbaa().tbaa_stack, intcast->getAlign());`
	`2512`	`+ emit_unbox_store(ctx, rhs, intcast, ctx.tbaa().tbaa_stack, MaybeAlign(), intcast->getAlign());`
`2513`	`2513`	`r = ctx.builder.CreateLoad(realelty, intcast);`
`2514`	`2514`	`if (!tracked_pointers) // oldval is a slot, so put the oldval back`
`2515`	`2515`	`ctx.builder.CreateStore(realCompare, intcast);`
`@@ -2556,7 +2556,7 @@ static jl_cgval_t typed_store(jl_codectx_t &ctx,`
`2556`	`2556`	`}`
`2557`	`2557`	`else {`
`2558`	`2558`	`assert(!isboxed && rhs.typ == jltype);`
`2559`		`- emit_unbox_store(ctx, rhs, ptr, tbaa, Align(alignment));`
	`2559`	`+ emit_unbox_store(ctx, rhs, ptr, tbaa, MaybeAlign(), Align(alignment));`
`2560`	`2560`	`}`
`2561`	`2561`	`ctx.builder.CreateBr(DoneBB);`
`2562`	`2562`	`instr = load;`
`@@ -3352,9 +3352,10 @@ static void init_bits_value(jl_codectx_t &ctx, Value newv, Value v, MDNode *tb`
`3352`	`3352`	`static void init_bits_cgval(jl_codectx_t &ctx, Value *newv, const jl_cgval_t &v)`
`3353`	`3353`	`{`
`3354`	`3354`	`MDNode *tbaa = jl_is_mutable(v.typ) ? ctx.tbaa().tbaa_mutab : ctx.tbaa().tbaa_immut;`
`3355`		`- Align newv_align{std::max(julia_alignment(v.typ), (unsigned)sizeof(void*))};`
	`3355`	`+ unsigned alignment = julia_alignment(v.typ);`
	`3356`	`+ unsigned newv_align = std::max(alignment, (unsigned)sizeof(void*));`
`3356`	`3357`	`newv = maybe_decay_tracked(ctx, newv);`
`3357`		`- emit_unbox_store(ctx, v, newv, tbaa, newv_align);`
	`3358`	`+ emit_unbox_store(ctx, v, newv, tbaa, Align(alignment), Align(newv_align));`
`3358`	`3359`	`}`
`3359`	`3360`
`3360`	`3361`	`static jl_value_t static_constant_instance(const llvm::DataLayout &DL, Constant constant, jl_value_t *jt)`
`@@ -3808,7 +3809,7 @@ static void emit_unionmove(jl_codectx_t &ctx, Value dest, MDNode tbaa_dst, con`
`3808`	`3809`	`if (jl_is_pointerfree(typ)) {`
`3809`	`3810`	`emit_guarded_test(ctx, skip, nullptr, [&] {`
`3810`	`3811`	`unsigned alignment = julia_alignment(typ);`
`3811`		`- emit_unbox_store(ctx, mark_julia_const(ctx, src.constant), dest, tbaa_dst, Align(alignment), isVolatile);`
	`3812`	`+ emit_unbox_store(ctx, mark_julia_const(ctx, src.constant), dest, tbaa_dst, Align(alignment), Align(alignment), isVolatile);`
`3812`	`3813`	`return nullptr;`
`3813`	`3814`	`});`
`3814`	`3815`	`}`
`@@ -3818,7 +3819,7 @@ static void emit_unionmove(jl_codectx_t &ctx, Value dest, MDNode tbaa_dst, con`
`3818`	`3819`	`if (jl_is_pointerfree(src.typ)) {`
`3819`	`3820`	`emit_guarded_test(ctx, skip, nullptr, [&] {`
`3820`	`3821`	`unsigned alignment = julia_alignment(src.typ);`
`3821`		`- emit_unbox_store(ctx, src, dest, tbaa_dst, Align(alignment), isVolatile);`
	`3822`	`+ emit_unbox_store(ctx, src, dest, tbaa_dst, Align(alignment), Align(alignment), isVolatile);`
`3822`	`3823`	`return nullptr;`
`3823`	`3824`	`});`
`3824`	`3825`	`}`
`@@ -4273,6 +4274,8 @@ static jl_cgval_t emit_new_struct(jl_codectx_t &ctx, jl_value_t *ty, size_t narg`
`4273`	`4274`	`}`
`4274`	`4275`	`}`
`4275`	`4276`	`else {`
	`4277`	`+ Align align_dst(jl_field_align(sty, i));`
	`4278`	`+ Align align_src(julia_alignment(jtype));`
`4276`	`4279`	`if (field_promotable) {`
`4277`	`4280`	`fval_info.V->replaceAllUsesWith(dest);`
`4278`	`4281`	`cast<Instruction>(fval_info.V)->eraseFromParent();`
`@@ -4281,10 +4284,10 @@ static jl_cgval_t emit_new_struct(jl_codectx_t &ctx, jl_value_t *ty, size_t narg`
`4281`	`4284`	`fval = emit_unbox(ctx, fty, fval_info, jtype);`
`4282`	`4285`	`}`
`4283`	`4286`	`else if (!roots.empty()) {`
`4284`		`- split_value_into(ctx, fval_info, Align(julia_alignment(jtype)), dest, Align(jl_field_align(sty, i)), jl_aliasinfo_t::fromTBAA(ctx, ctx.tbaa().tbaa_stack), roots);`
	`4287`	`+ split_value_into(ctx, fval_info, align_src, dest, align_dst, jl_aliasinfo_t::fromTBAA(ctx, ctx.tbaa().tbaa_stack), roots);`
`4285`	`4288`	`}`
`4286`	`4289`	`else {`
`4287`		`- emit_unbox_store(ctx, fval_info, dest, ctx.tbaa().tbaa_stack, Align(jl_field_align(sty, i)));`
	`4290`	`+ emit_unbox_store(ctx, fval_info, dest, ctx.tbaa().tbaa_stack, align_src, align_dst);`
`4288`	`4291`	`}`
`4289`	`4292`	`}`
`4290`	`4293`	`if (init_as_value) {`
Original file line number	Diff line number	Diff line change
`@@ -495,7 +495,7 @@ static Value emit_unbox(jl_codectx_t &ctx, Type to, const jl_cgval_t &x, jl_va`
`495`	`495`	`}`
`496`	`496`
`497`	`497`	`// emit code to store a raw value into a destination`
`498`		`-static void emit_unbox_store(jl_codectx_t &ctx, const jl_cgval_t &x, Value dest, MDNode tbaa_dest, Align alignment, bool isVolatile)`
	`498`	`+static void emit_unbox_store(jl_codectx_t &ctx, const jl_cgval_t &x, Value dest, MDNode tbaa_dest, MaybeAlign align_src, Align align_dst, bool isVolatile)`
`499`	`499`	`{`
`500`	`500`	`if (x.isghost) {`
`501`	`501`	`// this can happen when a branch yielding a different type ends`
`@@ -507,22 +507,22 @@ static void emit_unbox_store(jl_codectx_t &ctx, const jl_cgval_t &x, Value *dest`
`507`	`507`	`auto dest_ai = jl_aliasinfo_t::fromTBAA(ctx, tbaa_dest);`
`508`	`508`
`509`	`509`	`if (!x.inline_roots.empty()) {`
`510`		`- recombine_value(ctx, x, dest, dest_ai, alignment, isVolatile);`
	`510`	`+ recombine_value(ctx, x, dest, dest_ai, align_dst, isVolatile);`
`511`	`511`	`return;`
`512`	`512`	`}`
`513`	`513`
`514`	`514`	`if (!x.ispointer()) { // already unboxed, but sometimes need conversion (e.g. f32 -> i32)`
`515`	`515`	`assert(x.V);`
`516`	`516`	`Value *unboxed = zext_struct(ctx, x.V);`
`517`		`- StoreInst *store = ctx.builder.CreateAlignedStore(unboxed, dest, alignment);`
	`517`	`+ StoreInst *store = ctx.builder.CreateAlignedStore(unboxed, dest, align_dst);`
`518`	`518`	`store->setVolatile(isVolatile);`
`519`	`519`	`dest_ai.decorateInst(store);`
`520`	`520`	`return;`
`521`	`521`	`}`
`522`	`522`
`523`	`523`	`Value *src = data_pointer(ctx, x);`
`524`	`524`	`auto src_ai = jl_aliasinfo_t::fromTBAA(ctx, x.tbaa);`
`525`		`- emit_memcpy(ctx, dest, dest_ai, src, src_ai, jl_datatype_size(x.typ), Align(alignment), Align(julia_alignment(x.typ)), isVolatile);`
	`525`	`+ emit_memcpy(ctx, dest, dest_ai, src, src_ai, jl_datatype_size(x.typ), Align(align_dst), align_src ? *align_src : Align(julia_alignment(x.typ)), isVolatile);`
`526`	`526`	`}`
`527`	`527`
`528`	`528`	`static jl_datatype_t *staticeval_bitstype(const jl_cgval_t &targ)`