Optionally use 31-bits SMI value for 64-bit system

src/x64/lithium-codegen-x64.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 46 matching lines @@
     codegen_->RecordSafepoint(pointers_, deopt_mode_);
   }
 
  private:
   LCodeGen* codegen_;
   LPointerMap* pointers_;
   Safepoint::DeoptMode deopt_mode_;
 };
 
 
+class LithiumSmiInstructionWrapper
+  : public MacroAssembler::SmiInstructionWrapper {
+ public:
+  LithiumSmiInstructionWrapper(LCodeGen* codegen,
+                               LEnvironment* environment,
+                               bool check_overflow = false,
+                               bool check_minus_zero = false)
+      : codegen_(codegen),
+        environment_(environment),
+        check_overflow_(check_overflow),
+        check_minus_zero_(check_minus_zero) { }
+  virtual ~LithiumSmiInstructionWrapper() { }
+  virtual bool NeedsCheckOverflow() const { return check_overflow_; }
+  virtual bool NeedsCheckMinusZero() const { return check_minus_zero_; }
+  virtual bool NeedsKeepSourceOperandsIntact() const { return false; }
+  virtual void BailoutIf(Condition cc) const {
+    codegen_->DeoptimizeIf(cc, environment_);
+  }
+
+ private:
+  LCodeGen* codegen_;
+  LEnvironment* environment_;
+  bool check_overflow_;
+  bool check_minus_zero_;
+};
+
+
 #define __ masm()->
 
 bool LCodeGen::GenerateCode() {
   LPhase phase("Z_Code generation", chunk());
   ASSERT(is_unused());
   status_ = GENERATING;
 
   // Open a frame scope to indicate that there is a frame on the stack.  The
   // MANUAL indicates that the scope shouldn't actually generate code to set up
   // the frame (that is done in GeneratePrologue).
@@ skipping 332 matching lines @@
 }
 
 
 bool LCodeGen::IsTaggedConstant(LConstantOperand* op) const {
   return op->IsConstantOperand() &&
       chunk_->LookupLiteralRepresentation(op).IsTagged();
 }
 
 
 int32_t LCodeGen::ToInteger32(LConstantOperand* op) const {
-  HConstant* constant = chunk_->LookupConstant(op);
-  return constant->Integer32Value();
+  return ToRepresentation(op, Representation::Integer32());
 }
 
 
+int32_t LCodeGen::ToRepresentation(LConstantOperand* op,
+                                   const Representation& r) const {
+  HConstant* constant = chunk_->LookupConstant(op);
+  int32_t value = constant->Integer32Value();
+  if (r.IsInteger32()) return value;
+  ASSERT(r.IsSmiOrTagged());
+  return static_cast<int32_t>(reinterpret_cast<intptr_t>(Smi::FromInt(value)));
+}
+
+
 Smi* LCodeGen::ToSmi(LConstantOperand* op) const {
   HConstant* constant = chunk_->LookupConstant(op);
   return Smi::FromInt(constant->Integer32Value());
 }
 
 
 double LCodeGen::ToDouble(LConstantOperand* op) const {
   HConstant* constant = chunk_->LookupConstant(op);
   ASSERT(constant->HasDoubleValue());
   return constant->DoubleValue();
@@ skipping 921 matching lines @@
 }
 
 
 void LCodeGen::DoBitI(LBitI* instr) {
   LOperand* left = instr->left();
   LOperand* right = instr->right();
   ASSERT(left->Equals(instr->result()));
   ASSERT(left->IsRegister());
 
   if (right->IsConstantOperand()) {
-    int right_operand = ToInteger32(LConstantOperand::cast(right));
+    int32_t right_value = ToInteger32(LConstantOperand::cast(right));
     switch (instr->op()) {
       case Token::BIT_AND:
-        __ andl(ToRegister(left), Immediate(right_operand));
+        if (instr->hydrogen()->representation().IsSmi()) {
+          __ SmiAndConstant(ToRegister(left), ToRegister(left),
+                            Smi::FromInt(right_value));
+        } else {
+          __ andl(ToRegister(left), Immediate(right_value));
+        }
         break;
       case Token::BIT_OR:
-        __ orl(ToRegister(left), Immediate(right_operand));
+        if (instr->hydrogen()->representation().IsSmi()) {
+          __ SmiOrConstant(ToRegister(left), ToRegister(left),
+                           Smi::FromInt(right_value));
+        } else {
+          __ orl(ToRegister(left), Immediate(right_value));
+        }
         break;
       case Token::BIT_XOR:
-        __ xorl(ToRegister(left), Immediate(right_operand));
+        if (instr->hydrogen()->representation().IsSmi()) {
+          __ SmiXorConstant(ToRegister(left), ToRegister(left),
+                            Smi::FromInt(right_value));
+        } else {
+          __ xorl(ToRegister(left), Immediate(right_value));
+        }
         break;
       default:
         UNREACHABLE();
         break;
     }
   } else if (right->IsStackSlot()) {
     switch (instr->op()) {
       case Token::BIT_AND:
         __ and_(ToRegister(left), ToOperand(right));
         break;
@@ skipping 74 matching lines @@
         if (shift_count == 0 && instr->can_deopt()) {
           __ testl(ToRegister(left), ToRegister(left));
           DeoptimizeIf(negative, instr->environment());
         } else {
           __ shrl(ToRegister(left), Immediate(shift_count));
         }
         break;
       case Token::SHL:
         if (shift_count != 0) {
           if (instr->hydrogen_value()->representation().IsSmi()) {
-            __ shl(ToRegister(left), Immediate(shift_count));
+            if (SmiValuesAre32Bits() || !instr->can_deopt()) {
+              __ shl(ToRegister(left), Immediate(shift_count));
+            } else {
+              ASSERT(SmiValuesAre31Bits() && instr->can_deopt());
+              LithiumSmiInstructionWrapper wrapper(this, instr->environment());
+              __ SmiShiftLeftConstant(ToRegister(left), ToRegister(left),
+                                      shift_count, wrapper);
+            }
           } else {
             __ shll(ToRegister(left), Immediate(shift_count));
           }
         }
         break;
       default:
         UNREACHABLE();
         break;
     }
   }
 }
 
 
 void LCodeGen::DoSubI(LSubI* instr) {
   LOperand* left = instr->left();
   LOperand* right = instr->right();
   ASSERT(left->Equals(instr->result()));
 
+  bool check_overflow = instr->hydrogen()->CheckFlag(HValue::kCanOverflow);
+  LithiumSmiInstructionWrapper wrapper(this, instr->environment(),
+                                       check_overflow);
   if (right->IsConstantOperand()) {
-    __ subl(ToRegister(left),
-            Immediate(ToInteger32(LConstantOperand::cast(right))));
+    int32_t right_value = ToInteger32(LConstantOperand::cast(right));
+    if (instr->hydrogen()->representation().IsSmi()) {
+      __ SmiSubConstant(ToRegister(left), ToRegister(left),
+                        Smi::FromInt(right_value), wrapper);
+    } else {
+      __ subl(ToRegister(left), Immediate(right_value));
+    }
   } else if (right->IsRegister()) {
     if (instr->hydrogen_value()->representation().IsSmi()) {
-      __ subq(ToRegister(left), ToRegister(right));
+      __ SmiSub(ToRegister(left), ToRegister(left), ToRegister(right), wrapper);
     } else {
       __ subl(ToRegister(left), ToRegister(right));
     }
   } else {
     if (instr->hydrogen_value()->representation().IsSmi()) {
-      __ subq(ToRegister(left), ToOperand(right));
+      __ SmiSub(ToRegister(left), ToRegister(left), ToOperand(right), wrapper);
     } else {
       __ subl(ToRegister(left), ToOperand(right));
     }
   }
 
-  if (instr->hydrogen()->CheckFlag(HValue::kCanOverflow)) {
+  if (instr->hydrogen_value()->representation().IsInteger32() &&
+      check_overflow) {
     DeoptimizeIf(overflow, instr->environment());
   }
 }
 
 
 void LCodeGen::DoConstantI(LConstantI* instr) {
   __ Set(ToRegister(instr->result()), instr->value());
 }
 
 
@@ skipping 157 matching lines @@
   }
 }
 
 
 void LCodeGen::DoAddI(LAddI* instr) {
   LOperand* left = instr->left();
   LOperand* right = instr->right();
 
   if (LAddI::UseLea(instr->hydrogen()) && !left->Equals(instr->result())) {
     if (right->IsConstantOperand()) {
-      int32_t offset = ToInteger32(LConstantOperand::cast(right));
-      __ leal(ToRegister(instr->result()),
-              MemOperand(ToRegister(left), offset));
+      int32_t offset = ToRepresentation(LConstantOperand::cast(right),
+                                        instr->hydrogen()->representation());
+      if (instr->hydrogen()->representation().IsSmi()) {
+        __ lea(ToRegister(instr->result()),
+               MemOperand(ToRegister(left), offset));
+      } else {
+        __ leal(ToRegister(instr->result()),
+                MemOperand(ToRegister(left), offset));
+      }
     } else {
       Operand address(ToRegister(left), ToRegister(right), times_1, 0);
       if (instr->hydrogen()->representation().IsSmi()) {
         __ lea(ToRegister(instr->result()), address);
       } else {
         __ leal(ToRegister(instr->result()), address);
       }
     }
   } else {
+    bool check_overflow = instr->hydrogen()->CheckFlag(HValue::kCanOverflow);
+    LithiumSmiInstructionWrapper wrapper(this, instr->environment(),
+                                         check_overflow);
     if (right->IsConstantOperand()) {
-      __ addl(ToRegister(left),
-              Immediate(ToInteger32(LConstantOperand::cast(right))));
+      int32_t right_value = ToInteger32(LConstantOperand::cast(right));
+      if (instr->hydrogen()->representation().IsSmi()) {
+        __ SmiAddConstant(ToRegister(left), ToRegister(left),
+                          Smi::FromInt(right_value), wrapper);
+      } else {
+        __ addl(ToRegister(left), Immediate(right_value));
+      }
     } else if (right->IsRegister()) {
       if (instr->hydrogen_value()->representation().IsSmi()) {
-        __ addq(ToRegister(left), ToRegister(right));
+        __ SmiAdd(ToRegister(left), ToRegister(left), ToRegister(right),
+                  wrapper);
       } else {
         __ addl(ToRegister(left), ToRegister(right));
       }
     } else {
       if (instr->hydrogen_value()->representation().IsSmi()) {
-        __ addq(ToRegister(left), ToOperand(right));
+        __ SmiAdd(ToRegister(left), ToRegister(left), ToOperand(right),
+                  wrapper);
       } else {
         __ addl(ToRegister(left), ToOperand(right));
       }
     }
-    if (instr->hydrogen()->CheckFlag(HValue::kCanOverflow)) {
+
+    if (instr->hydrogen_value()->representation().IsInteger32() &&
+        check_overflow) {
       DeoptimizeIf(overflow, instr->environment());
     }
   }
 }
 
 
 void LCodeGen::DoMathMinMax(LMathMinMax* instr) {
   LOperand* left = instr->left();
   LOperand* right = instr->right();
   ASSERT(left->Equals(instr->result()));
   HMathMinMax::Operation operation = instr->hydrogen()->operation();
   if (instr->hydrogen()->representation().IsSmiOrInteger32()) {
     Label return_left;
     Condition condition = (operation == HMathMinMax::kMathMin)
         ? less_equal
         : greater_equal;
     Register left_reg = ToRegister(left);
     if (right->IsConstantOperand()) {
       Immediate right_imm =
-          Immediate(ToInteger32(LConstantOperand::cast(right)));
-      ASSERT(!instr->hydrogen_value()->representation().IsSmi());
+          Immediate(ToRepresentation(LConstantOperand::cast(right),
+                                     instr->hydrogen()->representation()));
       __ cmpl(left_reg, right_imm);
       __ j(condition, &return_left, Label::kNear);
       __ movq(left_reg, right_imm);
     } else if (right->IsRegister()) {
       Register right_reg = ToRegister(right);
       if (instr->hydrogen_value()->representation().IsSmi()) {
         __ cmpq(left_reg, right_reg);
       } else {
         __ cmpl(left_reg, right_reg);
       }
@@ skipping 1177 matching lines @@
 void LCodeGen::DoLoadKeyedExternalArray(LLoadKeyed* instr) {
   ElementsKind elements_kind = instr->elements_kind();
   LOperand* key = instr->key();
   if (!key->IsConstantOperand()) {
     Register key_reg = ToRegister(key);
     // Even though the HLoad/StoreKeyed (in this case) instructions force
     // the input representation for the key to be an integer, the input
     // gets replaced during bound check elimination with the index argument
     // to the bounds check, which can be tagged, so that case must be
     // handled here, too.
-    if (instr->hydrogen()->IsDehoisted()) {
+    if (instr->hydrogen()->key()->representation().IsSmi()) {
+      ASSERT(SmiValuesAre31Bits());
+      __ SmiToInteger64(key_reg, key_reg);
+    } else if (instr->hydrogen()->IsDehoisted()) {
       // Sign extend key because it could be a 32 bit negative value
       // and the dehoisted address computation happens in 64 bits
       __ movsxlq(key_reg, key_reg);
     }
   }
   Operand operand(BuildFastArrayOperand(
       instr->elements(),
       key,
       elements_kind,
       0,
@@ skipping 50 matching lines @@
 
 void LCodeGen::DoLoadKeyedFixedDoubleArray(LLoadKeyed* instr) {
   XMMRegister result(ToDoubleRegister(instr->result()));
   LOperand* key = instr->key();
   if (!key->IsConstantOperand()) {
     Register key_reg = ToRegister(key);
     // Even though the HLoad/StoreKeyed instructions force the input
     // representation for the key to be an integer, the input gets replaced
     // during bound check elimination with the index argument to the bounds
     // check, which can be tagged, so that case must be handled here, too.
-    if (instr->hydrogen()->IsDehoisted()) {
+    if (instr->hydrogen()->key()->representation().IsSmi()) {
+      ASSERT(SmiValuesAre31Bits());
+      __ SmiToInteger64(key_reg, key_reg);
+    } else if (instr->hydrogen()->IsDehoisted()) {
       // Sign extend key because it could be a 32 bit negative value
       // and the dehoisted address computation happens in 64 bits
       __ movsxlq(key_reg, key_reg);
     }
   }
 
   if (instr->hydrogen()->RequiresHoleCheck()) {
     int offset = FixedDoubleArray::kHeaderSize - kHeapObjectTag +
         sizeof(kHoleNanLower32);
     Operand hole_check_operand = BuildFastArrayOperand(
@@ skipping 19 matching lines @@
 void LCodeGen::DoLoadKeyedFixedArray(LLoadKeyed* instr) {
   Register result = ToRegister(instr->result());
   LOperand* key = instr->key();
   if (!key->IsConstantOperand()) {
     Register key_reg = ToRegister(key);
     // Even though the HLoad/StoreKeyedFastElement instructions force
     // the input representation for the key to be an integer, the input
     // gets replaced during bound check elimination with the index
     // argument to the bounds check, which can be tagged, so that
     // case must be handled here, too.
-    if (instr->hydrogen()->IsDehoisted()) {
+    if (instr->hydrogen()->key()->representation().IsSmi()) {
+      ASSERT(SmiValuesAre31Bits());
+      __ SmiToInteger64(key_reg, key_reg);
+    } else if (instr->hydrogen()->IsDehoisted()) {
       // Sign extend key because it could be a 32 bit negative value
       // and the dehoisted address computation happens in 64 bits
       __ movsxlq(key_reg, key_reg);
     }
   }
 
   // Load the result.
   __ movq(result,
           BuildFastArrayOperand(instr->elements(),
                                 key,
@@ skipping 367 matching lines @@
   Register input_reg = ToRegister(instr->value());
   __ testl(input_reg, input_reg);
   Label is_positive;
   __ j(not_sign, &is_positive, Label::kNear);
   __ negl(input_reg);  // Sets flags.
   DeoptimizeIf(negative, instr->environment());
   __ bind(&is_positive);
 }
 
 
-void LCodeGen::EmitInteger64MathAbs(LMathAbs* instr) {
+void LCodeGen::EmitSmiMathAbs(LMathAbs* instr) {
   Register input_reg = ToRegister(instr->value());
   __ testq(input_reg, input_reg);
   Label is_positive;
   __ j(not_sign, &is_positive, Label::kNear);
-  __ neg(input_reg);  // Sets flags.
+  if (SmiValuesAre32Bits()) {
+    __ neg(input_reg);  // Sets flags.
+  } else {
+    ASSERT(SmiValuesAre31Bits());
+    __ negl(input_reg);  // Sets flags.
+  }
   DeoptimizeIf(negative, instr->environment());
   __ bind(&is_positive);
 }
 
 
 void LCodeGen::DoMathAbs(LMathAbs* instr) {
   // Class for deferred case.
   class DeferredMathAbsTaggedHeapNumber: public LDeferredCode {
    public:
     DeferredMathAbsTaggedHeapNumber(LCodeGen* codegen, LMathAbs* instr)
@@ skipping 11 matching lines @@
 
   if (r.IsDouble()) {
     XMMRegister scratch = xmm0;
     XMMRegister input_reg = ToDoubleRegister(instr->value());
     __ xorps(scratch, scratch);
     __ subsd(scratch, input_reg);
     __ andpd(input_reg, scratch);
   } else if (r.IsInteger32()) {
     EmitIntegerMathAbs(instr);
   } else if (r.IsSmi()) {
-    EmitInteger64MathAbs(instr);
+    EmitSmiMathAbs(instr);
   } else {  // Tagged case.
     DeferredMathAbsTaggedHeapNumber* deferred =
         new(zone()) DeferredMathAbsTaggedHeapNumber(this, instr);
     Register input_reg = ToRegister(instr->value());
     // Smi check.
     __ JumpIfNotSmi(input_reg, deferred->entry());
-    __ SmiToInteger32(input_reg, input_reg);
-    EmitIntegerMathAbs(instr);
-    __ Integer32ToSmi(input_reg, input_reg);
+    EmitSmiMathAbs(instr);
     __ bind(deferred->exit());
   }
 }
 
 
 void LCodeGen::DoMathFloor(LMathFloor* instr) {
   XMMRegister xmm_scratch = xmm0;
   Register output_reg = ToRegister(instr->result());
   XMMRegister input_reg = ToDoubleRegister(instr->value());
 
@@ skipping 647 matching lines @@
 void LCodeGen::DoStoreKeyedExternalArray(LStoreKeyed* instr) {
   ElementsKind elements_kind = instr->elements_kind();
   LOperand* key = instr->key();
   if (!key->IsConstantOperand()) {
     Register key_reg = ToRegister(key);
     // Even though the HLoad/StoreKeyedFastElement instructions force
     // the input representation for the key to be an integer, the input
     // gets replaced during bound check elimination with the index
     // argument to the bounds check, which can be tagged, so that case
     // must be handled here, too.
-    if (instr->hydrogen()->IsDehoisted()) {
+    if (instr->hydrogen()->key()->representation().IsSmi()) {
+      ASSERT(SmiValuesAre31Bits());
+      __ SmiToInteger64(key_reg, key_reg);
+    } else if (instr->hydrogen()->IsDehoisted()) {
       // Sign extend key because it could be a 32 bit negative value
       // and the dehoisted address computation happens in 64 bits
       __ movsxlq(key_reg, key_reg);
     }
   }
   Operand operand(BuildFastArrayOperand(
       instr->elements(),
       key,
       elements_kind,
       0,
@@ skipping 41 matching lines @@
 void LCodeGen::DoStoreKeyedFixedDoubleArray(LStoreKeyed* instr) {
   XMMRegister value = ToDoubleRegister(instr->value());
   LOperand* key = instr->key();
   if (!key->IsConstantOperand()) {
     Register key_reg = ToRegister(key);
     // Even though the HLoad/StoreKeyedFastElement instructions force
     // the input representation for the key to be an integer, the
     // input gets replaced during bound check elimination with the index
     // argument to the bounds check, which can be tagged, so that case
     // must be handled here, too.
-    if (instr->hydrogen()->IsDehoisted()) {
+    if (instr->hydrogen()->key()->representation().IsSmi()) {
+      ASSERT(SmiValuesAre31Bits());
+      __ SmiToInteger64(key_reg, key_reg);
+    } else if (instr->hydrogen()->IsDehoisted()) {
       // Sign extend key because it could be a 32 bit negative value
       // and the dehoisted address computation happens in 64 bits
       __ movsxlq(key_reg, key_reg);
     }
   }
 
   if (instr->NeedsCanonicalization()) {
     Label have_value;
 
     __ ucomisd(value, value);
@@ skipping 20 matching lines @@
 void LCodeGen::DoStoreKeyedFixedArray(LStoreKeyed* instr) {
   Register elements = ToRegister(instr->elements());
   LOperand* key = instr->key();
   if (!key->IsConstantOperand()) {
     Register key_reg = ToRegister(key);
     // Even though the HLoad/StoreKeyedFastElement instructions force
     // the input representation for the key to be an integer, the
     // input gets replaced during bound check elimination with the index
     // argument to the bounds check, which can be tagged, so that case
     // must be handled here, too.
-    if (instr->hydrogen()->IsDehoisted()) {
+    if (instr->hydrogen()->key()->representation().IsSmi()) {
+      ASSERT(SmiValuesAre31Bits());
+      __ SmiToInteger64(key_reg, key_reg);
+    } else if (instr->hydrogen()->IsDehoisted()) {
       // Sign extend key because it could be a 32 bit negative value
       // and the dehoisted address computation happens in 64 bits
       __ movsxlq(key_reg, key_reg);
     }
   }
 
   Operand operand =
       BuildFastArrayOperand(instr->elements(),
                             key,
                             FAST_ELEMENTS,
@@ skipping 236 matching lines @@
   LOperand* output = instr->result();
   LOperand* temp = instr->temp();
 
   __ LoadUint32(ToDoubleRegister(output),
                 ToRegister(input),
                 ToDoubleRegister(temp));
 }
 
 
 void LCodeGen::DoNumberTagI(LNumberTagI* instr) {
-  LOperand* input = instr->value();
-  ASSERT(input->IsRegister() && input->Equals(instr->result()));
-  Register reg = ToRegister(input);
+  if (SmiValuesAre32Bits()) {
+    LOperand* input = instr->value();
+    ASSERT(input->IsRegister() && input->Equals(instr->result()));
+    Register reg = ToRegister(input);
 
-  __ Integer32ToSmi(reg, reg);
+    __ Integer32ToSmi(reg, reg);
+  } else {
+    ASSERT(SmiValuesAre31Bits());
+    class DeferredNumberTagI: public LDeferredCode {
+     public:
+      DeferredNumberTagI(LCodeGen* codegen, LNumberTagI* instr)
+          : LDeferredCode(codegen), instr_(instr) { }
+      virtual void Generate() {
+        codegen()->DoDeferredNumberTagI(instr_);
+      }
+      virtual LInstruction* instr() { return instr_; }
+     private:
+      LNumberTagI* instr_;
+    };
+
+    LOperand* input = instr->value();
+    ASSERT(input->IsRegister() && input->Equals(instr->result()));
+    Register reg = ToRegister(input);
+
+    DeferredNumberTagI* deferred = new(zone()) DeferredNumberTagI(this, instr);
+    __ shll(reg, Immediate(kSmiTagSize + kSmiShiftSize));
+    __ j(overflow, deferred->entry());
+    __ movsxlq(reg, reg);
+    __ bind(deferred->exit());
+  }
 }
 
 
+void LCodeGen::DoDeferredNumberTagI(LNumberTagI* instr) {
+  ASSERT(SmiValuesAre31Bits());
+  Label slow;
+  Register reg = ToRegister(instr->value());
+  Register tmp = reg.is(rax) ? kScratchRegister : rax;
+
+  // Preserve the value of all registers.
+  PushSafepointRegistersScope scope(this);
+
+  Label done;
+  // There was overflow, so bits 30 and 31 of the original integer
+  // disagree. Try to allocate a heap number in new space and store
+  // the value in there. If that fails, call the runtime system.
+  __ SmiToInteger32(reg, reg);
+  __ xorl(reg, Immediate(0x80000000));
+  __ cvtlsi2sd(xmm1, reg);
+
+  if (FLAG_inline_new) {
+    __ AllocateHeapNumber(reg, tmp, &slow);
+    __ jmp(&done, Label::kNear);
+  }
+
+  // Slow case: Call the runtime system to do the number allocation.
+  __ bind(&slow);
+
+  // Put a valid pointer value in the stack slot where the result
+  // register is stored, as this register is in the pointer map, but contains an
+  // integer value.
+  __ StoreToSafepointRegisterSlot(reg, Immediate(0));
+  CallRuntimeFromDeferred(Runtime::kAllocateHeapNumber, 0, instr);
+  // Set the pointer to the new heap number in tmp.
+  if (!reg.is(rax)) __ movq(reg, rax);
+
+  // Heap number allocated. Put the value in xmm0 into the value of the
+  // allocated heap number.
+  __ bind(&done);
+  __ movsd(FieldOperand(reg, HeapNumber::kValueOffset), xmm1);
+  __ StoreToSafepointRegisterSlot(reg, reg);
+}
+
+
 void LCodeGen::DoNumberTagU(LNumberTagU* instr) {
   class DeferredNumberTagU: public LDeferredCode {
    public:
     DeferredNumberTagU(LCodeGen* codegen, LNumberTagU* instr)
         : LDeferredCode(codegen), instr_(instr) { }
     virtual void Generate() {
       codegen()->DoDeferredNumberTagU(instr_);
     }
     virtual LInstruction* instr() { return instr_; }
    private:
@@ skipping 1056 matching lines @@
                                FixedArray::kHeaderSize - kPointerSize));
   __ bind(&done);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_X64