[turbofan] Cleanup the NodeProperties.

src/compiler/loop-analysis.cc

 // 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/compiler/node-properties.h"
 #include "src/zone.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 #define OFFSET(x) ((x)&0x1f)
 #define BIT(x) (1u << OFFSET(x))
 #define INDEX(x) ((x) >> 5)
 
@@ skipping 168 matching lines @@
       Node* node = queue_.front();
       info(node);
       queue_.pop_front();
       queued_.Set(node, false);
 
       int loop_num = -1;
       // Setup loop headers first.
       if (node->opcode() == IrOpcode::kLoop) {
         // found the loop node first.
         loop_num = CreateLoopInfo(node);
-      } else if (IrOpcode::IsPhiOpcode(node->opcode())) {
+      } else if (NodeProperties::IsPhi(node)) {
         // found a phi first.
         Node* merge = node->InputAt(node->InputCount() - 1);
         if (merge->opcode() == IrOpcode::kLoop) {
           loop_num = CreateLoopInfo(merge);
         }
       }
 
       // Propagate marks backwards from this node.
       for (int i = 0; i < node->InputCount(); i++) {
         Node* input = node->InputAt(i);
@@ skipping 17 matching lines @@
     if (INDEX(loop_num) >= width_) ResizeBackwardMarks();
 
     // Create a new loop.
     loops_.push_back({node, nullptr, nullptr, nullptr});
     loop_tree_->NewLoop();
     SetBackwardMark(node, loop_num);
     loop_tree_->node_to_loop_num_[node->id()] = loop_num;
 
     // Setup loop mark for phis attached to loop header.
     for (Node* use : node->uses()) {
-      if (IrOpcode::IsPhiOpcode(use->opcode())) {
+      if (NodeProperties::IsPhi(use)) {
         SetBackwardMark(use, loop_num);
         loop_tree_->node_to_loop_num_[use->id()] = loop_num;
       }
     }
 
     return loop_num;
   }
 
   void ResizeBackwardMarks() {
     int new_width = width_ + 1;
@@ skipping 34 matching lines @@
         if (!IsBackedge(use, edge)) {
           if (PropagateForwardMarks(node, use)) Queue(use);
         }
       }
     }
   }
 
   bool IsBackedge(Node* use, Edge& edge) {
     if (LoopNum(use) <= 0) return false;
     if (edge.index() == kAssumedLoopEntryIndex) return false;
-    if (IrOpcode::IsPhiOpcode(use->opcode())) {
+    if (NodeProperties::IsPhi(use)) {
       return !NodeProperties::IsControlEdge(edge);
     }
     return true;
   }
 
   int LoopNum(Node* node) { return loop_tree_->node_to_loop_num_[node->id()]; }
 
   NodeInfo& info(Node* node) {
     NodeInfo& i = info_[node->id()];
     if (i.node == nullptr) i.node = node;
@@ skipping 154 matching lines @@
   finder.Run();
   if (FLAG_trace_turbo_graph) {
     finder.Print();
   }
   return loop_tree;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8