[turbofan] Add support for ChangeUint32ToTagged in ChangeLowering.

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 35 matching lines @@
       case kRepWord32:
         return 4;
       case kRepWord64:
         return 8;
       default:
         break;
     }
     UNREACHABLE();
     return 0;
   }
+  int SmiMaxValue() const { return -(SmiMinValue() + 1); }
+  int SmiMinValue() const {
+    return static_cast<int>(0xffffffffu << (SmiValueSize() - 1));
+  }
   int SmiShiftAmount() const { return kSmiTagSize + SmiShiftSize(); }
   int SmiShiftSize() const {
     // TODO(turbofan): Work-around for weird GCC 4.6 linker issue:
     // src/compiler/change-lowering.cc:46: undefined reference to
     // `v8::internal::SmiTagging<4u>::kSmiShiftSize'
     // src/compiler/change-lowering.cc:46: undefined reference to
     // `v8::internal::SmiTagging<8u>::kSmiShiftSize'
     STATIC_ASSERT(SmiTagging<4>::kSmiShiftSize == 0);
     STATIC_ASSERT(SmiTagging<8>::kSmiShiftSize == 31);
     return Is32() ? 0 : 31;
   }
+  int SmiValueSize() const {
+    // TODO(turbofan): Work-around for weird GCC 4.6 linker issue:
+    // src/compiler/change-lowering.cc:46: undefined reference to
+    // `v8::internal::SmiTagging<4u>::kSmiValueSize'
+    // src/compiler/change-lowering.cc:46: undefined reference to
+    // `v8::internal::SmiTagging<8u>::kSmiValueSize'
+    STATIC_ASSERT(SmiTagging<4>::kSmiValueSize == 31);
+    STATIC_ASSERT(SmiTagging<8>::kSmiValueSize == 32);
+    return Is32() ? 31 : 32;
+  }
 
   Node* Parameter(int32_t index = 0) {
     return graph()->NewNode(common()->Parameter(index), graph()->start());
   }
 
   Reduction Reduce(Node* node) {
     Typer typer(zone());
     JSGraph jsgraph(graph(), common(), &typer);
     CompilationInfo info(isolate(), zone());
     Linkage linkage(&info);
@@ skipping 191 matching lines @@
                 IsControlEffect(CaptureEq(&if_true)))),
             IsWord32Sar(val, IsInt32Constant(SmiShiftAmount())),
             IsMerge(AllOf(CaptureEq(&if_true), IsIfTrue(CaptureEq(&branch))),
                     IsIfFalse(AllOf(
                         CaptureEq(&branch),
                         IsBranch(IsWord32And(val, IsInt32Constant(kSmiTagMask)),
                                  graph()->start()))))));
 }
 
 
+TARGET_TEST_F(ChangeLowering32Test, ChangeUint32ToTagged) {
+  STATIC_ASSERT(kSmiTag == 0);
+  STATIC_ASSERT(kSmiTagSize == 1);
+
+  Node* val = Parameter(0);
+  Node* node = graph()->NewNode(simplified()->ChangeUint32ToTagged(), val);
+  Reduction reduction = Reduce(node);
+  ASSERT_TRUE(reduction.Changed());
+
+  Node* phi = reduction.replacement();
+  Capture<Node*> branch, heap_number, if_false;
+  EXPECT_THAT(
+      phi,
+      IsPhi(
+          IsWord32Shl(val, IsInt32Constant(SmiShiftAmount())),
+          IsFinish(
+              AllOf(CaptureEq(&heap_number),
+                    IsAllocateHeapNumber(_, CaptureEq(&if_false))),
+              IsStore(kMachFloat64, kNoWriteBarrier, CaptureEq(&heap_number),
+                      IsInt32Constant(HeapNumberValueOffset()),
+                      IsChangeUint32ToFloat64(val), CaptureEq(&heap_number),
+                      CaptureEq(&if_false))),
+          IsMerge(
+              IsIfTrue(AllOf(CaptureEq(&branch),
+                             IsBranch(IsUint32LessThanOrEqual(
+                                          val, IsInt32Constant(SmiMaxValue())),
+                                      graph()->start()))),
+              AllOf(CaptureEq(&if_false), IsIfFalse(CaptureEq(&branch))))));
+}
+
+
 // -----------------------------------------------------------------------------
 // 64-bit
 
 
 class ChangeLowering64Test : public ChangeLoweringTest {
  public:
   virtual ~ChangeLowering64Test() {}
   virtual MachineType WordRepresentation() const V8_FINAL V8_OVERRIDE {
     return kRepWord64;
   }
@@ skipping 58 matching lines @@
                 IsControlEffect(CaptureEq(&if_true)))),
             IsTruncateInt64ToInt32(
                 IsWord64Sar(val, IsInt32Constant(SmiShiftAmount()))),
             IsMerge(AllOf(CaptureEq(&if_true), IsIfTrue(CaptureEq(&branch))),
                     IsIfFalse(AllOf(
                         CaptureEq(&branch),
                         IsBranch(IsWord64And(val, IsInt32Constant(kSmiTagMask)),
                                  graph()->start()))))));
 }
 
+
+TARGET_TEST_F(ChangeLowering64Test, ChangeUint32ToTagged) {
+  STATIC_ASSERT(kSmiTag == 0);
+  STATIC_ASSERT(kSmiTagSize == 1);
+
+  Node* val = Parameter(0);
+  Node* node = graph()->NewNode(simplified()->ChangeUint32ToTagged(), val);
+  Reduction reduction = Reduce(node);
+  ASSERT_TRUE(reduction.Changed());
+
+  Node* phi = reduction.replacement();
+  Capture<Node*> branch, heap_number, if_false;
+  EXPECT_THAT(
+      phi,
+      IsPhi(
+          IsWord64Shl(IsChangeUint32ToUint64(val),
+                      IsInt32Constant(SmiShiftAmount())),
+          IsFinish(
+              AllOf(CaptureEq(&heap_number),
+                    IsAllocateHeapNumber(_, CaptureEq(&if_false))),
+              IsStore(kMachFloat64, kNoWriteBarrier, CaptureEq(&heap_number),
+                      IsInt32Constant(HeapNumberValueOffset()),
+                      IsChangeUint32ToFloat64(val), CaptureEq(&heap_number),
+                      CaptureEq(&if_false))),
+          IsMerge(
+              IsIfTrue(AllOf(CaptureEq(&branch),
+                             IsBranch(IsUint32LessThanOrEqual(
+                                          val, IsInt32Constant(SmiMaxValue())),
+                                      graph()->start()))),
+              AllOf(CaptureEq(&if_false), IsIfFalse(CaptureEq(&branch))))));
+}
+
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8