rust/tests/codegen/placement-new.rs

//@ compile-flags: -O
#![crate_type = "lib"]

// Test to check that types with "complex" destructors, but trivial `Default` impls
// are constructed directly into the allocation in `Box::default` and `Arc::default`.

use std::sync::Arc;

// CHECK-LABEL: @box_default_inplace
#[no_mangle]
pub fn box_default_inplace() -> Box<(String, String)> {
    // CHECK-NOT: alloca
    // CHECK: [[BOX:%.*]] = {{.*}}call {{.*}}__rust_alloc(
    // CHECK-NOT: call void @llvm.memcpy
    // CHECK: ret ptr [[BOX]]
    Box::default()
}

// CHECK-LABEL: @arc_default_inplace
#[no_mangle]
pub fn arc_default_inplace() -> Arc<(String, String)> {
    // CHECK-NOT: alloca
    // CHECK: [[ARC:%.*]] = {{.*}}call {{.*}}__rust_alloc(
    // CHECK-NOT: call void @llvm.memcpy
    // CHECK: ret ptr [[ARC]]
    Arc::default()
}
add initial tests for placement new changes 2024-10-09 13:24:05 -05:00			`//@ compile-flags: -O`
			`#![crate_type = "lib"]`

			// Test to check that types with "complex" destructors, but trivial `Default` impls
			// are constructed directly into the allocation in `Box::default` and `Arc::default`.

			`use std::sync::Arc;`

			`// CHECK-LABEL: @box_default_inplace`
			`#[no_mangle]`
			`pub fn box_default_inplace() -> Box<(String, String)> {`
allocate before calling T::default in <Box<T>>::default() The `Box<T: Default>` impl currently calls `T::default()` before allocating the `Box`. Most `Default` impls are trivial, which should in theory allow LLVM to construct `T: Default` directly in the `Box` allocation when calling `<Box<T>>::default()`. However, the allocation may fail, which necessitates calling `T's` destructor if it has one. If the destructor is non-trivial, then LLVM has a hard time proving that it's sound to elide, which makes it construct `T` on the stack first, and then copy it into the allocation. Create an uninit `Box` first, and then write `T::default` into it, so that LLVM now only needs to prove that the `T::default` can't panic, which should be trivial for most `Default` impls. 2024-10-09 13:24:05 -05:00			`// CHECK-NOT: alloca`
add initial tests for placement new changes 2024-10-09 13:24:05 -05:00			`// CHECK: [[BOX:%.]] = {{.}}call {{.*}}__rust_alloc(`
allocate before calling T::default in <Box<T>>::default() The `Box<T: Default>` impl currently calls `T::default()` before allocating the `Box`. Most `Default` impls are trivial, which should in theory allow LLVM to construct `T: Default` directly in the `Box` allocation when calling `<Box<T>>::default()`. However, the allocation may fail, which necessitates calling `T's` destructor if it has one. If the destructor is non-trivial, then LLVM has a hard time proving that it's sound to elide, which makes it construct `T` on the stack first, and then copy it into the allocation. Create an uninit `Box` first, and then write `T::default` into it, so that LLVM now only needs to prove that the `T::default` can't panic, which should be trivial for most `Default` impls. 2024-10-09 13:24:05 -05:00			`// CHECK-NOT: call void @llvm.memcpy`
add initial tests for placement new changes 2024-10-09 13:24:05 -05:00			`// CHECK: ret ptr [[BOX]]`
			`Box::default()`
			`}`

			`// CHECK-LABEL: @arc_default_inplace`
			`#[no_mangle]`
			`pub fn arc_default_inplace() -> Arc<(String, String)> {`
allocate before calling T::default in <Arc<T>>::default() Same rationale as in the previous commit. 2024-10-09 13:24:05 -05:00			`// CHECK-NOT: alloca`
add initial tests for placement new changes 2024-10-09 13:24:05 -05:00			`// CHECK: [[ARC:%.]] = {{.}}call {{.*}}__rust_alloc(`
allocate before calling T::default in <Arc<T>>::default() Same rationale as in the previous commit. 2024-10-09 13:24:05 -05:00			`// CHECK-NOT: call void @llvm.memcpy`
add initial tests for placement new changes 2024-10-09 13:24:05 -05:00			`// CHECK: ret ptr [[ARC]]`
			`Arc::default()`
			`}`