1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
|
use core::any::TypeId;
use core::intrinsics::assume;
#[test]
fn test_typeid_sized_types() {
struct X;
struct Y(u32);
assert_eq!(TypeId::of::<X>(), TypeId::of::<X>());
assert_eq!(TypeId::of::<Y>(), TypeId::of::<Y>());
assert!(TypeId::of::<X>() != TypeId::of::<Y>());
}
#[test]
fn test_typeid_unsized_types() {
trait Z {}
struct X(str);
struct Y(dyn Z + 'static);
assert_eq!(TypeId::of::<X>(), TypeId::of::<X>());
assert_eq!(TypeId::of::<Y>(), TypeId::of::<Y>());
assert!(TypeId::of::<X>() != TypeId::of::<Y>());
}
// Check that `const_assume` feature allow `assume` intrinsic
// to be used in const contexts.
#[test]
fn test_assume_can_be_in_const_contexts() {
const unsafe fn foo(x: usize, y: usize) -> usize {
// SAFETY: the entire function is not safe,
// but it is just an example not used elsewhere.
unsafe { assume(y != 0) };
x / y
}
let rs = unsafe { foo(42, 97) };
assert_eq!(rs, 0);
}
#[test]
const fn test_write_bytes_in_const_contexts() {
use core::intrinsics::write_bytes;
const TEST: [u32; 3] = {
let mut arr = [1u32, 2, 3];
unsafe {
write_bytes(arr.as_mut_ptr(), 0, 2);
}
arr
};
assert!(TEST[0] == 0);
assert!(TEST[1] == 0);
assert!(TEST[2] == 3);
const TEST2: [u32; 3] = {
let mut arr = [1u32, 2, 3];
unsafe {
write_bytes(arr.as_mut_ptr(), 1, 2);
}
arr
};
assert!(TEST2[0] == 16843009);
assert!(TEST2[1] == 16843009);
assert!(TEST2[2] == 3);
}
#[test]
fn test_hints_in_const_contexts() {
use core::intrinsics::{likely, unlikely};
// In const contexts, they just return their argument.
const {
assert!(true == likely(true));
assert!(false == likely(false));
assert!(true == unlikely(true));
assert!(false == unlikely(false));
assert!(42u32 == core::intrinsics::black_box(42u32));
assert!(42u32 == core::hint::black_box(42u32));
}
}
#[test]
fn test_const_allocate_at_runtime() {
use core::intrinsics::const_allocate;
unsafe {
assert!(const_allocate(4, 4).is_null());
}
}
#[test]
fn test_const_deallocate_at_runtime() {
use core::intrinsics::const_deallocate;
const X: &u32 = &42u32;
let x = &0u32;
unsafe {
const_deallocate(X as *const _ as *mut u8, 4, 4); // nop
const_deallocate(x as *const _ as *mut u8, 4, 4); // nop
const_deallocate(core::ptr::null_mut(), 1, 1); // nop
}
}
|
