Tests for ChangeLowering are target tests since they use the Linkage.

test/compiler-unittests/change-lowering-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/change-lowering.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/graph.h"
 #include "src/compiler/node-properties-inl.h"
 #include "src/compiler/simplified-operator.h"
 #include "src/factory.h"
@@ skipping 48 matching lines @@
   Graph graph_;
   CommonOperatorBuilder common_;
   SimplifiedOperatorBuilder simplified_;
 };
 
 
 typedef ::testing::Types<int32_t, int64_t> ChangeLoweringTypes;
 TYPED_TEST_CASE(ChangeLoweringTest, ChangeLoweringTypes);
 
 
-TYPED_TEST(ChangeLoweringTest, ChangeBitToBool) {
+TARGET_TYPED_TEST(ChangeLoweringTest, ChangeBitToBool) {
   Node* val = this->Parameter(0);
   Node* node =
       this->graph()->NewNode(this->simplified()->ChangeBitToBool(), val);
   Reduction reduction = this->Reduce(node);
   ASSERT_TRUE(reduction.Changed());
 
   Node* phi = reduction.replacement();
   EXPECT_THAT(phi, IsPhi(IsHeapConstant(this->true_unique()),
                          IsHeapConstant(this->false_unique()), _));
 
   Node* merge = NodeProperties::GetControlInput(phi);
   ASSERT_EQ(IrOpcode::kMerge, merge->opcode());
 
   Node* if_true = NodeProperties::GetControlInput(merge, 0);
   ASSERT_EQ(IrOpcode::kIfTrue, if_true->opcode());
 
   Node* if_false = NodeProperties::GetControlInput(merge, 1);
   ASSERT_EQ(IrOpcode::kIfFalse, if_false->opcode());
 
   Node* branch = NodeProperties::GetControlInput(if_true);
   EXPECT_EQ(branch, NodeProperties::GetControlInput(if_false));
   EXPECT_THAT(branch, IsBranch(val, this->graph()->start()));
 }
 
 
-TYPED_TEST(ChangeLoweringTest, StringAdd) {
+TARGET_TYPED_TEST(ChangeLoweringTest, StringAdd) {
   Node* node = this->graph()->NewNode(this->simplified()->StringAdd(),
                                       this->Parameter(0), this->Parameter(1));
   Reduction reduction = this->Reduce(node);
   EXPECT_FALSE(reduction.Changed());
 }
 
 
 class ChangeLowering32Test : public ChangeLoweringTest<int32_t> {
  public:
   virtual ~ChangeLowering32Test() {}
 };
 
 
-TEST_F(ChangeLowering32Test, ChangeBoolToBit) {
+TARGET_TEST_F(ChangeLowering32Test, ChangeBoolToBit) {
   Node* val = Parameter(0);
   Node* node = graph()->NewNode(simplified()->ChangeBoolToBit(), val);
   Reduction reduction = Reduce(node);
   ASSERT_TRUE(reduction.Changed());
 
   EXPECT_THAT(reduction.replacement(),
               IsWord32Equal(val, IsHeapConstant(true_unique())));
 }
 
 
-TEST_F(ChangeLowering32Test, ChangeInt32ToTagged) {
+TARGET_TEST_F(ChangeLowering32Test, ChangeInt32ToTagged) {
   Node* val = Parameter(0);
   Node* node = graph()->NewNode(simplified()->ChangeInt32ToTagged(), val);
   Reduction reduction = Reduce(node);
   ASSERT_TRUE(reduction.Changed());
 
   Node* phi = reduction.replacement();
   ASSERT_EQ(IrOpcode::kPhi, phi->opcode());
 
   Node* smi = NodeProperties::GetValueInput(phi, 1);
   ASSERT_THAT(smi, IsProjection(0, IsInt32AddWithOverflow(val, val)));
@@ skipping 17 matching lines @@
   ASSERT_EQ(IrOpcode::kIfFalse, if_false->opcode());
 
   Node* branch = NodeProperties::GetControlInput(if_true);
   EXPECT_EQ(branch, NodeProperties::GetControlInput(if_false));
   EXPECT_THAT(branch,
               IsBranch(IsProjection(1, IsInt32AddWithOverflow(val, val)),
                        graph()->start()));
 }
 
 
-TEST_F(ChangeLowering32Test, ChangeTaggedToFloat64) {
+TARGET_TEST_F(ChangeLowering32Test, ChangeTaggedToFloat64) {
   Node* val = Parameter(0);
   Node* node = graph()->NewNode(simplified()->ChangeTaggedToFloat64(), val);
   Reduction reduction = Reduce(node);
   ASSERT_TRUE(reduction.Changed());
 
   const int32_t kShiftAmount =
       kSmiTagSize + SmiTagging<kPointerSize>::kSmiShiftSize;
   const int32_t kValueOffset = HeapNumber::kValueOffset - kHeapObjectTag;
   Node* phi = reduction.replacement();
   ASSERT_THAT(
@@ skipping 19 matching lines @@
                                graph()->start()));
 }
 
 
 class ChangeLowering64Test : public ChangeLoweringTest<int64_t> {
  public:
   virtual ~ChangeLowering64Test() {}
 };
 
 
-TEST_F(ChangeLowering64Test, ChangeBoolToBit) {
+TARGET_TEST_F(ChangeLowering64Test, ChangeBoolToBit) {
   Node* val = Parameter(0);
   Node* node = graph()->NewNode(simplified()->ChangeBoolToBit(), val);
   Reduction reduction = Reduce(node);
   ASSERT_TRUE(reduction.Changed());
 
   EXPECT_THAT(reduction.replacement(),
               IsWord64Equal(val, IsHeapConstant(true_unique())));
 }
 
 
-TEST_F(ChangeLowering64Test, ChangeInt32ToTagged) {
+TARGET_TEST_F(ChangeLowering64Test, ChangeInt32ToTagged) {
   Node* val = Parameter(0);
   Node* node = graph()->NewNode(simplified()->ChangeInt32ToTagged(), val);
   Reduction reduction = Reduce(node);
   ASSERT_TRUE(reduction.Changed());
 
   const int32_t kShiftAmount =
       kSmiTagSize + SmiTagging<kPointerSize>::kSmiShiftSize;
   EXPECT_THAT(reduction.replacement(),
               IsWord64Shl(val, IsInt32Constant(kShiftAmount)));
 }
 
 
-TEST_F(ChangeLowering64Test, ChangeTaggedToFloat64) {
+TARGET_TEST_F(ChangeLowering64Test, ChangeTaggedToFloat64) {
   Node* val = Parameter(0);
   Node* node = graph()->NewNode(simplified()->ChangeTaggedToFloat64(), val);
   Reduction reduction = Reduce(node);
   ASSERT_TRUE(reduction.Changed());
 
   const int32_t kShiftAmount =
       kSmiTagSize + SmiTagging<kPointerSize>::kSmiShiftSize;
   const int32_t kValueOffset = HeapNumber::kValueOffset - kHeapObjectTag;
   Node* phi = reduction.replacement();
   ASSERT_THAT(
@@ skipping 15 matching lines @@
   EXPECT_EQ(branch, NodeProperties::GetControlInput(if_false));
   STATIC_ASSERT(kSmiTag == 0);
   STATIC_ASSERT(kSmiTagSize == 1);
   EXPECT_THAT(branch, IsBranch(IsWord64And(val, IsInt32Constant(kSmiTagMask)),
                                graph()->start()));
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8