Skip to content

Commit fce6510

Browse files
cjgillotcjgillot
committed
Fold consecutive PtrToPtr casts.
1 parent 25f8d01 commit fce6510

13 files changed

+401
-379
lines changed

‎compiler/rustc_mir_transform/src/gvn.rs

+43-13
Original file line numberDiff line numberDiff line change
@@ -93,7 +93,6 @@ use rustc_index::IndexVec;
9393
use rustc_middle::mir::interpret::GlobalAlloc;
9494
use rustc_middle::mir::visit::*;
9595
use rustc_middle::mir::*;
96-
use rustc_middle::ty::adjustment::PointerCoercion;
9796
use rustc_middle::ty::layout::LayoutOf;
9897
use rustc_middle::ty::{self, Ty, TyCtxt, TypeAndMut};
9998
use rustc_span::def_id::DefId;
@@ -777,18 +776,8 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
777776

778777
// Operations.
779778
Rvalue::Len(ref mut place) => return self.simplify_len(place, location),
780-
Rvalue::Cast(kind, ref mut value, to) => {
781-
let from = value.ty(self.local_decls, self.tcx);
782-
let value = self.simplify_operand(value, location)?;
783-
if let CastKind::PointerCoercion(
784-
PointerCoercion::ReifyFnPointer | PointerCoercion::ClosureFnPointer(_),
785-
) = kind
786-
{
787-
// Each reification of a generic fn may get a different pointer.
788-
// Do not try to merge them.
789-
return self.new_opaque();
790-
}
791-
Value::Cast { kind, value, from, to }
779+
Rvalue::Cast(ref mut kind, ref mut value, to) => {
780+
return self.simplify_cast(kind, value, to, location);
792781
}
793782
Rvalue::BinaryOp(op, box (ref mut lhs, ref mut rhs)) => {
794783
let ty = lhs.ty(self.local_decls, self.tcx);
@@ -1031,6 +1020,47 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
10311020
}
10321021
}
10331022

1023+
fn simplify_cast(
1024+
&mut self,
1025+
kind: &mut CastKind,
1026+
operand: &mut Operand<'tcx>,
1027+
to: Ty<'tcx>,
1028+
location: Location,
1029+
) -> Option<VnIndex> {
1030+
use rustc_middle::ty::adjustment::PointerCoercion::*;
1031+
use CastKind::*;
1032+
1033+
let mut from = operand.ty(self.local_decls, self.tcx);
1034+
let mut value = self.simplify_operand(operand, location)?;
1035+
1036+
if let CastKind::PointerCoercion(ReifyFnPointer | ClosureFnPointer(_)) = kind {
1037+
// Each reification of a generic fn may get a different pointer.
1038+
// Do not try to merge them.
1039+
return self.new_opaque();
1040+
}
1041+
1042+
if let PtrToPtr | PointerCoercion(MutToConstPointer) = kind
1043+
&& let Value::Cast { kind: inner_kind, value: inner_value, from: inner_from, to: _ } =
1044+
*self.get(value)
1045+
&& let PtrToPtr | PointerCoercion(MutToConstPointer) = inner_kind
1046+
{
1047+
from = inner_from;
1048+
value = inner_value;
1049+
*kind = PtrToPtr;
1050+
if inner_from == to {
1051+
return Some(inner_value);
1052+
}
1053+
if let Some(const_) = self.try_as_constant(value) {
1054+
*operand = Operand::Constant(Box::new(const_));
1055+
} else if let Some(local) = self.try_as_local(value, location) {
1056+
*operand = Operand::Copy(local.into());
1057+
self.reused_locals.insert(local);
1058+
}
1059+
}
1060+
1061+
Some(self.insert(Value::Cast { kind: *kind, value, from, to }))
1062+
}
1063+
10341064
fn simplify_len(&mut self, place: &mut Place<'tcx>, location: Location) -> Option<VnIndex> {
10351065
// Trivial case: we are fetching a statically known length.
10361066
let place_ty = place.ty(self.local_decls, self.tcx).ty;

‎tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-abort.diff

+8-4
Original file line numberDiff line numberDiff line change
@@ -111,12 +111,16 @@
111111
StorageDead(_15);
112112
StorageDead(_12);
113113
StorageDead(_6);
114-
StorageLive(_18);
114+
- StorageLive(_18);
115+
+ nop;
115116
_18 = (_5.0: *const [u8]);
116-
_4 = move _18 as *mut [u8] (PtrToPtr);
117-
StorageDead(_18);
117+
- _4 = move _18 as *mut [u8] (PtrToPtr);
118+
- StorageDead(_18);
119+
+ _4 = _18 as *mut [u8] (PtrToPtr);
120+
+ nop;
118121
StorageDead(_5);
119-
_3 = move _4 as *mut u8 (PtrToPtr);
122+
- _3 = move _4 as *mut u8 (PtrToPtr);
123+
+ _3 = _18 as *mut u8 (PtrToPtr);
120124
StorageDead(_4);
121125
StorageDead(_3);
122126
- StorageDead(_1);

‎tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-unwind.diff

+8-4
Original file line numberDiff line numberDiff line change
@@ -50,12 +50,16 @@
5050

5151
bb1: {
5252
StorageDead(_6);
53-
StorageLive(_12);
53+
- StorageLive(_12);
54+
+ nop;
5455
_12 = (_5.0: *const [u8]);
55-
_4 = move _12 as *mut [u8] (PtrToPtr);
56-
StorageDead(_12);
56+
- _4 = move _12 as *mut [u8] (PtrToPtr);
57+
- StorageDead(_12);
58+
+ _4 = _12 as *mut [u8] (PtrToPtr);
59+
+ nop;
5760
StorageDead(_5);
58-
_3 = move _4 as *mut u8 (PtrToPtr);
61+
- _3 = move _4 as *mut u8 (PtrToPtr);
62+
+ _3 = _12 as *mut u8 (PtrToPtr);
5963
StorageDead(_4);
6064
StorageDead(_3);
6165
- StorageDead(_1);

‎tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-abort.diff

+8-4
Original file line numberDiff line numberDiff line change
@@ -111,12 +111,16 @@
111111
StorageDead(_15);
112112
StorageDead(_12);
113113
StorageDead(_6);
114-
StorageLive(_18);
114+
- StorageLive(_18);
115+
+ nop;
115116
_18 = (_5.0: *const [u8]);
116-
_4 = move _18 as *mut [u8] (PtrToPtr);
117-
StorageDead(_18);
117+
- _4 = move _18 as *mut [u8] (PtrToPtr);
118+
- StorageDead(_18);
119+
+ _4 = _18 as *mut [u8] (PtrToPtr);
120+
+ nop;
118121
StorageDead(_5);
119-
_3 = move _4 as *mut u8 (PtrToPtr);
122+
- _3 = move _4 as *mut u8 (PtrToPtr);
123+
+ _3 = _18 as *mut u8 (PtrToPtr);
120124
StorageDead(_4);
121125
StorageDead(_3);
122126
- StorageDead(_1);

‎tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-unwind.diff

+8-4
Original file line numberDiff line numberDiff line change
@@ -50,12 +50,16 @@
5050

5151
bb1: {
5252
StorageDead(_6);
53-
StorageLive(_12);
53+
- StorageLive(_12);
54+
+ nop;
5455
_12 = (_5.0: *const [u8]);
55-
_4 = move _12 as *mut [u8] (PtrToPtr);
56-
StorageDead(_12);
56+
- _4 = move _12 as *mut [u8] (PtrToPtr);
57+
- StorageDead(_12);
58+
+ _4 = _12 as *mut [u8] (PtrToPtr);
59+
+ nop;
5760
StorageDead(_5);
58-
_3 = move _4 as *mut u8 (PtrToPtr);
61+
- _3 = move _4 as *mut u8 (PtrToPtr);
62+
+ _3 = _12 as *mut u8 (PtrToPtr);
5963
StorageDead(_4);
6064
StorageDead(_3);
6165
- StorageDead(_1);

‎tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.PreCodegen.after.panic-abort.mir

+1-1
Original file line numberDiff line numberDiff line change
@@ -89,7 +89,7 @@ fn slice_get_unchecked_mut_range(_1: &mut [u32], _2: std::ops::Range<usize>) ->
8989
StorageLive(_12);
9090
StorageLive(_11);
9191
StorageLive(_10);
92-
_10 = _9 as *const () (PointerCoercion(MutToConstPointer));
92+
_10 = _8 as *const () (PtrToPtr);
9393
_11 = std::ptr::metadata::PtrComponents::<[u32]> { data_address: move _10, metadata: _6 };
9494
StorageDead(_10);
9595
_12 = std::ptr::metadata::PtrRepr::<[u32]> { const_ptr: move _11 };

‎tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.PreCodegen.after.panic-unwind.mir

+1-1
Original file line numberDiff line numberDiff line change
@@ -89,7 +89,7 @@ fn slice_get_unchecked_mut_range(_1: &mut [u32], _2: std::ops::Range<usize>) ->
8989
StorageLive(_12);
9090
StorageLive(_11);
9191
StorageLive(_10);
92-
_10 = _9 as *const () (PointerCoercion(MutToConstPointer));
92+
_10 = _8 as *const () (PtrToPtr);
9393
_11 = std::ptr::metadata::PtrComponents::<[u32]> { data_address: move _10, metadata: _6 };
9494
StorageDead(_10);
9595
_12 = std::ptr::metadata::PtrRepr::<[u32]> { const_ptr: move _11 };

‎tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.PreCodegen.after.panic-abort.mir

+57-61
Original file line numberDiff line numberDiff line change
@@ -4,22 +4,22 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
44
debug slice => _1;
55
debug f => _2;
66
let mut _0: ();
7-
let mut _13: std::slice::Iter<'_, T>;
7+
let mut _12: std::slice::Iter<'_, T>;
8+
let mut _13: std::iter::Enumerate<std::slice::Iter<'_, T>>;
89
let mut _14: std::iter::Enumerate<std::slice::Iter<'_, T>>;
9-
let mut _15: std::iter::Enumerate<std::slice::Iter<'_, T>>;
10-
let mut _16: &mut std::iter::Enumerate<std::slice::Iter<'_, T>>;
11-
let mut _17: std::option::Option<(usize, &T)>;
12-
let mut _18: isize;
13-
let mut _21: &impl Fn(usize, &T);
14-
let mut _22: (usize, &T);
15-
let _23: ();
10+
let mut _15: &mut std::iter::Enumerate<std::slice::Iter<'_, T>>;
11+
let mut _16: std::option::Option<(usize, &T)>;
12+
let mut _17: isize;
13+
let mut _20: &impl Fn(usize, &T);
14+
let mut _21: (usize, &T);
15+
let _22: ();
1616
scope 1 {
17-
debug iter => _15;
18-
let _19: usize;
19-
let _20: &T;
17+
debug iter => _14;
18+
let _18: usize;
19+
let _19: &T;
2020
scope 2 {
21-
debug i => _19;
22-
debug x => _20;
21+
debug i => _18;
22+
debug x => _19;
2323
}
2424
}
2525
scope 3 (inlined core::slice::<impl [T]>::iter) {
@@ -31,8 +31,8 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
3131
let mut _6: usize;
3232
let mut _8: usize;
3333
let mut _9: *mut T;
34-
let mut _11: std::ptr::NonNull<T>;
35-
let mut _12: *const T;
34+
let mut _10: std::ptr::NonNull<T>;
35+
let mut _11: *const T;
3636
scope 5 {
3737
debug ptr => _4;
3838
scope 6 {
@@ -41,22 +41,21 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
4141
debug end_or_len => _7;
4242
scope 13 (inlined NonNull::<T>::new_unchecked) {
4343
debug ptr => _9;
44-
let mut _10: *const T;
45-
let mut _24: *mut T;
44+
let mut _23: *mut T;
4645
scope 14 {
4746
scope 15 (inlined NonNull::<T>::new_unchecked::runtime::<T>) {
48-
debug ptr => _24;
47+
debug ptr => _23;
4948
scope 16 (inlined std::ptr::mut_ptr::<impl *mut T>::is_null) {
50-
debug self => _24;
51-
let mut _25: *mut u8;
49+
debug self => _23;
50+
let mut _24: *mut u8;
5251
scope 17 {
5352
scope 18 (inlined std::ptr::mut_ptr::<impl *mut T>::is_null::runtime_impl) {
54-
debug ptr => _25;
53+
debug ptr => _24;
5554
scope 19 (inlined std::ptr::mut_ptr::<impl *mut u8>::addr) {
56-
debug self => _25;
55+
debug self => _24;
5756
scope 20 {
5857
scope 21 (inlined std::ptr::mut_ptr::<impl *mut u8>::cast::<()>) {
59-
debug self => _25;
58+
debug self => _24;
6059
}
6160
}
6261
}
@@ -87,22 +86,21 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
8786
}
8887
}
8988
scope 22 (inlined <std::slice::Iter<'_, T> as Iterator>::enumerate) {
90-
debug self => _13;
89+
debug self => _12;
9190
scope 23 (inlined Enumerate::<std::slice::Iter<'_, T>>::new) {
92-
debug iter => _13;
91+
debug iter => _12;
9392
}
9493
}
9594
scope 24 (inlined <Enumerate<std::slice::Iter<'_, T>> as IntoIterator>::into_iter) {
96-
debug self => _14;
95+
debug self => _13;
9796
}
9897

9998
bb0: {
100-
StorageLive(_13);
99+
StorageLive(_12);
101100
StorageLive(_4);
102101
StorageLive(_3);
103102
_3 = &raw const (*_1);
104-
_4 = move _3 as *const T (PtrToPtr);
105-
StorageDead(_3);
103+
_4 = _3 as *const T (PtrToPtr);
106104
StorageLive(_7);
107105
StorageLive(_5);
108106
_5 = const _;
@@ -127,48 +125,46 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
127125

128126
bb3: {
129127
StorageDead(_5);
130-
StorageLive(_11);
131-
StorageLive(_9);
132-
_9 = _4 as *mut T (PtrToPtr);
133128
StorageLive(_10);
129+
StorageLive(_9);
130+
_9 = _3 as *mut T (PtrToPtr);
131+
StorageLive(_23);
134132
StorageLive(_24);
135-
StorageLive(_25);
136-
_10 = _9 as *const T (PointerCoercion(MutToConstPointer));
137-
_11 = NonNull::<T> { pointer: _10 };
138-
StorageDead(_25);
133+
_10 = NonNull::<T> { pointer: _4 };
139134
StorageDead(_24);
140-
StorageDead(_10);
135+
StorageDead(_23);
141136
StorageDead(_9);
142-
StorageLive(_12);
143-
_12 = _7;
144-
_13 = std::slice::Iter::<'_, T> { ptr: move _11, end_or_len: move _12, _marker: const ZeroSized: PhantomData<&T> };
145-
StorageDead(_12);
137+
StorageLive(_11);
138+
_11 = _7;
139+
_12 = std::slice::Iter::<'_, T> { ptr: move _10, end_or_len: move _11, _marker: const ZeroSized: PhantomData<&T> };
146140
StorageDead(_11);
141+
StorageDead(_10);
147142
StorageDead(_7);
143+
StorageDead(_3);
148144
StorageDead(_4);
149-
_14 = Enumerate::<std::slice::Iter<'_, T>> { iter: _13, count: const 0_usize };
150-
StorageDead(_13);
151-
StorageLive(_15);
152-
_15 = _14;
145+
_13 = Enumerate::<std::slice::Iter<'_, T>> { iter: _12, count: const 0_usize };
146+
StorageDead(_12);
147+
StorageLive(_14);
148+
_14 = _13;
153149
goto -> bb4;
154150
}
155151

156152
bb4: {
157-
StorageLive(_17);
158153
StorageLive(_16);
159-
_16 = &mut _15;
160-
_17 = <Enumerate<std::slice::Iter<'_, T>> as Iterator>::next(move _16) -> [return: bb5, unwind unreachable];
154+
StorageLive(_15);
155+
_15 = &mut _14;
156+
_16 = <Enumerate<std::slice::Iter<'_, T>> as Iterator>::next(move _15) -> [return: bb5, unwind unreachable];
161157
}
162158

163159
bb5: {
164-
StorageDead(_16);
165-
_18 = discriminant(_17);
166-
switchInt(move _18) -> [0: bb6, 1: bb8, otherwise: bb10];
160+
StorageDead(_15);
161+
_17 = discriminant(_16);
162+
switchInt(move _17) -> [0: bb6, 1: bb8, otherwise: bb10];
167163
}
168164

169165
bb6: {
170-
StorageDead(_17);
171-
StorageDead(_15);
166+
StorageDead(_16);
167+
StorageDead(_14);
172168
drop(_2) -> [return: bb7, unwind unreachable];
173169
}
174170

@@ -177,19 +173,19 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
177173
}
178174

179175
bb8: {
180-
_19 = (((_17 as Some).0: (usize, &T)).0: usize);
181-
_20 = (((_17 as Some).0: (usize, &T)).1: &T);
176+
_18 = (((_16 as Some).0: (usize, &T)).0: usize);
177+
_19 = (((_16 as Some).0: (usize, &T)).1: &T);
178+
StorageLive(_20);
179+
_20 = &_2;
182180
StorageLive(_21);
183-
_21 = &_2;
184-
StorageLive(_22);
185-
_22 = (_19, _20);
186-
_23 = <impl Fn(usize, &T) as Fn<(usize, &T)>>::call(move _21, move _22) -> [return: bb9, unwind unreachable];
181+
_21 = (_18, _19);
182+
_22 = <impl Fn(usize, &T) as Fn<(usize, &T)>>::call(move _20, move _21) -> [return: bb9, unwind unreachable];
187183
}
188184

189185
bb9: {
190-
StorageDead(_22);
191186
StorageDead(_21);
192-
StorageDead(_17);
187+
StorageDead(_20);
188+
StorageDead(_16);
193189
goto -> bb4;
194190
}
195191

0 commit comments

Comments
 (0)