Skip to content

Commit baf98e7

Browse files
scottmcmscottmcm
committed
Add transmute optimization tests and some extra comments
1 parent 1bcb0ec commit baf98e7

File tree

2 files changed

+118
-0
lines changed

2 files changed

+118
-0
lines changed

‎compiler/rustc_codegen_ssa/src/mir/rvalue.rs

+9
Original file line numberDiff line numberDiff line change
@@ -290,7 +290,13 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
290290

291291
use abi::Primitive::*;
292292
imm = bx.from_immediate(imm);
293+
294+
// When scalars are passed by value, there's no metadata recording their
295+
// valid ranges. For example, `char`s are passed as just `i32`, with no
296+
// way for LLVM to know that they're 0x10FFFF at most. Thus we assume
297+
// the range of the input value too, not just the output range.
293298
self.assume_scalar_range(bx, imm, from_scalar, from_backend_ty);
299+
294300
imm = match (from_scalar.primitive(), to_scalar.primitive()) {
295301
(Int(..) | F32 | F64, Int(..) | F32 | F64) => bx.bitcast(imm, to_backend_ty),
296302
(Pointer(..), Pointer(..)) => bx.pointercast(imm, to_backend_ty),
@@ -318,6 +324,9 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
318324
backend_ty: Bx::Type,
319325
) {
320326
if matches!(self.cx.sess().opts.optimize, OptLevel::No | OptLevel::Less)
327+
// For now, the critical niches are all over `Int`eger values.
328+
// Should floating-point values or pointers ever get more complex
329+
// niches, then this code will probably want to handle them too.
321330
|| !matches!(scalar.primitive(), abi::Primitive::Int(..))
322331
|| scalar.is_always_valid(self.cx)
323332
{

‎tests/codegen/transmute-optimized.rs

+109
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,109 @@
1+
// compile-flags: -O -Z merge-functions=disabled
2+
// min-llvm-version: 15.0 # this test uses `ptr`s
3+
// ignore-debug
4+
5+
#![crate_type = "lib"]
6+
7+
// This tests that LLVM can optimize based on the niches in the source or
8+
// destination types for transmutes.
9+
10+
#[repr(u32)]
11+
pub enum AlwaysZero32 { X = 0 }
12+
13+
// CHECK-LABEL: i32 @issue_109958(i32
14+
#[no_mangle]
15+
pub fn issue_109958(x: AlwaysZero32) -> i32 {
16+
// CHECK: ret i32 0
17+
unsafe { std::mem::transmute(x) }
18+
}
19+
20+
// CHECK-LABEL: i1 @reference_is_null(ptr
21+
#[no_mangle]
22+
pub fn reference_is_null(x: &i32) -> bool {
23+
// CHECK: ret i1 false
24+
let p: *const i32 = unsafe { std::mem::transmute(x) };
25+
p.is_null()
26+
}
27+
28+
// CHECK-LABEL: i1 @non_null_is_null(ptr
29+
#[no_mangle]
30+
pub fn non_null_is_null(x: std::ptr::NonNull<i32>) -> bool {
31+
// CHECK: ret i1 false
32+
let p: *const i32 = unsafe { std::mem::transmute(x) };
33+
p.is_null()
34+
}
35+
36+
// CHECK-LABEL: i1 @non_zero_is_null(
37+
#[no_mangle]
38+
pub fn non_zero_is_null(x: std::num::NonZeroUsize) -> bool {
39+
// CHECK: ret i1 false
40+
let p: *const i32 = unsafe { std::mem::transmute(x) };
41+
p.is_null()
42+
}
43+
44+
// CHECK-LABEL: i1 @non_null_is_zero(ptr
45+
#[no_mangle]
46+
pub fn non_null_is_zero(x: std::ptr::NonNull<i32>) -> bool {
47+
// CHECK: ret i1 false
48+
let a: isize = unsafe { std::mem::transmute(x) };
49+
a == 0
50+
}
51+
52+
// CHECK-LABEL: i1 @bool_ordering_is_ge(i1
53+
#[no_mangle]
54+
pub fn bool_ordering_is_ge(x: bool) -> bool {
55+
// CHECK: ret i1 true
56+
let y: std::cmp::Ordering = unsafe { std::mem::transmute(x) };
57+
y.is_ge()
58+
}
59+
60+
// CHECK-LABEL: i1 @ordering_is_ge_then_transmute_to_bool(i8
61+
#[no_mangle]
62+
pub fn ordering_is_ge_then_transmute_to_bool(x: std::cmp::Ordering) -> bool {
63+
let r = x.is_ge();
64+
let _: bool = unsafe { std::mem::transmute(x) };
65+
r
66+
}
67+
68+
// CHECK-LABEL: i32 @normal_div(i32
69+
#[no_mangle]
70+
pub fn normal_div(a: u32, b: u32) -> u32 {
71+
// CHECK: call core::panicking::panic
72+
a / b
73+
}
74+
75+
// CHECK-LABEL: i32 @div_transmute_nonzero(i32
76+
#[no_mangle]
77+
pub fn div_transmute_nonzero(a: u32, b: std::num::NonZeroI32) -> u32 {
78+
// CHECK-NOT: call core::panicking::panic
79+
// CHECK: %[[R:.+]] = udiv i32 %a, %b
80+
// CHECK-NEXT: ret i32 %[[R]]
81+
// CHECK-NOT: call core::panicking::panic
82+
let d: u32 = unsafe { std::mem::transmute(b) };
83+
a / d
84+
}
85+
86+
#[repr(i8)]
87+
pub enum OneTwoThree { One = 1, Two = 2, Three = 3 }
88+
89+
// CHECK-LABEL: i8 @ordering_transmute_onetwothree(i8
90+
#[no_mangle]
91+
pub unsafe fn ordering_transmute_onetwothree(x: std::cmp::Ordering) -> OneTwoThree {
92+
// CHECK: ret i8 1
93+
std::mem::transmute(x)
94+
}
95+
96+
// CHECK-LABEL: i8 @onetwothree_transmute_ordering(i8
97+
#[no_mangle]
98+
pub unsafe fn onetwothree_transmute_ordering(x: OneTwoThree) -> std::cmp::Ordering {
99+
// CHECK: ret i8 1
100+
std::mem::transmute(x)
101+
}
102+
103+
// CHECK-LABEL: i1 @char_is_negative(i32
104+
#[no_mangle]
105+
pub fn char_is_negative(c: char) -> bool {
106+
// CHECK: ret i1 false
107+
let x: i32 = unsafe { std::mem::transmute(c) };
108+
x < 0
109+
}

0 commit comments

Comments
 (0)