From 771e5cc519665ce0cc76985bb4803f0dd50c3b40 Mon Sep 17 00:00:00 2001
From: David Brazdil <dbrazdil@google.com>
Date: Thu, 29 Oct 2015 22:47:39 +0000
Subject: [PATCH] Revert "ART: Enable more passes under try/catch"

BCE does not set TryCatchInformation when creating new blocks.
Will be fixed with DynamicBCE CL.

This reverts commit 39fabd6bb6fcf7a712b370d3b6fd0ada83e2e5d8.

Change-Id: I76ae707ac132bb1a4a9f64f4916ffcd786ef730c
---
 compiler/optimizing/licm.cc                |  3 --
 compiler/optimizing/nodes.cc               |  8 -----
 compiler/optimizing/optimizing_compiler.cc | 56 ++++++++++++++++++------------
 3 files changed, 34 insertions(+), 33 deletions(-)

diff --git a/compiler/optimizing/licm.cc b/compiler/optimizing/licm.cc
index 27442d487..c38bbe347 100644
--- a/compiler/optimizing/licm.cc
+++ b/compiler/optimizing/licm.cc
@@ -122,9 +122,6 @@ void LICM::Run() {
           if (instruction->NeedsEnvironment()) {
             UpdateLoopPhisIn(instruction->GetEnvironment(), loop_info);
           }
-          // Move instruction into the pre header. Note that this cannot move
-          // a throwing instruction out of its try block since these are hoisted
-          // only from the header block (and TryBoundary would start a new block).
           instruction->MoveBefore(pre_header->GetLastInstruction());
         } else if (instruction->CanThrow()) {
           // If `instruction` can throw, we cannot move further instructions
diff --git a/compiler/optimizing/nodes.cc b/compiler/optimizing/nodes.cc
index 4345d55e9..348026551 100644
--- a/compiler/optimizing/nodes.cc
+++ b/compiler/optimizing/nodes.cc
@@ -1129,14 +1129,6 @@ std::ostream& operator<<(std::ostream& os, const HInstruction::InstructionKind&
 }
 
 void HInstruction::MoveBefore(HInstruction* cursor) {
-  if (kIsDebugBuild && CanThrowIntoCatchBlock()) {
-    // Make sure we are not moving a throwing instruction out of its try block.
-    DCHECK(cursor->GetBlock()->IsTryBlock());
-    const HTryBoundary& current_try = block_->GetTryCatchInformation()->GetTryEntry();
-    const HTryBoundary& cursor_try = cursor->GetBlock()->GetTryCatchInformation()->GetTryEntry();
-    DCHECK(cursor_try.HasSameExceptionHandlersAs(current_try));
-  }
-
   next_->previous_ = previous_;
   if (previous_ != nullptr) {
     previous_->next_ = next_;
diff --git a/compiler/optimizing/optimizing_compiler.cc b/compiler/optimizing/optimizing_compiler.cc
index 98acc3437..6632f95eb 100644
--- a/compiler/optimizing/optimizing_compiler.cc
+++ b/compiler/optimizing/optimizing_compiler.cc
@@ -494,30 +494,42 @@ static void RunOptimizations(HGraph* graph,
 
   // TODO: Update passes incompatible with try/catch so we have the same
   //       pipeline for all methods.
-  if (!graph->HasTryCatch()) {
+  if (graph->HasTryCatch()) {
+    HOptimization* optimizations2[] = {
+      side_effects,
+      gvn,
+      dce2,
+      // The codegen has a few assumptions that only the instruction simplifier
+      // can satisfy. For example, the code generator does not expect to see a
+      // HTypeConversion from a type to the same type.
+      simplify4,
+    };
+
+    RunOptimizations(optimizations2, arraysize(optimizations2), pass_observer);
+  } else {
     MaybeRunInliner(graph, codegen, driver, stats, dex_compilation_unit, pass_observer, handles);
-  }
 
-  HOptimization* optimizations2[] = {
-    // BooleanSimplifier depends on the InstructionSimplifier removing
-    // redundant suspend checks to recognize empty blocks.
-    boolean_simplify,
-    fold2,  // TODO: if we don't inline we can also skip fold2.
-    side_effects,
-    gvn,
-    licm,
-    induction,
-    bce,
-    simplify3,
-    lse,
-    dce2,
-    // The codegen has a few assumptions that only the instruction simplifier
-    // can satisfy. For example, the code generator does not expect to see a
-    // HTypeConversion from a type to the same type.
-    simplify4,
-  };
-
-  RunOptimizations(optimizations2, arraysize(optimizations2), pass_observer);
+    HOptimization* optimizations2[] = {
+      // BooleanSimplifier depends on the InstructionSimplifier removing
+      // redundant suspend checks to recognize empty blocks.
+      boolean_simplify,
+      fold2,  // TODO: if we don't inline we can also skip fold2.
+      side_effects,
+      gvn,
+      licm,
+      induction,
+      bce,
+      simplify3,
+      lse,
+      dce2,
+      // The codegen has a few assumptions that only the instruction simplifier
+      // can satisfy. For example, the code generator does not expect to see a
+      // HTypeConversion from a type to the same type.
+      simplify4,
+    };
+
+    RunOptimizations(optimizations2, arraysize(optimizations2), pass_observer);
+  }
 
   RunArchOptimizations(driver->GetInstructionSet(), graph, stats, pass_observer);
 }
-- 
2.11.0