mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Split gvn wide ptr tests.

Browse Source
This commit is contained in:
Camille GILLOT 2023-12-30 23:37:50 +00:00
parent 28df0a62f6
commit 5a6f14c4f4
8 changed files with 894 additions and 799 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
compiler/rustc_mir_transform/src/gvn.rs
View File

@ -1046,6 +1046,9 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
let mut from = operand.ty(self.local_decls, self.tcx);
let mut value = self.simplify_operand(operand, location)?;
if from == to {
return Some(value);
}
if let CastKind::PointerCoercion(ReifyFnPointer | ClosureFnPointer(_)) = kind {
// Each reification of a generic fn may get a different pointer.

56
tests/mir-opt/gvn.rs
View File

@ -644,25 +644,53 @@ fn constant_index_overflow<T: Copy>(x: &[T]) {
opaque(b)
}
fn wide_ptr_ops() {
/// Check that we do not attempt to simplify anything when there is provenance.
fn wide_ptr_provenance() {
// CHECK-LABEL: fn wide_ptr_provenance(
let a: *const dyn Send = &1 as &dyn Send;
let b: *const dyn Send = &1 as &dyn Send;
let _val = a == b;
let _val = a != b;
let _val = a < b;
let _val = a <= b;
let _val = a > b;
let _val = a >= b;
// CHECK: [[eqp:_.*]] = Eq([[a:_.*]], [[b:_.*]]);
// CHECK: opaque::<bool>(move [[eqp]])
opaque(a == b);
// CHECK: [[nep:_.*]] = Ne([[a]], [[b]]);
// CHECK: opaque::<bool>(move [[nep]])
opaque(a != b);
// CHECK: [[ltp:_.*]] = Lt([[a]], [[b]]);
// CHECK: opaque::<bool>(move [[ltp]])
opaque(a < b);
// CHECK: [[lep:_.*]] = Le([[a]], [[b]]);
// CHECK: opaque::<bool>(move [[lep]])
opaque(a <= b);
// CHECK: [[gtp:_.*]] = Gt([[a]], [[b]]);
// CHECK: opaque::<bool>(move [[gtp]])
opaque(a > b);
// CHECK: [[gep:_.*]] = Ge([[a]], [[b]]);
// CHECK: opaque::<bool>(move [[gep]])
opaque(a >= b);
}
/// Check that we do simplify when there is no provenance, and do not ICE.
fn wide_ptr_integer() {
// CHECK-LABEL: fn wide_ptr_integer(
// CHECK: debug a => [[a:_.*]];
// CHECK: debug b => [[b:_.*]];
let a: *const [u8] = unsafe { transmute((1usize, 1usize)) };
let b: *const [u8] = unsafe { transmute((1usize, 2usize)) };
opaque(!(a == b));
// CHECK: opaque::<bool>(const false)
opaque(a == b);
// CHECK: opaque::<bool>(const true)
opaque(a != b);
opaque(a <= b);
// CHECK: opaque::<bool>(const true)
opaque(a < b);
opaque(!(a >= b));
opaque(!(a > b));
// CHECK: opaque::<bool>(const true)
opaque(a <= b);
// CHECK: opaque::<bool>(const false)
opaque(a > b);
// CHECK: opaque::<bool>(const false)
opaque(a >= b);
}
fn main() {
@ -685,7 +713,8 @@ fn main() {
fn_pointers();
indirect_static();
constant_index_overflow(&[5, 3]);
wide_ptr_ops();
wide_ptr_provenance();
wide_ptr_integer();
}
#[inline(never)]
@ -714,4 +743,5 @@ fn identity<T>(x: T) -> T {
// EMIT_MIR gvn.fn_pointers.GVN.diff
// EMIT_MIR gvn.indirect_static.GVN.diff
// EMIT_MIR gvn.constant_index_overflow.GVN.diff
// EMIT_MIR gvn.wide_ptr_ops.GVN.diff
// EMIT_MIR gvn.wide_ptr_provenance.GVN.diff
// EMIT_MIR gvn.wide_ptr_integer.GVN.diff

192
tests/mir-opt/gvn.wide_ptr_integer.GVN.panic-abort.diff Normal file
View File

@ -0,0 +1,192 @@
- // MIR for `wide_ptr_integer` before GVN
+ // MIR for `wide_ptr_integer` after GVN
fn wide_ptr_integer() -> () {
let mut _0: ();
let _1: *const [u8];
let mut _2: (usize, usize);
let mut _4: (usize, usize);
let _5: ();
let mut _6: bool;
let mut _7: *const [u8];
let mut _8: *const [u8];
let _9: ();
let mut _10: bool;
let mut _11: *const [u8];
let mut _12: *const [u8];
let _13: ();
let mut _14: bool;
let mut _15: *const [u8];
let mut _16: *const [u8];
let _17: ();
let mut _18: bool;
let mut _19: *const [u8];
let mut _20: *const [u8];
let _21: ();
let mut _22: bool;
let mut _23: *const [u8];
let mut _24: *const [u8];
let _25: ();
let mut _26: bool;
let mut _27: *const [u8];
let mut _28: *const [u8];
scope 1 {
debug a => _1;
let _3: *const [u8];
scope 3 {
debug b => _3;
}
scope 4 {
}
}
scope 2 {
}
bb0: {
- StorageLive(_1);
+ nop;
StorageLive(_2);
- _2 = (const 1_usize, const 1_usize);
- _1 = move _2 as *const [u8] (Transmute);
+ _2 = const (1_usize, 1_usize);
+ _1 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
StorageDead(_2);
- StorageLive(_3);
+ nop;
StorageLive(_4);
- _4 = (const 1_usize, const 2_usize);
- _3 = move _4 as *const [u8] (Transmute);
+ _4 = const (1_usize, 2_usize);
+ _3 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
StorageDead(_4);
StorageLive(_5);
StorageLive(_6);
StorageLive(_7);
- _7 = _1;
+ _7 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
StorageLive(_8);
- _8 = _3;
- _6 = Eq(move _7, move _8);
+ _8 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+ _6 = const false;
StorageDead(_8);
StorageDead(_7);
- _5 = opaque::<bool>(move _6) -> [return: bb1, unwind unreachable];
+ _5 = opaque::<bool>(const false) -> [return: bb1, unwind unreachable];
}
bb1: {
StorageDead(_6);
StorageDead(_5);
StorageLive(_9);
StorageLive(_10);
StorageLive(_11);
- _11 = _1;
+ _11 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
StorageLive(_12);
- _12 = _3;
- _10 = Ne(move _11, move _12);
+ _12 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+ _10 = const true;
StorageDead(_12);
StorageDead(_11);
- _9 = opaque::<bool>(move _10) -> [return: bb2, unwind unreachable];
+ _9 = opaque::<bool>(const true) -> [return: bb2, unwind unreachable];
}
bb2: {
StorageDead(_10);
StorageDead(_9);
StorageLive(_13);
StorageLive(_14);
StorageLive(_15);
- _15 = _1;
+ _15 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
StorageLive(_16);
- _16 = _3;
- _14 = Lt(move _15, move _16);
+ _16 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+ _14 = const true;
StorageDead(_16);
StorageDead(_15);
- _13 = opaque::<bool>(move _14) -> [return: bb3, unwind unreachable];
+ _13 = opaque::<bool>(const true) -> [return: bb3, unwind unreachable];
}
bb3: {
StorageDead(_14);
StorageDead(_13);
StorageLive(_17);
StorageLive(_18);
StorageLive(_19);
- _19 = _1;
+ _19 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
StorageLive(_20);
- _20 = _3;
- _18 = Le(move _19, move _20);
+ _20 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+ _18 = const true;
StorageDead(_20);
StorageDead(_19);
- _17 = opaque::<bool>(move _18) -> [return: bb4, unwind unreachable];
+ _17 = opaque::<bool>(const true) -> [return: bb4, unwind unreachable];
}
bb4: {
StorageDead(_18);
StorageDead(_17);
StorageLive(_21);
StorageLive(_22);
StorageLive(_23);
- _23 = _1;
+ _23 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
StorageLive(_24);
- _24 = _3;
- _22 = Gt(move _23, move _24);
+ _24 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+ _22 = const false;
StorageDead(_24);
StorageDead(_23);
- _21 = opaque::<bool>(move _22) -> [return: bb5, unwind unreachable];
+ _21 = opaque::<bool>(const false) -> [return: bb5, unwind unreachable];
}
bb5: {
StorageDead(_22);
StorageDead(_21);
StorageLive(_25);
StorageLive(_26);
StorageLive(_27);
- _27 = _1;
+ _27 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
StorageLive(_28);
- _28 = _3;
- _26 = Ge(move _27, move _28);
+ _28 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+ _26 = const false;
StorageDead(_28);
StorageDead(_27);
- _25 = opaque::<bool>(move _26) -> [return: bb6, unwind unreachable];
+ _25 = opaque::<bool>(const false) -> [return: bb6, unwind unreachable];
}
bb6: {
StorageDead(_26);
StorageDead(_25);
_0 = const ();
- StorageDead(_3);
- StorageDead(_1);
+ nop;
+ nop;
return;
}
+ }
+
+ ALLOC1 (size: 16, align: 8) {
+ 01 00 00 00 00 00 00 00 02 00 00 00 00 00 00 00 │ ................
+ }
+
+ ALLOC0 (size: 16, align: 8) {
+ 01 00 00 00 00 00 00 00 01 00 00 00 00 00 00 00 │ ................
}

192
tests/mir-opt/gvn.wide_ptr_integer.GVN.panic-unwind.diff Normal file
View File

@ -0,0 +1,192 @@
- // MIR for `wide_ptr_integer` before GVN
+ // MIR for `wide_ptr_integer` after GVN
fn wide_ptr_integer() -> () {
let mut _0: ();
let _1: *const [u8];
let mut _2: (usize, usize);
let mut _4: (usize, usize);
let _5: ();
let mut _6: bool;
let mut _7: *const [u8];
let mut _8: *const [u8];
let _9: ();
let mut _10: bool;
let mut _11: *const [u8];
let mut _12: *const [u8];
let _13: ();
let mut _14: bool;
let mut _15: *const [u8];
let mut _16: *const [u8];
let _17: ();
let mut _18: bool;
let mut _19: *const [u8];
let mut _20: *const [u8];
let _21: ();
let mut _22: bool;
let mut _23: *const [u8];
let mut _24: *const [u8];
let _25: ();
let mut _26: bool;
let mut _27: *const [u8];
let mut _28: *const [u8];
scope 1 {
debug a => _1;
let _3: *const [u8];
scope 3 {
debug b => _3;
}
scope 4 {
}
}
scope 2 {
}
bb0: {
- StorageLive(_1);
+ nop;
StorageLive(_2);
- _2 = (const 1_usize, const 1_usize);
- _1 = move _2 as *const [u8] (Transmute);
+ _2 = const (1_usize, 1_usize);
+ _1 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
StorageDead(_2);
- StorageLive(_3);
+ nop;
StorageLive(_4);
- _4 = (const 1_usize, const 2_usize);
- _3 = move _4 as *const [u8] (Transmute);
+ _4 = const (1_usize, 2_usize);
+ _3 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
StorageDead(_4);
StorageLive(_5);
StorageLive(_6);
StorageLive(_7);
- _7 = _1;
+ _7 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
StorageLive(_8);
- _8 = _3;
- _6 = Eq(move _7, move _8);
+ _8 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+ _6 = const false;
StorageDead(_8);
StorageDead(_7);
- _5 = opaque::<bool>(move _6) -> [return: bb1, unwind continue];
+ _5 = opaque::<bool>(const false) -> [return: bb1, unwind continue];
}
bb1: {
StorageDead(_6);
StorageDead(_5);
StorageLive(_9);
StorageLive(_10);
StorageLive(_11);
- _11 = _1;
+ _11 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
StorageLive(_12);
- _12 = _3;
- _10 = Ne(move _11, move _12);
+ _12 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+ _10 = const true;
StorageDead(_12);
StorageDead(_11);
- _9 = opaque::<bool>(move _10) -> [return: bb2, unwind continue];
+ _9 = opaque::<bool>(const true) -> [return: bb2, unwind continue];
}
bb2: {
StorageDead(_10);
StorageDead(_9);
StorageLive(_13);
StorageLive(_14);
StorageLive(_15);
- _15 = _1;
+ _15 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
StorageLive(_16);
- _16 = _3;
- _14 = Lt(move _15, move _16);
+ _16 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+ _14 = const true;
StorageDead(_16);
StorageDead(_15);
- _13 = opaque::<bool>(move _14) -> [return: bb3, unwind continue];
+ _13 = opaque::<bool>(const true) -> [return: bb3, unwind continue];
}
bb3: {
StorageDead(_14);
StorageDead(_13);
StorageLive(_17);
StorageLive(_18);
StorageLive(_19);
- _19 = _1;
+ _19 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
StorageLive(_20);
- _20 = _3;
- _18 = Le(move _19, move _20);
+ _20 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+ _18 = const true;
StorageDead(_20);
StorageDead(_19);
- _17 = opaque::<bool>(move _18) -> [return: bb4, unwind continue];
+ _17 = opaque::<bool>(const true) -> [return: bb4, unwind continue];
}
bb4: {
StorageDead(_18);
StorageDead(_17);
StorageLive(_21);
StorageLive(_22);
StorageLive(_23);
- _23 = _1;
+ _23 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
StorageLive(_24);
- _24 = _3;
- _22 = Gt(move _23, move _24);
+ _24 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+ _22 = const false;
StorageDead(_24);
StorageDead(_23);
- _21 = opaque::<bool>(move _22) -> [return: bb5, unwind continue];
+ _21 = opaque::<bool>(const false) -> [return: bb5, unwind continue];
}
bb5: {
StorageDead(_22);
StorageDead(_21);
StorageLive(_25);
StorageLive(_26);
StorageLive(_27);
- _27 = _1;
+ _27 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
StorageLive(_28);
- _28 = _3;
- _26 = Ge(move _27, move _28);
+ _28 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+ _26 = const false;
StorageDead(_28);
StorageDead(_27);
- _25 = opaque::<bool>(move _26) -> [return: bb6, unwind continue];
+ _25 = opaque::<bool>(const false) -> [return: bb6, unwind continue];
}
bb6: {
StorageDead(_26);
StorageDead(_25);
_0 = const ();
- StorageDead(_3);
- StorageDead(_1);
+ nop;
+ nop;
return;
}
+ }
+
+ ALLOC1 (size: 16, align: 8) {
+ 01 00 00 00 00 00 00 00 02 00 00 00 00 00 00 00 │ ................
+ }
+
+ ALLOC0 (size: 16, align: 8) {
+ 01 00 00 00 00 00 00 00 01 00 00 00 00 00 00 00 │ ................
}

393
tests/mir-opt/gvn.wide_ptr_ops.GVN.panic-abort.diff
View File

@ -1,393 +0,0 @@
- // MIR for `wide_ptr_ops` before GVN
+ // MIR for `wide_ptr_ops` after GVN
fn wide_ptr_ops() -> () {
let mut _0: ();
let _1: *const dyn std::marker::Send;
let mut _2: *const dyn std::marker::Send;
let _3: &dyn std::marker::Send;
let mut _4: &i32;
let _5: &i32;
let _6: i32;
let mut _8: *const dyn std::marker::Send;
let _9: &dyn std::marker::Send;
let mut _10: &i32;
let _11: &i32;
let _12: i32;
let mut _14: *const dyn std::marker::Send;
let mut _15: *const dyn std::marker::Send;
let mut _16: *const dyn std::marker::Send;
let mut _18: *const dyn std::marker::Send;
let mut _19: *const dyn std::marker::Send;
let mut _20: *const dyn std::marker::Send;
let mut _22: *const dyn std::marker::Send;
let mut _23: *const dyn std::marker::Send;
let mut _24: *const dyn std::marker::Send;
let mut _26: *const dyn std::marker::Send;
let mut _27: *const dyn std::marker::Send;
let mut _28: *const dyn std::marker::Send;
let mut _30: *const dyn std::marker::Send;
let mut _31: *const dyn std::marker::Send;
let mut _32: *const dyn std::marker::Send;
let mut _34: *const dyn std::marker::Send;
let mut _35: *const dyn std::marker::Send;
let mut _36: *const dyn std::marker::Send;
let mut _38: (usize, usize);
let mut _40: (usize, usize);
let _41: ();
let mut _42: bool;
let mut _43: bool;
let mut _44: *const [u8];
let mut _45: *const [u8];
let _46: ();
let mut _47: bool;
let mut _48: *const [u8];
let mut _49: *const [u8];
let _50: ();
let mut _51: bool;
let mut _52: *const [u8];
let mut _53: *const [u8];
let _54: ();
let mut _55: bool;
let mut _56: *const [u8];
let mut _57: *const [u8];
let _58: ();
let mut _59: bool;
let mut _60: bool;
let mut _61: *const [u8];
let mut _62: *const [u8];
let _63: ();
let mut _64: bool;
let mut _65: bool;
let mut _66: *const [u8];
let mut _67: *const [u8];
let mut _69: &i32;
scope 1 {
debug a => _1;
let _7: *const dyn std::marker::Send;
let mut _68: &i32;
scope 2 {
debug b => _7;
let _13: bool;
scope 3 {
debug _val => _13;
let _17: bool;
scope 4 {
debug _val => _17;
let _21: bool;
scope 5 {
debug _val => _21;
let _25: bool;
scope 6 {
debug _val => _25;
let _29: bool;
scope 7 {
debug _val => _29;
let _33: bool;
scope 8 {
debug _val => _33;
let _37: *const [u8];
scope 9 {
debug a => _37;
let _39: *const [u8];
scope 11 {
debug b => _39;
}
scope 12 {
}
}
scope 10 {
}
}
}
}
}
}
}
}
}
bb0: {
- StorageLive(_1);
+ nop;
StorageLive(_2);
StorageLive(_3);
StorageLive(_4);
StorageLive(_5);
_69 = const _;
_5 = &(*_69);
_4 = &(*_5);
_3 = move _4 as &dyn std::marker::Send (PointerCoercion(Unsize));
StorageDead(_4);
_2 = &raw const (*_3);
_1 = move _2 as *const dyn std::marker::Send (PointerCoercion(Unsize));
StorageDead(_2);
StorageDead(_5);
StorageDead(_3);
- StorageLive(_7);
+ nop;
StorageLive(_8);
StorageLive(_9);
StorageLive(_10);
StorageLive(_11);
_68 = const _;
_11 = &(*_68);
_10 = &(*_11);
_9 = move _10 as &dyn std::marker::Send (PointerCoercion(Unsize));
StorageDead(_10);
_8 = &raw const (*_9);
_7 = move _8 as *const dyn std::marker::Send (PointerCoercion(Unsize));
StorageDead(_8);
StorageDead(_11);
StorageDead(_9);
StorageLive(_13);
StorageLive(_14);
_14 = _1;
- StorageLive(_15);
+ nop;
StorageLive(_16);
_16 = _7;
- _15 = move _16 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+ _15 = _7 as *const dyn std::marker::Send (PointerCoercion(Unsize));
StorageDead(_16);
- _13 = Eq(move _14, move _15);
- StorageDead(_15);
+ _13 = Eq(_1, _15);
+ nop;
StorageDead(_14);
StorageLive(_17);
StorageLive(_18);
_18 = _1;
StorageLive(_19);
StorageLive(_20);
_20 = _7;
- _19 = move _20 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+ _19 = _15;
StorageDead(_20);
- _17 = Ne(move _18, move _19);
+ _17 = Ne(_1, _15);
StorageDead(_19);
StorageDead(_18);
StorageLive(_21);
StorageLive(_22);
_22 = _1;
StorageLive(_23);
StorageLive(_24);
_24 = _7;
- _23 = move _24 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+ _23 = _15;
StorageDead(_24);
- _21 = Lt(move _22, move _23);
+ _21 = Lt(_1, _15);
StorageDead(_23);
StorageDead(_22);
StorageLive(_25);
StorageLive(_26);
_26 = _1;
StorageLive(_27);
StorageLive(_28);
_28 = _7;
- _27 = move _28 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+ _27 = _15;
StorageDead(_28);
- _25 = Le(move _26, move _27);
+ _25 = Le(_1, _15);
StorageDead(_27);
StorageDead(_26);
StorageLive(_29);
StorageLive(_30);
_30 = _1;
StorageLive(_31);
StorageLive(_32);
_32 = _7;
- _31 = move _32 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+ _31 = _15;
StorageDead(_32);
- _29 = Gt(move _30, move _31);
+ _29 = Gt(_1, _15);
StorageDead(_31);
StorageDead(_30);
StorageLive(_33);
StorageLive(_34);
_34 = _1;
StorageLive(_35);
StorageLive(_36);
_36 = _7;
- _35 = move _36 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+ _35 = _15;
StorageDead(_36);
- _33 = Ge(move _34, move _35);
+ _33 = Ge(_1, _15);
StorageDead(_35);
StorageDead(_34);
- StorageLive(_37);
+ nop;
StorageLive(_38);
- _38 = (const 1_usize, const 1_usize);
- _37 = move _38 as *const [u8] (Transmute);
+ _38 = const (1_usize, 1_usize);
+ _37 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
StorageDead(_38);
- StorageLive(_39);
+ nop;
StorageLive(_40);
- _40 = (const 1_usize, const 2_usize);
- _39 = move _40 as *const [u8] (Transmute);
+ _40 = const (1_usize, 2_usize);
+ _39 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
StorageDead(_40);
StorageLive(_41);
- StorageLive(_42);
+ nop;
StorageLive(_43);
StorageLive(_44);
- _44 = _37;
+ _44 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
StorageLive(_45);
- _45 = _39;
- _43 = Eq(move _44, move _45);
+ _45 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+ _43 = const false;
StorageDead(_45);
StorageDead(_44);
- _42 = Not(move _43);
+ _42 = const true;
StorageDead(_43);
- _41 = opaque::<bool>(move _42) -> [return: bb1, unwind unreachable];
+ _41 = opaque::<bool>(const true) -> [return: bb1, unwind unreachable];
}
bb1: {
- StorageDead(_42);
+ nop;
StorageDead(_41);
StorageLive(_46);
StorageLive(_47);
StorageLive(_48);
- _48 = _37;
+ _48 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
StorageLive(_49);
- _49 = _39;
- _47 = Ne(move _48, move _49);
+ _49 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+ _47 = const true;
StorageDead(_49);
StorageDead(_48);
- _46 = opaque::<bool>(move _47) -> [return: bb2, unwind unreachable];
+ _46 = opaque::<bool>(const true) -> [return: bb2, unwind unreachable];
}
bb2: {
StorageDead(_47);
StorageDead(_46);
StorageLive(_50);
StorageLive(_51);
StorageLive(_52);
- _52 = _37;
+ _52 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
StorageLive(_53);
- _53 = _39;
- _51 = Le(move _52, move _53);
+ _53 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+ _51 = const true;
StorageDead(_53);
StorageDead(_52);
- _50 = opaque::<bool>(move _51) -> [return: bb3, unwind unreachable];
+ _50 = opaque::<bool>(const true) -> [return: bb3, unwind unreachable];
}
bb3: {
StorageDead(_51);
StorageDead(_50);
StorageLive(_54);
StorageLive(_55);
StorageLive(_56);
- _56 = _37;
+ _56 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
StorageLive(_57);
- _57 = _39;
- _55 = Lt(move _56, move _57);
+ _57 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+ _55 = const true;
StorageDead(_57);
StorageDead(_56);
- _54 = opaque::<bool>(move _55) -> [return: bb4, unwind unreachable];
+ _54 = opaque::<bool>(const true) -> [return: bb4, unwind unreachable];
}
bb4: {
StorageDead(_55);
StorageDead(_54);
StorageLive(_58);
StorageLive(_59);
StorageLive(_60);
StorageLive(_61);
- _61 = _37;
+ _61 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
StorageLive(_62);
- _62 = _39;
- _60 = Ge(move _61, move _62);
+ _62 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+ _60 = const false;
StorageDead(_62);
StorageDead(_61);
- _59 = Not(move _60);
+ _59 = const true;
StorageDead(_60);
- _58 = opaque::<bool>(move _59) -> [return: bb5, unwind unreachable];
+ _58 = opaque::<bool>(const true) -> [return: bb5, unwind unreachable];
}
bb5: {
StorageDead(_59);
StorageDead(_58);
StorageLive(_63);
StorageLive(_64);
StorageLive(_65);
StorageLive(_66);
- _66 = _37;
+ _66 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
StorageLive(_67);
- _67 = _39;
- _65 = Gt(move _66, move _67);
+ _67 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+ _65 = const false;
StorageDead(_67);
StorageDead(_66);
- _64 = Not(move _65);
+ _64 = const true;
StorageDead(_65);
- _63 = opaque::<bool>(move _64) -> [return: bb6, unwind unreachable];
+ _63 = opaque::<bool>(const true) -> [return: bb6, unwind unreachable];
}
bb6: {
StorageDead(_64);
StorageDead(_63);
_0 = const ();
- StorageDead(_39);
- StorageDead(_37);
+ nop;
+ nop;
StorageDead(_33);
StorageDead(_29);
StorageDead(_25);
StorageDead(_21);
StorageDead(_17);
StorageDead(_13);
- StorageDead(_7);
- StorageDead(_1);
+ nop;
+ nop;
return;
}
+ }
+
+ ALLOC1 (size: 16, align: 8) {
+ 01 00 00 00 00 00 00 00 02 00 00 00 00 00 00 00 │ ................
+ }
+
+ ALLOC0 (size: 16, align: 8) {
+ 01 00 00 00 00 00 00 00 01 00 00 00 00 00 00 00 │ ................
}

393
tests/mir-opt/gvn.wide_ptr_ops.GVN.panic-unwind.diff
View File

@ -1,393 +0,0 @@
- // MIR for `wide_ptr_ops` before GVN
+ // MIR for `wide_ptr_ops` after GVN
fn wide_ptr_ops() -> () {
let mut _0: ();
let _1: *const dyn std::marker::Send;
let mut _2: *const dyn std::marker::Send;
let _3: &dyn std::marker::Send;
let mut _4: &i32;
let _5: &i32;
let _6: i32;
let mut _8: *const dyn std::marker::Send;
let _9: &dyn std::marker::Send;
let mut _10: &i32;
let _11: &i32;
let _12: i32;
let mut _14: *const dyn std::marker::Send;
let mut _15: *const dyn std::marker::Send;
let mut _16: *const dyn std::marker::Send;
let mut _18: *const dyn std::marker::Send;
let mut _19: *const dyn std::marker::Send;
let mut _20: *const dyn std::marker::Send;
let mut _22: *const dyn std::marker::Send;
let mut _23: *const dyn std::marker::Send;
let mut _24: *const dyn std::marker::Send;
let mut _26: *const dyn std::marker::Send;
let mut _27: *const dyn std::marker::Send;
let mut _28: *const dyn std::marker::Send;
let mut _30: *const dyn std::marker::Send;
let mut _31: *const dyn std::marker::Send;
let mut _32: *const dyn std::marker::Send;
let mut _34: *const dyn std::marker::Send;
let mut _35: *const dyn std::marker::Send;
let mut _36: *const dyn std::marker::Send;
let mut _38: (usize, usize);
let mut _40: (usize, usize);
let _41: ();
let mut _42: bool;
let mut _43: bool;
let mut _44: *const [u8];
let mut _45: *const [u8];
let _46: ();
let mut _47: bool;
let mut _48: *const [u8];
let mut _49: *const [u8];
let _50: ();
let mut _51: bool;
let mut _52: *const [u8];
let mut _53: *const [u8];
let _54: ();
let mut _55: bool;
let mut _56: *const [u8];
let mut _57: *const [u8];
let _58: ();
let mut _59: bool;
let mut _60: bool;
let mut _61: *const [u8];
let mut _62: *const [u8];
let _63: ();
let mut _64: bool;
let mut _65: bool;
let mut _66: *const [u8];
let mut _67: *const [u8];
let mut _69: &i32;
scope 1 {
debug a => _1;
let _7: *const dyn std::marker::Send;
let mut _68: &i32;
scope 2 {
debug b => _7;
let _13: bool;
scope 3 {
debug _val => _13;
let _17: bool;
scope 4 {
debug _val => _17;
let _21: bool;
scope 5 {
debug _val => _21;
let _25: bool;
scope 6 {
debug _val => _25;
let _29: bool;
scope 7 {
debug _val => _29;
let _33: bool;
scope 8 {
debug _val => _33;
let _37: *const [u8];
scope 9 {
debug a => _37;
let _39: *const [u8];
scope 11 {
debug b => _39;
}
scope 12 {
}
}
scope 10 {
}
}
}
}
}
}
}
}
}
bb0: {
- StorageLive(_1);
+ nop;
StorageLive(_2);
StorageLive(_3);
StorageLive(_4);
StorageLive(_5);
_69 = const _;
_5 = &(*_69);
_4 = &(*_5);
_3 = move _4 as &dyn std::marker::Send (PointerCoercion(Unsize));
StorageDead(_4);
_2 = &raw const (*_3);
_1 = move _2 as *const dyn std::marker::Send (PointerCoercion(Unsize));
StorageDead(_2);
StorageDead(_5);
StorageDead(_3);
- StorageLive(_7);
+ nop;
StorageLive(_8);
StorageLive(_9);
StorageLive(_10);
StorageLive(_11);
_68 = const _;
_11 = &(*_68);
_10 = &(*_11);
_9 = move _10 as &dyn std::marker::Send (PointerCoercion(Unsize));
StorageDead(_10);
_8 = &raw const (*_9);
_7 = move _8 as *const dyn std::marker::Send (PointerCoercion(Unsize));
StorageDead(_8);
StorageDead(_11);
StorageDead(_9);
StorageLive(_13);
StorageLive(_14);
_14 = _1;
- StorageLive(_15);
+ nop;
StorageLive(_16);
_16 = _7;
- _15 = move _16 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+ _15 = _7 as *const dyn std::marker::Send (PointerCoercion(Unsize));
StorageDead(_16);
- _13 = Eq(move _14, move _15);
- StorageDead(_15);
+ _13 = Eq(_1, _15);
+ nop;
StorageDead(_14);
StorageLive(_17);
StorageLive(_18);
_18 = _1;
StorageLive(_19);
StorageLive(_20);
_20 = _7;
- _19 = move _20 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+ _19 = _15;
StorageDead(_20);
- _17 = Ne(move _18, move _19);
+ _17 = Ne(_1, _15);
StorageDead(_19);
StorageDead(_18);
StorageLive(_21);
StorageLive(_22);
_22 = _1;
StorageLive(_23);
StorageLive(_24);
_24 = _7;
- _23 = move _24 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+ _23 = _15;
StorageDead(_24);
- _21 = Lt(move _22, move _23);
+ _21 = Lt(_1, _15);
StorageDead(_23);
StorageDead(_22);
StorageLive(_25);
StorageLive(_26);
_26 = _1;
StorageLive(_27);
StorageLive(_28);
_28 = _7;
- _27 = move _28 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+ _27 = _15;
StorageDead(_28);
- _25 = Le(move _26, move _27);
+ _25 = Le(_1, _15);
StorageDead(_27);
StorageDead(_26);
StorageLive(_29);
StorageLive(_30);
_30 = _1;
StorageLive(_31);
StorageLive(_32);
_32 = _7;
- _31 = move _32 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+ _31 = _15;
StorageDead(_32);
- _29 = Gt(move _30, move _31);
+ _29 = Gt(_1, _15);
StorageDead(_31);
StorageDead(_30);
StorageLive(_33);
StorageLive(_34);
_34 = _1;
StorageLive(_35);
StorageLive(_36);
_36 = _7;
- _35 = move _36 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+ _35 = _15;
StorageDead(_36);
- _33 = Ge(move _34, move _35);
+ _33 = Ge(_1, _15);
StorageDead(_35);
StorageDead(_34);
- StorageLive(_37);
+ nop;
StorageLive(_38);
- _38 = (const 1_usize, const 1_usize);
- _37 = move _38 as *const [u8] (Transmute);
+ _38 = const (1_usize, 1_usize);
+ _37 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
StorageDead(_38);
- StorageLive(_39);
+ nop;
StorageLive(_40);
- _40 = (const 1_usize, const 2_usize);
- _39 = move _40 as *const [u8] (Transmute);
+ _40 = const (1_usize, 2_usize);
+ _39 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
StorageDead(_40);
StorageLive(_41);
- StorageLive(_42);
+ nop;
StorageLive(_43);
StorageLive(_44);
- _44 = _37;
+ _44 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
StorageLive(_45);
- _45 = _39;
- _43 = Eq(move _44, move _45);
+ _45 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+ _43 = const false;
StorageDead(_45);
StorageDead(_44);
- _42 = Not(move _43);
+ _42 = const true;
StorageDead(_43);
- _41 = opaque::<bool>(move _42) -> [return: bb1, unwind continue];
+ _41 = opaque::<bool>(const true) -> [return: bb1, unwind continue];
}
bb1: {
- StorageDead(_42);
+ nop;
StorageDead(_41);
StorageLive(_46);
StorageLive(_47);
StorageLive(_48);
- _48 = _37;
+ _48 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
StorageLive(_49);
- _49 = _39;
- _47 = Ne(move _48, move _49);
+ _49 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+ _47 = const true;
StorageDead(_49);
StorageDead(_48);
- _46 = opaque::<bool>(move _47) -> [return: bb2, unwind continue];
+ _46 = opaque::<bool>(const true) -> [return: bb2, unwind continue];
}
bb2: {
StorageDead(_47);
StorageDead(_46);
StorageLive(_50);
StorageLive(_51);
StorageLive(_52);
- _52 = _37;
+ _52 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
StorageLive(_53);
- _53 = _39;
- _51 = Le(move _52, move _53);
+ _53 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+ _51 = const true;
StorageDead(_53);
StorageDead(_52);
- _50 = opaque::<bool>(move _51) -> [return: bb3, unwind continue];
+ _50 = opaque::<bool>(const true) -> [return: bb3, unwind continue];
}
bb3: {
StorageDead(_51);
StorageDead(_50);
StorageLive(_54);
StorageLive(_55);
StorageLive(_56);
- _56 = _37;
+ _56 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
StorageLive(_57);
- _57 = _39;
- _55 = Lt(move _56, move _57);
+ _57 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+ _55 = const true;
StorageDead(_57);
StorageDead(_56);
- _54 = opaque::<bool>(move _55) -> [return: bb4, unwind continue];
+ _54 = opaque::<bool>(const true) -> [return: bb4, unwind continue];
}
bb4: {
StorageDead(_55);
StorageDead(_54);
StorageLive(_58);
StorageLive(_59);
StorageLive(_60);
StorageLive(_61);
- _61 = _37;
+ _61 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
StorageLive(_62);
- _62 = _39;
- _60 = Ge(move _61, move _62);
+ _62 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+ _60 = const false;
StorageDead(_62);
StorageDead(_61);
- _59 = Not(move _60);
+ _59 = const true;
StorageDead(_60);
- _58 = opaque::<bool>(move _59) -> [return: bb5, unwind continue];
+ _58 = opaque::<bool>(const true) -> [return: bb5, unwind continue];
}
bb5: {
StorageDead(_59);
StorageDead(_58);
StorageLive(_63);
StorageLive(_64);
StorageLive(_65);
StorageLive(_66);
- _66 = _37;
+ _66 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
StorageLive(_67);
- _67 = _39;
- _65 = Gt(move _66, move _67);
+ _67 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+ _65 = const false;
StorageDead(_67);
StorageDead(_66);
- _64 = Not(move _65);
+ _64 = const true;
StorageDead(_65);
- _63 = opaque::<bool>(move _64) -> [return: bb6, unwind continue];
+ _63 = opaque::<bool>(const true) -> [return: bb6, unwind continue];
}
bb6: {
StorageDead(_64);
StorageDead(_63);
_0 = const ();
- StorageDead(_39);
- StorageDead(_37);
+ nop;
+ nop;
StorageDead(_33);
StorageDead(_29);
StorageDead(_25);
StorageDead(_21);
StorageDead(_17);
StorageDead(_13);
- StorageDead(_7);
- StorageDead(_1);
+ nop;
+ nop;
return;
}
+ }
+
+ ALLOC1 (size: 16, align: 8) {
+ 01 00 00 00 00 00 00 00 02 00 00 00 00 00 00 00 │ ................
+ }
+
+ ALLOC0 (size: 16, align: 8) {
+ 01 00 00 00 00 00 00 00 01 00 00 00 00 00 00 00 │ ................
}

232
tests/mir-opt/gvn.wide_ptr_provenance.GVN.panic-abort.diff Normal file
View File

@ -0,0 +1,232 @@
- // MIR for `wide_ptr_provenance` before GVN
+ // MIR for `wide_ptr_provenance` after GVN
fn wide_ptr_provenance() -> () {
let mut _0: ();
let _1: *const dyn std::marker::Send;
let mut _2: *const dyn std::marker::Send;
let _3: &dyn std::marker::Send;
let mut _4: &i32;
let _5: &i32;
let _6: i32;
let mut _8: *const dyn std::marker::Send;
let _9: &dyn std::marker::Send;
let mut _10: &i32;
let _11: &i32;
let _12: i32;
let _13: ();
let mut _14: bool;
let mut _15: *const dyn std::marker::Send;
let mut _16: *const dyn std::marker::Send;
let mut _17: *const dyn std::marker::Send;
let _18: ();
let mut _19: bool;
let mut _20: *const dyn std::marker::Send;
let mut _21: *const dyn std::marker::Send;
let mut _22: *const dyn std::marker::Send;
let _23: ();
let mut _24: bool;
let mut _25: *const dyn std::marker::Send;
let mut _26: *const dyn std::marker::Send;
let mut _27: *const dyn std::marker::Send;
let _28: ();
let mut _29: bool;
let mut _30: *const dyn std::marker::Send;
let mut _31: *const dyn std::marker::Send;
let mut _32: *const dyn std::marker::Send;
let _33: ();
let mut _34: bool;
let mut _35: *const dyn std::marker::Send;
let mut _36: *const dyn std::marker::Send;
let mut _37: *const dyn std::marker::Send;
let _38: ();
let mut _39: bool;
let mut _40: *const dyn std::marker::Send;
let mut _41: *const dyn std::marker::Send;
let mut _42: *const dyn std::marker::Send;
let mut _44: &i32;
scope 1 {
debug a => _1;
let _7: *const dyn std::marker::Send;
let mut _43: &i32;
scope 2 {
debug b => _7;
}
}
bb0: {
StorageLive(_1);
- StorageLive(_2);
+ nop;
StorageLive(_3);
StorageLive(_4);
StorageLive(_5);
_44 = const _;
_5 = &(*_44);
_4 = &(*_5);
_3 = move _4 as &dyn std::marker::Send (PointerCoercion(Unsize));
StorageDead(_4);
_2 = &raw const (*_3);
- _1 = move _2 as *const dyn std::marker::Send (PointerCoercion(Unsize));
- StorageDead(_2);
+ _1 = _2;
+ nop;
StorageDead(_5);
StorageDead(_3);
StorageLive(_7);
- StorageLive(_8);
+ nop;
StorageLive(_9);
StorageLive(_10);
StorageLive(_11);
_43 = const _;
_11 = &(*_43);
_10 = &(*_11);
_9 = move _10 as &dyn std::marker::Send (PointerCoercion(Unsize));
StorageDead(_10);
_8 = &raw const (*_9);
- _7 = move _8 as *const dyn std::marker::Send (PointerCoercion(Unsize));
- StorageDead(_8);
+ _7 = _8;
+ nop;
StorageDead(_11);
StorageDead(_9);
StorageLive(_13);
StorageLive(_14);
StorageLive(_15);
- _15 = _1;
+ _15 = _2;
StorageLive(_16);
StorageLive(_17);
- _17 = _7;
- _16 = move _17 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+ _17 = _8;
+ _16 = _8;
StorageDead(_17);
- _14 = Eq(move _15, move _16);
+ _14 = Eq(_2, _8);
StorageDead(_16);
StorageDead(_15);
_13 = opaque::<bool>(move _14) -> [return: bb1, unwind unreachable];
}
bb1: {
StorageDead(_14);
StorageDead(_13);
StorageLive(_18);
StorageLive(_19);
StorageLive(_20);
- _20 = _1;
+ _20 = _2;
StorageLive(_21);
StorageLive(_22);
- _22 = _7;
- _21 = move _22 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+ _22 = _8;
+ _21 = _8;
StorageDead(_22);
- _19 = Ne(move _20, move _21);
+ _19 = Ne(_2, _8);
StorageDead(_21);
StorageDead(_20);
_18 = opaque::<bool>(move _19) -> [return: bb2, unwind unreachable];
}
bb2: {
StorageDead(_19);
StorageDead(_18);
StorageLive(_23);
StorageLive(_24);
StorageLive(_25);
- _25 = _1;
+ _25 = _2;
StorageLive(_26);
StorageLive(_27);
- _27 = _7;
- _26 = move _27 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+ _27 = _8;
+ _26 = _8;
StorageDead(_27);
- _24 = Lt(move _25, move _26);
+ _24 = Lt(_2, _8);
StorageDead(_26);
StorageDead(_25);
_23 = opaque::<bool>(move _24) -> [return: bb3, unwind unreachable];
}
bb3: {
StorageDead(_24);
StorageDead(_23);
StorageLive(_28);
StorageLive(_29);
StorageLive(_30);
- _30 = _1;
+ _30 = _2;
StorageLive(_31);
StorageLive(_32);
- _32 = _7;
- _31 = move _32 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+ _32 = _8;
+ _31 = _8;
StorageDead(_32);
- _29 = Le(move _30, move _31);
+ _29 = Le(_2, _8);
StorageDead(_31);
StorageDead(_30);
_28 = opaque::<bool>(move _29) -> [return: bb4, unwind unreachable];
}
bb4: {
StorageDead(_29);
StorageDead(_28);
StorageLive(_33);
StorageLive(_34);
StorageLive(_35);
- _35 = _1;
+ _35 = _2;
StorageLive(_36);
StorageLive(_37);
- _37 = _7;
- _36 = move _37 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+ _37 = _8;
+ _36 = _8;
StorageDead(_37);
- _34 = Gt(move _35, move _36);
+ _34 = Gt(_2, _8);
StorageDead(_36);
StorageDead(_35);
_33 = opaque::<bool>(move _34) -> [return: bb5, unwind unreachable];
}
bb5: {
StorageDead(_34);
StorageDead(_33);
StorageLive(_38);
StorageLive(_39);
StorageLive(_40);
- _40 = _1;
+ _40 = _2;
StorageLive(_41);
StorageLive(_42);
- _42 = _7;
- _41 = move _42 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+ _42 = _8;
+ _41 = _8;
StorageDead(_42);
- _39 = Ge(move _40, move _41);
+ _39 = Ge(_2, _8);
StorageDead(_41);
StorageDead(_40);
_38 = opaque::<bool>(move _39) -> [return: bb6, unwind unreachable];
}
bb6: {
StorageDead(_39);
StorageDead(_38);
_0 = const ();
StorageDead(_7);
StorageDead(_1);
return;
}
}

232
tests/mir-opt/gvn.wide_ptr_provenance.GVN.panic-unwind.diff Normal file
View File

@ -0,0 +1,232 @@
- // MIR for `wide_ptr_provenance` before GVN
+ // MIR for `wide_ptr_provenance` after GVN
fn wide_ptr_provenance() -> () {
let mut _0: ();
let _1: *const dyn std::marker::Send;
let mut _2: *const dyn std::marker::Send;
let _3: &dyn std::marker::Send;
let mut _4: &i32;
let _5: &i32;
let _6: i32;
let mut _8: *const dyn std::marker::Send;
let _9: &dyn std::marker::Send;
let mut _10: &i32;
let _11: &i32;
let _12: i32;
let _13: ();
let mut _14: bool;
let mut _15: *const dyn std::marker::Send;
let mut _16: *const dyn std::marker::Send;
let mut _17: *const dyn std::marker::Send;
let _18: ();
let mut _19: bool;
let mut _20: *const dyn std::marker::Send;
let mut _21: *const dyn std::marker::Send;
let mut _22: *const dyn std::marker::Send;
let _23: ();
let mut _24: bool;
let mut _25: *const dyn std::marker::Send;
let mut _26: *const dyn std::marker::Send;
let mut _27: *const dyn std::marker::Send;
let _28: ();
let mut _29: bool;
let mut _30: *const dyn std::marker::Send;
let mut _31: *const dyn std::marker::Send;
let mut _32: *const dyn std::marker::Send;
let _33: ();
let mut _34: bool;
let mut _35: *const dyn std::marker::Send;
let mut _36: *const dyn std::marker::Send;
let mut _37: *const dyn std::marker::Send;
let _38: ();
let mut _39: bool;
let mut _40: *const dyn std::marker::Send;
let mut _41: *const dyn std::marker::Send;
let mut _42: *const dyn std::marker::Send;
let mut _44: &i32;
scope 1 {
debug a => _1;
let _7: *const dyn std::marker::Send;
let mut _43: &i32;
scope 2 {
debug b => _7;
}
}
bb0: {
StorageLive(_1);
- StorageLive(_2);
+ nop;
StorageLive(_3);
StorageLive(_4);
StorageLive(_5);
_44 = const _;
_5 = &(*_44);
_4 = &(*_5);
_3 = move _4 as &dyn std::marker::Send (PointerCoercion(Unsize));
StorageDead(_4);
_2 = &raw const (*_3);
- _1 = move _2 as *const dyn std::marker::Send (PointerCoercion(Unsize));
- StorageDead(_2);
+ _1 = _2;
+ nop;
StorageDead(_5);
StorageDead(_3);
StorageLive(_7);
- StorageLive(_8);
+ nop;
StorageLive(_9);
StorageLive(_10);
StorageLive(_11);
_43 = const _;
_11 = &(*_43);
_10 = &(*_11);
_9 = move _10 as &dyn std::marker::Send (PointerCoercion(Unsize));
StorageDead(_10);
_8 = &raw const (*_9);
- _7 = move _8 as *const dyn std::marker::Send (PointerCoercion(Unsize));
- StorageDead(_8);
+ _7 = _8;
+ nop;
StorageDead(_11);
StorageDead(_9);
StorageLive(_13);
StorageLive(_14);
StorageLive(_15);
- _15 = _1;
+ _15 = _2;
StorageLive(_16);
StorageLive(_17);
- _17 = _7;
- _16 = move _17 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+ _17 = _8;
+ _16 = _8;
StorageDead(_17);
- _14 = Eq(move _15, move _16);
+ _14 = Eq(_2, _8);
StorageDead(_16);
StorageDead(_15);
_13 = opaque::<bool>(move _14) -> [return: bb1, unwind continue];
}
bb1: {
StorageDead(_14);
StorageDead(_13);
StorageLive(_18);
StorageLive(_19);
StorageLive(_20);
- _20 = _1;
+ _20 = _2;
StorageLive(_21);
StorageLive(_22);
- _22 = _7;
- _21 = move _22 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+ _22 = _8;
+ _21 = _8;
StorageDead(_22);
- _19 = Ne(move _20, move _21);
+ _19 = Ne(_2, _8);
StorageDead(_21);
StorageDead(_20);
_18 = opaque::<bool>(move _19) -> [return: bb2, unwind continue];
}
bb2: {
StorageDead(_19);
StorageDead(_18);
StorageLive(_23);
StorageLive(_24);
StorageLive(_25);
- _25 = _1;
+ _25 = _2;
StorageLive(_26);
StorageLive(_27);
- _27 = _7;
- _26 = move _27 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+ _27 = _8;
+ _26 = _8;
StorageDead(_27);
- _24 = Lt(move _25, move _26);
+ _24 = Lt(_2, _8);
StorageDead(_26);
StorageDead(_25);
_23 = opaque::<bool>(move _24) -> [return: bb3, unwind continue];
}
bb3: {
StorageDead(_24);
StorageDead(_23);
StorageLive(_28);
StorageLive(_29);
StorageLive(_30);
- _30 = _1;
+ _30 = _2;
StorageLive(_31);
StorageLive(_32);
- _32 = _7;
- _31 = move _32 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+ _32 = _8;
+ _31 = _8;
StorageDead(_32);
- _29 = Le(move _30, move _31);
+ _29 = Le(_2, _8);
StorageDead(_31);
StorageDead(_30);
_28 = opaque::<bool>(move _29) -> [return: bb4, unwind continue];
}
bb4: {
StorageDead(_29);
StorageDead(_28);
StorageLive(_33);
StorageLive(_34);
StorageLive(_35);
- _35 = _1;
+ _35 = _2;
StorageLive(_36);
StorageLive(_37);
- _37 = _7;
- _36 = move _37 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+ _37 = _8;
+ _36 = _8;
StorageDead(_37);
- _34 = Gt(move _35, move _36);
+ _34 = Gt(_2, _8);
StorageDead(_36);
StorageDead(_35);
_33 = opaque::<bool>(move _34) -> [return: bb5, unwind continue];
}
bb5: {
StorageDead(_34);
StorageDead(_33);
StorageLive(_38);
StorageLive(_39);
StorageLive(_40);
- _40 = _1;
+ _40 = _2;
StorageLive(_41);
StorageLive(_42);
- _42 = _7;
- _41 = move _42 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+ _42 = _8;
+ _41 = _8;
StorageDead(_42);
- _39 = Ge(move _40, move _41);
+ _39 = Ge(_2, _8);
StorageDead(_41);
StorageDead(_40);
_38 = opaque::<bool>(move _39) -> [return: bb6, unwind continue];
}
bb6: {
StorageDead(_39);
StorageDead(_38);
_0 = const ();
StorageDead(_7);
StorageDead(_1);
return;
}
}