mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
a5c395ed94
rust/tests/mir-opt/simplify_arm.id_try.SimplifyArmIdentity.diff

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

90 lines
5.7 KiB
Diff
Raw Normal View History

Modify SimplifyArmIdentity so it can trigger on mir-opt-level=1 I also added test cases to make sure the optimization can fire on all of these cases: ```rust fn case_1(o: Option<u8>) -> Option<u8> { match o { Some(u) => Some(u), None => None, } } fn case2(r: Result<u8, i32>) -> Result<u8, i32> { match r { Ok(u) => Ok(u), Err(i) => Err(i), } } fn case3(r: Result<u8, i32>) -> Result<u8, i32> { let u = r?; Ok(u) } ``` Without MIR inlining, this still does not completely optimize away the `?` operator because the `Try::into_result()`, `From::from()` and `Try::from_error()` calls still exist. This does move us a bit closer to that goal though because: - We can now run the pass on mir-opt-level=1 - We no longer depend on the copy propagation pass running which is unlikely to stabilize anytime soon.
2020-05-11 19:13:15 -05:00
- // MIR for `id_try` before SimplifyArmIdentity
+ // MIR for `id_try` after SimplifyArmIdentity
Fix tests from rebase
2020-09-07 04:01:45 -05:00
path trimming: ignore type aliases
2021-01-28 10:01:36 -06:00
fn id_try(_1: Result<u8, i32>) -> Result<u8, i32> {
bless mir opt tests
2022-07-27 13:47:42 -05:00
debug r => _1; // in scope 0 at $DIR/simplify-arm.rs:+0:11: +0:12
let mut _0: std::result::Result<u8, i32>; // return place in scope 0 at $DIR/simplify-arm.rs:+0:34: +0:49
let _2: u8; // in scope 0 at $DIR/simplify-arm.rs:+1:9: +1:10
let mut _3: std::result::Result<u8, i32>; // in scope 0 at $DIR/simplify-arm.rs:+1:19: +1:33
let mut _4: std::result::Result<u8, i32>; // in scope 0 at $DIR/simplify-arm.rs:+1:31: +1:32
let mut _5: isize; // in scope 0 at $DIR/simplify-arm.rs:+2:9: +2:15
let _6: i32; // in scope 0 at $DIR/simplify-arm.rs:+2:13: +2:14
let mut _7: !; // in scope 0 at $DIR/simplify-arm.rs:+2:19: +2:51
let mut _8: i32; // in scope 0 at $DIR/simplify-arm.rs:+2:37: +2:50
let mut _9: i32; // in scope 0 at $DIR/simplify-arm.rs:+2:48: +2:49
let _10: u8; // in scope 0 at $DIR/simplify-arm.rs:+3:12: +3:13
let mut _11: u8; // in scope 0 at $DIR/simplify-arm.rs:+5:8: +5:9
Modify SimplifyArmIdentity so it can trigger on mir-opt-level=1 I also added test cases to make sure the optimization can fire on all of these cases: ```rust fn case_1(o: Option<u8>) -> Option<u8> { match o { Some(u) => Some(u), None => None, } } fn case2(r: Result<u8, i32>) -> Result<u8, i32> { match r { Ok(u) => Ok(u), Err(i) => Err(i), } } fn case3(r: Result<u8, i32>) -> Result<u8, i32> { let u = r?; Ok(u) } ``` Without MIR inlining, this still does not completely optimize away the `?` operator because the `Try::into_result()`, `From::from()` and `Try::from_error()` calls still exist. This does move us a bit closer to that goal though because: - We can now run the pass on mir-opt-level=1 - We no longer depend on the copy propagation pass running which is unlikely to stabilize anytime soon.
2020-05-11 19:13:15 -05:00
scope 1 {
bless mir opt tests
2022-07-27 13:47:42 -05:00
debug x => _2; // in scope 1 at $DIR/simplify-arm.rs:+1:9: +1:10
Modify SimplifyArmIdentity so it can trigger on mir-opt-level=1 I also added test cases to make sure the optimization can fire on all of these cases: ```rust fn case_1(o: Option<u8>) -> Option<u8> { match o { Some(u) => Some(u), None => None, } } fn case2(r: Result<u8, i32>) -> Result<u8, i32> { match r { Ok(u) => Ok(u), Err(i) => Err(i), } } fn case3(r: Result<u8, i32>) -> Result<u8, i32> { let u = r?; Ok(u) } ``` Without MIR inlining, this still does not completely optimize away the `?` operator because the `Try::into_result()`, `From::from()` and `Try::from_error()` calls still exist. This does move us a bit closer to that goal though because: - We can now run the pass on mir-opt-level=1 - We no longer depend on the copy propagation pass running which is unlikely to stabilize anytime soon.
2020-05-11 19:13:15 -05:00
}
scope 2 {
bless mir opt tests
2022-07-27 13:47:42 -05:00
debug e => _6; // in scope 2 at $DIR/simplify-arm.rs:+2:13: +2:14
mir-opt & codegen test updates `SimplifyArm` and such are currently in `-Zunsound-mir-opts` and thus weren't running by default, so having something like them for the new desugar shouldn't be necessary for switching.
2021-04-26 00:02:48 -05:00
scope 5 (inlined <i32 as From<i32>>::from) { // at $DIR/simplify-arm.rs:37:37: 37:50
Fix tests broken by deaggregation change
2022-04-05 18:02:57 -05:00
debug t => _9; // in scope 5 at $SRC_DIR/core/src/convert/mod.rs:LL:COL
Modify SimplifyArmIdentity so it can trigger on mir-opt-level=1 I also added test cases to make sure the optimization can fire on all of these cases: ```rust fn case_1(o: Option<u8>) -> Option<u8> { match o { Some(u) => Some(u), None => None, } } fn case2(r: Result<u8, i32>) -> Result<u8, i32> { match r { Ok(u) => Ok(u), Err(i) => Err(i), } } fn case3(r: Result<u8, i32>) -> Result<u8, i32> { let u = r?; Ok(u) } ``` Without MIR inlining, this still does not completely optimize away the `?` operator because the `Try::into_result()`, `From::from()` and `Try::from_error()` calls still exist. This does move us a bit closer to that goal though because: - We can now run the pass on mir-opt-level=1 - We no longer depend on the copy propagation pass running which is unlikely to stabilize anytime soon.
2020-05-11 19:13:15 -05:00
}
mir-opt & codegen test updates `SimplifyArm` and such are currently in `-Zunsound-mir-opts` and thus weren't running by default, so having something like them for the new desugar shouldn't be necessary for switching.
2021-04-26 00:02:48 -05:00
scope 6 (inlined from_error::<u8, i32>) { // at $DIR/simplify-arm.rs:37:26: 37:51
bless mir-opt tests
2022-07-29 11:52:38 -05:00
debug e => _8; // in scope 6 at $DIR/simplify-arm.rs:27:21: 27:22
Modify SimplifyArmIdentity so it can trigger on mir-opt-level=1 I also added test cases to make sure the optimization can fire on all of these cases: ```rust fn case_1(o: Option<u8>) -> Option<u8> { match o { Some(u) => Some(u), None => None, } } fn case2(r: Result<u8, i32>) -> Result<u8, i32> { match r { Ok(u) => Ok(u), Err(i) => Err(i), } } fn case3(r: Result<u8, i32>) -> Result<u8, i32> { let u = r?; Ok(u) } ``` Without MIR inlining, this still does not completely optimize away the `?` operator because the `Try::into_result()`, `From::from()` and `Try::from_error()` calls still exist. This does move us a bit closer to that goal though because: - We can now run the pass on mir-opt-level=1 - We no longer depend on the copy propagation pass running which is unlikely to stabilize anytime soon.
2020-05-11 19:13:15 -05:00
}
}
mir-opt & codegen test updates `SimplifyArm` and such are currently in `-Zunsound-mir-opts` and thus weren't running by default, so having something like them for the new desugar shouldn't be necessary for switching.
2021-04-26 00:02:48 -05:00
scope 3 {
bless mir opt tests
2022-07-27 13:47:42 -05:00
debug v => _10; // in scope 3 at $DIR/simplify-arm.rs:+3:12: +3:13
mir-opt & codegen test updates `SimplifyArm` and such are currently in `-Zunsound-mir-opts` and thus weren't running by default, so having something like them for the new desugar shouldn't be necessary for switching.
2021-04-26 00:02:48 -05:00
}
scope 4 (inlined into_result::<u8, i32>) { // at $DIR/simplify-arm.rs:36:19: 36:33
bless mir-opt tests
2022-07-29 11:52:38 -05:00
debug r => _4; // in scope 4 at $DIR/simplify-arm.rs:23:22: 23:23
Implement 'considered equal' for statements, so that for example `_0 = _1` and `discriminant(_0) = discriminant(0)` are considered equal if 0 is a fieldless variant of an enum
2020-07-25 10:46:11 -05:00
}
Fix tests from rebase
2020-09-07 04:01:45 -05:00
Modify SimplifyArmIdentity so it can trigger on mir-opt-level=1 I also added test cases to make sure the optimization can fire on all of these cases: ```rust fn case_1(o: Option<u8>) -> Option<u8> { match o { Some(u) => Some(u), None => None, } } fn case2(r: Result<u8, i32>) -> Result<u8, i32> { match r { Ok(u) => Ok(u), Err(i) => Err(i), } } fn case3(r: Result<u8, i32>) -> Result<u8, i32> { let u = r?; Ok(u) } ``` Without MIR inlining, this still does not completely optimize away the `?` operator because the `Try::into_result()`, `From::from()` and `Try::from_error()` calls still exist. This does move us a bit closer to that goal though because: - We can now run the pass on mir-opt-level=1 - We no longer depend on the copy propagation pass running which is unlikely to stabilize anytime soon.
2020-05-11 19:13:15 -05:00
bb0: {
bless mir opt tests
2022-07-27 13:47:42 -05:00
StorageLive(_2); // scope 0 at $DIR/simplify-arm.rs:+1:9: +1:10
StorageLive(_3); // scope 0 at $DIR/simplify-arm.rs:+1:19: +1:33
StorageLive(_4); // scope 0 at $DIR/simplify-arm.rs:+1:31: +1:32
_4 = _1; // scope 0 at $DIR/simplify-arm.rs:+1:31: +1:32
bless mir-opt tests
2022-07-29 11:52:38 -05:00
_3 = move _4; // scope 4 at $DIR/simplify-arm.rs:24:5: 24:6
bless mir opt tests
2022-07-27 13:47:42 -05:00
StorageDead(_4); // scope 0 at $DIR/simplify-arm.rs:+1:32: +1:33
_5 = discriminant(_3); // scope 0 at $DIR/simplify-arm.rs:+1:19: +1:33
switchInt(move _5) -> [0_isize: bb1, 1_isize: bb3, otherwise: bb2]; // scope 0 at $DIR/simplify-arm.rs:+1:13: +1:33
Modify SimplifyArmIdentity so it can trigger on mir-opt-level=1 I also added test cases to make sure the optimization can fire on all of these cases: ```rust fn case_1(o: Option<u8>) -> Option<u8> { match o { Some(u) => Some(u), None => None, } } fn case2(r: Result<u8, i32>) -> Result<u8, i32> { match r { Ok(u) => Ok(u), Err(i) => Err(i), } } fn case3(r: Result<u8, i32>) -> Result<u8, i32> { let u = r?; Ok(u) } ``` Without MIR inlining, this still does not completely optimize away the `?` operator because the `Try::into_result()`, `From::from()` and `Try::from_error()` calls still exist. This does move us a bit closer to that goal though because: - We can now run the pass on mir-opt-level=1 - We no longer depend on the copy propagation pass running which is unlikely to stabilize anytime soon.
2020-05-11 19:13:15 -05:00
}
Fix tests from rebase
2020-09-07 04:01:45 -05:00
Implement 'considered equal' for statements, so that for example `_0 = _1` and `discriminant(_0) = discriminant(0)` are considered equal if 0 is a fieldless variant of an enum
2020-07-25 10:46:11 -05:00
bb1: {
bless mir opt tests
2022-07-27 13:47:42 -05:00
StorageLive(_10); // scope 0 at $DIR/simplify-arm.rs:+3:12: +3:13
_10 = ((_3 as Ok).0: u8); // scope 0 at $DIR/simplify-arm.rs:+3:12: +3:13
_2 = _10; // scope 3 at $DIR/simplify-arm.rs:+3:18: +3:19
StorageDead(_10); // scope 0 at $DIR/simplify-arm.rs:+3:18: +3:19
StorageDead(_3); // scope 0 at $DIR/simplify-arm.rs:+4:6: +4:7
StorageLive(_11); // scope 1 at $DIR/simplify-arm.rs:+5:8: +5:9
_11 = _2; // scope 1 at $DIR/simplify-arm.rs:+5:8: +5:9
Deinit(_0); // scope 1 at $DIR/simplify-arm.rs:+5:5: +5:10
((_0 as Ok).0: u8) = move _11; // scope 1 at $DIR/simplify-arm.rs:+5:5: +5:10
discriminant(_0) = 0; // scope 1 at $DIR/simplify-arm.rs:+5:5: +5:10
StorageDead(_11); // scope 1 at $DIR/simplify-arm.rs:+5:9: +5:10
StorageDead(_2); // scope 0 at $DIR/simplify-arm.rs:+6:1: +6:2
goto -> bb4; // scope 0 at $DIR/simplify-arm.rs:+6:2: +6:2
Modify SimplifyArmIdentity so it can trigger on mir-opt-level=1 I also added test cases to make sure the optimization can fire on all of these cases: ```rust fn case_1(o: Option<u8>) -> Option<u8> { match o { Some(u) => Some(u), None => None, } } fn case2(r: Result<u8, i32>) -> Result<u8, i32> { match r { Ok(u) => Ok(u), Err(i) => Err(i), } } fn case3(r: Result<u8, i32>) -> Result<u8, i32> { let u = r?; Ok(u) } ``` Without MIR inlining, this still does not completely optimize away the `?` operator because the `Try::into_result()`, `From::from()` and `Try::from_error()` calls still exist. This does move us a bit closer to that goal though because: - We can now run the pass on mir-opt-level=1 - We no longer depend on the copy propagation pass running which is unlikely to stabilize anytime soon.
2020-05-11 19:13:15 -05:00
}
Fix tests from rebase
2020-09-07 04:01:45 -05:00
Implement 'considered equal' for statements, so that for example `_0 = _1` and `discriminant(_0) = discriminant(0)` are considered equal if 0 is a fieldless variant of an enum
2020-07-25 10:46:11 -05:00
bb2: {
bless mir opt tests
2022-07-27 13:47:42 -05:00
unreachable; // scope 0 at $DIR/simplify-arm.rs:+1:19: +1:33
Modify SimplifyArmIdentity so it can trigger on mir-opt-level=1 I also added test cases to make sure the optimization can fire on all of these cases: ```rust fn case_1(o: Option<u8>) -> Option<u8> { match o { Some(u) => Some(u), None => None, } } fn case2(r: Result<u8, i32>) -> Result<u8, i32> { match r { Ok(u) => Ok(u), Err(i) => Err(i), } } fn case3(r: Result<u8, i32>) -> Result<u8, i32> { let u = r?; Ok(u) } ``` Without MIR inlining, this still does not completely optimize away the `?` operator because the `Try::into_result()`, `From::from()` and `Try::from_error()` calls still exist. This does move us a bit closer to that goal though because: - We can now run the pass on mir-opt-level=1 - We no longer depend on the copy propagation pass running which is unlikely to stabilize anytime soon.
2020-05-11 19:13:15 -05:00
}
Fix tests from rebase
2020-09-07 04:01:45 -05:00
Implement 'considered equal' for statements, so that for example `_0 = _1` and `discriminant(_0) = discriminant(0)` are considered equal if 0 is a fieldless variant of an enum
2020-07-25 10:46:11 -05:00
bb3: {
bless mir opt tests
2022-07-27 13:47:42 -05:00
StorageLive(_6); // scope 0 at $DIR/simplify-arm.rs:+2:13: +2:14
_6 = ((_3 as Err).0: i32); // scope 0 at $DIR/simplify-arm.rs:+2:13: +2:14
StorageLive(_8); // scope 2 at $DIR/simplify-arm.rs:+2:37: +2:50
StorageLive(_9); // scope 2 at $DIR/simplify-arm.rs:+2:48: +2:49
_9 = _6; // scope 2 at $DIR/simplify-arm.rs:+2:48: +2:49
Fix tests broken by deaggregation change
2022-04-05 18:02:57 -05:00
_8 = move _9; // scope 5 at $SRC_DIR/core/src/convert/mod.rs:LL:COL
bless mir opt tests
2022-07-27 13:47:42 -05:00
StorageDead(_9); // scope 2 at $DIR/simplify-arm.rs:+2:49: +2:50
bless mir-opt tests
2022-07-29 11:52:38 -05:00
((_0 as Err).0: i32) = move _8; // scope 6 at $DIR/simplify-arm.rs:28:9: 28:10
Deinit(_0); // scope 6 at $DIR/simplify-arm.rs:28:5: 28:11
discriminant(_0) = 1; // scope 6 at $DIR/simplify-arm.rs:28:5: 28:11
bless mir opt tests
2022-07-27 13:47:42 -05:00
StorageDead(_8); // scope 2 at $DIR/simplify-arm.rs:+2:50: +2:51
StorageDead(_6); // scope 0 at $DIR/simplify-arm.rs:+2:50: +2:51
StorageDead(_3); // scope 0 at $DIR/simplify-arm.rs:+4:6: +4:7
StorageDead(_2); // scope 0 at $DIR/simplify-arm.rs:+6:1: +6:2
goto -> bb4; // scope 0 at $DIR/simplify-arm.rs:+6:2: +6:2
Modify SimplifyArmIdentity so it can trigger on mir-opt-level=1 I also added test cases to make sure the optimization can fire on all of these cases: ```rust fn case_1(o: Option<u8>) -> Option<u8> { match o { Some(u) => Some(u), None => None, } } fn case2(r: Result<u8, i32>) -> Result<u8, i32> { match r { Ok(u) => Ok(u), Err(i) => Err(i), } } fn case3(r: Result<u8, i32>) -> Result<u8, i32> { let u = r?; Ok(u) } ``` Without MIR inlining, this still does not completely optimize away the `?` operator because the `Try::into_result()`, `From::from()` and `Try::from_error()` calls still exist. This does move us a bit closer to that goal though because: - We can now run the pass on mir-opt-level=1 - We no longer depend on the copy propagation pass running which is unlikely to stabilize anytime soon.
2020-05-11 19:13:15 -05:00
}
Fix tests from rebase
2020-09-07 04:01:45 -05:00
Implement 'considered equal' for statements, so that for example `_0 = _1` and `discriminant(_0) = discriminant(0)` are considered equal if 0 is a fieldless variant of an enum
2020-07-25 10:46:11 -05:00
bb4: {
bless mir opt tests
2022-07-27 13:47:42 -05:00
return; // scope 0 at $DIR/simplify-arm.rs:+6:2: +6:2
further bless tests.
2020-06-04 11:26:13 -05:00
}
Modify SimplifyArmIdentity so it can trigger on mir-opt-level=1 I also added test cases to make sure the optimization can fire on all of these cases: ```rust fn case_1(o: Option<u8>) -> Option<u8> { match o { Some(u) => Some(u), None => None, } } fn case2(r: Result<u8, i32>) -> Result<u8, i32> { match r { Ok(u) => Ok(u), Err(i) => Err(i), } } fn case3(r: Result<u8, i32>) -> Result<u8, i32> { let u = r?; Ok(u) } ``` Without MIR inlining, this still does not completely optimize away the `?` operator because the `Try::into_result()`, `From::from()` and `Try::from_error()` calls still exist. This does move us a bit closer to that goal though because: - We can now run the pass on mir-opt-level=1 - We no longer depend on the copy propagation pass running which is unlikely to stabilize anytime soon.
2020-05-11 19:13:15 -05:00
}
Fix tests from rebase
2020-09-07 04:01:45 -05:00
Reference in New Issue Copy Permalink