[turbofan] Cleanup the NodeProperties.

src/compiler/control-reducer.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/common-operator.h"
 #include "src/compiler/control-reducer.h"
 #include "src/compiler/graph.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/node-marker.h"
 #include "src/compiler/node-matchers.h"
-#include "src/compiler/node-properties-inl.h"
+#include "src/compiler/node-properties.h"
 #include "src/zone-containers.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 enum VisitState { kUnvisited = 0, kOnStack = 1, kRevisit = 2, kVisited = 3 };
 enum Decision { kFalse, kUnknown, kTrue };
 
 class ReachabilityMarker : public NodeMarker<uint8_t> {
@@ skipping 104 matching lines @@
           AddBackwardsReachableNodes(marked, nodes, nodes.size() - 1);
 
           // Reset the use iterators for the entire stack.
           for (size_t i = 0; i < fw_stack.size(); i++) {
             FwIter& iter = fw_stack[i];
             fw_stack[i] = FwIter(iter.first, iter.first->uses().begin());
           }
           pop = false;  // restart traversing successors of this node.
           break;
         }
-        if (IrOpcode::IsControlOpcode(succ->opcode()) &&
+        if (NodeProperties::IsControl(succ) &&
             !marked.IsReachableFromStart(succ)) {
           // {succ} is a control node and not yet reached from start.
           marked.Push(succ);
           marked.SetReachableFromStart(succ);
           fw_stack.push_back(FwIter(succ, succ->uses().begin()));
           pop = false;  // "recurse" into successor control node.
           break;
         }
         ++fw_stack.back().second;
       }
       if (pop) {
         marked.Pop(node);
         fw_stack.pop_back();
       }
     }
 
     // Trim references from dead nodes to live nodes first.
     jsgraph_->GetCachedNodes(&nodes);
     TrimNodes(marked, nodes);
 
     // Any control nodes not reachable from start are dead, even loops.
     for (size_t i = 0; i < nodes.size(); i++) {
       Node* node = nodes[i];
-      if (IrOpcode::IsControlOpcode(node->opcode()) &&
+      if (NodeProperties::IsControl(node) &&
           !marked.IsReachableFromStart(node)) {
         ReplaceNode(node, dead());  // uses will be added to revisit queue.
       }
     }
     return TryRevisit();  // try to push a node onto the stack.
   }
 
   // Connect {loop}, the header of a non-terminating loop, to the end node.
   Node* ConnectNTL(Node* loop) {
     TRACE(("ConnectNTL: #%d:%s\n", loop->id(), loop->op()->mnemonic()));
@@ skipping 324 matching lines @@
     if (live > 1 && live == node->InputCount()) return node;  // nothing to do.
 
     TRACE(("ReduceMerge: #%d:%s (%d live)\n", node->id(),
            node->op()->mnemonic(), live));
 
     if (live == 0) return dead();  // no remaining inputs.
 
     // Gather phis and effect phis to be edited.
     ZoneVector<Node*> phis(zone_);
     for (Node* const use : node->uses()) {
-      if (IrOpcode::IsPhiOpcode(use->opcode())) phis.push_back(use);
+      if (NodeProperties::IsPhi(use)) phis.push_back(use);
     }
 
     if (live == 1) {
       // All phis are redundant. Replace them with their live input.
       for (Node* const phi : phis) ReplaceNode(phi, phi->InputAt(live_index));
       // The merge itself is redundant.
       return node->InputAt(live_index);
     }
 
     // Edit phis in place, removing dead inputs and revisiting them.
@@ skipping 118 matching lines @@
       return impl.ReduceIfTrue(node);
     case IrOpcode::kIfFalse:
       return impl.ReduceIfFalse(node);
     default:
       return node;
   }
 }
 }
 }
 }  // namespace v8::internal::compiler