Inline trivial OperatorProperties methods.

src/compiler/typer.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/bootstrapper.h"
 #include "src/compiler/graph-inl.h"
 #include "src/compiler/js-operator.h"
 #include "src/compiler/node.h"
 #include "src/compiler/node-properties-inl.h"
 #include "src/compiler/node-properties.h"
@@ skipping 234 matching lines @@
 };
 
 
 class Typer::RunVisitor : public Typer::Visitor {
  public:
   explicit RunVisitor(Typer* typer)
       : Visitor(typer),
         redo(NodeSet::key_compare(), NodeSet::allocator_type(typer->zone())) {}
 
   GenericGraphVisit::Control Post(Node* node) {
-    if (OperatorProperties::HasValueOutput(node->op()) &&
-        !NodeProperties::IsTyped(node)) {
+    if (node->op()->ValueOutputCount() > 0 && !NodeProperties::IsTyped(node)) {
       Bounds bounds = TypeNode(node);
       NodeProperties::SetBounds(node, bounds);
       // Remember incompletely typed nodes for least fixpoint iteration.
       if (!NodeProperties::AllValueInputsAreTyped(node)) redo.insert(node);
     }
     return GenericGraphVisit::CONTINUE;
   }
 
   NodeSet redo;
 };
 
 
 class Typer::NarrowVisitor : public Typer::Visitor {
  public:
   explicit NarrowVisitor(Typer* typer) : Visitor(typer) {}
 
   GenericGraphVisit::Control Pre(Node* node) {
-    if (OperatorProperties::HasValueOutput(node->op())) {
+    if (node->op()->ValueOutputCount() > 0) {
       Bounds previous = NodeProperties::GetBounds(node);
       Bounds current = TypeNode(node);
       NodeProperties::SetBounds(node, Bounds::Both(current, previous, zone()));
       DCHECK(current.Narrows(previous));
       // Stop when nothing changed (but allow re-entry in case it does later).
       return previous.Narrows(current) ? GenericGraphVisit::DEFER
                                        : GenericGraphVisit::REENTER;
     } else {
       return GenericGraphVisit::SKIP;
     }
   }
 
   GenericGraphVisit::Control Post(Node* node) {
     return GenericGraphVisit::REENTER;
   }
 };
 
 
 class Typer::WidenVisitor : public Typer::Visitor {
  public:
   explicit WidenVisitor(Typer* typer) : Visitor(typer) {}
 
   GenericGraphVisit::Control Pre(Node* node) {
-    if (OperatorProperties::HasValueOutput(node->op())) {
+    if (node->op()->ValueOutputCount() > 0) {
       Bounds previous = BoundsOrNone(node);
       Bounds current = TypeNode(node);
 
       // Speed up termination in the presence of range types:
       current.upper = Weaken(current.upper, previous.upper);
       current.lower = Weaken(current.lower, previous.lower);
 
       DCHECK(previous.lower->Is(current.lower));
       DCHECK(previous.upper->Is(current.upper));
 
@@ skipping 24 matching lines @@
 }
 
 
 void Typer::Narrow(Node* start) {
   NarrowVisitor typing(this);
   graph_->VisitNodeUsesFrom(start, &typing);
 }
 
 
 void Typer::Decorator::Decorate(Node* node) {
-  if (OperatorProperties::HasValueOutput(node->op())) {
+  if (node->op()->ValueOutputCount() > 0) {
     // Only eagerly type-decorate nodes with known input types.
     // Other cases will generally require a proper fixpoint iteration with Run.
     bool is_typed = NodeProperties::IsTyped(node);
     if (is_typed || NodeProperties::AllValueInputsAreTyped(node)) {
       Visitor typing(typer_);
       Bounds bounds = typing.TypeNode(node);
       if (is_typed) {
         bounds =
           Bounds::Both(bounds, NodeProperties::GetBounds(node), typer_->zone());
       }
@@ skipping 180 matching lines @@
   return Bounds(Type::None(zone()), Type::Internal(zone()));
 }
 
 
 Bounds Typer::Visitor::TypeSelect(Node* node) {
   return Bounds::Either(Operand(node, 1), Operand(node, 2), zone());
 }
 
 
 Bounds Typer::Visitor::TypePhi(Node* node) {
-  int arity = OperatorProperties::GetValueInputCount(node->op());
+  int arity = node->op()->ValueInputCount();
   Bounds bounds = Operand(node, 0);
   for (int i = 1; i < arity; ++i) {
     bounds = Bounds::Either(bounds, Operand(node, i), zone());
   }
   return bounds;
 }
 
 
 Bounds Typer::Visitor::TypeEffectPhi(Node* node) {
   UNREACHABLE();
@@ skipping 1325 matching lines @@
         return typer_->float64_array_fun_;
       }
     }
   }
   return Type::Constant(value, zone());
 }
 
 }
 }
 }  // namespace v8::internal::compiler