Auto merge of #104999 - saethlin:immediate-abort-inlining, r=thomcc

[rust.git] / compiler / rustc_mir_transform / src / dataflow_const_prop.rs

diff --git a/compiler/rustc_mir_transform/src/dataflow_const_prop.rs b/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
index 001b83ccda236ff1b287d3fe172f126431c4f648..e9027387413cfe1e97425a7992e74e33384fbfb3 100644 (file)
--- a/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
+++ b/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
@@ -7,14 +7,14 @@
 use rustc_middle::mir::visit::{MutVisitor, Visitor};
 use rustc_middle::mir::*;
 use rustc_middle::ty::{self, Ty, TyCtxt};
-use rustc_mir_dataflow::value_analysis::{
-    Map, State, TrackElem, ValueAnalysis, ValueOrPlace, ValueOrPlaceOrRef,
-};
+use rustc_mir_dataflow::value_analysis::{Map, State, TrackElem, ValueAnalysis, ValueOrPlace};
 use rustc_mir_dataflow::{lattice::FlatSet, Analysis, ResultsVisitor, SwitchIntEdgeEffects};
 use rustc_span::DUMMY_SP;
 
 use crate::MirPass;
 
+// These constants are somewhat random guesses and have not been optimized.
+// If `tcx.sess.mir_opt_level() >= 4`, we ignore the limits (this can become very expensive).
 const BLOCK_LIMIT: usize = 100;
 const PLACE_LIMIT: usize = 100;
 
@@ -22,12 +22,12 @@
 
 impl<'tcx> MirPass<'tcx> for DataflowConstProp {
     fn is_enabled(&self, sess: &rustc_session::Session) -> bool {
-        sess.mir_opt_level() >= 1
+        sess.mir_opt_level() >= 3
     }
 
     #[instrument(skip_all level = "debug")]
     fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
-        if body.basic_blocks.len() > BLOCK_LIMIT {
+        if tcx.sess.mir_opt_level() < 4 && body.basic_blocks.len() > BLOCK_LIMIT {
             debug!("aborted dataflow const prop due too many basic blocks");
             return;
         }
@@ -43,7 +43,7 @@ fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
         // `O(num_nodes * tracked_places * n)` in terms of time complexity. Since the number of
         // map nodes is strongly correlated to the number of tracked places, this becomes more or
         // less `O(n)` if we place a constant limit on the number of tracked places.
-        if map.tracked_places() > PLACE_LIMIT {
+        if tcx.sess.mir_opt_level() < 4 && map.tracked_places() > PLACE_LIMIT {
             debug!("aborted dataflow const prop due to too many tracked places");
             return;
         }
@@ -100,14 +100,14 @@ fn handle_assign(
                     let (val, overflow) = self.binary_op(state, *op, left, right);
 
                     if let Some(value_target) = value_target {
-                        state.assign_idx(value_target, ValueOrPlaceOrRef::Value(val), self.map());
+                        state.assign_idx(value_target, ValueOrPlace::Value(val), self.map());
                     }
                     if let Some(overflow_target) = overflow_target {
                         let overflow = match overflow {
                             FlatSet::Top => FlatSet::Top,
                             FlatSet::Elem(overflow) => {
                                 if overflow {
-                                    // Overflow cannot be reliable propagated. See: https://github.com/rust-lang/rust/pull/101168#issuecomment-1288091446
+                                    // Overflow cannot be reliably propagated. See: https://github.com/rust-lang/rust/pull/101168#issuecomment-1288091446
                                     FlatSet::Top
                                 } else {
                                     self.wrap_scalar(Scalar::from_bool(false), self.tcx.types.bool)
@@ -117,7 +117,7 @@ fn handle_assign(
                         };
                         state.assign_idx(
                             overflow_target,
-                            ValueOrPlaceOrRef::Value(overflow),
+                            ValueOrPlace::Value(overflow),
                             self.map(),
                         );
                     }
@@ -131,7 +131,7 @@ fn handle_rvalue(
         &self,
         rvalue: &Rvalue<'tcx>,
         state: &mut State<Self::Value>,
-    ) -> ValueOrPlaceOrRef<Self::Value> {
+    ) -> ValueOrPlace<Self::Value> {
         match rvalue {
             Rvalue::Cast(
                 kind @ (CastKind::IntToInt
@@ -150,23 +150,23 @@ fn handle_rvalue(
                     }
                     _ => unreachable!(),
                 }
-                .map(|result| ValueOrPlaceOrRef::Value(self.wrap_immediate(result, *ty)))
-                .unwrap_or(ValueOrPlaceOrRef::top()),
-                _ => ValueOrPlaceOrRef::top(),
+                .map(|result| ValueOrPlace::Value(self.wrap_immediate(result, *ty)))
+                .unwrap_or(ValueOrPlace::top()),
+                _ => ValueOrPlace::top(),
             },
             Rvalue::BinaryOp(op, box (left, right)) => {
                 // Overflows must be ignored here.
                 let (val, _overflow) = self.binary_op(state, *op, left, right);
-                ValueOrPlaceOrRef::Value(val)
+                ValueOrPlace::Value(val)
             }
             Rvalue::UnaryOp(op, operand) => match self.eval_operand(operand, state) {
                 FlatSet::Elem(value) => self
                     .ecx
                     .unary_op(*op, &value)
-                    .map(|val| ValueOrPlaceOrRef::Value(self.wrap_immty(val)))
-                    .unwrap_or(ValueOrPlaceOrRef::Value(FlatSet::Top)),
-                FlatSet::Bottom => ValueOrPlaceOrRef::Value(FlatSet::Bottom),
-                FlatSet::Top => ValueOrPlaceOrRef::Value(FlatSet::Top),
+                    .map(|val| ValueOrPlace::Value(self.wrap_immty(val)))
+                    .unwrap_or(ValueOrPlace::Value(FlatSet::Top)),
+                FlatSet::Bottom => ValueOrPlace::Value(FlatSet::Bottom),
+                FlatSet::Top => ValueOrPlace::Value(FlatSet::Top),
             },
             _ => self.super_rvalue(rvalue, state),
         }
@@ -318,7 +318,7 @@ struct CollectAndPatch<'tcx, 'map> {
 
     /// For a given MIR location, this stores the values of the operands used by that location. In
     /// particular, this is before the effect, such that the operands of `_1 = _1 + _2` are
-    /// properly captured.
+    /// properly captured. (This may become UB soon, but it is currently emitted even by safe code.)
     before_effect: FxHashMap<(Location, Place<'tcx>), ScalarTy<'tcx>>,
 
     /// Stores the assigned values for assignments where the Rvalue is constant.