rust/tests/codegen/issues/issue-105386-ub-in-debuginfo.rs

//@ compile-flags: --crate-type=lib -O -Cdebuginfo=2 -Cno-prepopulate-passes -Zmir-enable-passes=-ScalarReplacementOfAggregates
// MIR SROA will decompose the closure
#![feature(stmt_expr_attributes)]

pub struct S([usize; 8]);

#[no_mangle]
pub fn outer_function(x: S, y: S) -> usize {
    (#[inline(always)]
    || {
        let _z = x;
        y.0[0]
    })()
}

// Check that we do not attempt to load from the spilled arg before it is assigned to
// when generating debuginfo.
// CHECK-LABEL: @outer_function
// CHECK: [[spill:%.*]] = alloca
// CHECK-NOT: [[ptr_tmp:%.*]] = getelementptr inbounds i8, ptr [[spill]]
// CHECK-NOT: [[load:%.*]] = load ptr, ptr
// CHECK: call void @llvm.lifetime.start{{.*}}({{.*}}, ptr [[spill]])
// CHECK: [[inner:%.*]] = getelementptr inbounds i8, ptr [[spill]]
// CHECK: call void @llvm.memcpy{{.*}}(ptr {{align .*}} [[inner]], ptr {{align .*}} %x
Enable ScalarReplacementOfAggregates 2023-05-26 13:53:34 -05:00			`//@ compile-flags: --crate-type=lib -O -Cdebuginfo=2 -Cno-prepopulate-passes -Zmir-enable-passes=-ScalarReplacementOfAggregates`
			`// MIR SROA will decompose the closure`
Add test case for ub in generated LLVM IR 2022-12-08 18:06:27 -06:00			`#![feature(stmt_expr_attributes)]`

			`pub struct S([usize; 8]);`

			`#[no_mangle]`
			`pub fn outer_function(x: S, y: S) -> usize {`
Run rustfmt on `tests/codegen/`. Except for `simd-intrinsic/`, which has a lot of files containing multiple types like `u8x64` which really are better when hand-formatted. There is a surprising amount of two-space indenting in this directory. Non-trivial changes: - `rustfmt::skip` needed in `debug-column.rs` to preserve meaning of the test. - `rustfmt::skip` used in a few places where hand-formatting read more nicely: `enum/enum-match.rs` - Line number adjustments needed for the expected output of `debug-column.rs` and `coroutine-debug.rs`. 2024-05-28 23:11:20 -05:00			`(#[inline(always)]`
			`\|\| {`
Add test case for ub in generated LLVM IR 2022-12-08 18:06:27 -06:00			`let _z = x;`
			`y.0[0]`
			`})()`
			`}`

			`// Check that we do not attempt to load from the spilled arg before it is assigned to`
			`// when generating debuginfo.`
			`// CHECK-LABEL: @outer_function`
remove alloca type from issue-105386-ub-in-debuginfo It's irrelevant for the purposes of this test (there is only one alloca) and its size changes depending on the target, so it can't be matched easily. 2024-04-12 07:31:35 -05:00			`// CHECK: [[spill:%.*]] = alloca`
always use gep inbounds i8 (ptradd) for field offsets 2024-02-23 22:23:35 -06:00			`// CHECK-NOT: [[ptr_tmp:%.*]] = getelementptr inbounds i8, ptr [[spill]]`
Don't generate pointer loads to spills unless necessary In order for LLVM to correctly generate debuginfo for msvc, we sometimes need to spill arguments to the stack and perform some direct & indirect offsets into the value. Previously, this code always performed those actions, even when not required as LLVM would clean it up during optimization. However, when MIR inlining is enabled, this can cause problems as the operations occur prior to the spilled value being initialized. To solve this, we first calculate the necessary offsets using just the type which is side-effect free and does not alter the LLVM IR. Then, if we are in a situation which requires us to generate the LLVM IR (and this situation only occurs for arguments, not local variables) then we perform the same calculation again, this time generating the appropriate LLVM IR as we go. 2022-12-07 12:48:34 -06:00			`// CHECK-NOT: [[load:%.*]] = load ptr, ptr`
Add test case for ub in generated LLVM IR 2022-12-08 18:06:27 -06:00			`// CHECK: call void @llvm.lifetime.start{{.}}({{.}}, ptr [[spill]])`
always use gep inbounds i8 (ptradd) for field offsets 2024-02-23 22:23:35 -06:00			`// CHECK: [[inner:%.*]] = getelementptr inbounds i8, ptr [[spill]]`
fix codegen test 2023-04-05 14:15:32 -05:00			`// CHECK: call void @llvm.memcpy{{.}}(ptr {{align .}} [[inner]], ptr {{align .*}} %x`