Inline trivial OperatorProperties methods.

src/compiler/simplified-lowering.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/simplified-lowering.h"
 
 #include <limits>
 
 #include "src/base/bits.h"
 #include "src/code-factory.h"
@@ skipping 221 matching lines @@
          i < NodeProperties::PastControlIndex(node); ++i) {
       Enqueue(node->InputAt(i));  // Control inputs: just visit
     }
   }
 
   // The default, most general visitation case. For {node}, process all value,
   // context, effect, and control inputs, assuming that value inputs should have
   // {kRepTagged} representation and can observe all output values {kTypeAny}.
   void VisitInputs(Node* node) {
     InputIter i = node->inputs().begin();
-    for (int j = OperatorProperties::GetValueInputCount(node->op()); j > 0;
-         ++i, j--) {
+    for (int j = node->op()->ValueInputCount(); j > 0; ++i, j--) {
       ProcessInput(node, i.index(), kMachAnyTagged);  // Value inputs
     }
     for (int j = OperatorProperties::GetContextInputCount(node->op()); j > 0;
          ++i, j--) {
       ProcessInput(node, i.index(), kMachAnyTagged);  // Context inputs
     }
-    for (int j = OperatorProperties::GetEffectInputCount(node->op()); j > 0;
-         ++i, j--) {
+    for (int j = node->op()->EffectInputCount(); j > 0; ++i, j--) {
       Enqueue(*i);  // Effect inputs: just visit
     }
-    for (int j = OperatorProperties::GetControlInputCount(node->op()); j > 0;
-         ++i, j--) {
+    for (int j = node->op()->ControlInputCount(); j > 0; ++i, j--) {
       Enqueue(*i);  // Control inputs: just visit
     }
     SetOutput(node, kMachAnyTagged);
   }
 
   // Helper for binops of the I x I -> O variety.
   void VisitBinop(Node* node, MachineTypeUnion input_use,
                   MachineTypeUnion output) {
     DCHECK_EQ(2, node->InputCount());
     ProcessInput(node, 0, input_use);
@@ skipping 161 matching lines @@
     } else {
       // legal = kRepTagged;
       output = kRepTagged;
       propagate = kRepTagged;
     }
 
     MachineType output_type =
         static_cast<MachineType>(changer_->TypeFromUpperBound(upper) | output);
     SetOutput(node, output_type);
 
-    int values = OperatorProperties::GetValueInputCount(node->op());
+    int values = node->op()->ValueInputCount();
 
     if (lower()) {
       // Update the phi operator.
       MachineType type = static_cast<MachineType>(output_type);
       if (type != OpParameter<MachineType>(node)) {
         node->set_op(lowering->common()->Phi(type, values));
       }
 
       // Convert inputs to the output representation of this phi.
       Node::Inputs inputs = node->inputs();
@@ skipping 1073 matching lines @@
 
 void SimplifiedLowering::DoStringLessThanOrEqual(Node* node) {
   node->set_op(machine()->IntLessThanOrEqual());
   node->ReplaceInput(0, StringComparison(node, true));
   node->ReplaceInput(1, jsgraph()->SmiConstant(EQUAL));
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8