Inline trivial OperatorProperties methods.

test/unittests/compiler/common-operator-unittest.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 <limits>
 
 #include "src/compiler/operator-properties-inl.h"
 #include "test/unittests/test-utils.h"
@@ skipping 57 matching lines @@
   CommonOperatorBuilder common2(zone());
   EXPECT_EQ((common1.*sop.constructor)(), (common2.*sop.constructor)());
 }
 
 
 TEST_P(CommonSharedOperatorTest, NumberOfInputsAndOutputs) {
   CommonOperatorBuilder common(zone());
   const SharedOperator& sop = GetParam();
   const Operator* op = (common.*sop.constructor)();
 
-  EXPECT_EQ(sop.value_input_count, OperatorProperties::GetValueInputCount(op));
-  EXPECT_EQ(sop.effect_input_count,
-            OperatorProperties::GetEffectInputCount(op));
-  EXPECT_EQ(sop.control_input_count,
-            OperatorProperties::GetControlInputCount(op));
+  EXPECT_EQ(sop.value_input_count, op->ValueInputCount());
+  EXPECT_EQ(sop.effect_input_count, op->EffectInputCount());
+  EXPECT_EQ(sop.control_input_count, op->ControlInputCount());
   EXPECT_EQ(
       sop.value_input_count + sop.effect_input_count + sop.control_input_count,
       OperatorProperties::GetTotalInputCount(op));
 
-  EXPECT_EQ(0, OperatorProperties::GetValueOutputCount(op));
-  EXPECT_EQ(sop.effect_output_count,
-            OperatorProperties::GetEffectOutputCount(op));
-  EXPECT_EQ(sop.control_output_count,
-            OperatorProperties::GetControlOutputCount(op));
+  EXPECT_EQ(0, op->ValueOutputCount());
+  EXPECT_EQ(sop.effect_output_count, op->EffectOutputCount());
+  EXPECT_EQ(sop.control_output_count, op->ControlOutputCount());
 }
 
 
 TEST_P(CommonSharedOperatorTest, OpcodeIsCorrect) {
   CommonOperatorBuilder common(zone());
   const SharedOperator& sop = GetParam();
   const Operator* op = (common.*sop.constructor)();
   EXPECT_EQ(sop.opcode, op->opcode());
 }
 
@@ skipping 60 matching lines @@
 
 }  // namespace
 
 
 TEST_F(CommonOperatorTest, Branch) {
   TRACED_FOREACH(BranchHint, hint, kHints) {
     const Operator* const op = common()->Branch(hint);
     EXPECT_EQ(IrOpcode::kBranch, op->opcode());
     EXPECT_EQ(Operator::kFoldable, op->properties());
     EXPECT_EQ(hint, BranchHintOf(op));
-    EXPECT_EQ(1, OperatorProperties::GetValueInputCount(op));
-    EXPECT_EQ(0, OperatorProperties::GetEffectInputCount(op));
-    EXPECT_EQ(1, OperatorProperties::GetControlInputCount(op));
+    EXPECT_EQ(1, op->ValueInputCount());
+    EXPECT_EQ(0, op->EffectInputCount());
+    EXPECT_EQ(1, op->ControlInputCount());
     EXPECT_EQ(2, OperatorProperties::GetTotalInputCount(op));
-    EXPECT_EQ(0, OperatorProperties::GetValueOutputCount(op));
-    EXPECT_EQ(0, OperatorProperties::GetEffectOutputCount(op));
-    EXPECT_EQ(2, OperatorProperties::GetControlOutputCount(op));
+    EXPECT_EQ(0, op->ValueOutputCount());
+    EXPECT_EQ(0, op->EffectOutputCount());
+    EXPECT_EQ(2, op->ControlOutputCount());
   }
 }
 
 
 TEST_F(CommonOperatorTest, Select) {
   static const MachineType kTypes[] = {
       kMachInt8,    kMachUint8,   kMachInt16,    kMachUint16,
       kMachInt32,   kMachUint32,  kMachInt64,    kMachUint64,
       kMachFloat32, kMachFloat64, kMachAnyTagged};
   TRACED_FOREACH(MachineType, type, kTypes) {
     TRACED_FOREACH(BranchHint, hint, kHints) {
       const Operator* const op = common()->Select(type, hint);
       EXPECT_EQ(IrOpcode::kSelect, op->opcode());
       EXPECT_EQ(Operator::kPure, op->properties());
       EXPECT_EQ(type, SelectParametersOf(op).type());
       EXPECT_EQ(hint, SelectParametersOf(op).hint());
-      EXPECT_EQ(3, OperatorProperties::GetValueInputCount(op));
-      EXPECT_EQ(0, OperatorProperties::GetEffectInputCount(op));
-      EXPECT_EQ(0, OperatorProperties::GetControlInputCount(op));
+      EXPECT_EQ(3, op->ValueInputCount());
+      EXPECT_EQ(0, op->EffectInputCount());
+      EXPECT_EQ(0, op->ControlInputCount());
       EXPECT_EQ(3, OperatorProperties::GetTotalInputCount(op));
-      EXPECT_EQ(1, OperatorProperties::GetValueOutputCount(op));
-      EXPECT_EQ(0, OperatorProperties::GetEffectOutputCount(op));
-      EXPECT_EQ(0, OperatorProperties::GetControlOutputCount(op));
+      EXPECT_EQ(1, op->ValueOutputCount());
+      EXPECT_EQ(0, op->EffectOutputCount());
+      EXPECT_EQ(0, op->ControlOutputCount());
     }
   }
 }
 
 
 TEST_F(CommonOperatorTest, Float32Constant) {
   TRACED_FOREACH(float, value, kFloatValues) {
     const Operator* op = common()->Float32Constant(value);
     EXPECT_PRED2(base::bit_equal_to<float>(), value, OpParameter<float>(op));
-    EXPECT_EQ(0, OperatorProperties::GetValueInputCount(op));
+    EXPECT_EQ(0, op->ValueInputCount());
     EXPECT_EQ(0, OperatorProperties::GetTotalInputCount(op));
-    EXPECT_EQ(0, OperatorProperties::GetControlOutputCount(op));
-    EXPECT_EQ(0, OperatorProperties::GetEffectOutputCount(op));
-    EXPECT_EQ(1, OperatorProperties::GetValueOutputCount(op));
+    EXPECT_EQ(0, op->ControlOutputCount());
+    EXPECT_EQ(0, op->EffectOutputCount());
+    EXPECT_EQ(1, op->ValueOutputCount());
   }
   TRACED_FOREACH(float, v1, kFloatValues) {
     TRACED_FOREACH(float, v2, kFloatValues) {
       const Operator* op1 = common()->Float32Constant(v1);
       const Operator* op2 = common()->Float32Constant(v2);
       EXPECT_EQ(bit_cast<uint32_t>(v1) == bit_cast<uint32_t>(v2),
                 op1->Equals(op2));
     }
   }
 }
 
 
 TEST_F(CommonOperatorTest, Float64Constant) {
   TRACED_FOREACH(double, value, kFloatValues) {
     const Operator* op = common()->Float64Constant(value);
     EXPECT_PRED2(base::bit_equal_to<double>(), value, OpParameter<double>(op));
-    EXPECT_EQ(0, OperatorProperties::GetValueInputCount(op));
+    EXPECT_EQ(0, op->ValueInputCount());
     EXPECT_EQ(0, OperatorProperties::GetTotalInputCount(op));
-    EXPECT_EQ(0, OperatorProperties::GetControlOutputCount(op));
-    EXPECT_EQ(0, OperatorProperties::GetEffectOutputCount(op));
-    EXPECT_EQ(1, OperatorProperties::GetValueOutputCount(op));
+    EXPECT_EQ(0, op->ControlOutputCount());
+    EXPECT_EQ(0, op->EffectOutputCount());
+    EXPECT_EQ(1, op->ValueOutputCount());
   }
   TRACED_FOREACH(double, v1, kFloatValues) {
     TRACED_FOREACH(double, v2, kFloatValues) {
       const Operator* op1 = common()->Float64Constant(v1);
       const Operator* op2 = common()->Float64Constant(v2);
       EXPECT_EQ(bit_cast<uint64_t>(v1) == bit_cast<uint64_t>(v2),
                 op1->Equals(op2));
     }
   }
 }
 
 
 TEST_F(CommonOperatorTest, NumberConstant) {
   TRACED_FOREACH(double, value, kFloatValues) {
     const Operator* op = common()->NumberConstant(value);
     EXPECT_PRED2(base::bit_equal_to<double>(), value, OpParameter<double>(op));
-    EXPECT_EQ(0, OperatorProperties::GetValueInputCount(op));
+    EXPECT_EQ(0, op->ValueInputCount());
     EXPECT_EQ(0, OperatorProperties::GetTotalInputCount(op));
-    EXPECT_EQ(0, OperatorProperties::GetControlOutputCount(op));
-    EXPECT_EQ(0, OperatorProperties::GetEffectOutputCount(op));
-    EXPECT_EQ(1, OperatorProperties::GetValueOutputCount(op));
+    EXPECT_EQ(0, op->ControlOutputCount());
+    EXPECT_EQ(0, op->EffectOutputCount());
+    EXPECT_EQ(1, op->ValueOutputCount());
   }
   TRACED_FOREACH(double, v1, kFloatValues) {
     TRACED_FOREACH(double, v2, kFloatValues) {
       const Operator* op1 = common()->NumberConstant(v1);
       const Operator* op2 = common()->NumberConstant(v2);
       EXPECT_EQ(bit_cast<uint64_t>(v1) == bit_cast<uint64_t>(v2),
                 op1->Equals(op2));
     }
   }
 }
 
 
 TEST_F(CommonOperatorTest, ValueEffect) {
   TRACED_FOREACH(int, arguments, kArguments) {
     const Operator* op = common()->ValueEffect(arguments);
-    EXPECT_EQ(arguments, OperatorProperties::GetValueInputCount(op));
+    EXPECT_EQ(arguments, op->ValueInputCount());
     EXPECT_EQ(arguments, OperatorProperties::GetTotalInputCount(op));
-    EXPECT_EQ(0, OperatorProperties::GetControlOutputCount(op));
-    EXPECT_EQ(1, OperatorProperties::GetEffectOutputCount(op));
-    EXPECT_EQ(0, OperatorProperties::GetValueOutputCount(op));
+    EXPECT_EQ(0, op->ControlOutputCount());
+    EXPECT_EQ(1, op->EffectOutputCount());
+    EXPECT_EQ(0, op->ValueOutputCount());
   }
 }
 
 
 TEST_F(CommonOperatorTest, Finish) {
   TRACED_FOREACH(int, arguments, kArguments) {
     const Operator* op = common()->Finish(arguments);
-    EXPECT_EQ(1, OperatorProperties::GetValueInputCount(op));
-    EXPECT_EQ(arguments, OperatorProperties::GetEffectInputCount(op));
+    EXPECT_EQ(1, op->ValueInputCount());
+    EXPECT_EQ(arguments, op->EffectInputCount());
     EXPECT_EQ(arguments + 1, OperatorProperties::GetTotalInputCount(op));
-    EXPECT_EQ(0, OperatorProperties::GetControlOutputCount(op));
-    EXPECT_EQ(0, OperatorProperties::GetEffectOutputCount(op));
-    EXPECT_EQ(1, OperatorProperties::GetValueOutputCount(op));
+    EXPECT_EQ(0, op->ControlOutputCount());
+    EXPECT_EQ(0, op->EffectOutputCount());
+    EXPECT_EQ(1, op->ValueOutputCount());
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8