1 // unit-test: LowerIntrinsics
2 // EMIT_MIR_FOR_EACH_PANIC_STRATEGY
3
4 #![feature(core_intrinsics, intrinsics, rustc_attrs)]
5 #![crate_type = "lib"]
6
7 // EMIT_MIR lower_intrinsics.wrapping.LowerIntrinsics.diff
wrapping(a: i32, b: i32)8 pub fn wrapping(a: i32, b: i32) {
9 let _x = core::intrinsics::wrapping_add(a, b);
10 let _y = core::intrinsics::wrapping_sub(a, b);
11 let _z = core::intrinsics::wrapping_mul(a, b);
12 }
13
14 // EMIT_MIR lower_intrinsics.unchecked.LowerIntrinsics.diff
unchecked(a: i32, b: i32)15 pub unsafe fn unchecked(a: i32, b: i32) {
16 let _a = core::intrinsics::unchecked_add(a, b);
17 let _b = core::intrinsics::unchecked_sub(a, b);
18 let _c = core::intrinsics::unchecked_mul(a, b);
19 let _x = core::intrinsics::unchecked_div(a, b);
20 let _y = core::intrinsics::unchecked_rem(a, b);
21 let _i = core::intrinsics::unchecked_shl(a, b);
22 let _j = core::intrinsics::unchecked_shr(a, b);
23 }
24
25 // EMIT_MIR lower_intrinsics.size_of.LowerIntrinsics.diff
size_of<T>() -> usize26 pub fn size_of<T>() -> usize {
27 core::intrinsics::size_of::<T>()
28 }
29
30 // EMIT_MIR lower_intrinsics.align_of.LowerIntrinsics.diff
align_of<T>() -> usize31 pub fn align_of<T>() -> usize {
32 core::intrinsics::min_align_of::<T>()
33 }
34
35 // EMIT_MIR lower_intrinsics.forget.LowerIntrinsics.diff
forget<T>(t: T)36 pub fn forget<T>(t: T) {
37 core::intrinsics::forget(t)
38 }
39
40 // EMIT_MIR lower_intrinsics.unreachable.LowerIntrinsics.diff
unreachable() -> !41 pub fn unreachable() -> ! {
42 unsafe { core::intrinsics::unreachable() };
43 }
44
45 // EMIT_MIR lower_intrinsics.non_const.LowerIntrinsics.diff
non_const<T>() -> usize46 pub fn non_const<T>() -> usize {
47 // Check that lowering works with non-const operand as a func.
48 let size_of_t = core::intrinsics::size_of::<T>;
49 size_of_t()
50 }
51
52 // EMIT_MIR lower_intrinsics.transmute_inhabited.LowerIntrinsics.diff
transmute_inhabited(c: std::cmp::Ordering) -> i853 pub fn transmute_inhabited(c: std::cmp::Ordering) -> i8 {
54 unsafe { std::mem::transmute(c) }
55 }
56
57 // EMIT_MIR lower_intrinsics.transmute_uninhabited.LowerIntrinsics.diff
transmute_uninhabited(u: ()) -> Never58 pub unsafe fn transmute_uninhabited(u: ()) -> Never {
59 unsafe { std::mem::transmute::<(), Never>(u) }
60 }
61
62 // EMIT_MIR lower_intrinsics.transmute_ref_dst.LowerIntrinsics.diff
transmute_ref_dst<T: ?Sized>(u: &T) -> *const T63 pub unsafe fn transmute_ref_dst<T: ?Sized>(u: &T) -> *const T {
64 unsafe { std::mem::transmute(u) }
65 }
66
67 // EMIT_MIR lower_intrinsics.transmute_to_ref_uninhabited.LowerIntrinsics.diff
transmute_to_ref_uninhabited() -> !68 pub unsafe fn transmute_to_ref_uninhabited() -> ! {
69 let x: &Never = std::mem::transmute(1usize);
70 match *x {}
71 }
72
73 // EMIT_MIR lower_intrinsics.transmute_to_mut_uninhabited.LowerIntrinsics.diff
transmute_to_mut_uninhabited() -> !74 pub unsafe fn transmute_to_mut_uninhabited() -> ! {
75 let x: &mut Never = std::mem::transmute(1usize);
76 match *x {}
77 }
78
79 // EMIT_MIR lower_intrinsics.transmute_to_box_uninhabited.LowerIntrinsics.diff
transmute_to_box_uninhabited() -> !80 pub unsafe fn transmute_to_box_uninhabited() -> ! {
81 let x: Box<Never> = std::mem::transmute(1usize);
82 match *x {}
83 }
84
85 pub enum E {
86 A,
87 B,
88 C,
89 }
90
91 // EMIT_MIR lower_intrinsics.discriminant.LowerIntrinsics.diff
discriminant<T>(t: T)92 pub fn discriminant<T>(t: T) {
93 core::intrinsics::discriminant_value(&t);
94 core::intrinsics::discriminant_value(&0);
95 core::intrinsics::discriminant_value(&());
96 core::intrinsics::discriminant_value(&E::B);
97 }
98
99 extern "rust-intrinsic" {
100 // Cannot use `std::intrinsics::copy_nonoverlapping` as that is a wrapper function
101 #[rustc_nounwind]
copy_nonoverlapping<T>(src: *const T, dst: *mut T, count: usize)102 fn copy_nonoverlapping<T>(src: *const T, dst: *mut T, count: usize);
103 }
104
105 // EMIT_MIR lower_intrinsics.f_copy_nonoverlapping.LowerIntrinsics.diff
f_copy_nonoverlapping()106 pub fn f_copy_nonoverlapping() {
107 let src = ();
108 let mut dst = ();
109 unsafe {
110 copy_nonoverlapping(&src as *const _ as *const i32, &mut dst as *mut _ as *mut i32, 0);
111 }
112 }
113
114 // EMIT_MIR lower_intrinsics.assume.LowerIntrinsics.diff
assume()115 pub fn assume() {
116 unsafe {
117 std::intrinsics::assume(true);
118 }
119 }
120
121 // EMIT_MIR lower_intrinsics.with_overflow.LowerIntrinsics.diff
with_overflow(a: i32, b: i32)122 pub fn with_overflow(a: i32, b: i32) {
123 let _x = core::intrinsics::add_with_overflow(a, b);
124 let _y = core::intrinsics::sub_with_overflow(a, b);
125 let _z = core::intrinsics::mul_with_overflow(a, b);
126 }
127
128 // EMIT_MIR lower_intrinsics.read_via_copy_primitive.LowerIntrinsics.diff
read_via_copy_primitive(r: &i32) -> i32129 pub fn read_via_copy_primitive(r: &i32) -> i32 {
130 unsafe { core::intrinsics::read_via_copy(r) }
131 }
132
133 // EMIT_MIR lower_intrinsics.read_via_copy_uninhabited.LowerIntrinsics.diff
read_via_copy_uninhabited(r: &Never) -> Never134 pub fn read_via_copy_uninhabited(r: &Never) -> Never {
135 unsafe { core::intrinsics::read_via_copy(r) }
136 }
137
138 // EMIT_MIR lower_intrinsics.write_via_move_string.LowerIntrinsics.diff
write_via_move_string(r: &mut String, v: String)139 pub fn write_via_move_string(r: &mut String, v: String) {
140 unsafe { core::intrinsics::write_via_move(r, v) }
141 }
142
143 pub enum Never {}
144
145 // EMIT_MIR lower_intrinsics.option_payload.LowerIntrinsics.diff
option_payload(o: &Option<usize>, p: &Option<String>)146 pub fn option_payload(o: &Option<usize>, p: &Option<String>) {
147 unsafe {
148 let _x = core::intrinsics::option_payload_ptr(o);
149 let _y = core::intrinsics::option_payload_ptr(p);
150 }
151 }
152
153 // EMIT_MIR lower_intrinsics.ptr_offset.LowerIntrinsics.diff
ptr_offset(p: *const i32, d: isize) -> *const i32154 pub unsafe fn ptr_offset(p: *const i32, d: isize) -> *const i32 {
155 core::intrinsics::offset(p, d)
156 }
157