gvn: Allow evaluating rvalue operands

This reverts 8093f11. This makes nested arrays and operands
evaluable to const.

Author: tesuji

compiler/rustc_mir_transform/src/gvn.rs

@@ -778,11 +778,6 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             }
             Operand::Copy(ref mut place) | Operand::Move(ref mut place) => {
                 let value = self.simplify_place_value(place, location)?;
-                // NOTE(tesuji): We just want to promote rvalues of array kind that assigned to a local, and
-                // not evaluate this local as a const operand of a function to avoid bloating MIR.
-                if let Value::Aggregate(AggregateTy::Array, ..) = self.get(value) {
-                    return None;
-                }
                 if let Some(const_) = self.try_as_constant(value) {
                     *operand = Operand::Constant(Box::new(const_));
                 }

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

@@ -49,8 +49,9 @@
 +         _4 = const [178_i32, 9_i32, 4_i32, 56_i32, 221_i32];
           StorageLive(_5);
 -         _5 = [const 193_i32, const 164_i32, const 194_i32, const 197_i32, const 6_i32];
+-         _3 = [move _4, move _5];
 +         _5 = const [193_i32, 164_i32, 194_i32, 197_i32, 6_i32];
-          _3 = [move _4, move _5];
++         _3 = const [[178_i32, 9_i32, 4_i32, 56_i32, 221_i32], [193_i32, 164_i32, 194_i32, 197_i32, 6_i32]];
           StorageDead(_5);
           StorageDead(_4);
           StorageLive(_6);
@@ -63,8 +64,9 @@
           StorageLive(_9);
           StorageLive(_10);
 -         _10 = [const 31_u32, const 96_u32, const 173_u32, const 50_u32, const 1_u32];
+-         _9 = consume(move _10) -> [return: bb1, unwind continue];
 +         _10 = const [31_u32, 96_u32, 173_u32, 50_u32, 1_u32];
-          _9 = consume(move _10) -> [return: bb1, unwind continue];
++         _9 = consume(const [31_u32, 96_u32, 173_u32, 50_u32, 1_u32]) -> [return: bb1, unwind continue];
       }
 
       bb1: {
@@ -73,8 +75,9 @@
           StorageLive(_11);
           StorageLive(_12);
 -         _12 = [const 1f32, const 2f32, const 3f32, const 1f32, const 1f32, const 1f32, const 1f32, const 42f32];
+-         _11 = F32x8(move _12);
 +         _12 = const [1f32, 2f32, 3f32, 1f32, 1f32, 1f32, 1f32, 42f32];
-          _11 = F32x8(move _12);
++         _11 = F32x8(const [1f32, 2f32, 3f32, 1f32, 1f32, 1f32, 1f32, 42f32]);
           StorageDead(_12);
           StorageLive(_13);
           StorageLive(_14);
@@ -85,8 +88,9 @@
 +         _15 = const [0_i32, 1_i32, 0_i32];
           StorageLive(_16);
 -         _16 = [const 0_i32, const 0_i32, const 1_i32];
+-         _13 = [move _14, move _15, move _16];
 +         _16 = const [0_i32, 0_i32, 1_i32];
-          _13 = [move _14, move _15, move _16];
++         _13 = const [[1_i32, 0_i32, 0_i32], [0_i32, 1_i32, 0_i32], [0_i32, 0_i32, 1_i32]];
           StorageDead(_16);
           StorageDead(_15);
           StorageDead(_14);
@@ -101,21 +105,25 @@
       }
   }
 + 
-+ ALLOC0 (size: 12, align: 4) { .. }
++ ALLOC0 (size: 36, align: 4) { .. }
 + 
 + ALLOC1 (size: 12, align: 4) { .. }
 + 
 + ALLOC2 (size: 12, align: 4) { .. }
 + 
-+ ALLOC3 (size: 32, align: 4) { .. }
++ ALLOC3 (size: 12, align: 4) { .. }
 + 
-+ ALLOC4 (size: 20, align: 4) { .. }
++ ALLOC4 (size: 32, align: 4) { .. }
 + 
 + ALLOC5 (size: 20, align: 4) { .. }
 + 
-+ ALLOC6 (size: 20, align: 4) { .. }
++ ALLOC6 (size: 40, align: 4) { .. }
 + 
 + ALLOC7 (size: 20, align: 4) { .. }
 + 
 + ALLOC8 (size: 20, align: 4) { .. }
++ 
++ ALLOC9 (size: 20, align: 4) { .. }
++ 
++ ALLOC10 (size: 20, align: 4) { .. }
 

tests/mir-opt/const_array_locals.rs

@@ -19,25 +19,25 @@ pub fn main() {
     let _duplicated_arr = [255, 105, 15, 39, 62];
     // CHECK: [[subarray1:_[0-9]+]] = const [178_i32, 9_i32, 4_i32, 56_i32, 221_i32];
     // CHECK: [[subarray2:_[0-9]+]] = const [193_i32, 164_i32, 194_i32, 197_i32, 6_i32];
-    // CHECK: [[_foo]] = [move [[subarray1]], move [[subarray2]]];
+    // CHECK{LITERAL}: const [[178_i32, 9_i32, 4_i32, 56_i32, 221_i32], [193_i32, 164_i32, 194_i32, 197_i32, 6_i32]];
     let _foo = [[178, 9, 4, 56, 221], [193, 164, 194, 197, 6]];
     // CHECK: [[PROMOTED:_[0-9]+]] = const main::promoted[0];
     // CHECK: [[_darr]] = const [254_i32, 42_i32, 15_i32, 39_i32, 62_i32];
     let _darr = *&[254, 42, 15, 39, 62];
 
     // CHECK: [[ARG:_[0-9]+]] = const [31_u32, 96_u32, 173_u32, 50_u32, 1_u32];
-    // CHECK: consume(move [[ARG]])
+    // CHECK: consume(const [31_u32, 96_u32, 173_u32, 50_u32, 1_u32])
     consume([31, 96, 173, 50, 1]);
 
     // CHECK: [[OP:_[0-9]+]] = const [1f32, 2f32, 3f32, 1f32, 1f32, 1f32, 1f32, 42f32];
-    // CHECK: [[_f]] = F32x8(move [[OP]]);
+    // CHECK: [[_f]] = F32x8(const [1f32, 2f32, 3f32, 1f32, 1f32, 1f32, 1f32, 42f32]);
     let _f = F32x8([1.0, 2.0, 3.0, 1.0, 1.0, 1.0, 1.0, 42.0]);
 
     // ice with small arrays
     // CHECK: [[A:_[0-9]+]] = const [1_i32, 0_i32, 0_i32];
     // CHECK: [[B:_[0-9]+]] = const [0_i32, 1_i32, 0_i32];
     // CHECK: [[C:_[0-9]+]] = const [0_i32, 0_i32, 1_i32];
-    // CHECK: {{_[0-9]+}} = [move [[A]], move [[B]], move [[C]]];
+    // CHECK{LITERAL}: const [[1_i32, 0_i32, 0_i32], [0_i32, 1_i32, 0_i32], [0_i32, 0_i32, 1_i32]];
     [[1, 0, 0], [0, 1, 0], [0, 0, 1]]; // 2D array
 }