Merge "ART: Ignore google-default-arguments tidy check"
diff --git a/compiler/optimizing/bounds_check_elimination.cc b/compiler/optimizing/bounds_check_elimination.cc
index d2357a5..7dc094b 100644
--- a/compiler/optimizing/bounds_check_elimination.cc
+++ b/compiler/optimizing/bounds_check_elimination.cc
@@ -548,7 +548,21 @@
void VisitBasicBlock(HBasicBlock* block) OVERRIDE {
DCHECK(!IsAddedBlock(block));
first_index_bounds_check_map_.clear();
- HGraphVisitor::VisitBasicBlock(block);
+ // Visit phis and instructions using a safe iterator. The iteration protects
+ // against deleting the current instruction during iteration. However, it
+ // must advance next_ if that instruction is deleted during iteration.
+ for (HInstruction* instruction = block->GetFirstPhi(); instruction != nullptr;) {
+ DCHECK(instruction->IsInBlock());
+ next_ = instruction->GetNext();
+ instruction->Accept(this);
+ instruction = next_;
+ }
+ for (HInstruction* instruction = block->GetFirstInstruction(); instruction != nullptr;) {
+ DCHECK(instruction->IsInBlock());
+ next_ = instruction->GetNext();
+ instruction->Accept(this);
+ instruction = next_;
+ }
// We should never deoptimize from an osr method, otherwise we might wrongly optimize
// code dominated by the deoptimization.
if (!GetGraph()->IsCompilingOsr()) {
@@ -1798,7 +1812,12 @@
}
/** Helper method to replace an instruction with another instruction. */
- static void ReplaceInstruction(HInstruction* instruction, HInstruction* replacement) {
+ void ReplaceInstruction(HInstruction* instruction, HInstruction* replacement) {
+ // Safe iteration.
+ if (instruction == next_) {
+ next_ = next_->GetNext();
+ }
+ // Replace and remove.
instruction->ReplaceWith(replacement);
instruction->GetBlock()->RemoveInstruction(instruction);
}
@@ -1831,6 +1850,9 @@
// Range analysis based on induction variables.
InductionVarRange induction_range_;
+ // Safe iteration.
+ HInstruction* next_;
+
DISALLOW_COPY_AND_ASSIGN(BCEVisitor);
};
diff --git a/compiler/optimizing/instruction_simplifier_arm.h b/compiler/optimizing/instruction_simplifier_arm.h
index 782110c..9b54511 100644
--- a/compiler/optimizing/instruction_simplifier_arm.h
+++ b/compiler/optimizing/instruction_simplifier_arm.h
@@ -48,7 +48,7 @@
class InstructionSimplifierArm : public HOptimization {
public:
InstructionSimplifierArm(HGraph* graph, OptimizingCompilerStats* stats)
- : HOptimization(graph, kInstructionSimplifierArmPassName, stats) {}
+ : HOptimization(graph, kInstructionSimplifierArmPassName, stats) {}
static constexpr const char* kInstructionSimplifierArmPassName = "instruction_simplifier_arm";
diff --git a/compiler/optimizing/instruction_simplifier_arm64.h b/compiler/optimizing/instruction_simplifier_arm64.h
index f71684e..d4cb1f1 100644
--- a/compiler/optimizing/instruction_simplifier_arm64.h
+++ b/compiler/optimizing/instruction_simplifier_arm64.h
@@ -82,9 +82,10 @@
class InstructionSimplifierArm64 : public HOptimization {
public:
InstructionSimplifierArm64(HGraph* graph, OptimizingCompilerStats* stats)
- : HOptimization(graph, kInstructionSimplifierArm64PassName, stats) {}
- static constexpr const char* kInstructionSimplifierArm64PassName
- = "instruction_simplifier_arm64";
+ : HOptimization(graph, kInstructionSimplifierArm64PassName, stats) {}
+
+ static constexpr const char* kInstructionSimplifierArm64PassName = "instruction_simplifier_arm64";
+
void Run() OVERRIDE {
InstructionSimplifierArm64Visitor visitor(graph_, stats_);
visitor.VisitReversePostOrder();
diff --git a/compiler/optimizing/loop_optimization.cc b/compiler/optimizing/loop_optimization.cc
index 55e1a2c..f4616e3 100644
--- a/compiler/optimizing/loop_optimization.cc
+++ b/compiler/optimizing/loop_optimization.cc
@@ -28,7 +28,7 @@
instruction->GetBlock()->RemoveInstructionOrPhi(instruction, /*ensure_safety=*/ false);
}
-// Detects a goto block and sets succ to the single successor.
+// Detect a goto block and sets succ to the single successor.
static bool IsGotoBlock(HBasicBlock* block, /*out*/ HBasicBlock** succ) {
if (block->GetPredecessors().size() == 1 &&
block->GetSuccessors().size() == 1 &&
@@ -39,6 +39,19 @@
return false;
}
+// Detect an early exit loop.
+static bool IsEarlyExit(HLoopInformation* loop_info) {
+ HBlocksInLoopReversePostOrderIterator it_loop(*loop_info);
+ for (it_loop.Advance(); !it_loop.Done(); it_loop.Advance()) {
+ for (HBasicBlock* successor : it_loop.Current()->GetSuccessors()) {
+ if (!loop_info->Contains(*successor)) {
+ return true;
+ }
+ }
+ }
+ return false;
+}
+
//
// Class methods.
//
@@ -179,7 +192,9 @@
int32_t use_count = 0;
if (IsPhiInduction(phi) &&
IsOnlyUsedAfterLoop(node->loop_info, phi, &use_count) &&
- TryReplaceWithLastValue(phi, use_count, preheader)) {
+ // No uses, or no early-exit with proper replacement.
+ (use_count == 0 ||
+ (!IsEarlyExit(node->loop_info) && TryReplaceWithLastValue(phi, preheader)))) {
for (HInstruction* i : *iset_) {
RemoveFromCycle(i);
}
@@ -277,7 +292,8 @@
if (IsEmptyHeader(header) &&
IsEmptyBody(body) &&
IsOnlyUsedAfterLoop(node->loop_info, header->GetFirstPhi(), &use_count) &&
- TryReplaceWithLastValue(header->GetFirstPhi(), use_count, preheader)) {
+ // No uses, or proper replacement.
+ (use_count == 0 || TryReplaceWithLastValue(header->GetFirstPhi(), preheader))) {
body->DisconnectAndDelete();
exit->RemovePredecessor(header);
header->RemoveSuccessor(exit);
@@ -395,20 +411,16 @@
}
}
-bool HLoopOptimization::TryReplaceWithLastValue(HInstruction* instruction,
- int32_t use_count,
- HBasicBlock* block) {
- // If true uses appear after the loop, replace these uses with the last value. Environment
- // uses can consume this value too, since any first true use is outside the loop (although
- // this may imply that de-opting may look "ahead" a bit on the phi value). If there are only
- // environment uses, the value is dropped altogether, since the computations have no effect.
- if (use_count > 0) {
- if (!induction_range_.CanGenerateLastValue(instruction)) {
- return false;
- }
+bool HLoopOptimization::TryReplaceWithLastValue(HInstruction* instruction, HBasicBlock* block) {
+ // Try to replace outside uses with the last value. Environment uses can consume this
+ // value too, since any first true use is outside the loop (although this may imply
+ // that de-opting may look "ahead" a bit on the phi value). If there are only environment
+ // uses, the value is dropped altogether, since the computations have no effect.
+ if (induction_range_.CanGenerateLastValue(instruction)) {
ReplaceAllUses(instruction, induction_range_.GenerateLastValue(instruction, graph_, block));
+ return true;
}
- return true;
+ return false;
}
} // namespace art
diff --git a/compiler/optimizing/loop_optimization.h b/compiler/optimizing/loop_optimization.h
index e18d175..3391bef 100644
--- a/compiler/optimizing/loop_optimization.h
+++ b/compiler/optimizing/loop_optimization.h
@@ -72,9 +72,7 @@
HInstruction* instruction,
/*out*/ int32_t* use_count);
void ReplaceAllUses(HInstruction* instruction, HInstruction* replacement);
- bool TryReplaceWithLastValue(HInstruction* instruction,
- int32_t use_count,
- HBasicBlock* block);
+ bool TryReplaceWithLastValue(HInstruction* instruction, HBasicBlock* block);
// Range information based on prior induction variable analysis.
InductionVarRange induction_range_;
diff --git a/runtime/intern_table.cc b/runtime/intern_table.cc
index 7b75109..d885226 100644
--- a/runtime/intern_table.cc
+++ b/runtime/intern_table.cc
@@ -199,7 +199,8 @@
{
ScopedThreadSuspension sts(self, kWaitingWeakGcRootRead);
MutexLock mu(self, *Locks::intern_table_lock_);
- while (weak_root_state_ == gc::kWeakRootStateNoReadsOrWrites) {
+ while ((!kUseReadBarrier && weak_root_state_ == gc::kWeakRootStateNoReadsOrWrites) ||
+ (kUseReadBarrier && !self->GetWeakRefAccessEnabled())) {
weak_intern_condition_.Wait(self);
}
}
diff --git a/test/562-no-intermediate/expected.txt b/test/562-checker-no-intermediate/expected.txt
similarity index 100%
rename from test/562-no-intermediate/expected.txt
rename to test/562-checker-no-intermediate/expected.txt
diff --git a/test/562-checker-no-intermediate/info.txt b/test/562-checker-no-intermediate/info.txt
new file mode 100644
index 0000000..38f1f65
--- /dev/null
+++ b/test/562-checker-no-intermediate/info.txt
@@ -0,0 +1,2 @@
+Regression test for optimizing, checking that there is no
+intermediate address live across a Java call.
diff --git a/test/562-checker-no-intermediate/src/Main.java b/test/562-checker-no-intermediate/src/Main.java
new file mode 100644
index 0000000..104ba8b
--- /dev/null
+++ b/test/562-checker-no-intermediate/src/Main.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+public class Main {
+
+ /**
+ * Check that the intermediate address computation is not reordered or merged
+ * across the call to Math.abs().
+ */
+
+ /// CHECK-START-ARM: void Main.main(java.lang.String[]) instruction_simplifier_arm (before)
+ /// CHECK-DAG: <<ConstM42:i\d+>> IntConstant -42
+ /// CHECK-DAG: <<Array:l\d+>> NullCheck
+ /// CHECK-DAG: <<Index:i\d+>> BoundsCheck
+ /// CHECK-DAG: <<ArrayGet:i\d+>> ArrayGet [<<Array>>,<<Index>>]
+ /// CHECK-DAG: <<AbsM42:i\d+>> InvokeStaticOrDirect [<<ConstM42>>] intrinsic:MathAbsInt
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<ArrayGet>>,<<AbsM42>>]
+ /// CHECK-DAG: ArraySet [<<Array>>,<<Index>>,<<Add>>]
+
+ /// CHECK-START-ARM: void Main.main(java.lang.String[]) instruction_simplifier_arm (after)
+ /// CHECK-DAG: <<ConstM42:i\d+>> IntConstant -42
+ /// CHECK-DAG: <<DataOffset:i\d+>> IntConstant
+ /// CHECK-DAG: <<Array:l\d+>> NullCheck
+ /// CHECK-DAG: <<Index:i\d+>> BoundsCheck
+ /// CHECK-DAG: <<Address1:i\d+>> IntermediateAddress [<<Array>>,<<DataOffset>>]
+ /// CHECK-DAG: <<ArrayGet:i\d+>> ArrayGet [<<Address1>>,<<Index>>]
+ /// CHECK-DAG: <<AbsM42:i\d+>> InvokeStaticOrDirect [<<ConstM42>>] intrinsic:MathAbsInt
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<ArrayGet>>,<<AbsM42>>]
+ /// CHECK-DAG: <<Address2:i\d+>> IntermediateAddress [<<Array>>,<<DataOffset>>]
+ /// CHECK-DAG: ArraySet [<<Address2>>,<<Index>>,<<Add>>]
+
+ /// CHECK-START-ARM: void Main.main(java.lang.String[]) GVN$after_arch (after)
+ /// CHECK-DAG: <<ConstM42:i\d+>> IntConstant -42
+ /// CHECK-DAG: <<DataOffset:i\d+>> IntConstant
+ /// CHECK-DAG: <<Array:l\d+>> NullCheck
+ /// CHECK-DAG: <<Index:i\d+>> BoundsCheck
+ /// CHECK-DAG: <<Address1:i\d+>> IntermediateAddress [<<Array>>,<<DataOffset>>]
+ /// CHECK-DAG: <<ArrayGet:i\d+>> ArrayGet [<<Address1>>,<<Index>>]
+ /// CHECK-DAG: <<AbsM42:i\d+>> InvokeStaticOrDirect [<<ConstM42>>] intrinsic:MathAbsInt
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<ArrayGet>>,<<AbsM42>>]
+ /// CHECK-DAG: <<Address2:i\d+>> IntermediateAddress [<<Array>>,<<DataOffset>>]
+ /// CHECK-DAG: ArraySet [<<Address2>>,<<Index>>,<<Add>>]
+
+
+ /// CHECK-START-ARM64: void Main.main(java.lang.String[]) instruction_simplifier_arm64 (before)
+ /// CHECK-DAG: <<ConstM42:i\d+>> IntConstant -42
+ /// CHECK-DAG: <<Array:l\d+>> NullCheck
+ /// CHECK-DAG: <<Index:i\d+>> BoundsCheck
+ /// CHECK-DAG: <<ArrayGet:i\d+>> ArrayGet [<<Array>>,<<Index>>]
+ /// CHECK-DAG: <<AbsM42:i\d+>> InvokeStaticOrDirect [<<ConstM42>>] intrinsic:MathAbsInt
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<ArrayGet>>,<<AbsM42>>]
+ /// CHECK-DAG: ArraySet [<<Array>>,<<Index>>,<<Add>>]
+
+ /// CHECK-START-ARM64: void Main.main(java.lang.String[]) instruction_simplifier_arm64 (after)
+ /// CHECK-DAG: <<ConstM42:i\d+>> IntConstant -42
+ /// CHECK-DAG: <<DataOffset:i\d+>> IntConstant
+ /// CHECK-DAG: <<Array:l\d+>> NullCheck
+ /// CHECK-DAG: <<Index:i\d+>> BoundsCheck
+ /// CHECK-DAG: <<Address1:i\d+>> IntermediateAddress [<<Array>>,<<DataOffset>>]
+ /// CHECK-DAG: <<ArrayGet:i\d+>> ArrayGet [<<Address1>>,<<Index>>]
+ /// CHECK-DAG: <<AbsM42:i\d+>> InvokeStaticOrDirect [<<ConstM42>>] intrinsic:MathAbsInt
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<ArrayGet>>,<<AbsM42>>]
+ /// CHECK-DAG: <<Address2:i\d+>> IntermediateAddress [<<Array>>,<<DataOffset>>]
+ /// CHECK-DAG: ArraySet [<<Address2>>,<<Index>>,<<Add>>]
+
+ /// CHECK-START-ARM64: void Main.main(java.lang.String[]) GVN$after_arch (after)
+ /// CHECK-DAG: <<ConstM42:i\d+>> IntConstant -42
+ /// CHECK-DAG: <<DataOffset:i\d+>> IntConstant
+ /// CHECK-DAG: <<Array:l\d+>> NullCheck
+ /// CHECK-DAG: <<Index:i\d+>> BoundsCheck
+ /// CHECK-DAG: <<Address1:i\d+>> IntermediateAddress [<<Array>>,<<DataOffset>>]
+ /// CHECK-DAG: <<ArrayGet:i\d+>> ArrayGet [<<Address1>>,<<Index>>]
+ /// CHECK-DAG: <<AbsM42:i\d+>> InvokeStaticOrDirect [<<ConstM42>>] intrinsic:MathAbsInt
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<ArrayGet>>,<<AbsM42>>]
+ /// CHECK-DAG: <<Address2:i\d+>> IntermediateAddress [<<Array>>,<<DataOffset>>]
+ /// CHECK-DAG: ArraySet [<<Address2>>,<<Index>>,<<Add>>]
+
+ public static void main(String[] args) {
+ array[index] += Math.abs(-42);
+ }
+
+ static int index = 0;
+ static int[] array = new int[2];
+}
diff --git a/test/562-no-intermediate/info.txt b/test/562-no-intermediate/info.txt
deleted file mode 100644
index 4f21aeb..0000000
--- a/test/562-no-intermediate/info.txt
+++ /dev/null
@@ -1,2 +0,0 @@
-Regression test for optimizing, checking that there is no
-intermediate address between a Java call.
diff --git a/test/562-no-intermediate/src/Main.java b/test/562-no-intermediate/src/Main.java
deleted file mode 100644
index 3b74d6f..0000000
--- a/test/562-no-intermediate/src/Main.java
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * Copyright (C) 2016 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-public class Main {
-
- /// CHECK-START-ARM64: int Main.main(String[]) register_allocator (after)
- /// CHECK-NOT: IntermediateAddress
- public static void main(String[] args) {
- array[index] += Math.cos(42);
- }
-
- static int index = 0;
- static double[] array = new double[2];
-}
diff --git a/test/622-checker-bce-regressions/expected.txt b/test/622-checker-bce-regressions/expected.txt
new file mode 100644
index 0000000..b0aad4d
--- /dev/null
+++ b/test/622-checker-bce-regressions/expected.txt
@@ -0,0 +1 @@
+passed
diff --git a/test/622-checker-bce-regressions/info.txt b/test/622-checker-bce-regressions/info.txt
new file mode 100644
index 0000000..a753dfa
--- /dev/null
+++ b/test/622-checker-bce-regressions/info.txt
@@ -0,0 +1 @@
+Regression tests on BCE.
diff --git a/test/622-checker-bce-regressions/src/Main.java b/test/622-checker-bce-regressions/src/Main.java
new file mode 100644
index 0000000..6ba2644
--- /dev/null
+++ b/test/622-checker-bce-regressions/src/Main.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Regression tests for BCE.
+ */
+public class Main {
+
+ static int[] array = new int[10];
+
+ /// CHECK-START: int Main.doNotVisitAfterForwardBCE(int[]) BCE (before)
+ /// CHECK-DAG: BoundsCheck loop:<<Loop:B\d+>> outer_loop:none
+ /// CHECK-DAG: BoundsCheck loop:<<Loop>> outer_loop:none
+ //
+ /// CHECK-START: int Main.doNotVisitAfterForwardBCE(int[]) BCE (after)
+ /// CHECK-NOT: BoundsCheck
+ static int doNotVisitAfterForwardBCE(int[] a) {
+ if (a == null) {
+ throw new Error("Null");
+ }
+ int k = 0;
+ int j = 0;
+ for (int i = 1; i < 10; i++) {
+ j = i - 1;
+ // b/32547652: after DCE, bounds checks become consecutive,
+ // and second should not be revisited after forward BCE.
+ k = a[i] + a[i - 1];
+ }
+ return j;
+ }
+
+ public static void main(String[] args) {
+ expectEquals(8, doNotVisitAfterForwardBCE(array));
+ System.out.println("passed");
+ }
+
+ private static void expectEquals(int expected, int result) {
+ if (expected != result) {
+ throw new Error("Expected: " + expected + ", found: " + result);
+ }
+ }
+}
diff --git a/test/623-checker-loop-regressions/expected.txt b/test/623-checker-loop-regressions/expected.txt
new file mode 100644
index 0000000..b0aad4d
--- /dev/null
+++ b/test/623-checker-loop-regressions/expected.txt
@@ -0,0 +1 @@
+passed
diff --git a/test/623-checker-loop-regressions/info.txt b/test/623-checker-loop-regressions/info.txt
new file mode 100644
index 0000000..6271600
--- /dev/null
+++ b/test/623-checker-loop-regressions/info.txt
@@ -0,0 +1 @@
+Regression tests on loop optimizations.
diff --git a/test/623-checker-loop-regressions/src/Main.java b/test/623-checker-loop-regressions/src/Main.java
new file mode 100644
index 0000000..ce5bda1
--- /dev/null
+++ b/test/623-checker-loop-regressions/src/Main.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Regression tests for loop optimizations.
+ */
+public class Main {
+
+ /// CHECK-START: int Main.earlyExitFirst(int) loop_optimization (before)
+ /// CHECK-DAG: Phi loop:<<Loop:B\d+>> outer_loop:none
+ /// CHECK-DAG: Phi loop:<<Loop>> outer_loop:none
+ //
+ /// CHECK-START: int Main.earlyExitFirst(int) loop_optimization (after)
+ /// CHECK-DAG: Phi loop:<<Loop:B\d+>> outer_loop:none
+ /// CHECK-DAG: Phi loop:<<Loop>> outer_loop:none
+ static int earlyExitFirst(int m) {
+ int k = 0;
+ for (int i = 0; i < 10; i++) {
+ if (i == m) {
+ return k;
+ }
+ k++;
+ }
+ return k;
+ }
+
+ /// CHECK-START: int Main.earlyExitLast(int) loop_optimization (before)
+ /// CHECK-DAG: Phi loop:<<Loop:B\d+>> outer_loop:none
+ /// CHECK-DAG: Phi loop:<<Loop>> outer_loop:none
+ //
+ /// CHECK-START: int Main.earlyExitLast(int) loop_optimization (after)
+ /// CHECK-DAG: Phi loop:<<Loop:B\d+>> outer_loop:none
+ /// CHECK-DAG: Phi loop:<<Loop>> outer_loop:none
+ static int earlyExitLast(int m) {
+ int k = 0;
+ for (int i = 0; i < 10; i++) {
+ k++;
+ if (i == m) {
+ return k;
+ }
+ }
+ return k;
+ }
+
+ /// CHECK-START: int Main.earlyExitNested() loop_optimization (before)
+ /// CHECK-DAG: Phi loop:<<Loop1:B\d+>> outer_loop:none
+ /// CHECK-DAG: Phi loop:<<Loop1>> outer_loop:none
+ /// CHECK-DAG: Phi loop:<<Loop2:B\d+>> outer_loop:<<Loop1>>
+ /// CHECK-DAG: Phi loop:<<Loop2>> outer_loop:<<Loop1>>
+ //
+ /// CHECK-START: int Main.earlyExitNested() loop_optimization (after)
+ /// CHECK-DAG: Phi loop:<<Loop1:B\d+>> outer_loop:none
+ /// CHECK-DAG: Phi loop:<<Loop1>> outer_loop:none
+ //
+ /// CHECK-START: int Main.earlyExitNested() loop_optimization (after)
+ /// CHECK-NOT: Phi loop:{{B\d+}} outer_loop:{{B\d+}}
+ static int earlyExitNested() {
+ int offset = 0;
+ for (int i = 0; i < 2; i++) {
+ int start = offset;
+ // This loop can be removed.
+ for (int j = 0; j < 2; j++) {
+ offset++;
+ }
+ if (i == 1) {
+ return start;
+ }
+ }
+ return 0;
+ }
+
+ public static void main(String[] args) {
+ expectEquals(10, earlyExitFirst(-1));
+ for (int i = 0; i <= 10; i++) {
+ expectEquals(i, earlyExitFirst(i));
+ }
+ expectEquals(10, earlyExitFirst(11));
+
+ expectEquals(10, earlyExitLast(-1));
+ for (int i = 0; i < 10; i++) {
+ expectEquals(i + 1, earlyExitLast(i));
+ }
+ expectEquals(10, earlyExitLast(10));
+ expectEquals(10, earlyExitLast(11));
+
+ expectEquals(2, earlyExitNested());
+
+ System.out.println("passed");
+ }
+
+ private static void expectEquals(int expected, int result) {
+ if (expected != result) {
+ throw new Error("Expected: " + expected + ", found: " + result);
+ }
+ }
+}
diff --git a/test/Android.run-test.mk b/test/Android.run-test.mk
index ae569f9..11425e1 100644
--- a/test/Android.run-test.mk
+++ b/test/Android.run-test.mk
@@ -384,7 +384,7 @@
908-gc-start-finish \
913-heaps \
961-default-iface-resolution-gen \
- 964-default-iface-init-gen \
+ 964-default-iface-init-gen
ifneq (,$(filter gcstress,$(GC_TYPES)))
ART_TEST_KNOWN_BROKEN += $(call all-run-test-names,$(TARGET_TYPES),$(RUN_TYPES),$(PREBUILD_TYPES), \
@@ -610,9 +610,12 @@
# more parallel moves on x86, thus some Checker assertions may fail.
# 527: On ARM64 and ARM, the read barrier instrumentation does not support the HIntermediateAddress
# instruction yet (b/26601270).
+# 562: On ARM64 and ARM, the read barrier instrumentation does not support the HIntermediateAddress
+# instruction yet (b/26601270).
TEST_ART_BROKEN_OPTIMIZING_READ_BARRIER_RUN_TESTS := \
484-checker-register-hints \
- 527-checker-array-access-split
+ 527-checker-array-access-split \
+ 562-checker-no-intermediate
# Tests that should fail in the read barrier configuration with JIT (Optimizing compiler).
TEST_ART_BROKEN_JIT_READ_BARRIER_RUN_TESTS :=