[turbofan] Support lowering of ChangeFloat64ToTagged/ChangeTaggedToInt32.

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/js-graph.h"
 #include "src/compiler/node-properties-inl.h"
 #include "src/compiler/simplified-operator.h"
 #include "src/compiler/typer.h"
 #include "test/compiler-unittests/graph-unittest.h"
@@ skipping 67 matching lines @@
   Capture<Node*> branch;
   EXPECT_THAT(
       phi, IsPhi(IsHeapConstant(this->true_unique()),
                  IsHeapConstant(this->false_unique()),
                  IsMerge(IsIfTrue(AllOf(CaptureEq(&branch),
                                         IsBranch(val, this->graph()->start()))),
                          IsIfFalse(CaptureEq(&branch)))));
 }
 
 
+TARGET_TYPED_TEST(ChangeLoweringTest, ChangeFloat64ToTagged) {
+  Node* val = this->Parameter(0);
+  Node* node =
+      this->graph()->NewNode(this->simplified()->ChangeFloat64ToTagged(), val);
+  Reduction reduction = this->Reduce(node);
+  ASSERT_TRUE(reduction.Changed());
+
+  Node* finish = reduction.replacement();
+  Capture<Node*> heap_number;
+  const int32_t kValueOffset = this->kHeapNumberValueOffset - kHeapObjectTag;
+  EXPECT_THAT(
+      finish,
+      IsFinish(AllOf(CaptureEq(&heap_number),
+                     this->IsAllocateHeapNumber(IsValueEffect(val),
+                                                this->graph()->start())),
+               IsStore(kMachFloat64, kNoWriteBarrier, CaptureEq(&heap_number),
+                       IsInt32Constant(kValueOffset), val,
+                       CaptureEq(&heap_number), this->graph()->start())));
+}
+
+
 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:
@@ skipping 16 matching lines @@
   Node* val = Parameter(0);
   Node* node = graph()->NewNode(simplified()->ChangeInt32ToTagged(), val);
   Reduction reduction = Reduce(node);
   ASSERT_TRUE(reduction.Changed());
 
   Node* phi = reduction.replacement();
   Capture<Node*> add, branch, heap_number, if_true;
   const int32_t kValueOffset = kHeapNumberValueOffset - kHeapObjectTag;
   EXPECT_THAT(
       phi,
-      IsPhi(
-          IsFinish(
-              AllOf(
-                  CaptureEq(&heap_number),
-                  IsCall(
-                      _, IsHeapConstant(
-                             PrintableUnique<HeapObject>::CreateImmovable(
-                                 zone(), CEntryStub(isolate(), 1).GetCode())),
-                      IsExternalConstant(ExternalReference(
-                          Runtime::FunctionForId(Runtime::kAllocateHeapNumber),
-                          isolate())),
-                      IsInt32Constant(0), IsNumberConstant(0.0),
-                      graph()->start(), CaptureEq(&if_true))),
-              IsStore(kMachFloat64, kNoWriteBarrier, CaptureEq(&heap_number),
-                      IsInt32Constant(kValueOffset),
-                      IsChangeInt32ToFloat64(val), CaptureEq(&heap_number),
-                      CaptureEq(&if_true))),
-          IsProjection(
-              0, AllOf(CaptureEq(&add), IsInt32AddWithOverflow(val, val))),
-          IsMerge(AllOf(CaptureEq(&if_true), IsIfTrue(CaptureEq(&branch))),
-                  IsIfFalse(AllOf(CaptureEq(&branch),
-                                  IsBranch(IsProjection(1, CaptureEq(&add)),
-                                           graph()->start()))))));
+      IsPhi(IsFinish(
+                AllOf(CaptureEq(&heap_number),
+                      IsAllocateHeapNumber(_, CaptureEq(&if_true))),
+                IsStore(kMachFloat64, kNoWriteBarrier, CaptureEq(&heap_number),
+                        IsInt32Constant(kValueOffset),
+                        IsChangeInt32ToFloat64(val), CaptureEq(&heap_number),
+                        CaptureEq(&if_true))),
+            IsProjection(
+                0, AllOf(CaptureEq(&add), IsInt32AddWithOverflow(val, val))),
+            IsMerge(AllOf(CaptureEq(&if_true), IsIfTrue(CaptureEq(&branch))),
+                    IsIfFalse(AllOf(CaptureEq(&branch),
+                                    IsBranch(IsProjection(1, CaptureEq(&add)),
+                                             graph()->start()))))));
 }
 
 
 TARGET_TEST_F(ChangeLowering32Test, ChangeTaggedToFloat64) {
   STATIC_ASSERT(kSmiTag == 0);
   STATIC_ASSERT(kSmiTagSize == 1);
 
   Node* val = Parameter(0);
   Node* node = graph()->NewNode(simplified()->ChangeTaggedToFloat64(), val);
   Reduction reduction = Reduce(node);
@@ skipping 14 matching lines @@
           IsMerge(
               AllOf(CaptureEq(&if_true),
                     IsIfTrue(AllOf(
                         CaptureEq(&branch),
                         IsBranch(IsWord32And(val, IsInt32Constant(kSmiTagMask)),
                                  graph()->start())))),
               IsIfFalse(CaptureEq(&branch)))));
 }
 
 
+TARGET_TEST_F(ChangeLowering32Test, ChangeTaggedToInt32) {
+  STATIC_ASSERT(kSmiTag == 0);
+  STATIC_ASSERT(kSmiTagSize == 1);
+
+  Node* val = Parameter(0);
+  Node* node = graph()->NewNode(simplified()->ChangeTaggedToInt32(), val);
+  Reduction reduction = Reduce(node);
+  ASSERT_TRUE(reduction.Changed());
+
+  const int32_t kShiftAmount =
+      kSmiTagSize + SmiTagging<kPointerSize>::kSmiShiftSize;
+  const int32_t kValueOffset = kHeapNumberValueOffset - kHeapObjectTag;
+  Node* phi = reduction.replacement();
+  Capture<Node*> branch, if_true;
+  EXPECT_THAT(
+      phi,
+      IsPhi(IsChangeFloat64ToInt32(
+                IsLoad(kMachFloat64, val, IsInt32Constant(kValueOffset),
+                       IsControlEffect(CaptureEq(&if_true)))),
+            IsWord32Sar(val, IsInt32Constant(kShiftAmount)),
+            IsMerge(AllOf(CaptureEq(&if_true), IsIfTrue(CaptureEq(&branch))),
+                    IsIfFalse(AllOf(
+                        CaptureEq(&branch),
+                        IsBranch(IsWord32And(val, IsInt32Constant(kSmiTagMask)),
+                                 graph()->start()))))));
+}
+
+
 class ChangeLowering64Test : public ChangeLoweringTest<int64_t> {
  public:
   virtual ~ChangeLowering64Test() {}
 };
 
 
 TARGET_TEST_F(ChangeLowering64Test, ChangeBoolToBit) {
   Node* val = Parameter(0);
   Node* node = graph()->NewNode(simplified()->ChangeBoolToBit(), val);
   Reduction reduction = Reduce(node);
@@ skipping 40 matching lines @@
               IsWord64Sar(val, IsInt32Constant(kShiftAmount)))),
           IsMerge(
               AllOf(CaptureEq(&if_true),
                     IsIfTrue(AllOf(
                         CaptureEq(&branch),
                         IsBranch(IsWord64And(val, IsInt32Constant(kSmiTagMask)),
                                  graph()->start())))),
               IsIfFalse(CaptureEq(&branch)))));
 }
 
+
+TARGET_TEST_F(ChangeLowering64Test, ChangeTaggedToInt32) {
+  STATIC_ASSERT(kSmiTag == 0);
+  STATIC_ASSERT(kSmiTagSize == 1);
+
+  Node* val = Parameter(0);
+  Node* node = graph()->NewNode(simplified()->ChangeTaggedToInt32(), val);
+  Reduction reduction = Reduce(node);
+  ASSERT_TRUE(reduction.Changed());
+
+  const int32_t kShiftAmount =
+      kSmiTagSize + SmiTagging<kPointerSize>::kSmiShiftSize;
+  const int32_t kValueOffset = kHeapNumberValueOffset - kHeapObjectTag;
+  Node* phi = reduction.replacement();
+  Capture<Node*> branch, if_true;
+  EXPECT_THAT(
+      phi,
+      IsPhi(IsChangeFloat64ToInt32(
+                IsLoad(kMachFloat64, val, IsInt32Constant(kValueOffset),
+                       IsControlEffect(CaptureEq(&if_true)))),
+            IsConvertInt64ToInt32(
+                IsWord64Sar(val, IsInt32Constant(kShiftAmount))),
+            IsMerge(AllOf(CaptureEq(&if_true), IsIfTrue(CaptureEq(&branch))),
+                    IsIfFalse(AllOf(
+                        CaptureEq(&branch),
+                        IsBranch(IsWord64And(val, IsInt32Constant(kSmiTagMask)),
+                                 graph()->start()))))));
+}
+
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8