From 8cb0b6ca5bf1321d38f4602113b0f41c837d0586 Mon Sep 17 00:00:00 2001 From: Erik Desjardins Date: Sat, 5 Feb 2022 01:00:37 -0500 Subject: [PATCH 1/5] Apply noundef attribute to &T, &mut T, Box, bool This doesn't handle `char` because it's a bit awkward to distinguish it from u32 at this point in codegen. Note that for some types (like `&Struct` and `&mut Struct`), we already apply `dereferenceable`, which implies `noundef`, so the IR does not change. --- compiler/rustc_codegen_llvm/src/abi.rs | 6 ++- compiler/rustc_codegen_llvm/src/llvm/ffi.rs | 1 + .../rustc_llvm/llvm-wrapper/LLVMWrapper.h | 1 + .../rustc_llvm/llvm-wrapper/RustWrapper.cpp | 2 + compiler/rustc_middle/src/ty/layout.rs | 8 +++- compiler/rustc_target/src/abi/call/mod.rs | 7 +++- src/test/codegen/function-arguments.rs | 37 +++++++++++++------ src/test/codegen/scalar-pair-bool.rs | 10 ++--- src/test/codegen/transmute-scalar.rs | 4 +- src/test/codegen/union-abi.rs | 2 +- 10 files changed, 56 insertions(+), 22 deletions(-) diff --git a/compiler/rustc_codegen_llvm/src/abi.rs b/compiler/rustc_codegen_llvm/src/abi.rs index e9b66b54c58b3..ff03df79ab15b 100644 --- a/compiler/rustc_codegen_llvm/src/abi.rs +++ b/compiler/rustc_codegen_llvm/src/abi.rs @@ -37,7 +37,7 @@ impl ArgAttributeExt for ArgAttribute { where F: FnMut(llvm::Attribute), { - for_each_kind!(self, f, NoAlias, NoCapture, NonNull, ReadOnly, InReg) + for_each_kind!(self, f, NoAlias, NoCapture, NonNull, ReadOnly, InReg, NoUndef) } } @@ -69,7 +69,9 @@ impl ArgAttributesExt for ArgAttributes { } else { llvm::LLVMRustAddDereferenceableOrNullAttr(llfn, idx.as_uint(), deref); } + // dereferenceable implies nonnull noundef; dereferenceable_or_null implies noundef regular -= ArgAttribute::NonNull; + regular -= ArgAttribute::NoUndef; } if let Some(align) = self.pointee_align { llvm::LLVMRustAddAlignmentAttr(llfn, idx.as_uint(), align.bytes() as u32); @@ -109,7 +111,9 @@ impl ArgAttributesExt for ArgAttributes { deref, ); } + // dereferenceable implies nonnull noundef; dereferenceable_or_null implies noundef regular -= ArgAttribute::NonNull; + regular -= ArgAttribute::NoUndef; } if let Some(align) = self.pointee_align { llvm::LLVMRustAddAlignmentCallSiteAttr( diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs index 367c86a1dc942..4f62c68556841 100644 --- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs +++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs @@ -189,6 +189,7 @@ pub enum Attribute { StackProtectReq = 30, StackProtectStrong = 31, StackProtect = 32, + NoUndef = 33, } /// LLVMIntPredicate diff --git a/compiler/rustc_llvm/llvm-wrapper/LLVMWrapper.h b/compiler/rustc_llvm/llvm-wrapper/LLVMWrapper.h index e2ce7da0e84af..9e0a9b354e196 100644 --- a/compiler/rustc_llvm/llvm-wrapper/LLVMWrapper.h +++ b/compiler/rustc_llvm/llvm-wrapper/LLVMWrapper.h @@ -82,6 +82,7 @@ enum LLVMRustAttribute { StackProtectReq = 30, StackProtectStrong = 31, StackProtect = 32, + NoUndef = 33, }; typedef struct OpaqueRustString *RustStringRef; diff --git a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp index d871290744f8b..fb9c5e6a527a7 100644 --- a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp +++ b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp @@ -224,6 +224,8 @@ static Attribute::AttrKind fromRust(LLVMRustAttribute Kind) { return Attribute::StackProtectStrong; case StackProtect: return Attribute::StackProtect; + case NoUndef: + return Attribute::NoUndef; } report_fatal_error("bad AttributeKind"); } diff --git a/compiler/rustc_middle/src/ty/layout.rs b/compiler/rustc_middle/src/ty/layout.rs index ad817e185a3cf..d2d22fbf31c13 100644 --- a/compiler/rustc_middle/src/ty/layout.rs +++ b/compiler/rustc_middle/src/ty/layout.rs @@ -3048,9 +3048,10 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> { layout: TyAndLayout<'tcx>, offset: Size, is_return: bool| { - // Booleans are always an i1 that needs to be zero-extended. + // Booleans are always a noundef i1 that needs to be zero-extended. if scalar.is_bool() { attrs.ext(ArgExtension::Zext); + attrs.set(ArgAttribute::NoUndef); return; } @@ -3075,6 +3076,11 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> { _ => pointee.size, }; + // `Box`, `&T`, and `&mut T` cannot be undef. + // Note that this only applies to the value of the pointer itself; + // this attribute doesn't make it UB for the pointed-to data to be undef. + attrs.set(ArgAttribute::NoUndef); + // `Box` pointer parameters never alias because ownership is transferred // `&mut` pointer parameters never alias other parameters, // or mutable global data diff --git a/compiler/rustc_target/src/abi/call/mod.rs b/compiler/rustc_target/src/abi/call/mod.rs index 735b7e76e3862..b605f21d0518d 100644 --- a/compiler/rustc_target/src/abi/call/mod.rs +++ b/compiler/rustc_target/src/abi/call/mod.rs @@ -73,6 +73,7 @@ mod attr_impl { // or not to actually emit the attribute. It can also be controlled // with the `-Zmutable-noalias` debugging option. const NoAliasMutRef = 1 << 6; + const NoUndef = 1 << 7; } } } @@ -494,7 +495,11 @@ impl<'a, Ty> ArgAbi<'a, Ty> { // For non-immediate arguments the callee gets its own copy of // the value on the stack, so there are no aliases. It's also // program-invisible so can't possibly capture - attrs.set(ArgAttribute::NoAlias).set(ArgAttribute::NoCapture).set(ArgAttribute::NonNull); + attrs + .set(ArgAttribute::NoAlias) + .set(ArgAttribute::NoCapture) + .set(ArgAttribute::NonNull) + .set(ArgAttribute::NoUndef); attrs.pointee_size = layout.size; // FIXME(eddyb) We should be doing this, but at least on // i686-pc-windows-msvc, it results in wrong stack offsets. diff --git a/src/test/codegen/function-arguments.rs b/src/test/codegen/function-arguments.rs index 3e10e227e55fe..998f389090062 100644 --- a/src/test/codegen/function-arguments.rs +++ b/src/test/codegen/function-arguments.rs @@ -11,7 +11,7 @@ pub struct UnsafeInner { _field: std::cell::UnsafeCell, } -// CHECK: zeroext i1 @boolean(i1 zeroext %x) +// CHECK: noundef zeroext i1 @boolean(i1 noundef zeroext %x) #[no_mangle] pub fn boolean(x: bool) -> bool { x @@ -64,9 +64,14 @@ pub fn indirect_struct(_: S) { pub fn borrowed_struct(_: &S) { } +// CHECK: @raw_struct(%S* %_1) +#[no_mangle] +pub fn raw_struct(_: *const S) { +} + // `Box` can get deallocated during execution of the function, so it should // not get `dereferenceable`. -// CHECK: noalias nonnull align 4 i32* @_box(i32* noalias nonnull align 4 %x) +// CHECK: noalias noundef nonnull align 4 i32* @_box(i32* noalias noundef nonnull align 4 %x) #[no_mangle] pub fn _box(x: Box) -> Box { x @@ -86,48 +91,58 @@ pub fn struct_return() -> S { pub fn helper(_: usize) { } -// CHECK: @slice([0 x i8]* noalias nonnull readonly align 1 %_1.0, [[USIZE]] %_1.1) +// CHECK: @slice([0 x i8]* noalias noundef nonnull readonly align 1 %_1.0, [[USIZE]] %_1.1) // FIXME #25759 This should also have `nocapture` #[no_mangle] pub fn slice(_: &[u8]) { } -// CHECK: @mutable_slice([0 x i8]* noalias nonnull align 1 %_1.0, [[USIZE]] %_1.1) +// CHECK: @mutable_slice([0 x i8]* noalias noundef nonnull align 1 %_1.0, [[USIZE]] %_1.1) // FIXME #25759 This should also have `nocapture` #[no_mangle] pub fn mutable_slice(_: &mut [u8]) { } -// CHECK: @unsafe_slice([0 x i16]* nonnull align 2 %_1.0, [[USIZE]] %_1.1) +// CHECK: @unsafe_slice([0 x i16]* noundef nonnull align 2 %_1.0, [[USIZE]] %_1.1) // unsafe interior means this isn't actually readonly and there may be aliases ... #[no_mangle] pub fn unsafe_slice(_: &[UnsafeInner]) { } -// CHECK: @str([0 x i8]* noalias nonnull readonly align 1 %_1.0, [[USIZE]] %_1.1) +// CHECK: @raw_slice([0 x i8]* %_1.0, [[USIZE]] %_1.1) +#[no_mangle] +pub fn raw_slice(_: *const [u8]) { +} + +// CHECK: @str([0 x i8]* noalias noundef nonnull readonly align 1 %_1.0, [[USIZE]] %_1.1) // FIXME #25759 This should also have `nocapture` #[no_mangle] pub fn str(_: &[u8]) { } -// CHECK: @trait_borrow({}* nonnull align 1 %_1.0, [3 x [[USIZE]]]* noalias readonly align {{.*}} dereferenceable({{.*}}) %_1.1) +// CHECK: @trait_borrow({}* noundef nonnull align 1 %_1.0, [3 x [[USIZE]]]* noalias readonly align {{.*}} dereferenceable({{.*}}) %_1.1) // FIXME #25759 This should also have `nocapture` #[no_mangle] pub fn trait_borrow(_: &Drop) { } -// CHECK: @trait_box({}* noalias nonnull align 1{{( %0)?}}, [3 x [[USIZE]]]* noalias readonly align {{.*}} dereferenceable({{.*}}){{( %1)?}}) +// CHECK: @trait_raw({}* %_1.0, [3 x [[USIZE]]]* noalias readonly align {{.*}} dereferenceable({{.*}}) %_1.1) +#[no_mangle] +pub fn trait_raw(_: *const Drop) { +} + +// CHECK: @trait_box({}* noalias noundef nonnull align 1{{( %0)?}}, [3 x [[USIZE]]]* noalias readonly align {{.*}} dereferenceable({{.*}}){{( %1)?}}) #[no_mangle] pub fn trait_box(_: Box) { } -// CHECK: { i8*, i8* } @trait_option(i8* noalias align 1 %x.0, i8* %x.1) +// CHECK: { i8*, i8* } @trait_option(i8* noalias noundef align 1 %x.0, i8* %x.1) #[no_mangle] pub fn trait_option(x: Option>) -> Option> { x } -// CHECK: { [0 x i16]*, [[USIZE]] } @return_slice([0 x i16]* noalias nonnull readonly align 2 %x.0, [[USIZE]] %x.1) +// CHECK: { [0 x i16]*, [[USIZE]] } @return_slice([0 x i16]* noalias noundef nonnull readonly align 2 %x.0, [[USIZE]] %x.1) #[no_mangle] pub fn return_slice(x: &[u16]) -> &[u16] { x @@ -139,7 +154,7 @@ pub fn enum_id_1(x: Option>) -> Option> { x } -// CHECK: { i8, i8 } @enum_id_2(i1 zeroext %x.0, i8 %x.1) +// CHECK: { i8, i8 } @enum_id_2(i1 noundef zeroext %x.0, i8 %x.1) #[no_mangle] pub fn enum_id_2(x: Option) -> Option { x diff --git a/src/test/codegen/scalar-pair-bool.rs b/src/test/codegen/scalar-pair-bool.rs index 473272158d099..264f28fdb5fee 100644 --- a/src/test/codegen/scalar-pair-bool.rs +++ b/src/test/codegen/scalar-pair-bool.rs @@ -2,25 +2,25 @@ #![crate_type = "lib"] -// CHECK: define{{.*}}{ i8, i8 } @pair_bool_bool(i1 zeroext %pair.0, i1 zeroext %pair.1) +// CHECK: define{{.*}}{ i8, i8 } @pair_bool_bool(i1 noundef zeroext %pair.0, i1 noundef zeroext %pair.1) #[no_mangle] pub fn pair_bool_bool(pair: (bool, bool)) -> (bool, bool) { pair } -// CHECK: define{{.*}}{ i8, i32 } @pair_bool_i32(i1 zeroext %pair.0, i32 %pair.1) +// CHECK: define{{.*}}{ i8, i32 } @pair_bool_i32(i1 noundef zeroext %pair.0, i32 %pair.1) #[no_mangle] pub fn pair_bool_i32(pair: (bool, i32)) -> (bool, i32) { pair } -// CHECK: define{{.*}}{ i32, i8 } @pair_i32_bool(i32 %pair.0, i1 zeroext %pair.1) +// CHECK: define{{.*}}{ i32, i8 } @pair_i32_bool(i32 %pair.0, i1 noundef zeroext %pair.1) #[no_mangle] pub fn pair_i32_bool(pair: (i32, bool)) -> (i32, bool) { pair } -// CHECK: define{{.*}}{ i8, i8 } @pair_and_or(i1 zeroext %_1.0, i1 zeroext %_1.1) +// CHECK: define{{.*}}{ i8, i8 } @pair_and_or(i1 noundef zeroext %_1.0, i1 noundef zeroext %_1.1) #[no_mangle] pub fn pair_and_or((a, b): (bool, bool)) -> (bool, bool) { // Make sure it can operate directly on the unpacked args @@ -30,7 +30,7 @@ pub fn pair_and_or((a, b): (bool, bool)) -> (bool, bool) { (a && b, a || b) } -// CHECK: define{{.*}}void @pair_branches(i1 zeroext %_1.0, i1 zeroext %_1.1) +// CHECK: define{{.*}}void @pair_branches(i1 noundef zeroext %_1.0, i1 noundef zeroext %_1.1) #[no_mangle] pub fn pair_branches((a, b): (bool, bool)) { // Make sure it can branch directly on the unpacked bool args diff --git a/src/test/codegen/transmute-scalar.rs b/src/test/codegen/transmute-scalar.rs index e9584929f3a9e..a5aeb80de85c3 100644 --- a/src/test/codegen/transmute-scalar.rs +++ b/src/test/codegen/transmute-scalar.rs @@ -15,7 +15,7 @@ pub fn f32_to_bits(x: f32) -> u32 { unsafe { std::mem::transmute(x) } } -// CHECK-LABEL: define{{.*}}i8 @bool_to_byte(i1 zeroext %b) +// CHECK-LABEL: define{{.*}}i8 @bool_to_byte(i1 noundef zeroext %b) // CHECK: %1 = zext i1 %b to i8 // CHECK-NEXT: store i8 %1, i8* %0 // CHECK-NEXT: %2 = load i8, i8* %0 @@ -25,7 +25,7 @@ pub fn bool_to_byte(b: bool) -> u8 { unsafe { std::mem::transmute(b) } } -// CHECK-LABEL: define{{.*}}zeroext i1 @byte_to_bool(i8 %byte) +// CHECK-LABEL: define{{.*}}noundef zeroext i1 @byte_to_bool(i8 %byte) // CHECK: %1 = trunc i8 %byte to i1 // CHECK-NEXT: %2 = zext i1 %1 to i8 // CHECK-NEXT: store i8 %2, i8* %0 diff --git a/src/test/codegen/union-abi.rs b/src/test/codegen/union-abi.rs index f282fd237054c..bb87d263bdf3d 100644 --- a/src/test/codegen/union-abi.rs +++ b/src/test/codegen/union-abi.rs @@ -75,7 +75,7 @@ pub union CUnionU128x2{a:(u128, u128)} pub fn test_CUnionU128x2(_: CUnionU128x2) { loop {} } pub union UnionBool { b:bool } -// CHECK: define zeroext i1 @test_UnionBool(i8 %b) +// CHECK: define noundef zeroext i1 @test_UnionBool(i8 %b) #[no_mangle] pub fn test_UnionBool(b: UnionBool) -> bool { unsafe { b.b } } // CHECK: %0 = trunc i8 %b to i1 From ced947fc124197bf87e2bdc6741d50db92d296a8 Mon Sep 17 00:00:00 2001 From: Erik Desjardins Date: Sun, 6 Feb 2022 21:09:21 -0500 Subject: [PATCH 2/5] test that MaybeUninit is not noundef --- src/test/codegen/function-arguments.rs | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/src/test/codegen/function-arguments.rs b/src/test/codegen/function-arguments.rs index 998f389090062..1ada49d5d0ad7 100644 --- a/src/test/codegen/function-arguments.rs +++ b/src/test/codegen/function-arguments.rs @@ -3,6 +3,8 @@ #![crate_type = "lib"] #![feature(rustc_attrs)] +use std::mem::MaybeUninit; + pub struct S { _field: [i32; 8], } @@ -17,6 +19,12 @@ pub fn boolean(x: bool) -> bool { x } +// CHECK: i8 @maybeuninit_boolean(i8 %x) +#[no_mangle] +pub fn maybeuninit_boolean(x: MaybeUninit) -> MaybeUninit { + x +} + // CHECK: @readonly_borrow(i32* noalias readonly align 4 dereferenceable(4) %_1) // FIXME #25759 This should also have `nocapture` #[no_mangle] From 75ed7def5d31845f5672461c706609bd76f93d08 Mon Sep 17 00:00:00 2001 From: Erik Desjardins Date: Sun, 6 Feb 2022 21:11:11 -0500 Subject: [PATCH 3/5] apply noundef explicitly in all cases instead of relying on dereferenceable implying it --- compiler/rustc_codegen_llvm/src/abi.rs | 4 ---- src/test/codegen/function-arguments.rs | 24 ++++++++++++------------ src/test/codegen/packed.rs | 4 ++-- 3 files changed, 14 insertions(+), 18 deletions(-) diff --git a/compiler/rustc_codegen_llvm/src/abi.rs b/compiler/rustc_codegen_llvm/src/abi.rs index ff03df79ab15b..8a11e3e71bc81 100644 --- a/compiler/rustc_codegen_llvm/src/abi.rs +++ b/compiler/rustc_codegen_llvm/src/abi.rs @@ -69,9 +69,7 @@ impl ArgAttributesExt for ArgAttributes { } else { llvm::LLVMRustAddDereferenceableOrNullAttr(llfn, idx.as_uint(), deref); } - // dereferenceable implies nonnull noundef; dereferenceable_or_null implies noundef regular -= ArgAttribute::NonNull; - regular -= ArgAttribute::NoUndef; } if let Some(align) = self.pointee_align { llvm::LLVMRustAddAlignmentAttr(llfn, idx.as_uint(), align.bytes() as u32); @@ -111,9 +109,7 @@ impl ArgAttributesExt for ArgAttributes { deref, ); } - // dereferenceable implies nonnull noundef; dereferenceable_or_null implies noundef regular -= ArgAttribute::NonNull; - regular -= ArgAttribute::NoUndef; } if let Some(align) = self.pointee_align { llvm::LLVMRustAddAlignmentCallSiteAttr( diff --git a/src/test/codegen/function-arguments.rs b/src/test/codegen/function-arguments.rs index 1ada49d5d0ad7..17b54d86cb09f 100644 --- a/src/test/codegen/function-arguments.rs +++ b/src/test/codegen/function-arguments.rs @@ -25,48 +25,48 @@ pub fn maybeuninit_boolean(x: MaybeUninit) -> MaybeUninit { x } -// CHECK: @readonly_borrow(i32* noalias readonly align 4 dereferenceable(4) %_1) +// CHECK: @readonly_borrow(i32* noalias noundef readonly align 4 dereferenceable(4) %_1) // FIXME #25759 This should also have `nocapture` #[no_mangle] pub fn readonly_borrow(_: &i32) { } -// CHECK: @static_borrow(i32* noalias readonly align 4 dereferenceable(4) %_1) +// CHECK: @static_borrow(i32* noalias noundef readonly align 4 dereferenceable(4) %_1) // static borrow may be captured #[no_mangle] pub fn static_borrow(_: &'static i32) { } -// CHECK: @named_borrow(i32* noalias readonly align 4 dereferenceable(4) %_1) +// CHECK: @named_borrow(i32* noalias noundef readonly align 4 dereferenceable(4) %_1) // borrow with named lifetime may be captured #[no_mangle] pub fn named_borrow<'r>(_: &'r i32) { } -// CHECK: @unsafe_borrow(i16* align 2 dereferenceable(2) %_1) +// CHECK: @unsafe_borrow(i16* noundef align 2 dereferenceable(2) %_1) // unsafe interior means this isn't actually readonly and there may be aliases ... #[no_mangle] pub fn unsafe_borrow(_: &UnsafeInner) { } -// CHECK: @mutable_unsafe_borrow(i16* noalias align 2 dereferenceable(2) %_1) +// CHECK: @mutable_unsafe_borrow(i16* noalias noundef align 2 dereferenceable(2) %_1) // ... unless this is a mutable borrow, those never alias #[no_mangle] pub fn mutable_unsafe_borrow(_: &mut UnsafeInner) { } -// CHECK: @mutable_borrow(i32* noalias align 4 dereferenceable(4) %_1) +// CHECK: @mutable_borrow(i32* noalias noundef align 4 dereferenceable(4) %_1) // FIXME #25759 This should also have `nocapture` #[no_mangle] pub fn mutable_borrow(_: &mut i32) { } -// CHECK: @indirect_struct(%S* noalias nocapture dereferenceable(32) %_1) +// CHECK: @indirect_struct(%S* noalias nocapture noundef dereferenceable(32) %_1) #[no_mangle] pub fn indirect_struct(_: S) { } -// CHECK: @borrowed_struct(%S* noalias readonly align 4 dereferenceable(32) %_1) +// CHECK: @borrowed_struct(%S* noalias noundef readonly align 4 dereferenceable(32) %_1) // FIXME #25759 This should also have `nocapture` #[no_mangle] pub fn borrowed_struct(_: &S) { @@ -85,7 +85,7 @@ pub fn _box(x: Box) -> Box { x } -// CHECK: @struct_return(%S* noalias nocapture sret(%S) dereferenceable(32){{( %0)?}}) +// CHECK: @struct_return(%S* noalias nocapture noundef sret(%S) dereferenceable(32){{( %0)?}}) #[no_mangle] pub fn struct_return() -> S { S { @@ -128,18 +128,18 @@ pub fn raw_slice(_: *const [u8]) { pub fn str(_: &[u8]) { } -// CHECK: @trait_borrow({}* noundef nonnull align 1 %_1.0, [3 x [[USIZE]]]* noalias readonly align {{.*}} dereferenceable({{.*}}) %_1.1) +// CHECK: @trait_borrow({}* noundef nonnull align 1 %_1.0, [3 x [[USIZE]]]* noalias noundef readonly align {{.*}} dereferenceable({{.*}}) %_1.1) // FIXME #25759 This should also have `nocapture` #[no_mangle] pub fn trait_borrow(_: &Drop) { } -// CHECK: @trait_raw({}* %_1.0, [3 x [[USIZE]]]* noalias readonly align {{.*}} dereferenceable({{.*}}) %_1.1) +// CHECK: @trait_raw({}* %_1.0, [3 x [[USIZE]]]* noalias noundef readonly align {{.*}} dereferenceable({{.*}}) %_1.1) #[no_mangle] pub fn trait_raw(_: *const Drop) { } -// CHECK: @trait_box({}* noalias noundef nonnull align 1{{( %0)?}}, [3 x [[USIZE]]]* noalias readonly align {{.*}} dereferenceable({{.*}}){{( %1)?}}) +// CHECK: @trait_box({}* noalias noundef nonnull align 1{{( %0)?}}, [3 x [[USIZE]]]* noalias noundef readonly align {{.*}} dereferenceable({{.*}}){{( %1)?}}) #[no_mangle] pub fn trait_box(_: Box) { } diff --git a/src/test/codegen/packed.rs b/src/test/codegen/packed.rs index dfa7803d4f2f1..5d1fb80ec0051 100644 --- a/src/test/codegen/packed.rs +++ b/src/test/codegen/packed.rs @@ -52,7 +52,7 @@ pub struct BigPacked2 { #[no_mangle] pub fn call_pkd1(f: fn() -> Array) -> BigPacked1 { // CHECK: [[ALLOCA:%[_a-z0-9]+]] = alloca %Array -// CHECK: call void %{{.*}}(%Array* noalias nocapture sret{{.*}} dereferenceable(32) [[ALLOCA]]) +// CHECK: call void %{{.*}}(%Array* noalias nocapture noundef sret{{.*}} dereferenceable(32) [[ALLOCA]]) // CHECK: call void @llvm.memcpy.{{.*}}(i8* align 1 %{{.*}}, i8* align 4 %{{.*}}, i{{[0-9]+}} 32, i1 false) // check that calls whose destination is a field of a packed struct // go through an alloca rather than calling the function with an @@ -64,7 +64,7 @@ pub fn call_pkd1(f: fn() -> Array) -> BigPacked1 { #[no_mangle] pub fn call_pkd2(f: fn() -> Array) -> BigPacked2 { // CHECK: [[ALLOCA:%[_a-z0-9]+]] = alloca %Array -// CHECK: call void %{{.*}}(%Array* noalias nocapture sret{{.*}} dereferenceable(32) [[ALLOCA]]) +// CHECK: call void %{{.*}}(%Array* noalias nocapture noundef sret{{.*}} dereferenceable(32) [[ALLOCA]]) // CHECK: call void @llvm.memcpy.{{.*}}(i8* align 2 %{{.*}}, i8* align 4 %{{.*}}, i{{[0-9]+}} 32, i1 false) // check that calls whose destination is a field of a packed struct // go through an alloca rather than calling the function with an From ae877003ec0d1941992a86996630df947582990e Mon Sep 17 00:00:00 2001 From: Erik Desjardins Date: Sat, 12 Feb 2022 00:13:10 -0500 Subject: [PATCH 4/5] fix non-x64 tests --- src/test/codegen/fastcall-inreg.rs | 2 +- src/test/codegen/riscv-abi/riscv64-lp64-lp64f-lp64d-abi.rs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/test/codegen/fastcall-inreg.rs b/src/test/codegen/fastcall-inreg.rs index adbeae454494a..d8e5856822efe 100644 --- a/src/test/codegen/fastcall-inreg.rs +++ b/src/test/codegen/fastcall-inreg.rs @@ -70,7 +70,7 @@ pub mod tests { #[no_mangle] pub extern "fastcall" fn f5(_: i64, _: i32) {} - // CHECK: @f6(i1 inreg zeroext %_1, i32 inreg %_2, i32 %_3) + // CHECK: @f6(i1 inreg noundef zeroext %_1, i32 inreg %_2, i32 %_3) #[no_mangle] pub extern "fastcall" fn f6(_: bool, _: i32, _: i32) {} } diff --git a/src/test/codegen/riscv-abi/riscv64-lp64-lp64f-lp64d-abi.rs b/src/test/codegen/riscv-abi/riscv64-lp64-lp64f-lp64d-abi.rs index 693f0d99c4fff..8593a035787d4 100644 --- a/src/test/codegen/riscv-abi/riscv64-lp64-lp64f-lp64d-abi.rs +++ b/src/test/codegen/riscv-abi/riscv64-lp64-lp64f-lp64d-abi.rs @@ -9,7 +9,7 @@ #[no_mangle] pub extern "C" fn f_void() {} -// CHECK: define zeroext i1 @f_scalar_0(i1 zeroext %a) +// CHECK: define noundef zeroext i1 @f_scalar_0(i1 noundef zeroext %a) #[no_mangle] pub extern "C" fn f_scalar_0(a: bool) -> bool { a From 401307759aaf6f1e49c8a2c840a76ae41ec1f865 Mon Sep 17 00:00:00 2001 From: Erik Desjardins Date: Sat, 12 Feb 2022 12:28:19 -0500 Subject: [PATCH 5/5] make fastcall-inreg and riscv64-lp64-lp64f-lp64d-abi tests able to run on any host platform (with the right llvm components) --- src/test/codegen/fastcall-inreg.rs | 53 ++++--------------- .../riscv-abi/riscv64-lp64-lp64f-lp64d-abi.rs | 24 ++++----- 2 files changed, 21 insertions(+), 56 deletions(-) diff --git a/src/test/codegen/fastcall-inreg.rs b/src/test/codegen/fastcall-inreg.rs index d8e5856822efe..ec7a679159286 100644 --- a/src/test/codegen/fastcall-inreg.rs +++ b/src/test/codegen/fastcall-inreg.rs @@ -2,52 +2,17 @@ // as "inreg" like the C/C++ compilers for the platforms. // x86 only. -// ignore-aarch64 -// ignore-aarch64_be -// ignore-arm -// ignore-armeb -// ignore-avr -// ignore-bpfel -// ignore-bpfeb -// ignore-hexagon -// ignore-mips -// ignore-mips64 -// ignore-msp430 -// ignore-powerpc64 -// ignore-powerpc64le -// ignore-powerpc -// ignore-r600 -// ignore-riscv64 -// ignore-amdgcn -// ignore-sparc -// ignore-sparc64 -// ignore-sparcv9 -// ignore-sparcel -// ignore-s390x -// ignore-tce -// ignore-thumb -// ignore-thumbeb -// ignore-x86_64 -// ignore-xcore -// ignore-nvptx -// ignore-nvptx64 -// ignore-le32 -// ignore-le64 -// ignore-amdil -// ignore-amdil64 -// ignore-hsail -// ignore-hsail64 -// ignore-spir -// ignore-spir64 -// ignore-kalimba -// ignore-shave -// ignore-wasm32 -// ignore-wasm64 -// ignore-emscripten - -// compile-flags: -C no-prepopulate-passes +// compile-flags: --target i686-unknown-linux-gnu -C no-prepopulate-passes +// needs-llvm-components: x86 #![crate_type = "lib"] +#![no_core] +#![feature(no_core, lang_items)] + +#[lang = "sized"] +trait Sized {} +#[lang = "copy"] +trait Copy {} pub mod tests { // CHECK: @f1(i32 inreg %_1, i32 inreg %_2, i32 %_3) diff --git a/src/test/codegen/riscv-abi/riscv64-lp64-lp64f-lp64d-abi.rs b/src/test/codegen/riscv-abi/riscv64-lp64-lp64f-lp64d-abi.rs index 8593a035787d4..c67406ea69338 100644 --- a/src/test/codegen/riscv-abi/riscv64-lp64-lp64f-lp64d-abi.rs +++ b/src/test/codegen/riscv-abi/riscv64-lp64-lp64f-lp64d-abi.rs @@ -1,10 +1,16 @@ -// -// compile-flags: -C no-prepopulate-passes -// only-riscv64 -// only-linux +// compile-flags: --target riscv64gc-unknown-linux-gnu -C no-prepopulate-passes +// needs-llvm-components: riscv + #![crate_type = "lib"] +#![no_core] +#![feature(no_core, lang_items)] #![allow(improper_ctypes)] +#[lang = "sized"] +trait Sized {} +#[lang = "copy"] +trait Copy {} + // CHECK: define void @f_void() #[no_mangle] pub extern "C" fn f_void() {} @@ -70,8 +76,6 @@ pub struct Tiny { // CHECK: define void @f_agg_tiny(i64 %0) #[no_mangle] pub extern "C" fn f_agg_tiny(mut e: Tiny) { - e.a += e.b; - e.c += e.d; } // CHECK: define i64 @f_agg_tiny_ret() @@ -89,14 +93,12 @@ pub struct Small { // CHECK: define void @f_agg_small([2 x i64] %0) #[no_mangle] pub extern "C" fn f_agg_small(mut x: Small) { - x.a += unsafe { *x.b }; - x.b = &mut x.a; } // CHECK: define [2 x i64] @f_agg_small_ret() #[no_mangle] pub extern "C" fn f_agg_small_ret() -> Small { - Small { a: 1, b: core::ptr::null_mut() } + Small { a: 1, b: 0 as *mut _ } } #[repr(C)] @@ -107,7 +109,6 @@ pub struct SmallAligned { // CHECK: define void @f_agg_small_aligned(i128 %0) #[no_mangle] pub extern "C" fn f_agg_small_aligned(mut x: SmallAligned) { - x.a += x.a; } #[repr(C)] @@ -121,7 +122,6 @@ pub struct Large { // CHECK: define void @f_agg_large(%Large* {{.*}}%x) #[no_mangle] pub extern "C" fn f_agg_large(mut x: Large) { - x.a = x.b + x.c + x.d; } // CHECK: define void @f_agg_large_ret(%Large* {{.*}}sret{{.*}}, i32 signext %i, i8 signext %j) @@ -172,7 +172,7 @@ pub unsafe extern "C" fn f_va_caller() { 4.0f64, 5.0f64, Tiny { a: 1, b: 2, c: 3, d: 4 }, - Small { a: 10, b: core::ptr::null_mut() }, + Small { a: 10, b: 0 as *mut _ }, SmallAligned { a: 11 }, Large { a: 12, b: 13, c: 14, d: 15 }, );