Revert "Restrict the use of ConstantFolding's VisitIf"

This reverts commit 5eb1fd0dae3832ceee2102613bb08c291daca6f3.

Reason for revert: In aosp/2903248 we implemented a faster way of
doing `ReplaceUsesDominatedBy` which is used by `VisitIf`. The impact
of `VisitIf` is now small enough that running VisitIf in all passes
is faster that the previous implementation running some of the time.

This CLs re-enables the optimization in all constant folding passes
because:
A) Lets this optimization (and others that can use the result) kick in
   earlier
B) Run it for callee graphs in the inliner (which has been disabled as
   of CL aosp/2543831)
C) Consistency of the ConstantFolding pass, which helps to have a
   simpler mental model

Bug: 278626992
Test: art/test/testrunner/testrunner.py --host --64 --optimizing -b
Test: Locally compiled GMS and compared time to compile
Change-Id: I5dc5f591557c8de0bc4d23dbfd0b91b5b7e56ab5

6 files changed, 7 insertions, 33 deletions

diff --git a/compiler/optimizing/constant_folding.cc b/compiler/optimizing/constant_folding.cc
index 66bbf548bb..64ef17898a 100644
--- a/compiler/optimizing/constant_folding.cc
+++ b/compiler/optimizing/constant_folding.cc
@@ -32,8 +32,8 @@ namespace art HIDDEN {
 // as constants.
 class HConstantFoldingVisitor final : public HGraphDelegateVisitor {
  public:
-  HConstantFoldingVisitor(HGraph* graph, OptimizingCompilerStats* stats, bool use_all_optimizations)
-      : HGraphDelegateVisitor(graph, stats), use_all_optimizations_(use_all_optimizations) {}
+  explicit HConstantFoldingVisitor(HGraph* graph, OptimizingCompilerStats* stats)
+      : HGraphDelegateVisitor(graph, stats) {}
 
  private:
   void VisitBasicBlock(HBasicBlock* block) override;
@@ -66,9 +66,6 @@ class HConstantFoldingVisitor final : public HGraphDelegateVisitor {
   void FoldNumberOfLeadingZerosIntrinsic(HInvoke* invoke);
   void FoldNumberOfTrailingZerosIntrinsic(HInvoke* invoke);
 
-  // Use all optimizations without restrictions.
-  bool use_all_optimizations_;
-
   DISALLOW_COPY_AND_ASSIGN(HConstantFoldingVisitor);
 };
 
@@ -109,7 +106,7 @@ class InstructionWithAbsorbingInputSimplifier : public HGraphVisitor {
 
 
 bool HConstantFolding::Run() {
-  HConstantFoldingVisitor visitor(graph_, stats_, use_all_optimizations_);
+  HConstantFoldingVisitor visitor(graph_, stats_);
   // Process basic blocks in reverse post-order in the dominator tree,
   // so that an instruction turned into a constant, used as input of
   // another instruction, may possibly be used to turn that second
@@ -232,11 +229,6 @@ void HConstantFoldingVisitor::PropagateValue(HBasicBlock* starting_block,
     uses_before = variable->GetUses().SizeSlow();
   }
 
-  if (variable->GetUses().HasExactlyOneElement()) {
-    // Nothing to do, since we only have the `if (variable)` use or the `condition` use.
-    return;
-  }
-
   variable->ReplaceUsesDominatedBy(
       starting_block->GetFirstInstruction(), constant, /* strictly_dominated= */ false);
 
@@ -249,12 +241,6 @@ void HConstantFoldingVisitor::PropagateValue(HBasicBlock* starting_block,
 }
 
 void HConstantFoldingVisitor::VisitIf(HIf* inst) {
-  // This optimization can take a lot of compile time since we have a lot of If instructions in
-  // graphs.
-  if (!use_all_optimizations_) {
-    return;
-  }
-
   // Consistency check: the true and false successors do not dominate each other.
   DCHECK(!inst->IfTrueSuccessor()->Dominates(inst->IfFalseSuccessor()) &&
          !inst->IfFalseSuccessor()->Dominates(inst->IfTrueSuccessor()));
diff --git a/compiler/optimizing/constant_folding.h b/compiler/optimizing/constant_folding.h
index 29648e907c..73ac3ceb81 100644
--- a/compiler/optimizing/constant_folding.h
+++ b/compiler/optimizing/constant_folding.h
@@ -43,18 +43,14 @@ class HConstantFolding : public HOptimization {
  public:
   HConstantFolding(HGraph* graph,
                    OptimizingCompilerStats* stats = nullptr,
-                   const char* name = kConstantFoldingPassName,
-                   bool use_all_optimizations = false)
-      : HOptimization(graph, name, stats), use_all_optimizations_(use_all_optimizations) {}
+                   const char* name = kConstantFoldingPassName)
+      : HOptimization(graph, name, stats) {}
 
   bool Run() override;
 
   static constexpr const char* kConstantFoldingPassName = "constant_folding";
 
  private:
-  // Use all optimizations without restrictions.
-  bool use_all_optimizations_;
-
   DISALLOW_COPY_AND_ASSIGN(HConstantFolding);
 };
 
diff --git a/compiler/optimizing/constant_folding_test.cc b/compiler/optimizing/constant_folding_test.cc
index acdc8e6d3c..689d77111c 100644
--- a/compiler/optimizing/constant_folding_test.cc
+++ b/compiler/optimizing/constant_folding_test.cc
@@ -60,9 +60,7 @@ class ConstantFoldingTest : public CommonCompilerTest, public OptimizingUnitTest
     std::string actual_before = printer_before.str();
     EXPECT_EQ(expected_before, actual_before);
 
-    HConstantFolding constant_folding(
-        graph_, /* stats= */ nullptr, "constant_folding", /* use_all_optimizations= */ true);
-    constant_folding.Run();
+    HConstantFolding(graph_, /* stats= */ nullptr, "constant_folding").Run();
     GraphChecker graph_checker_cf(graph_);
     graph_checker_cf.Run();
     ASSERT_TRUE(graph_checker_cf.IsValid());
diff --git a/compiler/optimizing/optimization.cc b/compiler/optimizing/optimization.cc
index 16045d447c..9c1506afa5 100644
--- a/compiler/optimizing/optimization.cc
+++ b/compiler/optimizing/optimization.cc
@@ -80,7 +80,6 @@ const char* OptimizationPassName(OptimizationPass pass) {
       return BoundsCheckElimination::kBoundsCheckEliminationPassName;
     case OptimizationPass::kLoadStoreElimination:
       return LoadStoreElimination::kLoadStoreEliminationPassName;
-    case OptimizationPass::kAggressiveConstantFolding:
     case OptimizationPass::kConstantFolding:
       return HConstantFolding::kConstantFoldingPassName;
     case OptimizationPass::kDeadCodeElimination:
@@ -238,10 +237,6 @@ ArenaVector<HOptimization*> ConstructOptimizations(
       case OptimizationPass::kConstantFolding:
         opt = new (allocator) HConstantFolding(graph, stats, pass_name);
         break;
-      case OptimizationPass::kAggressiveConstantFolding:
-        opt = new (allocator)
-            HConstantFolding(graph, stats, pass_name, /* use_all_optimizations_ = */ true);
-        break;
       case OptimizationPass::kDeadCodeElimination:
         opt = new (allocator) HDeadCodeElimination(graph, stats, pass_name);
         break;
diff --git a/compiler/optimizing/optimization.h b/compiler/optimizing/optimization.h
index 57c5f4639c..55aa8f914b 100644
--- a/compiler/optimizing/optimization.h
+++ b/compiler/optimizing/optimization.h
@@ -67,7 +67,6 @@ class HOptimization : public ArenaObject<kArenaAllocOptimization> {
 // field is preferred over a string lookup at places where performance matters.
 // TODO: generate this table and lookup methods below automatically?
 enum class OptimizationPass {
-  kAggressiveConstantFolding,
   kAggressiveInstructionSimplifier,
   kBoundsCheckElimination,
   kCHAGuardOptimization,
diff --git a/compiler/optimizing/optimizing_compiler.cc b/compiler/optimizing/optimizing_compiler.cc
index d458462226..8909a59ddf 100644
--- a/compiler/optimizing/optimizing_compiler.cc
+++ b/compiler/optimizing/optimizing_compiler.cc
@@ -666,7 +666,7 @@ void OptimizingCompiler::RunOptimizations(HGraph* graph,
       OptDef(OptimizationPass::kGlobalValueNumbering),
       // Simplification (TODO: only if GVN occurred).
       OptDef(OptimizationPass::kSelectGenerator),
-      OptDef(OptimizationPass::kAggressiveConstantFolding,
+      OptDef(OptimizationPass::kConstantFolding,
              "constant_folding$after_gvn"),
       OptDef(OptimizationPass::kInstructionSimplifier,
              "instruction_simplifier$after_gvn"),