Implement a few basic InstCombine optimizations

Author: saethlin

compiler/rustc_mir_transform/src/instcombine.rs

@@ -76,6 +76,7 @@ mod ffi_unwind_calls;
 mod function_item_references;
 mod generator;
 mod inline;
+mod instcombine;
 mod instsimplify;
 mod large_enums;
 mod lower_intrinsics;
@@ -575,6 +576,7 @@ fn run_optimization_passes<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
             &simplify_comparison_integral::SimplifyComparisonIntegral,
             &dead_store_elimination::DeadStoreElimination,
             &dest_prop::DestinationPropagation,
+            &instcombine::InstCombine,
             &o1(simplify_branches::SimplifyConstCondition::Final),
             &o1(remove_noop_landing_pads::RemoveNoopLandingPads),
             &o1(simplify::SimplifyCfg::Final),

compiler/rustc_mir_transform/src/lib.rs

@@ -3,13 +3,9 @@
 fn roundtrip(_1: *const u8) -> *const u8 {
     debug x => _1;
     let mut _0: *const u8;
-    let mut _2: *mut u8;
 
     bb0: {
-        StorageLive(_2);
-        _2 = _1 as *mut u8 (PtrToPtr);
-        _0 = move _2 as *const u8 (Pointer(MutToConstPointer));
-        StorageDead(_2);
+        _0 = _1 as *const u8 (PtrToPtr);
         return;
     }
 }

tests/mir-opt/casts.roundtrip.PreCodegen.after.mir

@@ -158,13 +158,11 @@
 +         StorageLive(_17);
 +         StorageLive(_18);
 +         _18 = (_11.0: *const [u8]);
-+         _17 = move _18 as *mut [u8] (PtrToPtr);
-+         StorageDead(_18);
-+         _16 = _17 as *mut u8 (PtrToPtr);
-+         StorageDead(_17);
 +         StorageLive(_19);
++         _19 = move _18 as *const u8 (PtrToPtr);
++         StorageDead(_18);
 +         StorageLive(_20);
-+         _19 = _16 as *const u8 (Pointer(MutToConstPointer));
++         StorageDead(_17);
 +         _15 = NonNull::<u8> { pointer: _19 };
 +         StorageDead(_20);
 +         StorageDead(_19);

tests/mir-opt/inline/inline_into_box_place.main.Inline.panic-abort.diff

@@ -175,13 +175,11 @@
 +         StorageLive(_17);
 +         StorageLive(_18);
 +         _18 = (_11.0: *const [u8]);
-+         _17 = move _18 as *mut [u8] (PtrToPtr);
-+         StorageDead(_18);
-+         _16 = _17 as *mut u8 (PtrToPtr);
-+         StorageDead(_17);
 +         StorageLive(_19);
++         _19 = move _18 as *const u8 (PtrToPtr);
++         StorageDead(_18);
 +         StorageLive(_20);
-+         _19 = _16 as *const u8 (Pointer(MutToConstPointer));
++         StorageDead(_17);
 +         _15 = NonNull::<u8> { pointer: _19 };
 +         StorageDead(_20);
 +         StorageDead(_19);

tests/mir-opt/inline/inline_into_box_place.main.Inline.panic-unwind.diff

@@ -0,0 +1,22 @@
+- // MIR for `place_projection` before InstCombine
++ // MIR for `place_projection` after InstCombine
+  
+  fn place_projection(_1: Outer) -> u8 {
+      debug o => _1;
+      let mut _0: u8;
+      let _2: Inner;
+      scope 1 {
+          debug temp => _2;
+      }
+  
+      bb0: {
+          StorageLive(_2);
+-         _2 = move (_1.0: Inner);
+-         _0 = (_2.0: u8);
++         _0 = ((_1.0: Inner).0: u8);
++         nop;
+          StorageDead(_2);
+          return;
+      }
+  }
+  

tests/mir-opt/instcombine/place_projection.place_projection.InstCombine.diff

@@ -0,0 +1,16 @@
+// unit-test: InstCombine
+#![crate_type = "lib"]
+
+pub struct Outer {
+    inner: Inner,
+}
+
+struct Inner {
+    field: u8,
+}
+
+// EMIT_MIR place_projection.place_projection.InstCombine.diff
+pub fn place_projection(o: Outer) -> u8 {
+    let temp = o.inner;
+    temp.field
+}

tests/mir-opt/instcombine/place_projection.rs

@@ -0,0 +1,23 @@
+- // MIR for `ptr_cast` before InstCombine
++ // MIR for `ptr_cast` after InstCombine
+  
+  fn ptr_cast(_1: *const u8) -> *mut () {
+      debug p => _1;
+      let mut _0: *mut ();
+      let mut _2: *mut u8;
+      let mut _3: *const u8;
+  
+      bb0: {
+          StorageLive(_2);
+          StorageLive(_3);
+          _3 = _1;
+-         _2 = move _3 as *mut u8 (PtrToPtr);
++         _0 = move _3 as *mut () (PtrToPtr);
++         nop;
+          StorageDead(_3);
+-         _0 = move _2 as *mut () (PtrToPtr);
+          StorageDead(_2);
+          return;
+      }
+  }
+  

tests/mir-opt/instcombine/ptr_cast.ptr_cast.InstCombine.diff

@@ -0,0 +1,7 @@
+// unit-test: InstCombine
+#![crate_type = "lib"]
+
+// EMIT_MIR ptr_cast.ptr_cast.InstCombine.diff
+pub fn ptr_cast(p: *const u8) -> *mut () {
+    p as *mut u8 as *mut ()
+}

tests/mir-opt/instcombine/ptr_cast.rs

@@ -0,0 +1,44 @@
+- // MIR for `ref_addressof` before InstCombine
++ // MIR for `ref_addressof` after InstCombine
+  
+  fn ref_addressof(_1: T) -> () {
+      debug t => _1;
+      let mut _0: ();
+      let _2: &T;
+      let _4: ();
+      let mut _5: *const T;
+      scope 1 {
+          debug r => _2;
+          let _3: *const T;
+          scope 2 {
+              debug ptr => _3;
+          }
+      }
+  
+      bb0: {
+          StorageLive(_2);
+-         _2 = &_1;
+          StorageLive(_3);
+-         _3 = &raw const (*_2);
++         _3 = &raw const _1;
++         nop;
+          StorageLive(_4);
+          StorageLive(_5);
+          _5 = _3;
+          _4 = std::mem::drop::<*const T>(move _5) -> [return: bb1, unwind unreachable];
+      }
+  
+      bb1: {
+          StorageDead(_5);
+          StorageDead(_4);
+          _0 = const ();
+          StorageDead(_3);
+          StorageDead(_2);
+          drop(_1) -> [return: bb2, unwind unreachable];
+      }
+  
+      bb2: {
+          return;
+      }
+  }
+