src/v8/src/compiler/simplified-operator-unittest.cc

   1 // Copyright 2014 the V8 project authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "src/compiler/simplified-operator.h"
   6
   7 #include "src/compiler/operator-properties-inl.h"
   8 #include "src/test/test-utils.h"
   9
  10 namespace v8 {
  11 namespace internal {
  12 namespace compiler {
  13
  14 // TODO(bmeurer): Drop once we use std::ostream instead of our OStream.
  15 inline std::ostream& operator<<(std::ostream& os, const ElementAccess& access) {
  16   OStringStream ost;
  17   ost << access;
  18   return os << ost.c_str();
  19 }
  20
  21
  22 // -----------------------------------------------------------------------------
  23 // Pure operators.
  24
  25
  26 namespace {
  27
  28 struct PureOperator {
  29   const Operator* (SimplifiedOperatorBuilder::*constructor)();
  30   IrOpcode::Value opcode;
  31   Operator::Properties properties;
  32   int value_input_count;
  33 };
  34
  35
  36 std::ostream& operator<<(std::ostream& os, const PureOperator& pop) {
  37   return os << IrOpcode::Mnemonic(pop.opcode);
  38 }
  39
  40
  41 const PureOperator kPureOperators[] = {
  42 #define PURE(Name, properties, input_count)              \
  43   {                                                      \
  44     &SimplifiedOperatorBuilder::Name, IrOpcode::k##Name, \
  45         Operator::kPure | properties, input_count        \
  46   }
  47     PURE(BooleanNot, Operator::kNoProperties, 1),
  48     PURE(NumberEqual, Operator::kCommutative, 2),
  49     PURE(NumberLessThan, Operator::kNoProperties, 2),
  50     PURE(NumberLessThanOrEqual, Operator::kNoProperties, 2),
  51     PURE(NumberAdd, Operator::kCommutative, 2),
  52     PURE(NumberSubtract, Operator::kNoProperties, 2),
  53     PURE(NumberMultiply, Operator::kCommutative, 2),
  54     PURE(NumberDivide, Operator::kNoProperties, 2),
  55     PURE(NumberModulus, Operator::kNoProperties, 2),
  56     PURE(NumberToInt32, Operator::kNoProperties, 1),
  57     PURE(NumberToUint32, Operator::kNoProperties, 1),
  58     PURE(StringEqual, Operator::kCommutative, 2),
  59     PURE(StringLessThan, Operator::kNoProperties, 2),
  60     PURE(StringLessThanOrEqual, Operator::kNoProperties, 2),
  61     PURE(StringAdd, Operator::kNoProperties, 2),
  62     PURE(ChangeTaggedToInt32, Operator::kNoProperties, 1),
  63     PURE(ChangeTaggedToUint32, Operator::kNoProperties, 1),
  64     PURE(ChangeTaggedToFloat64, Operator::kNoProperties, 1),
  65     PURE(ChangeInt32ToTagged, Operator::kNoProperties, 1),
  66     PURE(ChangeUint32ToTagged, Operator::kNoProperties, 1),
  67     PURE(ChangeFloat64ToTagged, Operator::kNoProperties, 1),
  68     PURE(ChangeBoolToBit, Operator::kNoProperties, 1),
  69     PURE(ChangeBitToBool, Operator::kNoProperties, 1)
  70 #undef PURE
  71 };
  72
  73 }  // namespace
  74
  75
  76 class SimplifiedPureOperatorTest
  77     : public TestWithZone,
  78       public ::testing::WithParamInterface<PureOperator> {};
  79
  80
  81 TEST_P(SimplifiedPureOperatorTest, InstancesAreGloballyShared) {
  82   const PureOperator& pop = GetParam();
  83   SimplifiedOperatorBuilder simplified1(zone());
  84   SimplifiedOperatorBuilder simplified2(zone());
  85   EXPECT_EQ((simplified1.*pop.constructor)(), (simplified2.*pop.constructor)());
  86 }
  87
  88
  89 TEST_P(SimplifiedPureOperatorTest, NumberOfInputsAndOutputs) {
  90   SimplifiedOperatorBuilder simplified(zone());
  91   const PureOperator& pop = GetParam();
  92   const Operator* op = (simplified.*pop.constructor)();
  93
  94   EXPECT_EQ(pop.value_input_count, OperatorProperties::GetValueInputCount(op));
  95   EXPECT_EQ(0, OperatorProperties::GetEffectInputCount(op));
  96   EXPECT_EQ(0, OperatorProperties::GetControlInputCount(op));
  97   EXPECT_EQ(pop.value_input_count, OperatorProperties::GetTotalInputCount(op));
  98
  99   EXPECT_EQ(1, OperatorProperties::GetValueOutputCount(op));
 100   EXPECT_EQ(0, OperatorProperties::GetEffectOutputCount(op));
 101   EXPECT_EQ(0, OperatorProperties::GetControlOutputCount(op));
 102 }
 103
 104
 105 TEST_P(SimplifiedPureOperatorTest, OpcodeIsCorrect) {
 106   SimplifiedOperatorBuilder simplified(zone());
 107   const PureOperator& pop = GetParam();
 108   const Operator* op = (simplified.*pop.constructor)();
 109   EXPECT_EQ(pop.opcode, op->opcode());
 110 }
 111
 112
 113 TEST_P(SimplifiedPureOperatorTest, Properties) {
 114   SimplifiedOperatorBuilder simplified(zone());
 115   const PureOperator& pop = GetParam();
 116   const Operator* op = (simplified.*pop.constructor)();
 117   EXPECT_EQ(pop.properties, op->properties() & pop.properties);
 118 }
 119
 120 INSTANTIATE_TEST_CASE_P(SimplifiedOperatorTest, SimplifiedPureOperatorTest,
 121                         ::testing::ValuesIn(kPureOperators));
 122
 123
 124 // -----------------------------------------------------------------------------
 125 // Element access operators.
 126
 127 namespace {
 128
 129 const ElementAccess kElementAccesses[] = {
 130     {kTaggedBase, FixedArray::kHeaderSize, Type::Any(), kMachAnyTagged},
 131     {kUntaggedBase, kNonHeapObjectHeaderSize - kHeapObjectTag, Type::Any(),
 132      kMachInt8},
 133     {kUntaggedBase, kNonHeapObjectHeaderSize - kHeapObjectTag, Type::Any(),
 134      kMachInt16},
 135     {kUntaggedBase, kNonHeapObjectHeaderSize - kHeapObjectTag, Type::Any(),
 136      kMachInt32},
 137     {kUntaggedBase, kNonHeapObjectHeaderSize - kHeapObjectTag, Type::Any(),
 138      kMachUint8},
 139     {kUntaggedBase, kNonHeapObjectHeaderSize - kHeapObjectTag, Type::Any(),
 140      kMachUint16},
 141     {kUntaggedBase, kNonHeapObjectHeaderSize - kHeapObjectTag, Type::Any(),
 142      kMachUint32},
 143     {kUntaggedBase, 0, Type::Signed32(), kMachInt8},
 144     {kUntaggedBase, 0, Type::Unsigned32(), kMachUint8},
 145     {kUntaggedBase, 0, Type::Signed32(), kMachInt16},
 146     {kUntaggedBase, 0, Type::Unsigned32(), kMachUint16},
 147     {kUntaggedBase, 0, Type::Signed32(), kMachInt32},
 148     {kUntaggedBase, 0, Type::Unsigned32(), kMachUint32},
 149     {kUntaggedBase, 0, Type::Number(), kRepFloat32},
 150     {kUntaggedBase, 0, Type::Number(), kRepFloat64},
 151     {kTaggedBase, FixedTypedArrayBase::kDataOffset, Type::Signed32(),
 152      kMachInt8},
 153     {kTaggedBase, FixedTypedArrayBase::kDataOffset, Type::Unsigned32(),
 154      kMachUint8},
 155     {kTaggedBase, FixedTypedArrayBase::kDataOffset, Type::Signed32(),
 156      kMachInt16},
 157     {kTaggedBase, FixedTypedArrayBase::kDataOffset, Type::Unsigned32(),
 158      kMachUint16},
 159     {kTaggedBase, FixedTypedArrayBase::kDataOffset, Type::Signed32(),
 160      kMachInt32},
 161     {kTaggedBase, FixedTypedArrayBase::kDataOffset, Type::Unsigned32(),
 162      kMachUint32},
 163     {kTaggedBase, FixedTypedArrayBase::kDataOffset, Type::Number(),
 164      kRepFloat32},
 165     {kTaggedBase, FixedTypedArrayBase::kDataOffset, Type::Number(),
 166      kRepFloat64}};
 167
 168 }  // namespace
 169
 170
 171 class SimplifiedElementAccessOperatorTest
 172     : public TestWithZone,
 173       public ::testing::WithParamInterface<ElementAccess> {};
 174
 175
 176 TEST_P(SimplifiedElementAccessOperatorTest, LoadElement) {
 177   SimplifiedOperatorBuilder simplified(zone());
 178   const ElementAccess& access = GetParam();
 179   const Operator* op = simplified.LoadElement(access);
 180
 181   EXPECT_EQ(IrOpcode::kLoadElement, op->opcode());
 182   EXPECT_EQ(Operator::kNoThrow | Operator::kNoWrite, op->properties());
 183   EXPECT_EQ(access, ElementAccessOf(op));
 184
 185   EXPECT_EQ(3, OperatorProperties::GetValueInputCount(op));
 186   EXPECT_EQ(1, OperatorProperties::GetEffectInputCount(op));
 187   EXPECT_EQ(0, OperatorProperties::GetControlInputCount(op));
 188   EXPECT_EQ(4, OperatorProperties::GetTotalInputCount(op));
 189
 190   EXPECT_EQ(1, OperatorProperties::GetValueOutputCount(op));
 191   EXPECT_EQ(1, OperatorProperties::GetEffectOutputCount(op));
 192   EXPECT_EQ(0, OperatorProperties::GetControlOutputCount(op));
 193 }
 194
 195
 196 TEST_P(SimplifiedElementAccessOperatorTest, StoreElement) {
 197   SimplifiedOperatorBuilder simplified(zone());
 198   const ElementAccess& access = GetParam();
 199   const Operator* op = simplified.StoreElement(access);
 200
 201   EXPECT_EQ(IrOpcode::kStoreElement, op->opcode());
 202   EXPECT_EQ(Operator::kNoRead | Operator::kNoThrow, op->properties());
 203   EXPECT_EQ(access, ElementAccessOf(op));
 204
 205   EXPECT_EQ(4, OperatorProperties::GetValueInputCount(op));
 206   EXPECT_EQ(1, OperatorProperties::GetEffectInputCount(op));
 207   EXPECT_EQ(1, OperatorProperties::GetControlInputCount(op));
 208   EXPECT_EQ(6, OperatorProperties::GetTotalInputCount(op));
 209
 210   EXPECT_EQ(0, OperatorProperties::GetValueOutputCount(op));
 211   EXPECT_EQ(1, OperatorProperties::GetEffectOutputCount(op));
 212   EXPECT_EQ(0, OperatorProperties::GetControlOutputCount(op));
 213 }
 214
 215
 216 INSTANTIATE_TEST_CASE_P(SimplifiedOperatorTest,
 217                         SimplifiedElementAccessOperatorTest,
 218                         ::testing::ValuesIn(kElementAccesses));
 219
 220 }  // namespace compiler
 221 }  // namespace internal
 222 }  // namespace v8