WIP enable by default.

Author: cjgillot

compiler/rustc_mir_transform/src/jump_threading.rs

@@ -55,7 +55,7 @@ const MAX_PLACES: usize = 100;
 
 impl<'tcx> MirPass<'tcx> for JumpThreading {
     fn is_enabled(&self, sess: &rustc_session::Session) -> bool {
-        sess.mir_opt_level() >= 4
+        sess.mir_opt_level() >= 2
     }
 
     #[instrument(skip_all level = "debug")]

tests/mir-opt/pre-codegen/checked_ops.step_forward.PreCodegen.after.mir

@@ -4,66 +4,12 @@ fn step_forward(_1: u32, _2: usize) -> u32 {
     debug x => _1;
     debug n => _2;
     let mut _0: u32;
-    scope 1 (inlined <u32 as Step>::forward) {
-        debug start => _1;
-        debug n => _2;
-        let _3: std::option::Option<u32>;
-        let mut _4: &std::option::Option<u32>;
-        let mut _7: bool;
-        let mut _8: u32;
-        scope 2 {
-        }
-        scope 3 (inlined Option::<u32>::is_none) {
-            debug self => _4;
-            let mut _6: bool;
-            scope 4 (inlined Option::<u32>::is_some) {
-                debug self => _4;
-                let mut _5: isize;
-            }
-        }
-        scope 5 (inlined core::num::<impl u32>::wrapping_add) {
-            debug self => _1;
-            debug rhs => _8;
-        }
-    }
 
     bb0: {
-        StorageLive(_7);
-        StorageLive(_4);
-        StorageLive(_3);
-        _3 = <u32 as Step>::forward_checked(_1, _2) -> [return: bb1, unwind continue];
+        _0 = <u32 as Step>::forward(move _1, move _2) -> [return: bb1, unwind continue];
     }
 
     bb1: {
-        _4 = &_3;
-        StorageLive(_6);
-        StorageLive(_5);
-        _5 = discriminant(_3);
-        _6 = Eq(_5, const 1_isize);
-        StorageDead(_5);
-        _7 = Not(move _6);
-        StorageDead(_6);
-        switchInt(move _7) -> [0: bb2, otherwise: bb3];
-    }
-
-    bb2: {
-        StorageDead(_3);
-        StorageDead(_4);
-        goto -> bb4;
-    }
-
-    bb3: {
-        StorageDead(_3);
-        StorageDead(_4);
-        assert(!const true, "attempt to compute `{} + {}`, which would overflow", const _, const 1_u32) -> [success: bb4, unwind continue];
-    }
-
-    bb4: {
-        StorageDead(_7);
-        StorageLive(_8);
-        _8 = _2 as u32 (IntToInt);
-        _0 = Add(_1, _8);
-        StorageDead(_8);
         return;
     }
 }

tests/mir-opt/pre-codegen/loops.int_range.PreCodegen.after.mir

@@ -7,14 +7,13 @@ fn int_range(_1: usize, _2: usize) -> () {
     let mut _3: std::ops::Range<usize>;
     let mut _4: std::ops::Range<usize>;
     let mut _5: &mut std::ops::Range<usize>;
-    let mut _11: std::option::Option<usize>;
-    let mut _14: isize;
-    let _16: ();
+    let mut _13: std::option::Option<usize>;
+    let _15: ();
     scope 1 {
         debug iter => _4;
-        let _15: usize;
+        let _14: usize;
         scope 2 {
-            debug i => _15;
+            debug i => _14;
         }
         scope 4 (inlined iter::range::<impl Iterator for std::ops::Range<usize>>::next) {
             debug self => _5;
@@ -23,10 +22,10 @@ fn int_range(_1: usize, _2: usize) -> () {
                 let mut _6: &usize;
                 let mut _7: &usize;
                 let mut _10: bool;
-                let _12: usize;
-                let mut _13: usize;
+                let _11: usize;
+                let mut _12: usize;
                 scope 6 {
-                    debug old => _12;
+                    debug old => _11;
                     scope 7 {
                     }
                 }
@@ -51,9 +50,9 @@ fn int_range(_1: usize, _2: usize) -> () {
     }
 
     bb1: {
-        StorageLive(_11);
+        StorageLive(_13);
         _5 = &mut _4;
-        StorageLive(_12);
+        StorageLive(_11);
         StorageLive(_10);
         StorageLive(_6);
         _6 = &(_4.0: usize);
@@ -72,49 +71,33 @@ fn int_range(_1: usize, _2: usize) -> () {
     bb2: {
         StorageDead(_7);
         StorageDead(_6);
-        _11 = Option::<usize>::None;
-        goto -> bb5;
+        StorageDead(_10);
+        StorageDead(_11);
+        StorageDead(_13);
+        StorageDead(_4);
+        return;
     }
 
     bb3: {
         StorageDead(_7);
         StorageDead(_6);
-        _12 = (_4.0: usize);
-        StorageLive(_13);
-        _13 = <usize as Step>::forward_unchecked(_12, const 1_usize) -> [return: bb4, unwind continue];
+        _11 = (_4.0: usize);
+        StorageLive(_12);
+        _12 = <usize as Step>::forward_unchecked(_11, const 1_usize) -> [return: bb4, unwind continue];
     }
 
     bb4: {
-        (_4.0: usize) = move _13;
-        StorageDead(_13);
-        _11 = Option::<usize>::Some(_12);
-        goto -> bb5;
-    }
-
-    bb5: {
-        StorageDead(_10);
+        (_4.0: usize) = move _12;
         StorageDead(_12);
-        _14 = discriminant(_11);
-        switchInt(move _14) -> [0: bb6, 1: bb7, otherwise: bb9];
-    }
-
-    bb6: {
+        _13 = Option::<usize>::Some(_11);
+        StorageDead(_10);
         StorageDead(_11);
-        StorageDead(_4);
-        return;
+        _14 = ((_13 as Some).0: usize);
+        _15 = opaque::<usize>(move _14) -> [return: bb5, unwind continue];
     }
 
-    bb7: {
-        _15 = ((_11 as Some).0: usize);
-        _16 = opaque::<usize>(move _15) -> [return: bb8, unwind continue];
-    }
-
-    bb8: {
-        StorageDead(_11);
+    bb5: {
+        StorageDead(_13);
         goto -> bb1;
     }
-
-    bb9: {
-        unreachable;
-    }
 }

tests/mir-opt/pre-codegen/mem_replace.mem_replace.PreCodegen.after.mir

@@ -14,6 +14,35 @@ fn mem_replace(_1: &mut u32, _2: u32) -> u32 {
                     debug dst => _1;
                     debug src => _2;
                     scope 17 {
+                        scope 18 (inlined std::ptr::write::runtime::<u32>) {
+                            debug dst => _1;
+                            let mut _4: *const u32;
+                            scope 19 (inlined intrinsics::is_aligned_and_not_null::<u32>) {
+                                debug ptr => _4;
+                                scope 20 (inlined ptr::const_ptr::<impl *const u32>::is_null) {
+                                    debug self => _4;
+                                    let mut _5: *const u8;
+                                    scope 21 {
+                                        scope 22 (inlined ptr::const_ptr::<impl *const T>::is_null::runtime_impl) {
+                                            debug ptr => _5;
+                                            scope 23 (inlined ptr::const_ptr::<impl *const u8>::addr) {
+                                                debug self => _5;
+                                                scope 24 {
+                                                    scope 25 (inlined ptr::const_ptr::<impl *const u8>::cast::<()>) {
+                                                        debug self => _5;
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                scope 26 (inlined ptr::const_ptr::<impl *const u32>::is_aligned) {
+                                    debug self => _4;
+                                    scope 27 (inlined align_of::<u32>) {
+                                    }
+                                }
+                            }
+                        }
                     }
                 }
             }
@@ -57,7 +86,11 @@ fn mem_replace(_1: &mut u32, _2: u32) -> u32 {
         StorageLive(_3);
         _0 = (*_1);
         StorageDead(_3);
+        StorageLive(_4);
+        StorageLive(_5);
         (*_1) = _2;
+        StorageDead(_5);
+        StorageDead(_4);
         return;
     }
 }

tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-abort.mir

@@ -8,16 +8,15 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () {
     let mut _4: std::ops::Range<u32>;
     let mut _5: std::ops::Range<u32>;
     let mut _6: &mut std::ops::Range<u32>;
-    let mut _12: std::option::Option<u32>;
-    let mut _15: isize;
-    let mut _17: &impl Fn(u32);
-    let mut _18: (u32,);
-    let _19: ();
+    let mut _14: std::option::Option<u32>;
+    let mut _16: &impl Fn(u32);
+    let mut _17: (u32,);
+    let _18: ();
     scope 1 {
         debug iter => _5;
-        let _16: u32;
+        let _15: u32;
         scope 2 {
-            debug x => _16;
+            debug x => _15;
         }
         scope 4 (inlined iter::range::<impl Iterator for std::ops::Range<u32>>::next) {
             debug self => _6;
@@ -26,10 +25,10 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () {
                 let mut _7: &u32;
                 let mut _8: &u32;
                 let mut _11: bool;
-                let _13: u32;
-                let mut _14: u32;
+                let _12: u32;
+                let mut _13: u32;
                 scope 6 {
-                    debug old => _13;
+                    debug old => _12;
                     scope 7 {
                     }
                 }
@@ -54,9 +53,9 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () {
     }
 
     bb1: {
-        StorageLive(_12);
+        StorageLive(_14);
         _6 = &mut _5;
-        StorageLive(_13);
+        StorageLive(_12);
         StorageLive(_11);
         StorageLive(_7);
         _7 = &(_5.0: u32);
@@ -69,65 +68,49 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () {
         _11 = Lt(move _9, move _10);
         StorageDead(_10);
         StorageDead(_9);
-        switchInt(move _11) -> [0: bb2, otherwise: bb3];
+        switchInt(move _11) -> [0: bb2, otherwise: bb4];
     }
 
     bb2: {
         StorageDead(_8);
         StorageDead(_7);
-        _12 = Option::<u32>::None;
-        goto -> bb5;
+        StorageDead(_11);
+        StorageDead(_12);
+        StorageDead(_14);
+        StorageDead(_5);
+        drop(_3) -> [return: bb3, unwind unreachable];
     }
 
     bb3: {
-        StorageDead(_8);
-        StorageDead(_7);
-        _13 = (_5.0: u32);
-        StorageLive(_14);
-        _14 = <u32 as Step>::forward_unchecked(_13, const 1_usize) -> [return: bb4, unwind unreachable];
+        return;
     }
 
     bb4: {
-        (_5.0: u32) = move _14;
-        StorageDead(_14);
-        _12 = Option::<u32>::Some(_13);
-        goto -> bb5;
+        StorageDead(_8);
+        StorageDead(_7);
+        _12 = (_5.0: u32);
+        StorageLive(_13);
+        _13 = <u32 as Step>::forward_unchecked(_12, const 1_usize) -> [return: bb5, unwind unreachable];
     }
 
     bb5: {
-        StorageDead(_11);
+        (_5.0: u32) = move _13;
         StorageDead(_13);
-        _15 = discriminant(_12);
-        switchInt(move _15) -> [0: bb6, 1: bb8, otherwise: bb10];
-    }
-
-    bb6: {
+        _14 = Option::<u32>::Some(_12);
+        StorageDead(_11);
         StorageDead(_12);
-        StorageDead(_5);
-        drop(_3) -> [return: bb7, unwind unreachable];
-    }
-
-    bb7: {
-        return;
-    }
-
-    bb8: {
-        _16 = ((_12 as Some).0: u32);
+        _15 = ((_14 as Some).0: u32);
+        StorageLive(_16);
+        _16 = &_3;
         StorageLive(_17);
-        _17 = &_3;
-        StorageLive(_18);
-        _18 = (_16,);
-        _19 = <impl Fn(u32) as Fn<(u32,)>>::call(move _17, move _18) -> [return: bb9, unwind unreachable];
+        _17 = (_15,);
+        _18 = <impl Fn(u32) as Fn<(u32,)>>::call(move _16, move _17) -> [return: bb6, unwind unreachable];
     }
 
-    bb9: {
-        StorageDead(_18);
+    bb6: {
         StorageDead(_17);
-        StorageDead(_12);
+        StorageDead(_16);
+        StorageDead(_14);
         goto -> bb1;
     }
-
-    bb10: {
-        unreachable;
-    }
 }