[turbofan] First version of loop peeling.

src/compiler/loop-analysis.cc

-// Copyright 2013 the V8 project authors. All rights reserved.
+// Copyright 2014 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"
 #include "src/zone.h"
@@ skipping 137 matching lines @@
     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, ni);
-      } else if (node->opcode() == IrOpcode::kPhi ||
-                 node->opcode() == IrOpcode::kEffectPhi) {
+      } else if (IrOpcode::IsPhiOpcode(node->opcode())) {
         // found a phi first.
         Node* merge = node->InputAt(node->InputCount() - 1);
         if (merge->opcode() == IrOpcode::kLoop) {
           NodeInfo& mi = info(merge);
           CreateLoopInfo(merge, mi);
           ni.MarkBackward(mi.loop_mark);
         }
       }
 
       // Propagate reachability marks backwards from this node.
@@ skipping 26 matching lines @@
     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.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) {
+      if (IrOpcode::IsPhiOpcode(use->opcode())) {
         info(use).loop_mark = loop_mark;
       }
     }
   }
 
   // Propagate marks forward from loops.
   void PropagateForward() {
     for (LoopInfo& li : loops_) {
       queued_.Set(li.header, true);
       queue_.push_back(li.header);
@@ skipping 16 matching lines @@
           queue_.push_back(use);
         }
       }
     }
   }
 
   bool IsBackedge(Node* use, NodeInfo& ui, Edge& edge) {
     // TODO(titzer): checking for backedges here is ugly.
     if (!ui.IsLoopHeader()) return false;
     if (edge.index() == kAssumedLoopEntryIndex) return false;
-    if (use->opcode() == IrOpcode::kPhi ||
-        use->opcode() == IrOpcode::kEffectPhi) {
+    if (IrOpcode::IsPhiOpcode(use->opcode())) {
       return !NodeProperties::IsControlEdge(edge);
     }
     return true;
   }
 
   NodeInfo& info(Node* node) {
     NodeInfo& i = info_[node->id()];
     if (i.node == nullptr) i.node = node;
     return i;
   }
@@ skipping 149 matching lines @@
   finder.Run();
   if (FLAG_trace_turbo_graph) {
     finder.Print();
   }
   return loop_tree;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8