[interpreter] Use VisitForTest for loop conditions

src/compiler/bytecode-loop-analysis.cc

Index: src/compiler/bytecode-loop-analysis.cc
diff --git a/src/compiler/bytecode-loop-analysis.cc b/src/compiler/bytecode-loop-analysis.cc
index 76b90f882ef44543cec21bd16f39de62f8dca6a8..0a353ac443f18eb9d8988d455be17943838ec0a2 100644
--- a/src/compiler/bytecode-loop-analysis.cc
+++ b/src/compiler/bytecode-loop-analysis.cc
@@ -37,18 +37,32 @@ void BytecodeLoopAnalysis::Analyze() {
 }
 
 void BytecodeLoopAnalysis::AddLoopEntry(int entry_offset) {
+  if (found_current_backedge_) {
+    // We assume that all backedges of a loop must occur together and before
+    // another loop entry or an outer loop backedge.

[Jarin, 2016/08/18 12:49:50]

Could you explain how you guard against the assumption being violated? (I have
convinced myself the DCHECK on line 60 somehow does the job, but it would be
good to have a coherent argument here.)

[klaasb, 2016/08/18 13:38:01]

The combination of the DCHECKs on 58, 60 and 63 does it.
When we encounter a backedge, we are either still searching and finding
backedges of the current loop (63), or we need to have found at least one back
edge to the current loop (58) and thus the backedge must target the parent loop
(60), which also guarantees that we found the (first) backedge of the parent.

Assuming there could be a backedge out of order with a backedge to the parent
loop, then 63 would fail, as target_offset > current_loop_offset_.

After setting the current_loop_offset_ at loop entry, we can only encounter a
backedge to the current loop (63) or parent loop (60) and 58 checks that if it
goes to the parent loop, we actually ended the current loop.

Only in the case of a sibling loop do we enter the branch here and then
resetting found_current_backedge to false guarantees failure for invalid
backedges at 58/63. I moved line 48 to the branch to have it at the actually
relevant place.

I've also expanded this comment to summarize the argument above.

+    // Thus here, the current loop actually ended before.
+    current_loop_offset_ = loop_header_to_parent_[current_loop_offset_];
+  }
   loop_header_to_parent_[entry_offset] = current_loop_offset_;
   current_loop_offset_ = entry_offset;
+  found_current_backedge_ = false;
 }
 
 void BytecodeLoopAnalysis::AddBranch(int origin_offset, int target_offset) {
-  // If this is a backedge, record it and update the current loop to the parent.
+  // If this is a backedge, record it.
   if (target_offset < origin_offset) {
     backedge_to_header_[origin_offset] = target_offset;
-    // Check that we are finishing the current loop. This assumes that
-    // there is one backedge for each loop.
-    DCHECK_EQ(target_offset, current_loop_offset_);
-    current_loop_offset_ = loop_header_to_parent_[target_offset];
+    // Check whether this is actually a backedge of the outer loop and we have
+    // already finished the current loop.
+    if (target_offset < current_loop_offset_) {
+      DCHECK(found_current_backedge_);
+      int parent_offset = loop_header_to_parent_[current_loop_offset_];
+      DCHECK_EQ(target_offset, parent_offset);
+      current_loop_offset_ = parent_offset;
+    } else {
+      DCHECK_EQ(target_offset, current_loop_offset_);
+      found_current_backedge_ = true;
+    }
   }
 }