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

src/x64/macro-assembler-x64.cc

 // Copyright 2012 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 973 matching lines @@
 
 
 bool MacroAssembler::IsUnsafeInt(const int x) {
   static const int kMaxBits = 17;
   return !is_intn(x, kMaxBits);
 }
 
 
 void MacroAssembler::SafeMove(Register dst, Smi* src) {
   ASSERT(!dst.is(kScratchRegister));
+#if !V8_USE_31_BITS_SMI_VALUE
   ASSERT(kSmiValueSize == 32);  // JIT cookie can be converted to Smi.
   if (IsUnsafeInt(src->value()) && jit_cookie() != 0) {
     Move(dst, Smi::FromInt(src->value() ^ jit_cookie()));
     Move(kScratchRegister, Smi::FromInt(jit_cookie()));
     xor_(dst, kScratchRegister);
   } else {
     Move(dst, src);
   }
+#else
+  ASSERT(kSmiValueSize == 31);
+  if (IsUnsafeInt(src->value()) && jit_cookie() != 0) {
+    movq(dst, Immediate(static_cast<int>(reinterpret_cast<intptr_t>(src)) ^
+                        jit_cookie()));
+    movq(kScratchRegister, Immediate(jit_cookie()));
+    xor_(dst, kScratchRegister);
+  } else {
+    Move(dst, src);
+  }
+#endif
 }
 
 
 void MacroAssembler::SafePush(Smi* src) {
+#if !V8_USE_31_BITS_SMI_VALUE
   ASSERT(kSmiValueSize == 32);  // JIT cookie can be converted to Smi.
   if (IsUnsafeInt(src->value()) && jit_cookie() != 0) {
     Push(Smi::FromInt(src->value() ^ jit_cookie()));
     Move(kScratchRegister, Smi::FromInt(jit_cookie()));
     xor_(Operand(rsp, 0), kScratchRegister);
   } else {
     Push(src);
   }
+#else
+  ASSERT(kSmiValueSize == 31);
+  if (IsUnsafeInt(src->value()) && jit_cookie() != 0) {
+    push(Immediate(static_cast<int>(reinterpret_cast<intptr_t>(src)) ^
+                   jit_cookie()));
+    movq(kScratchRegister, Immediate(jit_cookie()));
+    xor_(Operand(rsp, 0), kScratchRegister);
+  } else {
+    Push(src);
+  }
+#endif
 }
 
 
 // ----------------------------------------------------------------------------
 // Smi tagging, untagging and tag detection.
 
 Register MacroAssembler::GetSmiConstant(Smi* source) {
   int value = source->value();
   if (value == 0) {
     xorl(kScratchRegister, kScratchRegister);
@@ skipping 65 matching lines @@
     neg(dst);
   }
 }
 
 
 void MacroAssembler::Integer32ToSmi(Register dst, Register src) {
   STATIC_ASSERT(kSmiTag == 0);
   if (!dst.is(src)) {
     movl(dst, src);
   }
+#if !V8_USE_31_BITS_SMI_VALUE
   shl(dst, Immediate(kSmiShift));
+#else
+  shll(dst, Immediate(kSmiShift));
+  movsxlq(dst, dst);
+#endif
 }
 
 
 void MacroAssembler::Integer32ToSmiField(const Operand& dst, Register src) {
   if (emit_debug_code()) {
     testb(dst, Immediate(0x01));
     Label ok;
     j(zero, &ok, Label::kNear);
     if (allow_stub_calls()) {
       Abort("Integer32ToSmiField writing to non-smi location");
     } else {
       int3();
     }
     bind(&ok);
   }
+#if !V8_USE_31_BITS_SMI_VALUE
   ASSERT(kSmiShift % kBitsPerByte == 0);
   movl(Operand(dst, kSmiShift / kBitsPerByte), src);
+#else
+  Integer32ToSmi(kScratchRegister, src);
+  movq(dst, kScratchRegister);
+#endif
 }
 
 
 void MacroAssembler::Integer64PlusConstantToSmi(Register dst,
                                                 Register src,
                                                 int constant) {
   if (dst.is(src)) {
     addl(dst, Immediate(constant));
   } else {
     leal(dst, Operand(src, constant));
   }
-  shl(dst, Immediate(kSmiShift));
+  Integer32ToSmi(dst, dst);
 }
 
 
 void MacroAssembler::SmiToInteger32(Register dst, Register src) {
   STATIC_ASSERT(kSmiTag == 0);
   if (!dst.is(src)) {
     movq(dst, src);
   }
+#if !V8_USE_31_BITS_SMI_VALUE
   shr(dst, Immediate(kSmiShift));
+#else
+  sarl(dst, Immediate(kSmiShift));
+#endif
 }
 
 
 void MacroAssembler::SmiToInteger32(Register dst, const Operand& src) {
+#if !V8_USE_31_BITS_SMI_VALUE
   movl(dst, Operand(src, kSmiShift / kBitsPerByte));
+#else
+  movl(dst, src);
+  sarl(dst, Immediate(kSmiShift));
+#endif
 }
 
 
 void MacroAssembler::SmiToInteger64(Register dst, Register src) {
   STATIC_ASSERT(kSmiTag == 0);
   if (!dst.is(src)) {
     movq(dst, src);
   }
   sar(dst, Immediate(kSmiShift));
 }
 
 
 void MacroAssembler::SmiToInteger64(Register dst, const Operand& src) {
+#if !V8_USE_31_BITS_SMI_VALUE
   movsxlq(dst, Operand(src, kSmiShift / kBitsPerByte));
+#else
+  movq(dst, src);
+  SmiToInteger64(dst, dst);
+#endif
 }
 
 
 void MacroAssembler::SmiTest(Register src) {
   AssertSmi(src);
+#if !V8_USE_31_BITS_SMI_VALUE
   testq(src, src);
+#else
+  testl(src, src);
+#endif
 }
 
 
 void MacroAssembler::SmiCompare(Register smi1, Register smi2) {
   AssertSmi(smi1);
   AssertSmi(smi2);
+#if !V8_USE_31_BITS_SMI_VALUE
   cmpq(smi1, smi2);
+#else
+  cmpl(smi1, smi2);
+#endif
 }
 
 
 void MacroAssembler::SmiCompare(Register dst, Smi* src) {
   AssertSmi(dst);
   Cmp(dst, src);
 }
 
 
 void MacroAssembler::Cmp(Register dst, Smi* src) {
   ASSERT(!dst.is(kScratchRegister));
   if (src->value() == 0) {
+#if !V8_USE_31_BITS_SMI_VALUE
     testq(dst, dst);
+#else
+    testl(dst, dst);
+#endif
   } else {
     Register constant_reg = GetSmiConstant(src);
+#if !V8_USE_31_BITS_SMI_VALUE
     cmpq(dst, constant_reg);
+#else
+    cmpl(dst, constant_reg);
+#endif
   }
 }
 
 
 void MacroAssembler::SmiCompare(Register dst, const Operand& src) {
   AssertSmi(dst);
   AssertSmi(src);
+#if !V8_USE_31_BITS_SMI_VALUE
   cmpq(dst, src);
+#else
+  cmpl(dst, src);
+#endif
 }
 
 
 void MacroAssembler::SmiCompare(const Operand& dst, Register src) {
   AssertSmi(dst);
   AssertSmi(src);
+#if !V8_USE_31_BITS_SMI_VALUE
   cmpq(dst, src);
+#else
+  cmpl(dst, src);
+#endif
 }
 
 
 void MacroAssembler::SmiCompare(const Operand& dst, Smi* src) {
   AssertSmi(dst);
+#if !V8_USE_31_BITS_SMI_VALUE
   cmpl(Operand(dst, kSmiShift / kBitsPerByte), Immediate(src->value()));
+#else
+  cmpl(dst, Immediate(src));
+#endif
 }
 
 
 void MacroAssembler::Cmp(const Operand& dst, Smi* src) {
+#if !V8_USE_31_BITS_SMI_VALUE
   // The Operand cannot use the smi register.
   Register smi_reg = GetSmiConstant(src);
   ASSERT(!dst.AddressUsesRegister(smi_reg));
   cmpq(dst, smi_reg);
+#else
+  cmpl(dst, Immediate(src));
+#endif
 }
 
 
 void MacroAssembler::SmiCompareInteger32(const Operand& dst, Register src) {
+#if !V8_USE_31_BITS_SMI_VALUE
   cmpl(Operand(dst, kSmiShift / kBitsPerByte), src);
+#else
+  SmiToInteger32(kScratchRegister, dst);
+  cmpl(kScratchRegister, src);
+#endif
 }
 
 
 void MacroAssembler::PositiveSmiTimesPowerOfTwoToInteger64(Register dst,
                                                            Register src,
                                                            int power) {
   ASSERT(power >= 0);
   ASSERT(power < 64);
   if (power == 0) {
     SmiToInteger64(dst, src);
     return;
   }
   if (!dst.is(src)) {
     movq(dst, src);
   }
   if (power < kSmiShift) {
     sar(dst, Immediate(kSmiShift - power));
   } else if (power > kSmiShift) {
     shl(dst, Immediate(power - kSmiShift));
   }
 }
 
 
 void MacroAssembler::PositiveSmiDivPowerOfTwoToInteger32(Register dst,
                                                          Register src,
                                                          int power) {
   ASSERT((0 <= power) && (power < 32));
   if (dst.is(src)) {
+#if !V8_USE_31_BITS_SMI_VALUE
     shr(dst, Immediate(power + kSmiShift));
+#else
+    shrl(dst, Immediate(power + kSmiShift));
+#endif
   } else {
     UNIMPLEMENTED();  // Not used.
   }
 }
 
 
 void MacroAssembler::SmiOrIfSmis(Register dst, Register src1, Register src2,
                                  Label* on_not_smis,
                                  Label::Distance near_jump) {
   if (dst.is(src1) || dst.is(src2)) {
@@ skipping 20 matching lines @@
 
 Condition MacroAssembler::CheckSmi(const Operand& src) {
   STATIC_ASSERT(kSmiTag == 0);
   testb(src, Immediate(kSmiTagMask));
   return zero;
 }
 
 
 Condition MacroAssembler::CheckNonNegativeSmi(Register src) {
   STATIC_ASSERT(kSmiTag == 0);
+#if !V8_USE_31_BITS_SMI_VALUE
   // Test that both bits of the mask 0x8000000000000001 are zero.
   movq(kScratchRegister, src);
   rol(kScratchRegister, Immediate(1));
+#else
+  movl(kScratchRegister, src);
+  roll(kScratchRegister, Immediate(1));
+#endif
   testb(kScratchRegister, Immediate(3));
   return zero;
 }
 
 
 Condition MacroAssembler::CheckBothSmi(Register first, Register second) {
   if (first.is(second)) {
     return CheckSmi(first);
   }
   STATIC_ASSERT(kSmiTag == 0 && kHeapObjectTag == 1 && kHeapObjectTagMask == 3);
+#if !V8_USE_31_BITS_SMI_VALUE
   leal(kScratchRegister, Operand(first, second, times_1, 0));
   testb(kScratchRegister, Immediate(0x03));
+#else
+  movl(kScratchRegister, first);
+  orl(kScratchRegister, second);
+  testb(kScratchRegister, Immediate(kSmiTagMask));
+#endif
   return zero;
 }
 
 
 Condition MacroAssembler::CheckBothNonNegativeSmi(Register first,
                                                   Register second) {
   if (first.is(second)) {
     return CheckNonNegativeSmi(first);
   }
+#if !V8_USE_31_BITS_SMI_VALUE
   movq(kScratchRegister, first);
   or_(kScratchRegister, second);
   rol(kScratchRegister, Immediate(1));
+#else
+  movl(kScratchRegister, first);
+  orl(kScratchRegister, second);
+  roll(kScratchRegister, Immediate(1));
+#endif
   testl(kScratchRegister, Immediate(3));
   return zero;
 }
 
 
 Condition MacroAssembler::CheckEitherSmi(Register first,
                                          Register second,
                                          Register scratch) {
   if (first.is(second)) {
     return CheckSmi(first);
   }
   if (scratch.is(second)) {
     andl(scratch, first);
   } else {
     if (!scratch.is(first)) {
       movl(scratch, first);
     }
     andl(scratch, second);
   }
   testb(scratch, Immediate(kSmiTagMask));
   return zero;
 }
 
 
 Condition MacroAssembler::CheckIsMinSmi(Register src) {
   ASSERT(!src.is(kScratchRegister));
   // If we overflow by subtracting one, it's the minimal smi value.
+#if !V8_USE_31_BITS_SMI_VALUE
   cmpq(src, kSmiConstantRegister);
+#else
+  cmpl(src, kSmiConstantRegister);
+#endif
   return overflow;
 }
 
 
 Condition MacroAssembler::CheckInteger32ValidSmiValue(Register src) {
+#if !V8_USE_31_BITS_SMI_VALUE
   // A 32-bit integer value can always be converted to a smi.
   return always;
+#else
+  cmpl(src, Immediate(0xc0000000));
+  return positive;
+#endif
 }
 
 
 Condition MacroAssembler::CheckUInteger32ValidSmiValue(Register src) {
+#if !V8_USE_31_BITS_SMI_VALUE
   // An unsigned 32-bit integer value is valid as long as the high bit
   // is not set.
   testl(src, src);
   return positive;
+#else
+  testl(src, Immediate(0xc0000000));
+  return zero;
+#endif
 }
 
 
 void MacroAssembler::CheckSmiToIndicator(Register dst, Register src) {
   if (dst.is(src)) {
     andl(dst, Immediate(kSmiTagMask));
   } else {
     movl(dst, Immediate(kSmiTagMask));
     andl(dst, src);
   }
@@ skipping 85 matching lines @@
                                        Label::Distance near_jump) {
   // Does not assume that src is a smi.
   ASSERT_EQ(static_cast<int>(1), static_cast<int>(kSmiTagMask));
   STATIC_ASSERT(kSmiTag == 0);
   ASSERT(!dst.is(kScratchRegister));
   ASSERT(!src.is(kScratchRegister));
 
   JumpIfNotSmi(src, on_not_smi_result, near_jump);
   Register tmp = (dst.is(src) ? kScratchRegister : dst);
   LoadSmiConstant(tmp, constant);
+#if !V8_USE_31_BITS_SMI_VALUE
   addq(tmp, src);
+#else
+  addl(tmp, src);
+#endif
   j(overflow, on_not_smi_result, near_jump);
   if (dst.is(src)) {
     movq(dst, tmp);
   }
+#if V8_USE_31_BITS_SMI_VALUE
+  movsxlq(dst, dst);
+#endif
 }
 
 
 void MacroAssembler::SmiAddConstant(Register dst, Register src, Smi* constant) {
   if (constant->value() == 0) {
     if (!dst.is(src)) {
       movq(dst, src);
     }
     return;
   } else if (dst.is(src)) {
@@ skipping 34 matching lines @@
         LoadSmiConstant(dst, constant);
         addq(dst, src);
         return;
     }
   }
 }
 
 
 void MacroAssembler::SmiAddConstant(const Operand& dst, Smi* constant) {
   if (constant->value() != 0) {
+#if !V8_USE_31_BITS_SMI_VALUE
     addl(Operand(dst, kSmiShift / kBitsPerByte), Immediate(constant->value()));
+#else
+    addq(dst, Immediate(constant));
+#endif
   }
 }
 
 
 void MacroAssembler::SmiAddConstant(Register dst,
                                     Register src,
                                     Smi* constant,
                                     Label* on_not_smi_result,
                                     Label::Distance near_jump) {
   if (constant->value() == 0) {
     if (!dst.is(src)) {
       movq(dst, src);
     }
   } else if (dst.is(src)) {
     ASSERT(!dst.is(kScratchRegister));
 
     LoadSmiConstant(kScratchRegister, constant);
+#if !V8_USE_31_BITS_SMI_VALUE
     addq(kScratchRegister, src);
+#else
+    addl(kScratchRegister, src);
+#endif
     j(overflow, on_not_smi_result, near_jump);
+#if !V8_USE_31_BITS_SMI_VALUE
     movq(dst, kScratchRegister);
+#else
+    movsxlq(dst, kScratchRegister);
+#endif
   } else {
     LoadSmiConstant(dst, constant);
+#if !V8_USE_31_BITS_SMI_VALUE
     addq(dst, src);
+#else
+    addl(dst, src);
+#endif
     j(overflow, on_not_smi_result, near_jump);
+#if V8_USE_31_BITS_SMI_VALUE
+    movsxlq(dst, dst);
+#endif
   }
 }
 
 
 void MacroAssembler::SmiSubConstant(Register dst, Register src, Smi* constant) {
   if (constant->value() == 0) {
     if (!dst.is(src)) {
       movq(dst, src);
     }
   } else if (dst.is(src)) {
     ASSERT(!dst.is(kScratchRegister));
     Register constant_reg = GetSmiConstant(constant);
     subq(dst, constant_reg);
   } else {
     if (constant->value() == Smi::kMinValue) {
+#if !V8_USE_31_BITS_SMI_VALUE
       LoadSmiConstant(dst, constant);
       // Adding and subtracting the min-value gives the same result, it only
       // differs on the overflow bit, which we don't check here.
       addq(dst, src);
+#else
+      movq(dst, src);
+      subq(dst, Immediate(constant));
+#endif
     } else {
       // Subtract by adding the negation.
       LoadSmiConstant(dst, Smi::FromInt(-constant->value()));
       addq(dst, src);
     }
   }
 }
 
 
 void MacroAssembler::SmiSubConstant(Register dst,
                                     Register src,
                                     Smi* constant,
                                     Label* on_not_smi_result,
                                     Label::Distance near_jump) {
   if (constant->value() == 0) {
     if (!dst.is(src)) {
       movq(dst, src);
     }
   } else if (dst.is(src)) {
     ASSERT(!dst.is(kScratchRegister));
     if (constant->value() == Smi::kMinValue) {
       // Subtracting min-value from any non-negative value will overflow.
       // We test the non-negativeness before doing the subtraction.
+#if !V8_USE_31_BITS_SMI_VALUE
       testq(src, src);
+#else
+      testl(src, src);
+#endif
       j(not_sign, on_not_smi_result, near_jump);
       LoadSmiConstant(kScratchRegister, constant);
       subq(dst, kScratchRegister);
     } else {
       // Subtract by adding the negation.
       LoadSmiConstant(kScratchRegister, Smi::FromInt(-constant->value()));
+#if !V8_USE_31_BITS_SMI_VALUE
       addq(kScratchRegister, dst);
+#else
+      addl(kScratchRegister, dst);
+#endif
       j(overflow, on_not_smi_result, near_jump);
+#if !V8_USE_31_BITS_SMI_VALUE
       movq(dst, kScratchRegister);
+#else
+      movsxlq(dst, kScratchRegister);
+#endif
     }
   } else {
     if (constant->value() == Smi::kMinValue) {
       // Subtracting min-value from any non-negative value will overflow.
       // We test the non-negativeness before doing the subtraction.
+#if !V8_USE_31_BITS_SMI_VALUE
       testq(src, src);
       j(not_sign, on_not_smi_result, near_jump);
       LoadSmiConstant(dst, constant);
       // Adding and subtracting the min-value gives the same result, it only
       // differs on the overflow bit, which we don't check here.
       addq(dst, src);
+#else
+      testl(src, src);
+      j(not_sign, on_not_smi_result, near_jump);
+      movq(dst, src);
+      subq(dst, Immediate(constant));
+#endif
     } else {
       // Subtract by adding the negation.
       LoadSmiConstant(dst, Smi::FromInt(-(constant->value())));
+#if !V8_USE_31_BITS_SMI_VALUE
       addq(dst, src);
+#else
+      addl(dst, src);
+#endif
       j(overflow, on_not_smi_result, near_jump);
+#if V8_USE_31_BITS_SMI_VALUE
+      movsxlq(dst, dst);
+#endif
     }
   }
 }
 
 
 void MacroAssembler::SmiNeg(Register dst,
                             Register src,
                             Label* on_smi_result,
                             Label::Distance near_jump) {
   if (dst.is(src)) {
     ASSERT(!dst.is(kScratchRegister));
     movq(kScratchRegister, src);
     neg(dst);  // Low 32 bits are retained as zero by negation.
     // Test if result is zero or Smi::kMinValue.
+#if !V8_USE_31_BITS_SMI_VALUE
     cmpq(dst, kScratchRegister);
+#else
+    cmpl(dst, kScratchRegister);
+#endif
     j(not_equal, on_smi_result, near_jump);
     movq(src, kScratchRegister);
   } else {
     movq(dst, src);
     neg(dst);
+#if !V8_USE_31_BITS_SMI_VALUE
     cmpq(dst, src);
+#else
+    cmpl(dst, src);
+#endif
     // If the result is zero or Smi::kMinValue, negation failed to create a smi.
     j(not_equal, on_smi_result, near_jump);
   }
 }
 
 
 void MacroAssembler::SmiAdd(Register dst,
                             Register src1,
                             Register src2,
                             Label* on_not_smi_result,
                             Label::Distance near_jump) {
   ASSERT_NOT_NULL(on_not_smi_result);
   ASSERT(!dst.is(src2));
   if (dst.is(src1)) {
     movq(kScratchRegister, src1);
+#if !V8_USE_31_BITS_SMI_VALUE
     addq(kScratchRegister, src2);
+#else
+    addl(kScratchRegister, src2);
+#endif
     j(overflow, on_not_smi_result, near_jump);
+#if !V8_USE_31_BITS_SMI_VALUE
     movq(dst, kScratchRegister);
+#else
+    movsxlq(dst, kScratchRegister);
+#endif
   } else {
     movq(dst, src1);
+#if !V8_USE_31_BITS_SMI_VALUE
     addq(dst, src2);
+#else
+    addl(dst, src2);
+#endif
     j(overflow, on_not_smi_result, near_jump);
+#if V8_USE_31_BITS_SMI_VALUE
+    movsxlq(dst, dst);
+#endif
   }
 }
 
 
 void MacroAssembler::SmiAdd(Register dst,
                             Register src1,
                             const Operand& src2,
                             Label* on_not_smi_result,
                             Label::Distance near_jump) {
   ASSERT_NOT_NULL(on_not_smi_result);
   if (dst.is(src1)) {
     movq(kScratchRegister, src1);
+#if !V8_USE_31_BITS_SMI_VALUE
     addq(kScratchRegister, src2);
+#else
+    addl(kScratchRegister, src2);
+#endif
     j(overflow, on_not_smi_result, near_jump);
+#if !V8_USE_31_BITS_SMI_VALUE
     movq(dst, kScratchRegister);
+#else
+    movsxlq(dst, kScratchRegister);
+#endif
   } else {
     ASSERT(!src2.AddressUsesRegister(dst));
     movq(dst, src1);
+#if !V8_USE_31_BITS_SMI_VALUE
     addq(dst, src2);
+#else
+    addl(dst, src2);
+#endif
     j(overflow, on_not_smi_result, near_jump);
+#if V8_USE_31_BITS_SMI_VALUE
+    movsxlq(dst, dst);
+#endif
   }
 }
 
 
 void MacroAssembler::SmiAdd(Register dst,
                             Register src1,
                             Register src2) {
   // No overflow checking. Use only when it's known that
   // overflowing is impossible.
   if (!dst.is(src1)) {
@@ skipping 11 matching lines @@
 
 
 void MacroAssembler::SmiSub(Register dst,
                             Register src1,
                             Register src2,
                             Label* on_not_smi_result,
                             Label::Distance near_jump) {
   ASSERT_NOT_NULL(on_not_smi_result);
   ASSERT(!dst.is(src2));
   if (dst.is(src1)) {
+#if !V8_USE_31_BITS_SMI_VALUE
     cmpq(dst, src2);
+#else
+    cmpl(dst, src2);
+#endif
     j(overflow, on_not_smi_result, near_jump);
     subq(dst, src2);
   } else {
+#if !V8_USE_31_BITS_SMI_VALUE
     movq(dst, src1);
     subq(dst, src2);
+#else
+    movl(dst, src1);
+    subl(dst, src2);
+#endif
     j(overflow, on_not_smi_result, near_jump);
+#if V8_USE_31_BITS_SMI_VALUE
+    movsxlq(dst, dst);
+#endif
   }
 }
 
 
 void MacroAssembler::SmiSub(Register dst, Register src1, Register src2) {
   // No overflow checking. Use only when it's known that
   // overflowing is impossible (e.g., subtracting two positive smis).
   ASSERT(!dst.is(src2));
   if (!dst.is(src1)) {
     movq(dst, src1);
   }
   subq(dst, src2);
   Assert(no_overflow, "Smi subtraction overflow");
 }
 
 
 void MacroAssembler::SmiSub(Register dst,
                             Register src1,
                             const Operand& src2,
                             Label* on_not_smi_result,
                             Label::Distance near_jump) {
   ASSERT_NOT_NULL(on_not_smi_result);
   if (dst.is(src1)) {
+#if !V8_USE_31_BITS_SMI_VALUE
     movq(kScratchRegister, src2);
     cmpq(src1, kScratchRegister);
+#else
+    movl(kScratchRegister, src2);
+    cmpl(src1, kScratchRegister);
+#endif
     j(overflow, on_not_smi_result, near_jump);
+#if !V8_USE_31_BITS_SMI_VALUE
     subq(src1, kScratchRegister);
+#else
+    movsxlq(src1, kScratchRegister);
+#endif
   } else {
+#if !V8_USE_31_BITS_SMI_VALUE
     movq(dst, src1);
     subq(dst, src2);
+#else
+    movl(dst, src1);
+    subl(dst, src2);
+#endif
     j(overflow, on_not_smi_result, near_jump);
+#if V8_USE_31_BITS_SMI_VALUE
+    movsxlq(dst, dst);
+#endif
   }
 }
 
 
 void MacroAssembler::SmiSub(Register dst,
                             Register src1,
                             const Operand& src2) {
   // No overflow checking. Use only when it's known that
   // overflowing is impossible (e.g., subtracting two positive smis).
   if (!dst.is(src1)) {
@@ skipping 10 matching lines @@
                             Label* on_not_smi_result,
                             Label::Distance near_jump) {
   ASSERT(!dst.is(src2));
   ASSERT(!dst.is(kScratchRegister));
   ASSERT(!src1.is(kScratchRegister));
   ASSERT(!src2.is(kScratchRegister));
 
   if (dst.is(src1)) {
     Label failure, zero_correct_result;
     movq(kScratchRegister, src1);  // Create backup for later testing.
+#if !V8_USE_31_BITS_SMI_VALUE
     SmiToInteger64(dst, src1);
     imul(dst, src2);
+#else
+    SmiToInteger32(dst, src1);
+    imull(dst, src2);
+#endif
     j(overflow, &failure, Label::kNear);
 
     // Check for negative zero result.  If product is zero, and one
     // argument is negative, go to slow case.
     Label correct_result;
     testq(dst, dst);
     j(not_zero, &correct_result, Label::kNear);
 
     movq(dst, kScratchRegister);
     xor_(dst, src2);
     // Result was positive zero.
     j(positive, &zero_correct_result, Label::kNear);
 
     bind(&failure);  // Reused failure exit, restores src1.
     movq(src1, kScratchRegister);
     jmp(on_not_smi_result, near_jump);
 
     bind(&zero_correct_result);
     Set(dst, 0);
 
     bind(&correct_result);
+#if V8_USE_31_BITS_SMI_VALUE
+    movsxlq(dst, dst);
+#endif
   } else {
+#if !V8_USE_31_BITS_SMI_VALUE
     SmiToInteger64(dst, src1);
     imul(dst, src2);
+#else
+    SmiToInteger32(dst, src1);
+    imull(dst, src2);
+#endif
     j(overflow, on_not_smi_result, near_jump);
     // Check for negative zero result.  If product is zero, and one
     // argument is negative, go to slow case.
     Label correct_result;
     testq(dst, dst);
     j(not_zero, &correct_result, Label::kNear);
     // One of src1 and src2 is zero, the check whether the other is
     // negative.
     movq(kScratchRegister, src1);
     xor_(kScratchRegister, src2);
     j(negative, on_not_smi_result, near_jump);
     bind(&correct_result);
+#if V8_USE_31_BITS_SMI_VALUE
+    movsxlq(dst, dst);
+#endif
   }
 }
 
 
 void MacroAssembler::SmiDiv(Register dst,
                             Register src1,
                             Register src2,
                             Label* on_not_smi_result,
                             Label::Distance near_jump) {
   ASSERT(!src1.is(kScratchRegister));
@@ skipping 12 matching lines @@
   }
   SmiToInteger32(rax, src1);
   // We need to rule out dividing Smi::kMinValue by -1, since that would
   // overflow in idiv and raise an exception.
   // We combine this with negative zero test (negative zero only happens
   // when dividing zero by a negative number).
 
   // We overshoot a little and go to slow case if we divide min-value
   // by any negative value, not just -1.
   Label safe_div;
+#if !V8_USE_31_BITS_SMI_VALUE
   testl(rax, Immediate(0x7fffffff));
+#else
+  testl(rax, Immediate(0x3fffffff));
+#endif
   j(not_zero, &safe_div, Label::kNear);
   testq(src2, src2);
   if (src1.is(rax)) {
     j(positive, &safe_div, Label::kNear);
     movq(src1, kScratchRegister);
     jmp(on_not_smi_result, near_jump);
   } else {
     j(negative, on_not_smi_result, near_jump);
   }
   bind(&safe_div);
@@ skipping 73 matching lines @@
   testq(src1, src1);
   j(negative, on_not_smi_result, near_jump);
   bind(&smi_result);
   Integer32ToSmi(dst, rdx);
 }
 
 
 void MacroAssembler::SmiNot(Register dst, Register src) {
   ASSERT(!dst.is(kScratchRegister));
   ASSERT(!src.is(kScratchRegister));
+#if !V8_USE_31_BITS_SMI_VALUE
   // Set tag and padding bits before negating, so that they are zero afterwards.
   movl(kScratchRegister, Immediate(~0));
+#else
+  movl(kScratchRegister, Immediate(1));
+#endif
   if (dst.is(src)) {
     xor_(dst, kScratchRegister);
   } else {
     lea(dst, Operand(src, kScratchRegister, times_1, 0));
   }
   not_(dst);
 }
 
 
 void MacroAssembler::SmiAnd(Register dst, Register src1, Register src2) {
@@ skipping 69 matching lines @@
     if (dst.is(src)) {
       sar(dst, Immediate(shift_value + kSmiShift));
       shl(dst, Immediate(kSmiShift));
     } else {
       UNIMPLEMENTED();  // Not used.
     }
   }
 }
 
 
+#if !V8_USE_31_BITS_SMI_VALUE
 void MacroAssembler::SmiShiftLeftConstant(Register dst,
                                           Register src,
                                           int shift_value) {
   if (!dst.is(src)) {
     movq(dst, src);
   }
   if (shift_value > 0) {
     shl(dst, Immediate(shift_value));
   }
 }
+#else
+void MacroAssembler::SmiShiftLeftConstant(Register dst,
+                                          Register src,
+                                          int shift_value,
+                                          Label* on_not_smi_result) {
+  if (!dst.is(src)) {
+    movq(dst, src);
+  }
+
+  if (shift_value > 0) {
+    Label result_ok;
+    SmiToInteger32(dst, dst);
+    shll(dst, Immediate(shift_value));
+    cmpl(dst, Immediate(0xc0000000));
+    j(not_sign, &result_ok);
+    jmp(on_not_smi_result);
+    bind(&result_ok);
+    Integer32ToSmi(dst, dst);
+  }
+}
+#endif
 
 
 void MacroAssembler::SmiShiftLogicalRightConstant(
     Register dst, Register src, int shift_value,
     Label* on_not_smi_result, Label::Distance near_jump) {
   // Logic right shift interprets its result as an *unsigned* number.
   if (dst.is(src)) {
     UNIMPLEMENTED();  // Not used.
   } else {
     movq(dst, src);
     if (shift_value == 0) {
+#if !V8_USE_31_BITS_SMI_VALUE
       testq(dst, dst);
+#else
+      testl(dst, dst);
+#endif
       j(negative, on_not_smi_result, near_jump);
     }
+#if !V8_USE_31_BITS_SMI_VALUE
     shr(dst, Immediate(shift_value + kSmiShift));
     shl(dst, Immediate(kSmiShift));
+#else
+    SmiToInteger32(dst, dst);
+    shrl(dst, Immediate(shift_value));
+    testl(dst, Immediate(0xc0000000));
+    j(not_zero, on_not_smi_result, near_jump);
+    shll(dst, Immediate(kSmiShift));
+#endif
   }
 }
 
 
+#if !V8_USE_31_BITS_SMI_VALUE
 void MacroAssembler::SmiShiftLeft(Register dst,
                                   Register src1,
                                   Register src2) {
   ASSERT(!dst.is(rcx));
   // Untag shift amount.
   if (!dst.is(src1)) {
     movq(dst, src1);
   }
   SmiToInteger32(rcx, src2);
   // Shift amount specified by lower 5 bits, not six as the shl opcode.
   and_(rcx, Immediate(0x1f));
   shl_cl(dst);
 }
+#else
+void MacroAssembler::SmiShiftLeft(Register dst,
+                                  Register src1,
+                                  Register src2,
+                                  Label* on_not_smi_result) {
+  ASSERT(!dst.is(kScratchRegister));
+  ASSERT(!src1.is(kScratchRegister));
+  ASSERT(!src2.is(kScratchRegister));
+  ASSERT(!dst.is(rcx));
+  Label result_ok;
+
+  if (src1.is(rcx) || src2.is(rcx)) {
+    movq(kScratchRegister, rcx);
+  }
+  // Untag shift amount.
+  if (!dst.is(src1)) {
+    movq(dst, src1);
+  }
+  SmiToInteger32(dst, dst);
+  SmiToInteger32(rcx, src2);
+  // Shift amount specified by lower 5 bits, not six as the shl opcode.
+  andl(rcx, Immediate(0x1f));
+  shll_cl(dst);
+  cmpl(dst, Immediate(0xc0000000));
+  j(not_sign, &result_ok);
+  if (src1.is(rcx) || src2.is(rcx)) {
+    if (src1.is(rcx)) {
+      movq(src1, kScratchRegister);
+    } else {
+      movq(src2, kScratchRegister);
+    }
+  }
+  jmp(on_not_smi_result);
+  bind(&result_ok);
+  Integer32ToSmi(dst, dst);
+}
+#endif
 
 
 void MacroAssembler::SmiShiftLogicalRight(Register dst,
                                           Register src1,
                                           Register src2,
                                           Label* on_not_smi_result,
                                           Label::Distance near_jump) {
+#if !V8_USE_31_BITS_SMI_VALUE
   ASSERT(!dst.is(kScratchRegister));
   ASSERT(!src1.is(kScratchRegister));
   ASSERT(!src2.is(kScratchRegister));
   ASSERT(!dst.is(rcx));
   // dst and src1 can be the same, because the one case that bails out
   // is a shift by 0, which leaves dst, and therefore src1, unchanged.
   if (src1.is(rcx) || src2.is(rcx)) {
     movq(kScratchRegister, rcx);
   }
   if (!dst.is(src1)) {
@@ skipping 11 matching lines @@
       movq(src1, kScratchRegister);
     } else {
       movq(src2, kScratchRegister);
     }
     jmp(on_not_smi_result, near_jump);
     bind(&positive_result);
   } else {
     // src2 was zero and src1 negative.
     j(negative, on_not_smi_result, near_jump);
   }
+#else
+  ASSERT(!dst.is(kScratchRegister));
+  ASSERT(!src1.is(kScratchRegister));
+  ASSERT(!src2.is(kScratchRegister));
+  ASSERT(!dst.is(rcx));
+  Label result_ok;
+
+  // dst and src1 can be the same, because the one case that bails out
+  // is a shift by 0, which leaves dst, and therefore src1, unchanged.
+  if (src1.is(rcx) || src2.is(rcx)) {
+    movq(kScratchRegister, rcx);
+  }
+  if (!dst.is(src1)) {
+    movq(dst, src1);
+  }
+  SmiToInteger32(rcx, src2);
+  SmiToInteger32(dst, dst);
+  shrl_cl(dst);
+  testl(dst, Immediate(0xc0000000));
+  j(zero, &result_ok);
+  if (src1.is(rcx) || src2.is(rcx)) {
+    if (src1.is(rcx)) {
+      movq(src1, kScratchRegister);
+    } else {
+      movq(src2, kScratchRegister);
+    }
+  }
+  jmp(on_not_smi_result);
+  bind(&result_ok);
+  Integer32ToSmi(dst, dst);
+#endif
 }
 
 
 void MacroAssembler::SmiShiftArithmeticRight(Register dst,
                                              Register src1,
                                              Register src2) {
   ASSERT(!dst.is(kScratchRegister));
   ASSERT(!src1.is(kScratchRegister));
   ASSERT(!src2.is(kScratchRegister));
   ASSERT(!dst.is(rcx));
   if (src1.is(rcx)) {
     movq(kScratchRegister, src1);
   } else if (src2.is(rcx)) {
     movq(kScratchRegister, src2);
   }
   if (!dst.is(src1)) {
     movq(dst, src1);
   }
   SmiToInteger32(rcx, src2);
+#if !V8_USE_31_BITS_SMI_VALUE
   orl(rcx, Immediate(kSmiShift));
   sar_cl(dst);  // Shift 32 + original rcx & 0x1f.
-  shl(dst, Immediate(kSmiShift));
+#else
+  SmiToInteger32(dst, dst);
+  sarl_cl(dst);
+#endif
+  Integer32ToSmi(dst, dst);
   if (src1.is(rcx)) {
     movq(src1, kScratchRegister);
   } else if (src2.is(rcx)) {
     movq(src2, kScratchRegister);
   }
 }
 
 
 void MacroAssembler::SelectNonSmi(Register dst,
                                   Register src1,
@@ skipping 36 matching lines @@
 
 SmiIndex MacroAssembler::SmiToIndex(Register dst,
                                     Register src,
                                     int shift) {
   ASSERT(is_uint6(shift));
   // There is a possible optimization if shift is in the range 60-63, but that
   // will (and must) never happen.
   if (!dst.is(src)) {
     movq(dst, src);
   }
+#if !V8_USE_31_BITS_SMI_VALUE
   if (shift < kSmiShift) {
     sar(dst, Immediate(kSmiShift - shift));
   } else {
     shl(dst, Immediate(shift - kSmiShift));
   }
   return SmiIndex(dst, times_1);
+#else
+  if (shift == times_1) {
+    sar(dst, Immediate(kSmiShift));
+    return SmiIndex(dst, times_1);
+  }
+  return SmiIndex(dst, static_cast<ScaleFactor>(shift - 1));
+#endif
 }
 
+
 SmiIndex MacroAssembler::SmiToNegativeIndex(Register dst,
                                             Register src,
                                             int shift) {
   // Register src holds a positive smi.
   ASSERT(is_uint6(shift));
   if (!dst.is(src)) {
     movq(dst, src);
   }
   neg(dst);
+#if !V8_USE_31_BITS_SMI_VALUE
   if (shift < kSmiShift) {
     sar(dst, Immediate(kSmiShift - shift));
   } else {
     shl(dst, Immediate(shift - kSmiShift));
   }
   return SmiIndex(dst, times_1);
+#else
+  if (shift == times_1) {
+    sar(dst, Immediate(kSmiShift));
+    return SmiIndex(dst, times_1);
+  }
+  return SmiIndex(dst, static_cast<ScaleFactor>(shift - 1));
+#endif
 }
 
 
 void MacroAssembler::AddSmiField(Register dst, const Operand& src) {
+#if !V8_USE_31_BITS_SMI_VALUE
   ASSERT_EQ(0, kSmiShift % kBitsPerByte);
   addl(dst, Operand(src, kSmiShift / kBitsPerByte));
+#else
+  SmiToInteger32(kScratchRegister, src);
+  addl(dst, kScratchRegister);
+#endif
 }
 
 
 void MacroAssembler::JumpIfNotString(Register object,
                                      Register object_map,
                                      Label* not_string,
                                      Label::Distance near_jump) {
   Condition is_smi = CheckSmi(object);
   j(is_smi, not_string, near_jump);
   CmpObjectType(object, FIRST_NONSTRING_TYPE, object_map);
@@ skipping 241 matching lines @@
 
 
 void MacroAssembler::Drop(int stack_elements) {
   if (stack_elements > 0) {
     addq(rsp, Immediate(stack_elements * kPointerSize));
   }
 }
 
 
 void MacroAssembler::Test(const Operand& src, Smi* source) {
+#if !V8_USE_31_BITS_SMI_VALUE
   testl(Operand(src, kIntSize), Immediate(source->value()));
+#else
+  testl(src, Immediate(source));
+#endif
 }
 
 
 void MacroAssembler::TestBit(const Operand& src, int bits) {
+#if V8_USE_31_BITS_SMI_VALUE
+  bits += kSmiTagSize + kSmiShiftSize;
+#endif
   int byte_offset = bits / kBitsPerByte;
   int bit_in_byte = bits & (kBitsPerByte - 1);
   testb(Operand(src, byte_offset), Immediate(1 << bit_in_byte));
 }
 
 
 void MacroAssembler::Jump(ExternalReference ext) {
   LoadAddress(kScratchRegister, ext);
   jmp(kScratchRegister);
 }
@@ skipping 2197 matching lines @@
   j(greater, &no_memento_available);
   CompareRoot(MemOperand(scratch_reg, -AllocationMemento::kSize),
               Heap::kAllocationMementoMapRootIndex);
   bind(&no_memento_available);
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_X64