[turbofan] Fix corner case in loop analysis.

src/compiler/loop-analysis.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/compiler/loop-analysis.h"
 
 #include "src/compiler/graph.h"
 #include "src/compiler/node.h"
 #include "src/compiler/node-marker.h"
 #include "src/compiler/node-properties-inl.h"
@@ skipping 134 matching lines @@
   // Propagate marks backward from loop headers.
   void PropagateBackward() {
     PropagateBackward(end_, kVisited);
 
     while (!queue_.empty()) {
       Node* node = queue_.front();
       queue_.pop_front();
       queued_.Set(node, false);
 
       // Setup loop headers first.
+      NodeInfo& ni = info(node);
       if (node->opcode() == IrOpcode::kLoop) {
         // found the loop node first.
-        CreateLoopInfo(node);
+        CreateLoopInfo(node, ni);
       } else if (node->opcode() == IrOpcode::kPhi ||
                  node->opcode() == IrOpcode::kEffectPhi) {
         // found a phi first.
         Node* merge = node->InputAt(node->InputCount() - 1);
-        if (merge->opcode() == IrOpcode::kLoop) CreateLoopInfo(merge);
+        if (merge->opcode() == IrOpcode::kLoop) {
+          NodeInfo& mi = info(merge);
+          CreateLoopInfo(merge, mi);
+          ni.MarkBackward(mi.loop_mark);
+        }
       }
 
       // Propagate reachability marks backwards from this node.
-      NodeInfo& ni = info(node);
       if (ni.IsLoopHeader()) {
         // Handle edges from loop header nodes specially.
         for (int i = 0; i < node->InputCount(); i++) {
           if (i == kAssumedLoopEntryIndex) {
             // Don't propagate the loop mark backwards on the entry edge.
             PropagateBackward(node->InputAt(0),
                               kVisited | (ni.backward & ~ni.loop_mark));
           } else {
             // Only propagate the loop mark on backedges.
             PropagateBackward(node->InputAt(i), ni.loop_mark);
           }
         }
       } else {
         // Propagate all loop marks backwards for a normal node.
         for (Node* const input : node->inputs()) {
           PropagateBackward(input, ni.backward);
         }
       }
     }
   }
 
   // Make a new loop header for the given node.
-  void CreateLoopInfo(Node* node) {
-    NodeInfo& ni = info(node);
+  void CreateLoopInfo(Node* node, NodeInfo& ni) {
     if (ni.IsLoopHeader()) return;  // loop already set up.
 
     loops_found_++;
     size_t loop_num = loops_.size() + 1;
     CHECK(loops_found_ <= kMaxLoops);  // TODO(titzer): don't crash.
     // Create a new loop.
     loops_.push_back({node, nullptr, nullptr, nullptr});
     loop_tree_->NewLoop();
     LoopMarks loop_mark = kVisited | (1 << loop_num);
-    ni.node = node;
     ni.loop_mark = loop_mark;
 
     // Setup loop mark for phis attached to loop header.
     for (Node* use : node->uses()) {
       if (use->opcode() == IrOpcode::kPhi ||
           use->opcode() == IrOpcode::kEffectPhi) {
         info(use).loop_mark = loop_mark;
       }
     }
   }
@@ skipping 193 matching lines @@
   finder.Run();
   if (FLAG_trace_turbo_graph) {
     finder.Print();
   }
   return loop_tree;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8