[WIP] mir-opt: promoting const read-only arrays

compiler/rustc_mir_transform/src/lib.rs

@@ -91,6 +91,7 @@ mod normalize_array_len;
 mod nrvo;
 mod prettify;
 mod promote_consts;
+mod promote_consts_local_arrays;
 mod ref_prop;
 mod remove_noop_landing_pads;
 mod remove_storage_markers;
@@ -342,14 +343,22 @@ fn mir_promoted(
 
     // What we need to run borrowck etc.
     let promote_pass = promote_consts::PromoteTemps::default();
+    let promote_array = promote_consts_local_arrays::PromoteArraysOpt::default();
     pm::run_passes(
         tcx,
         &mut body,
-        &[&promote_pass, &simplify::SimplifyCfg::PromoteConsts, &coverage::InstrumentCoverage],
+        &[
+            &promote_pass,
+            &promote_array,
+            &simplify::SimplifyCfg::PromoteConsts,
+            &coverage::InstrumentCoverage,
+        ],
         Some(MirPhase::Analysis(AnalysisPhase::Initial)),
     );
 
-    let promoted = promote_pass.promoted_fragments.into_inner();
+    let mut promoted = promote_pass.promoted_fragments.into_inner();
+    let array_promoted = promote_array.promoted_fragments.into_inner();
+    promoted.extend(array_promoted);
     (tcx.alloc_steal_mir(body), tcx.alloc_steal_promoted(promoted))
 }
 

compiler/rustc_mir_transform/src/promote_consts.rs

@@ -98,33 +98,36 @@ struct Collector<'a, 'tcx> {
 }
 
 impl<'tcx> Visitor<'tcx> for Collector<'_, 'tcx> {
+    #[instrument(level = "debug", skip(self))]
     fn visit_local(&mut self, index: Local, context: PlaceContext, location: Location) {
-        debug!("visit_local: index={:?} context={:?} location={:?}", index, context, location);
         // We're only interested in temporaries and the return place
         match self.ccx.body.local_kind(index) {
             LocalKind::Arg => return,
-            LocalKind::Temp if self.ccx.body.local_decls[index].is_user_variable() => return,
+            LocalKind::Temp
+                if {
+                    let is_user_variable = self.ccx.body.local_decls[index].is_user_variable();
+                    debug!(?is_user_variable);
+                    is_user_variable
+                } =>
+            {
+                return;
+            }
             LocalKind::ReturnPointer | LocalKind::Temp => {}
         }
 
         // Ignore drops, if the temp gets promoted,
         // then it's constant and thus drop is noop.
         // Non-uses are also irrelevant.
         if context.is_drop() || !context.is_use() {
-            debug!(
-                "visit_local: context.is_drop={:?} context.is_use={:?}",
-                context.is_drop(),
-                context.is_use(),
-            );
+            debug!(is_drop = context.is_drop(), is_use = context.is_use());
             return;
         }
 
         let temp = &mut self.temps[index];
-        debug!("visit_local: temp={:?}", temp);
+        debug!(?temp);
         *temp = match *temp {
             TempState::Undefined => match context {
-                PlaceContext::MutatingUse(MutatingUseContext::Store)
-                | PlaceContext::MutatingUse(MutatingUseContext::Call) => {
+                PlaceContext::MutatingUse(MutatingUseContext::Store | MutatingUseContext::Call) => {
                     TempState::Defined { location, uses: 0, valid: Err(()) }
                 }
                 _ => TempState::Unpromotable,
@@ -137,7 +140,7 @@ impl<'tcx> Visitor<'tcx> for Collector<'_, 'tcx> {
                     | PlaceContext::NonMutatingUse(_) => true,
                     PlaceContext::MutatingUse(_) | PlaceContext::NonUse(_) => false,
                 };
-                debug!("visit_local: allowed_use={:?}", allowed_use);
+                debug!(?allowed_use);
                 if allowed_use {
                     *uses += 1;
                     return;
@@ -146,6 +149,7 @@ impl<'tcx> Visitor<'tcx> for Collector<'_, 'tcx> {
             }
             TempState::Unpromotable | TempState::PromotedOut => TempState::Unpromotable,
         };
+        debug!(?temp);
     }
 
     fn visit_rvalue(&mut self, rvalue: &Rvalue<'tcx>, location: Location) {
@@ -972,7 +976,12 @@ fn promote_candidates<'tcx>(
     candidates: Vec<Candidate>,
 ) -> IndexVec<Promoted, Body<'tcx>> {
     // Visit candidates in reverse, in case they're nested.
-    debug!("promote_candidates({:?})", candidates);
+    debug!(promote_candidates = ?candidates);
+
+    // eagerly fail fast
+    if candidates.is_empty() {
+        return IndexVec::new();
+    }
 
     let mut promotions = IndexVec::new();
 

library/panic_unwind/Cargo.toml

@@ -16,7 +16,7 @@ alloc = { path = "../alloc" }
 core = { path = "../core" }
 unwind = { path = "../unwind" }
 compiler_builtins = "0.1.0"
-cfg-if = "1.0"
+cfg-if = { version = "1.0", features = ['rustc-dep-of-std'] }
 
 [target.'cfg(not(all(windows, target_env = "msvc")))'.dependencies]
 libc = { version = "0.2", default-features = false }

tests/mir-opt/const_array_locals.main.PromoteArraysOpt.diff

@@ -0,0 +1,103 @@
+- // MIR for `main` before PromoteArraysOpt
++ // MIR for `main` after PromoteArraysOpt
+
+  fn main() -> () {
+      let mut _0: ();
+      let _1: [i32; 32];
+      let mut _3: [i32; 12];
+      let mut _4: [i32; 12];
+      let mut _6: &[i32; 32];
+      let _7: [i32; 32];
+      let _8: ();
+      let mut _9: [u16; 32];
+      let mut _11: [f32; 8];
+      let _12: [[i32; 3]; 3];
+      let mut _13: [i32; 3];
+      let mut _14: [i32; 3];
+      let mut _15: [i32; 3];
++     let mut _19: &[i32; 32];
+      scope 1 {
+          debug _arr => _1;
+          let _2: [[i32; 12]; 2];
++         let mut _18: &[[i32; 12]; 2];
+          scope 2 {
+              debug _foo => _2;
+              let _5: [i32; 32];
+              let mut _16: &[i32; 32];
+              scope 3 {
+                  debug _darr => _5;
+                  let _10: F32x8;
++                 let mut _17: &[u16; 32];
+                  scope 4 {
+                      debug _f => _10;
+                  }
+              }
+          }
+      }
+
+      bb0: {
+-         StorageLive(_1);
+-         _1 = [const 255_i32, const 105_i32, const 15_i32, const 39_i32, const 62_i32, const 251_i32, const 191_i32, const 178_i32, const 9_i32, const 4_i32, const 56_i32, const 221_i32, const 193_i32, const 164_i32, const 194_i32, const 197_i32, const 6_i32, const 243_i32, const 218_i32, const 171_i32, const 87_i32, const 247_i32, const 104_i32, const 159_i32, const 22_i32, const 157_i32, const 105_i32, const 31_i32, const 96_i32, const 173_i32, const 50_i32, const 1_i32];
++         _19 = const main::promoted[3];
++         _1 = (*_19);
+          FakeRead(ForLet(None), _1);
+-         StorageLive(_2);
+-         StorageLive(_3);
+-         _3 = [const 255_i32, const 105_i32, const 15_i32, const 39_i32, const 62_i32, const 251_i32, const 191_i32, const 178_i32, const 9_i32, const 4_i32, const 56_i32, const 221_i32];
+-         StorageLive(_4);
+-         _4 = [const 193_i32, const 164_i32, const 194_i32, const 197_i32, const 6_i32, const 243_i32, const 218_i32, const 171_i32, const 87_i32, const 247_i32, const 104_i32, const 42_i32];
+-         _2 = [move _3, move _4];
+-         StorageDead(_4);
+-         StorageDead(_3);
++         _18 = const main::promoted[2];
++         _2 = (*_18);
+          FakeRead(ForLet(None), _2);
+          StorageLive(_5);
+          StorageLive(_6);
+          _16 = const main::promoted[0];
+          _6 = &(*_16);
+          _5 = (*_6);
+          FakeRead(ForLet(None), _5);
+          StorageDead(_6);
+          StorageLive(_8);
+-         StorageLive(_9);
+-         _9 = [const 255_u16, const 105_u16, const 15_u16, const 39_u16, const 62_u16, const 251_u16, const 191_u16, const 178_u16, const 9_u16, const 4_u16, const 56_u16, const 221_u16, const 193_u16, const 164_u16, const 194_u16, const 197_u16, const 6_u16, const 243_u16, const 218_u16, const 171_u16, const 87_u16, const 247_u16, const 104_u16, const 159_u16, const 22_u16, const 157_u16, const 105_u16, const 31_u16, const 96_u16, const 173_u16, const 50_u16, const 1_u16];
++         _17 = const main::promoted[1];
++         _9 = (*_17);
+          _8 = consume(move _9) -> [return: bb1, unwind: bb2];
+      }
+
+      bb1: {
+-         StorageDead(_9);
+          StorageDead(_8);
+          StorageLive(_10);
+          StorageLive(_11);
+          _11 = [const 1f32, const 1f32, const 1f32, const 1f32, const 1f32, const 1f32, const 1f32, const 1f32];
+          _10 = F32x8(move _11);
+          StorageDead(_11);
+          FakeRead(ForLet(None), _10);
+          StorageLive(_12);
+          StorageLive(_13);
+          _13 = [const 1_i32, const 0_i32, const 0_i32];
+          StorageLive(_14);
+          _14 = [const 0_i32, const 1_i32, const 0_i32];
+          StorageLive(_15);
+          _15 = [const 0_i32, const 0_i32, const 1_i32];
+          _12 = [move _13, move _14, move _15];
+          StorageDead(_15);
+          StorageDead(_14);
+          StorageDead(_13);
+          StorageDead(_12);
+          _0 = const ();
+          StorageDead(_10);
+          StorageDead(_5);
+-         StorageDead(_2);
+-         StorageDead(_1);
+          return;
+      }
+
+      bb2 (cleanup): {
+          resume;
+      }
+  }
+

tests/mir-opt/const_array_locals.rs

@@ -0,0 +1,44 @@
+//@ test-mir-pass: PromoteArraysOpt
+#![feature(repr_simd)]
+
+#[repr(simd)]
+struct F32x8([f32; 8]);
+
+// EMIT_MIR const_array_locals.main.PromoteArraysOpt.diff
+// CHECK-LABEL: fn main(
+#[rustfmt::skip]
+pub fn main() {
+    // CHECK: let [[array_lit:_.*]]: [i32; 32];
+    // CHECK: let mut [[moved_array:_.*]]: [u16; 32];
+    // CHECK:     debug _arr => [[arr:_.*]];
+
+    // CHECK:       [[array_lit]] = (*{{_[0-9]*}})
+    let _arr = [
+        255, 105, 15, 39, 62, 251, 191, 178, 9, 4, 56, 221,
+        193, 164, 194, 197, 6, 243, 218, 171, 87, 247, 104,
+        159, 22, 157, 105, 31, 96, 173, 50, 1,
+    ];
+    let _foo = [
+        [255, 105, 15, 39, 62, 251, 191, 178, 9, 4, 56, 221],
+        [193, 164, 194, 197, 6, 243, 218, 171, 87, 247, 104, 42],
+    ];
+    let _darr = *&[
+        255, 105, 15, 39, 62, 251, 191, 178, 9, 4, 56, 221,
+        193, 164, 194, 197, 6, 243, 218, 171, 87, 247, 104,
+        159, 22, 157, 105, 31, 96, 173, 50, 1,
+    ];
+
+    // CHECK:       [[moved_array]] = (*{{_[0-9]*}})
+    consume([255, 105, 15, 39, 62, 251, 191, 178, 9, 4, 56, 221,
+        193, 164, 194, 197, 6, 243, 218, 171, 87, 247, 104,
+        159, 22, 157, 105, 31, 96, 173, 50, 1,]);
+
+    let _f = F32x8([1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]);
+
+    // ice
+    [[1, 0, 0], [0, 1, 0], [0, 0, 1]]; // 2D array
+}
+
+fn consume(_arr: [u16; 32]) {
+    unimplemented!()
+}