Replace SingleUseConsts by GVN.

Author: cjgillot

compiler/rustc_mir_transform/src/gvn.rs

@@ -145,6 +145,10 @@ impl<'tcx> crate::MirPass<'tcx> for GVN {
             state.visit_basic_block_data(bb, data);
         }
 
+        for var_debug_info in body.var_debug_info.iter_mut() {
+            state.visit_var_debug_info(var_debug_info);
+        }
+
         // For each local that is reused (`y` above), we remove its storage statements do avoid any
         // difficulty. Those locals are SSA, so should be easy to optimize by LLVM without storage
         // statements.
@@ -865,10 +869,11 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
 
     /// Simplify the projection chain if we know better.
     #[instrument(level = "trace", skip(self))]
-    fn simplify_place_projection(&mut self, place: &mut Place<'tcx>, location: Location) {
+    fn simplify_place_projection(&mut self, place: &mut Place<'tcx>, location: Option<Location>) {
         // If the projection is indirect, we treat the local as a value, so can replace it with
         // another local.
-        if place.is_indirect_first_projection()
+        if let Some(location) = location
+            && place.is_indirect_first_projection()
             && let Some(base) = self.locals[place.local]
             && let Some(new_local) = self.try_as_local(base, location)
             && place.local != new_local
@@ -890,7 +895,8 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
                 {
                     projection.to_mut()[i] =
                         ProjectionElem::ConstantIndex { offset, min_length, from_end: false };
-                } else if let Some(new_idx_local) = self.try_as_local(idx, location)
+                } else if let Some(location) = location
+                    && let Some(new_idx_local) = self.try_as_local(idx, location)
                     && idx_local != new_idx_local
                 {
                     projection.to_mut()[i] = ProjectionElem::Index(new_idx_local);
@@ -912,7 +918,7 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
     fn compute_place_value(
         &mut self,
         place: Place<'tcx>,
-        location: Location,
+        location: Option<Location>,
     ) -> Result<VnIndex, PlaceRef<'tcx>> {
         // Invariant: `place` and `place_ref` point to the same value, even if they point to
         // different memory locations.
@@ -923,7 +929,9 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
         // Invariant: `value` has type `place_ty`, with optional downcast variant if needed.
         let mut place_ty = PlaceTy::from_ty(self.local_decls[place.local].ty);
         for (index, proj) in place.projection.iter().enumerate() {
-            if let Some(local) = self.try_as_local(value, location) {
+            if let Some(location) = location
+                && let Some(local) = self.try_as_local(value, location)
+            {
                 // Both `local` and `Place { local: place.local, projection: projection[..index] }`
                 // hold the same value. Therefore, following place holds the value in the original
                 // `place`.
@@ -948,13 +956,14 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
     fn simplify_place_value(
         &mut self,
         place: &mut Place<'tcx>,
-        location: Location,
+        location: Option<Location>,
     ) -> Option<VnIndex> {
         self.simplify_place_projection(place, location);
 
         match self.compute_place_value(*place, location) {
             Ok(value) => {
-                if let Some(new_place) = self.try_as_place(value, location, true)
+                if let Some(location) = location
+                    && let Some(new_place) = self.try_as_place(value, location, true)
                     && (new_place.local != place.local
                         || new_place.projection.len() < place.projection.len())
                 {
@@ -985,7 +994,7 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
         let value = match *operand {
             Operand::Constant(ref constant) => self.insert_constant(constant.const_),
             Operand::Copy(ref mut place) | Operand::Move(ref mut place) => {
-                self.simplify_place_value(place, location)?
+                self.simplify_place_value(place, Some(location))?
             }
         };
         if let Some(const_) = self.try_as_constant(value) {
@@ -1019,11 +1028,11 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
             Rvalue::NullaryOp(op, ty) => Value::NullaryOp(op, ty),
             Rvalue::Aggregate(..) => return self.simplify_aggregate(lhs, rvalue, location),
             Rvalue::Ref(_, borrow_kind, ref mut place) => {
-                self.simplify_place_projection(place, location);
+                self.simplify_place_projection(place, Some(location));
                 return self.new_pointer(*place, AddressKind::Ref(borrow_kind));
             }
             Rvalue::RawPtr(mutbl, ref mut place) => {
-                self.simplify_place_projection(place, location);
+                self.simplify_place_projection(place, Some(location));
                 return self.new_pointer(*place, AddressKind::Address(mutbl));
             }
             Rvalue::WrapUnsafeBinder(ref mut op, _) => {
@@ -1042,7 +1051,7 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
                 return self.simplify_unary(op, arg_op, location);
             }
             Rvalue::Discriminant(ref mut place) => {
-                let place = self.simplify_place_value(place, location)?;
+                let place = self.simplify_place_value(place, Some(location))?;
                 if let Some(discr) = self.simplify_discriminant(place) {
                     return Some(discr);
                 }
@@ -1852,8 +1861,21 @@ impl<'tcx> MutVisitor<'tcx> for VnState<'_, '_, 'tcx> {
         self.tcx
     }
 
+    fn visit_var_debug_info(&mut self, var_debug_info: &mut VarDebugInfo<'tcx>) {
+        match &mut var_debug_info.value {
+            VarDebugInfoContents::Const(_) => {}
+            VarDebugInfoContents::Place(place) => {
+                if let Some(value) = self.simplify_place_value(place, None)
+                    && let Some(constant) = self.try_as_constant(value)
+                {
+                    var_debug_info.value = VarDebugInfoContents::Const(constant);
+                }
+            }
+        }
+    }
+
     fn visit_place(&mut self, place: &mut Place<'tcx>, context: PlaceContext, location: Location) {
-        self.simplify_place_projection(place, location);
+        self.simplify_place_projection(place, Some(location));
         if context.is_mutating_use() && place.is_indirect() {
             // Non-local mutation maybe invalidate deref.
             self.invalidate_derefs();
@@ -1872,7 +1894,7 @@ impl<'tcx> MutVisitor<'tcx> for VnState<'_, '_, 'tcx> {
         rvalue: &mut Rvalue<'tcx>,
         location: Location,
     ) {
-        self.simplify_place_projection(lhs, location);
+        self.simplify_place_projection(lhs, Some(location));
 
         let value = self.simplify_rvalue(lhs, rvalue, location);
         if let Some(value) = value {

compiler/rustc_mir_transform/src/lib.rs

@@ -191,7 +191,6 @@ declare_passes! {
         Final
     };
     mod simplify_comparison_integral : SimplifyComparisonIntegral;
-    mod single_use_consts : SingleUseConsts;
     mod sroa : ScalarReplacementOfAggregates;
     mod strip_debuginfo : StripDebugInfo;
     mod unreachable_enum_branching : UnreachableEnumBranching;
@@ -709,7 +708,6 @@ pub(crate) fn run_optimization_passes<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'
             &simplify::SimplifyLocals::AfterGVN,
             &match_branches::MatchBranchSimplification,
             &dataflow_const_prop::DataflowConstProp,
-            &single_use_consts::SingleUseConsts,
             &o1(simplify_branches::SimplifyConstCondition::AfterConstProp),
             &jump_threading::JumpThreading,
             &early_otherwise_branch::EarlyOtherwiseBranch,

compiler/rustc_mir_transform/src/single_use_consts.rs

@@ -10,7 +10,7 @@ extern crate minicore;
 
 // CHECK-LABEL: @ref_of_local
 // CHECK: [[alloca:%[0-9]]] = alloca
-// CHECK: %i = addrspacecast ptr addrspace(5) [[alloca]] to ptr
+// CHECK: {{%.*}} = addrspacecast ptr addrspace(5) [[alloca]] to ptr
 #[no_mangle]
 pub fn ref_of_local(f: fn(&i32)) {
     let i = 0;

tests/codegen-llvm/amdgpu-addrspacecast.rs

@@ -64,7 +64,7 @@ pub fn change_field_order_struct_like() -> Enum {
 #[cfg(not(any(cfail1,cfail4)))]
 #[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,typeck")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,typeck,optimized_mir")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,typeck")]
 #[rustc_clean(cfg="cfail6")]
 // FIXME(michaelwoerister):Interesting. I would have thought that that changes the MIR. And it
 // would if it were not all constants

tests/incremental/hashes/enum_constructors.rs

@@ -61,7 +61,7 @@ pub fn change_field_order_regular_struct() -> RegularStruct {
 #[cfg(not(any(cfail1,cfail4)))]
 #[rustc_clean(cfg="cfail2", except="opt_hir_owner_nodes,typeck")]
 #[rustc_clean(cfg="cfail3")]
-#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,typeck,optimized_mir")]
+#[rustc_clean(cfg="cfail5", except="opt_hir_owner_nodes,typeck")]
 #[rustc_clean(cfg="cfail6")]
 pub fn change_field_order_regular_struct() -> RegularStruct {
     RegularStruct {