Inline trivial OperatorProperties methods.

src/compiler/js-inlining.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/ast.h"
 #include "src/ast-numbering.h"
 #include "src/compiler/access-builder.h"
 #include "src/compiler/ast-graph-builder.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/generic-node-inl.h"
@@ skipping 101 matching lines @@
 void Inlinee::UnifyReturn(JSGraph* jsgraph) {
   Graph* graph = jsgraph->graph();
 
   Node* final_merge = NodeProperties::GetControlInput(graph->end(), 0);
   if (final_merge->opcode() == IrOpcode::kReturn) {
     // nothing to do
     return;
   }
   DCHECK_EQ(IrOpcode::kMerge, final_merge->opcode());
 
-  int predecessors =
-      OperatorProperties::GetControlInputCount(final_merge->op());
+  int predecessors = final_merge->op()->ControlInputCount();
 
   const Operator* op_phi = jsgraph->common()->Phi(kMachAnyTagged, predecessors);
   const Operator* op_ephi = jsgraph->common()->EffectPhi(predecessors);
 
   NodeVector values(jsgraph->zone());
   NodeVector effects(jsgraph->zone());
   // Iterate over all control flow predecessors,
   // which must be return statements.
   InputIter iter = final_merge->inputs().begin();
   while (iter != final_merge->inputs().end()) {
@@ skipping 104 matching lines @@
   SimplifiedOperatorBuilder simplified(jsgraph->zone());
   Node* context = jsgraph->graph()->NewNode(
       simplified.LoadField(AccessBuilder::ForJSFunctionContext()),
       NodeProperties::GetValueInput(call, 0),
       NodeProperties::GetEffectInput(call), control);
 
   // Context is last argument.
   int inlinee_context_index = static_cast<int>(total_parameters()) - 1;
   // {inliner_inputs} counts JSFunction, Receiver, arguments, but not
   // context, effect, control.
-  int inliner_inputs = OperatorProperties::GetValueInputCount(call->op());
+  int inliner_inputs = call->op()->ValueInputCount();
   // Iterate over all uses of the start node.
   UseIter iter = start_->uses().begin();
   while (iter != start_->uses().end()) {
     Node* use = *iter;
     switch (use->opcode()) {
       case IrOpcode::kParameter: {
         int index = 1 + OpParameter<int>(use->op());
         if (index < inliner_inputs && index < inlinee_context_index) {
           // There is an input from the call, and the index is a value
           // projection but not the context, so rewire the input.
@@ skipping 42 matching lines @@
 
   Node* receiver() { return call_->InputAt(1); }
 
   Node* formal_argument(size_t index) {
     DCHECK(index < formal_arguments());
     return call_->InputAt(static_cast<int>(2 + index));
   }
 
   size_t formal_arguments() {
     // {value_inputs} includes jsfunction and receiver.
-    size_t value_inputs = OperatorProperties::GetValueInputCount(call_->op());
+    size_t value_inputs = call_->op()->ValueInputCount();
     DCHECK_GE(call_->InputCount(), 2);
     return value_inputs - 2;
   }
 
   Node* frame_state() { return NodeProperties::GetFrameStateInput(call_); }
 
  private:
   Node* call_;
 };
 
@@ skipping 112 matching lines @@
   explicit JSCallRuntimeAccessor(Node* call) : call_(call) {
     DCHECK_EQ(IrOpcode::kJSCallRuntime, call->opcode());
   }
 
   Node* formal_argument(size_t index) {
     DCHECK(index < formal_arguments());
     return call_->InputAt(static_cast<int>(index));
   }
 
   size_t formal_arguments() {
-    size_t value_inputs = OperatorProperties::GetValueInputCount(call_->op());
+    size_t value_inputs = call_->op()->ValueInputCount();
     return value_inputs;
   }
 
   Node* frame_state() const {
     return NodeProperties::GetFrameStateInput(call_);
   }
   Node* context() const { return NodeProperties::GetContextInput(call_); }
   Node* control() const { return NodeProperties::GetControlInput(call_); }
   Node* effect() const { return NodeProperties::GetEffectInput(call_); }
 
@@ skipping 34 matching lines @@
              info_->shared_info()->DebugName()->ToCString().get());
     }
     NodeProperties::ReplaceWithValue(call_node, r.first, r.second);
     call_node->RemoveAllInputs();
     DCHECK_EQ(0, call_node->UseCount());
   }
 }
 }
 }
 }  // namespace v8::internal::compiler