nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-30 02:33:55 +00:00
Code Issues Packages Projects Releases Wiki Activity
37b22cf2d5
rust/tests/codegen/fastcall-inreg.rs

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

42 lines
1.4 KiB
Rust
Raw Normal View History

Cleaned up the code and added tests.
2016-12-22 08:47:26 +00:00
// Checks if the "fastcall" calling convention marks function arguments
// as "inreg" like the C/C++ compilers for the platforms.
// x86 only.
make tests work on noopt builder
2022-02-24 23:16:10 +00:00
// compile-flags: --target i686-unknown-linux-gnu -O -C no-prepopulate-passes
make fastcall-inreg and riscv64-lp64-lp64f-lp64d-abi tests able to run on any host platform (with the right llvm components)
2022-02-12 17:28:19 +00:00
// needs-llvm-components: x86
Cleaned up the code and added tests.
2016-12-22 08:47:26 +00:00
#![crate_type = "lib"]
make fastcall-inreg and riscv64-lp64-lp64f-lp64d-abi tests able to run on any host platform (with the right llvm components)
2022-02-12 17:28:19 +00:00
#![no_core]
#![feature(no_core, lang_items)]
#[lang = "sized"]
trait Sized {}
#[lang = "copy"]
trait Copy {}
Cleaned up the code and added tests.
2016-12-22 08:47:26 +00:00
Update fastcall-inreg codegen test so that functions actually get instantiated.
2017-11-08 10:09:48 +00:00
pub mod tests {
Put `noundef` on all scalars that don't allow uninit Previously, it was only put on scalars with range validity invariants like bool, was uninit was obviously invalid for those. Since then, we have normatively declared all uninit primitives to be undefined behavior and can therefore put `noundef` on them. The remaining concern was the `mem::uninitialized` function, which cause quite a lot of UB in the older parts of the ecosystem. This function now doesn't return uninit values anymore, making users of it safe from this change. The only real sources of UB where people could encounter uninit primitives are `MaybeUninit::uninit().assume_init()`, which has always be clear in the docs about being UB and from heap allocations (like reading from the spare capacity of a vec. This is hopefully rare enough to not break anything.
2022-12-30 14:55:05 +00:00
// CHECK: @f1(i32 inreg noundef %_1, i32 inreg noundef %_2, i32 noundef %_3)
Cleaned up the code and added tests.
2016-12-22 08:47:26 +00:00
#[no_mangle]
Update fastcall-inreg codegen test so that functions actually get instantiated.
2017-11-08 10:09:48 +00:00
pub extern "fastcall" fn f1(_: i32, _: i32, _: i32) {}
Cleaned up the code and added tests.
2016-12-22 08:47:26 +00:00
Put `noundef` on all scalars that don't allow uninit Previously, it was only put on scalars with range validity invariants like bool, was uninit was obviously invalid for those. Since then, we have normatively declared all uninit primitives to be undefined behavior and can therefore put `noundef` on them. The remaining concern was the `mem::uninitialized` function, which cause quite a lot of UB in the older parts of the ecosystem. This function now doesn't return uninit values anymore, making users of it safe from this change. The only real sources of UB where people could encounter uninit primitives are `MaybeUninit::uninit().assume_init()`, which has always be clear in the docs about being UB and from heap allocations (like reading from the spare capacity of a vec. This is hopefully rare enough to not break anything.
2022-12-30 14:55:05 +00:00
// CHECK: @f2({{i32\*|ptr}} inreg noundef %_1, {{i32\*|ptr}} inreg noundef %_2, {{i32\*|ptr}} noundef %_3)
Cleaned up the code and added tests.
2016-12-22 08:47:26 +00:00
#[no_mangle]
Update fastcall-inreg codegen test so that functions actually get instantiated.
2017-11-08 10:09:48 +00:00
pub extern "fastcall" fn f2(_: *const i32, _: *const i32, _: *const i32) {}
Cleaned up the code and added tests.
2016-12-22 08:47:26 +00:00
Put `noundef` on all scalars that don't allow uninit Previously, it was only put on scalars with range validity invariants like bool, was uninit was obviously invalid for those. Since then, we have normatively declared all uninit primitives to be undefined behavior and can therefore put `noundef` on them. The remaining concern was the `mem::uninitialized` function, which cause quite a lot of UB in the older parts of the ecosystem. This function now doesn't return uninit values anymore, making users of it safe from this change. The only real sources of UB where people could encounter uninit primitives are `MaybeUninit::uninit().assume_init()`, which has always be clear in the docs about being UB and from heap allocations (like reading from the spare capacity of a vec. This is hopefully rare enough to not break anything.
2022-12-30 14:55:05 +00:00
// CHECK: @f3(float noundef %_1, i32 inreg noundef %_2, i32 inreg noundef %_3, i32 noundef %_4)
Cleaned up the code and added tests.
2016-12-22 08:47:26 +00:00
#[no_mangle]
Update fastcall-inreg codegen test so that functions actually get instantiated.
2017-11-08 10:09:48 +00:00
pub extern "fastcall" fn f3(_: f32, _: i32, _: i32, _: i32) {}
Cleaned up the code and added tests.
2016-12-22 08:47:26 +00:00
Put `noundef` on all scalars that don't allow uninit Previously, it was only put on scalars with range validity invariants like bool, was uninit was obviously invalid for those. Since then, we have normatively declared all uninit primitives to be undefined behavior and can therefore put `noundef` on them. The remaining concern was the `mem::uninitialized` function, which cause quite a lot of UB in the older parts of the ecosystem. This function now doesn't return uninit values anymore, making users of it safe from this change. The only real sources of UB where people could encounter uninit primitives are `MaybeUninit::uninit().assume_init()`, which has always be clear in the docs about being UB and from heap allocations (like reading from the spare capacity of a vec. This is hopefully rare enough to not break anything.
2022-12-30 14:55:05 +00:00
// CHECK: @f4(i32 inreg noundef %_1, float noundef %_2, i32 inreg noundef %_3, i32 noundef %_4)
Cleaned up the code and added tests.
2016-12-22 08:47:26 +00:00
#[no_mangle]
Update fastcall-inreg codegen test so that functions actually get instantiated.
2017-11-08 10:09:48 +00:00
pub extern "fastcall" fn f4(_: i32, _: f32, _: i32, _: i32) {}
Cleaned up the code and added tests.
2016-12-22 08:47:26 +00:00
Put `noundef` on all scalars that don't allow uninit Previously, it was only put on scalars with range validity invariants like bool, was uninit was obviously invalid for those. Since then, we have normatively declared all uninit primitives to be undefined behavior and can therefore put `noundef` on them. The remaining concern was the `mem::uninitialized` function, which cause quite a lot of UB in the older parts of the ecosystem. This function now doesn't return uninit values anymore, making users of it safe from this change. The only real sources of UB where people could encounter uninit primitives are `MaybeUninit::uninit().assume_init()`, which has always be clear in the docs about being UB and from heap allocations (like reading from the spare capacity of a vec. This is hopefully rare enough to not break anything.
2022-12-30 14:55:05 +00:00
// CHECK: @f5(i64 noundef %_1, i32 noundef %_2)
Cleaned up the code and added tests.
2016-12-22 08:47:26 +00:00
#[no_mangle]
Update fastcall-inreg codegen test so that functions actually get instantiated.
2017-11-08 10:09:48 +00:00
pub extern "fastcall" fn f5(_: i64, _: i32) {}
Cleaned up the code and added tests.
2016-12-22 08:47:26 +00:00
Put `noundef` on all scalars that don't allow uninit Previously, it was only put on scalars with range validity invariants like bool, was uninit was obviously invalid for those. Since then, we have normatively declared all uninit primitives to be undefined behavior and can therefore put `noundef` on them. The remaining concern was the `mem::uninitialized` function, which cause quite a lot of UB in the older parts of the ecosystem. This function now doesn't return uninit values anymore, making users of it safe from this change. The only real sources of UB where people could encounter uninit primitives are `MaybeUninit::uninit().assume_init()`, which has always be clear in the docs about being UB and from heap allocations (like reading from the spare capacity of a vec. This is hopefully rare enough to not break anything.
2022-12-30 14:55:05 +00:00
// CHECK: @f6(i1 inreg noundef zeroext %_1, i32 inreg noundef %_2, i32 noundef %_3)
Cleaned up the code and added tests.
2016-12-22 08:47:26 +00:00
#[no_mangle]
Update fastcall-inreg codegen test so that functions actually get instantiated.
2017-11-08 10:09:48 +00:00
pub extern "fastcall" fn f6(_: bool, _: i32, _: i32) {}
Cleaned up the code and added tests.
2016-12-22 08:47:26 +00:00
}
Reference in New Issue Copy Permalink