[turbofan] Add support for ChangeUint32ToTagged in ChangeLowering.

src/compiler/change-lowering.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"
 
 namespace v8 {
 namespace internal {
@@ skipping 10 matching lines @@
     case IrOpcode::kChangeBoolToBit:
       return ChangeBoolToBit(node->InputAt(0));
     case IrOpcode::kChangeFloat64ToTagged:
       return ChangeFloat64ToTagged(node->InputAt(0), control);
     case IrOpcode::kChangeInt32ToTagged:
       return ChangeInt32ToTagged(node->InputAt(0), control);
     case IrOpcode::kChangeTaggedToFloat64:
       return ChangeTaggedToFloat64(node->InputAt(0), control);
     case IrOpcode::kChangeTaggedToInt32:
       return ChangeTaggedToInt32(node->InputAt(0), control);
+    case IrOpcode::kChangeUint32ToTagged:
+      return ChangeUint32ToTagged(node->InputAt(0), control);
     default:
       return NoChange();
   }
   UNREACHABLE();
   return NoChange();
 }
 
 
 Node* ChangeLowering::HeapNumberValueIndexConstant() {
   STATIC_ASSERT(HeapNumber::kValueOffset % kPointerSize == 0);
   const int heap_number_value_offset =
       ((HeapNumber::kValueOffset / kPointerSize) * (machine()->is64() ? 8 : 4));
   return jsgraph()->Int32Constant(heap_number_value_offset - kHeapObjectTag);
 }
 
 
+Node* ChangeLowering::SmiMaxValueConstant() {
+  // 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);
+  const int smi_value_size = machine()->is64() ? 32 : 31;
+  return jsgraph()->Int32Constant(
+      -(static_cast<int>(0xffffffffu << (smi_value_size - 1)) + 1));
+}
+
+
 Node* ChangeLowering::SmiShiftBitsConstant() {
   // 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);
   const int smi_shift_size = machine()->is64() ? 31 : 0;
   return jsgraph()->Int32Constant(smi_shift_size + kSmiTagSize);
@@ skipping 106 matching lines @@
           ? graph()->NewNode(machine()->TruncateInt64ToInt32(), integer)
           : integer);
 
   Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false);
   Node* phi = graph()->NewNode(common()->Phi(2), load, number, merge);
 
   return Replace(phi);
 }
 
 
+Reduction ChangeLowering::ChangeUint32ToTagged(Node* val, Node* control) {
+  STATIC_ASSERT(kSmiTag == 0);
+  STATIC_ASSERT(kSmiTagMask == 1);
+
+  Node* cmp = graph()->NewNode(machine()->Uint32LessThanOrEqual(), val,
+                               SmiMaxValueConstant());
+  Node* branch = graph()->NewNode(common()->Branch(), cmp, control);
+
+  Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
+  Node* smi = graph()->NewNode(
+      machine()->WordShl(),
+      machine()->is64()
+          ? graph()->NewNode(machine()->ChangeUint32ToUint64(), val)
+          : val,
+      SmiShiftBitsConstant());
+
+  Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
+  Node* heap_number = AllocateHeapNumberWithValue(
+      graph()->NewNode(machine()->ChangeUint32ToFloat64(), val), if_false);
+
+  Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false);
+  Node* phi = graph()->NewNode(common()->Phi(2), smi, heap_number, merge);
+
+  return Replace(phi);
+}
+
+
 Isolate* ChangeLowering::isolate() const { return jsgraph()->isolate(); }
 
 
 Graph* ChangeLowering::graph() const { return jsgraph()->graph(); }
 
 
 CommonOperatorBuilder* ChangeLowering::common() const {
   return jsgraph()->common();
 }
 
@@ skipping 14 matching lines @@
       jsgraph()->Int32Constant(function->nargs), context, effect, control);
   Node* store = graph()->NewNode(
       machine()->Store(kMachFloat64, kNoWriteBarrier), heap_number,
       HeapNumberValueIndexConstant(), value, heap_number, control);
   return graph()->NewNode(common()->Finish(1), heap_number, store);
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8