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 966 matching lines @@
 void MacroAssembler::Set(const Operand& dst, int64_t x) {
   if (is_int32(x)) {
     movq(dst, Immediate(static_cast<int32_t>(x)));
   } else {
     Set(kScratchRegister, x);
     movq(dst, kScratchRegister);
   }
 }
 
 
+// ----------------------------------------------------------------------------
+// Smi tagging, untagging and tag detection.
+
+
+static inline Immediate SmiToImmediate(Smi* src) {
+  if (kSmiValueSize == 32) {
+    UNREACHABLE();
+    return Immediate(2);
+  } else {
+    return Immediate(static_cast<int32_t>(reinterpret_cast<intptr_t>(src)));
+  }
+}
+
+
 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));
-  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);
+  if (kSmiValueSize == 32) {
+    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 {
-    Move(dst, src);
+    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);
+    }
   }
 }
 
 
 void MacroAssembler::SafePush(Smi* src) {
-  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);
+  if (kSmiValueSize == 32) {
+    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 {
-    Push(src);
+    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);
+    }
   }
 }
 
 
-// ----------------------------------------------------------------------------
-// Smi tagging, untagging and tag detection.
-
 Register MacroAssembler::GetSmiConstant(Smi* source) {
   int value = source->value();
   if (value == 0) {
     xorl(kScratchRegister, kScratchRegister);
     return kScratchRegister;
   }
   if (value == 1) {
     return kSmiConstantRegister;
   }
   LoadSmiConstant(kScratchRegister, source);
@@ skipping 59 matching lines @@
     neg(dst);
   }
 }
 
 
 void MacroAssembler::Integer32ToSmi(Register dst, Register src) {
   STATIC_ASSERT(kSmiTag == 0);
   if (!dst.is(src)) {
     movl(dst, src);
   }
-  shl(dst, Immediate(kSmiShift));
+  if (kSmiValueSize == 32) {
+    shl(dst, Immediate(kSmiShift));
+  } else {
+    ASSERT(kSmiValueSize == 31);
+    shll(dst, Immediate(kSmiShift));
+    movsxlq(dst, dst);
+  }
 }
 
 
 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(kInteger32ToSmiFieldWritingToNonSmiLocation);
     } else {
       int3();
     }
     bind(&ok);
   }
-  ASSERT(kSmiShift % kBitsPerByte == 0);
-  movl(Operand(dst, kSmiShift / kBitsPerByte), src);
+  if (kSmiValueSize == 32) {
+    ASSERT(kSmiShift % kBitsPerByte == 0);
+    movl(Operand(dst, kSmiShift / kBitsPerByte), src);
+  } else {
+    ASSERT(kSmiValueSize == 31);
+    Integer32ToSmi(kScratchRegister, src);
+    movq(dst, kScratchRegister);
+  }
 }
 
 
 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);
   }
-  shr(dst, Immediate(kSmiShift));
+  if (kSmiValueSize == 32) {
+    shr(dst, Immediate(kSmiShift));
+  } else {
+    ASSERT(kSmiValueSize == 31);
+    sarl(dst, Immediate(kSmiShift));
+  }
 }
 
 
 void MacroAssembler::SmiToInteger32(Register dst, const Operand& src) {
-  movl(dst, Operand(src, kSmiShift / kBitsPerByte));
+  if (kSmiValueSize == 32) {
+    movl(dst, Operand(src, kSmiShift / kBitsPerByte));
+  } else {
+    ASSERT(kSmiValueSize == 31);
+    movl(dst, src);
+    sarl(dst, Immediate(kSmiShift));
+  }
 }
 
 
 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) {
-  movsxlq(dst, Operand(src, kSmiShift / kBitsPerByte));
+  if (kSmiValueSize == 32) {
+    movsxlq(dst, Operand(src, kSmiShift / kBitsPerByte));
+  } else {
+    ASSERT(kSmiValueSize == 31);
+    movq(dst, src);
+    SmiToInteger64(dst, dst);
+  }
 }
 
 
 void MacroAssembler::SmiTest(Register src) {
   AssertSmi(src);
-  testq(src, src);
+  if (kSmiValueSize == 32) {
+    testq(src, src);
+  } else {
+    ASSERT(kSmiValueSize == 31);
+    testl(src, src);
+  }
 }
 
 
 void MacroAssembler::SmiCompare(Register smi1, Register smi2) {
   AssertSmi(smi1);
   AssertSmi(smi2);
-  cmpq(smi1, smi2);
+  if (kSmiValueSize == 32) {
+    cmpq(smi1, smi2);
+  } else {
+    ASSERT(kSmiValueSize == 31);
+    cmpl(smi1, smi2);
+  }
 }
 
 
 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) {
-    testq(dst, dst);
+    if (kSmiValueSize == 32) {
+      testq(dst, dst);
+    } else {
+      ASSERT(kSmiValueSize == 31);
+      testl(dst, dst);
+    }
   } else {
     Register constant_reg = GetSmiConstant(src);
-    cmpq(dst, constant_reg);
+    if (kSmiValueSize == 32) {
+      cmpq(dst, constant_reg);
+    } else {
+      ASSERT(kSmiValueSize == 31);
+      cmpl(dst, constant_reg);
+    }
   }
 }
 
 
 void MacroAssembler::SmiCompare(Register dst, const Operand& src) {
   AssertSmi(dst);
   AssertSmi(src);
-  cmpq(dst, src);
+  if (kSmiValueSize == 32) {
+    cmpq(dst, src);
+  } else {
+    ASSERT(kSmiValueSize == 31);
+    cmpl(dst, src);
+  }
 }
 
 
 void MacroAssembler::SmiCompare(const Operand& dst, Register src) {
   AssertSmi(dst);
   AssertSmi(src);
-  cmpq(dst, src);
+  if (kSmiValueSize == 32) {
+    cmpq(dst, src);
+  } else {
+    ASSERT(kSmiValueSize == 31);
+    cmpl(dst, src);
+  }
 }
 
 
 void MacroAssembler::SmiCompare(const Operand& dst, Smi* src) {
   AssertSmi(dst);
-  cmpl(Operand(dst, kSmiShift / kBitsPerByte), Immediate(src->value()));
+  if (kSmiValueSize == 32) {
+    cmpl(Operand(dst, kSmiShift / kBitsPerByte), Immediate(src->value()));
+  } else {
+    ASSERT(kSmiValueSize == 31);
+    cmpl(dst, SmiToImmediate(src));
+  }
 }
 
 
 void MacroAssembler::Cmp(const Operand& dst, Smi* src) {
-  // The Operand cannot use the smi register.
-  Register smi_reg = GetSmiConstant(src);
-  ASSERT(!dst.AddressUsesRegister(smi_reg));
-  cmpq(dst, smi_reg);
+  if (kSmiValueSize == 32) {
+    // The Operand cannot use the smi register.
+    Register smi_reg = GetSmiConstant(src);
+    ASSERT(!dst.AddressUsesRegister(smi_reg));
+    cmpq(dst, smi_reg);
+  } else {
+    ASSERT(kSmiValueSize == 31);
+    cmpl(dst, SmiToImmediate(src));
+  }
 }
 
 
 void MacroAssembler::SmiCompareInteger32(const Operand& dst, Register src) {
-  cmpl(Operand(dst, kSmiShift / kBitsPerByte), src);
+  if (kSmiValueSize == 32) {
+    cmpl(Operand(dst, kSmiShift / kBitsPerByte), src);
+  } else {
+    ASSERT(kSmiValueSize == 31);
+    SmiToInteger32(kScratchRegister, dst);
+    cmpl(kScratchRegister, src);
+  }
 }
 
 
 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)) {
-    shr(dst, Immediate(power + kSmiShift));
+    if (kSmiValueSize == 32) {
+      shr(dst, Immediate(power + kSmiShift));
+    } else {
+      ASSERT(kSmiValueSize == 31);
+      shrl(dst, Immediate(power + kSmiShift));
+    }
   } 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 33 matching lines @@
   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);
-  leal(kScratchRegister, Operand(first, second, times_1, 0));
-  testb(kScratchRegister, Immediate(0x03));
+  if (kSmiValueSize == 32) {
+    leal(kScratchRegister, Operand(first, second, times_1, 0));
+    testb(kScratchRegister, Immediate(0x03));
+  } else {
+    ASSERT(kSmiValueSize == 31);
+    movl(kScratchRegister, first);
+    orl(kScratchRegister, second);
+    testb(kScratchRegister, Immediate(kSmiTagMask));
+  }
   return zero;
 }
 
 
 Condition MacroAssembler::CheckBothNonNegativeSmi(Register first,
                                                   Register second) {
   if (first.is(second)) {
     return CheckNonNegativeSmi(first);
   }
   movq(kScratchRegister, first);
@@ skipping 19 matching lines @@
     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.
-  cmpq(src, kSmiConstantRegister);
+  if (kSmiValueSize == 32) {
+    cmpq(src, kSmiConstantRegister);
+  } else {
+    ASSERT(kSmiValueSize == 31);
+    cmpl(src, kSmiConstantRegister);
+  }
   return overflow;
 }
 
 
 Condition MacroAssembler::CheckInteger32ValidSmiValue(Register src) {
-  // A 32-bit integer value can always be converted to a smi.
-  return always;
+  if (kSmiValueSize == 32) {
+    // A 32-bit integer value can always be converted to a smi.
+    return always;
+  } else {
+    ASSERT(kSmiValueSize == 31);
+    cmpl(src, Immediate(0xc0000000));
+    return positive;
+  }
 }
 
 
 Condition MacroAssembler::CheckUInteger32ValidSmiValue(Register src) {
-  // An unsigned 32-bit integer value is valid as long as the high bit
-  // is not set.
-  testl(src, src);
-  return positive;
+  if (kSmiValueSize == 32) {
+    // An unsigned 32-bit integer value is valid as long as the high bit
+    // is not set.
+    testl(src, src);
+    return positive;
+  } else {
+    ASSERT(kSmiValueSize == 31);
+    testl(src, Immediate(0xc0000000));
+    return zero;
+  }
 }
 
 
 void MacroAssembler::CheckSmiToIndicator(Register dst, Register src) {
   if (dst.is(src)) {
     andl(dst, Immediate(kSmiTagMask));
   } else {
     movl(dst, Immediate(kSmiTagMask));
     andl(dst, src);
   }
@@ skipping 12 matching lines @@
 
 
 void MacroAssembler::JumpIfNotValidSmiValue(Register src,
                                             Label* on_invalid,
                                             Label::Distance near_jump) {
   Condition is_valid = CheckInteger32ValidSmiValue(src);
   j(NegateCondition(is_valid), on_invalid, near_jump);
 }
 
 
+void MacroAssembler::JumpIfValidSmiValue(Register src,
+                                         Label* on_valid,
+                                         Label::Distance near_jump) {
+  Condition is_valid = CheckInteger32ValidSmiValue(src);
+  j(is_valid, on_valid, near_jump);
+}
+
+
 void MacroAssembler::JumpIfUIntNotValidSmiValue(Register src,
                                                 Label* on_invalid,
                                                 Label::Distance near_jump) {
   Condition is_valid = CheckUInteger32ValidSmiValue(src);
   j(NegateCondition(is_valid), on_invalid, near_jump);
 }
 
 
+void MacroAssembler::JumpIfUIntValidSmiValue(Register src,
+                                             Label* on_valid,
+                                             Label::Distance near_jump) {
+  Condition is_valid = CheckUInteger32ValidSmiValue(src);
+  j(is_valid, on_valid, near_jump);
+}
+
+
 void MacroAssembler::JumpIfSmi(Register src,
                                Label* on_smi,
                                Label::Distance near_jump) {
   Condition smi = CheckSmi(src);
   j(smi, on_smi, near_jump);
 }
 
 
 void MacroAssembler::JumpIfNotSmi(Register src,
                                   Label* on_not_smi,
@@ skipping 45 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);
-  addq(tmp, src);
+  if (kSmiValueSize == 32) {
+    addq(tmp, src);
+  } else {
+    ASSERT(kSmiValueSize == 31);
+    addl(tmp, src);
+  }
   j(overflow, on_not_smi_result, near_jump);
   if (dst.is(src)) {
     movq(dst, tmp);
   }
+  if (kSmiValueSize == 31) {
+    movsxlq(dst, dst);
+  }
 }
 
 
 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) {
-    addl(Operand(dst, kSmiShift / kBitsPerByte), Immediate(constant->value()));
+    if (kSmiValueSize == 32) {
+      addl(Operand(dst, kSmiShift / kBitsPerByte),
+           Immediate(constant->value()));
+    } else {
+      ASSERT(kSmiValueSize == 31);
+      addq(dst, SmiToImmediate(constant));
+    }
   }
 }
 
 
 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);
-    addq(kScratchRegister, src);
+    if (kSmiValueSize == 32) {
+      addq(kScratchRegister, src);
+    } else {
+      ASSERT(kSmiValueSize == 31);
+      addl(kScratchRegister, src);
+    }
     j(overflow, on_not_smi_result, near_jump);
-    movq(dst, kScratchRegister);
+    if (kSmiValueSize == 32) {
+      movq(dst, kScratchRegister);
+    } else {
+      ASSERT(kSmiValueSize == 31);
+      movsxlq(dst, kScratchRegister);
+    }
   } else {
     LoadSmiConstant(dst, constant);
-    addq(dst, src);
+    if (kSmiValueSize == 32) {
+      addq(dst, src);
+    } else {
+      ASSERT(kSmiValueSize == 31);
+      addl(dst, src);
+    }
     j(overflow, on_not_smi_result, near_jump);
+    if (kSmiValueSize == 31) {
+      movsxlq(dst, dst);
+    }
   }
 }
 
 
 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) {
-      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);
+      if (kSmiValueSize == 32) {
+        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 {
+        ASSERT(kSmiValueSize == 31);
+        movq(dst, src);
+        subq(dst, SmiToImmediate(constant));
+      }
     } 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.
-      testq(src, src);
+      if (kSmiValueSize == 32) {
+        testq(src, src);
+      } else {
+        ASSERT(kSmiValueSize == 31);
+        testl(src, src);
+      }
       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()));
-      addq(kScratchRegister, dst);
+      if (kSmiValueSize == 32) {
+        addq(kScratchRegister, dst);
+      } else {
+        ASSERT(kSmiValueSize == 31);
+        addl(kScratchRegister, dst);
+      }
       j(overflow, on_not_smi_result, near_jump);
-      movq(dst, kScratchRegister);
+      if (kSmiValueSize == 32) {
+        movq(dst, kScratchRegister);
+      } else {
+        ASSERT(kSmiValueSize == 31);
+        movsxlq(dst, kScratchRegister);
+      }
     }
   } 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.
-      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);
+      if (kSmiValueSize == 32) {
+        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 {
+        ASSERT(kSmiValueSize == 31);
+        testl(src, src);
+        j(not_sign, on_not_smi_result, near_jump);
+        movq(dst, src);
+        subq(dst, SmiToImmediate(constant));
+      }
     } else {
       // Subtract by adding the negation.
       LoadSmiConstant(dst, Smi::FromInt(-(constant->value())));
-      addq(dst, src);
+      if (kSmiValueSize == 32) {
+        addq(dst, src);
+      } else {
+        ASSERT(kSmiValueSize == 31);
+        addl(dst, src);
+      }
       j(overflow, on_not_smi_result, near_jump);
+      if (kSmiValueSize == 31) {
+        movsxlq(dst, dst);
+      }
     }
   }
 }
 
 
 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 (kSmiValueSize == 32) {
     cmpq(dst, kScratchRegister);
-    j(not_equal, on_smi_result, near_jump);
-    movq(src, kScratchRegister);
+  } else {
+    ASSERT(kSmiValueSize == 31);
+    cmpl(dst, kScratchRegister);
+  }
+  j(not_equal, on_smi_result, near_jump);
+  movq(src, kScratchRegister);
   } else {
     movq(dst, src);
     neg(dst);
-    cmpq(dst, src);
+    if (kSmiValueSize == 32) {
+      cmpq(dst, src);
+    } else {
+      ASSERT(kSmiValueSize == 31);
+      cmpl(dst, src);
+    }
     // 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);
-    addq(kScratchRegister, src2);
+    if (kSmiValueSize == 32) {
+      addq(kScratchRegister, src2);
+    } else {
+      ASSERT(kSmiValueSize == 31);
+      addl(kScratchRegister, src2);
+    }
     j(overflow, on_not_smi_result, near_jump);
-    movq(dst, kScratchRegister);
+    if (kSmiValueSize == 32) {
+      movq(dst, kScratchRegister);
+    } else {
+      ASSERT(kSmiValueSize == 31);
+      movsxlq(dst, kScratchRegister);
+    }
   } else {
     movq(dst, src1);
-    addq(dst, src2);
+    if (kSmiValueSize == 32) {
+      addq(dst, src2);
+    } else {
+      ASSERT(kSmiValueSize == 31);
+      addl(dst, src2);
+    }
     j(overflow, on_not_smi_result, near_jump);
+    if (kSmiValueSize == 31) {
+      movsxlq(dst, dst);
+    }
   }
 }
 
 
 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);
-    addq(kScratchRegister, src2);
+    if (kSmiValueSize == 32) {
+      addq(kScratchRegister, src2);
+    } else {
+      ASSERT(kSmiValueSize == 31);
+      addl(kScratchRegister, src2);
+    }
     j(overflow, on_not_smi_result, near_jump);
-    movq(dst, kScratchRegister);
+    if (kSmiValueSize == 32) {
+      movq(dst, kScratchRegister);
+    } else {
+      ASSERT(kSmiValueSize == 31);
+      movsxlq(dst, kScratchRegister);
+    }
   } else {
     ASSERT(!src2.AddressUsesRegister(dst));
     movq(dst, src1);
-    addq(dst, src2);
+    if (kSmiValueSize == 32) {
+      addq(dst, src2);
+    } else {
+      ASSERT(kSmiValueSize == 31);
+      addl(dst, src2);
+    }
     j(overflow, on_not_smi_result, near_jump);
+  if (kSmiValueSize == 31) {
+    movsxlq(dst, dst);
   }
 }
+}
 
 
 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)) {
     if (emit_debug_code()) {
       movq(kScratchRegister, src1);
       addq(kScratchRegister, src2);
       Check(no_overflow, kSmiAdditionOverflow);
     }
     lea(dst, Operand(src1, src2, times_1, 0));
   } else {
     addq(dst, src2);
     Assert(no_overflow, kSmiAdditionOverflow);
   }
 }
 
 
 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)) {
-    cmpq(dst, src2);
+    if (kSmiValueSize == 32) {
+      cmpq(dst, src2);
+    } else {
+      ASSERT(kSmiValueSize == 31);
+      cmpl(dst, src2);
+    }
     j(overflow, on_not_smi_result, near_jump);
     subq(dst, src2);
   } else {
-    movq(dst, src1);
-    subq(dst, src2);
+    if (kSmiValueSize == 32) {
+      movq(dst, src1);
+      subq(dst, src2);
+    } else {
+      ASSERT(kSmiValueSize == 31);
+      movl(dst, src1);
+      subl(dst, src2);
+    }
     j(overflow, on_not_smi_result, near_jump);
+    if (kSmiValueSize == 31) {
+      movsxlq(dst, dst);
+    }
   }
 }
 
 
 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, kSmiSubtractionOverflow);
 }
 
 
 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)) {
-    movq(kScratchRegister, src2);
-    cmpq(src1, kScratchRegister);
+    if (kSmiValueSize == 32) {
+      movq(kScratchRegister, src2);
+      cmpq(src1, kScratchRegister);
+    } else {
+      ASSERT(kSmiValueSize == 31);
+      movl(kScratchRegister, src2);
+      cmpl(src1, kScratchRegister);
+    }
     j(overflow, on_not_smi_result, near_jump);
-    subq(src1, kScratchRegister);
+    if (kSmiValueSize == 32) {
+      subq(src1, kScratchRegister);
+    } else {
+      ASSERT(kSmiValueSize == 31);
+      movsxlq(src1, kScratchRegister);
+    }
   } else {
-    movq(dst, src1);
-    subq(dst, src2);
+    if (kSmiValueSize == 32) {
+      movq(dst, src1);
+      subq(dst, src2);
+    } else {
+      ASSERT(kSmiValueSize == 31);
+      movl(dst, src1);
+      subl(dst, src2);
+    }
     j(overflow, on_not_smi_result, near_jump);
+    if (kSmiValueSize == 31) {
+      movsxlq(dst, dst);
+    }
   }
 }
 
 
 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.
-    SmiToInteger64(dst, src1);
-    imul(dst, src2);
+    if (kSmiValueSize == 32) {
+      SmiToInteger64(dst, src1);
+      imul(dst, src2);
+    } else {
+      ASSERT(kSmiValueSize == 31);
+      SmiToInteger32(dst, src1);
+      imull(dst, src2);
+    }
     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 (kSmiValueSize == 31) {
+      movsxlq(dst, dst);
+    }
   } else {
-    SmiToInteger64(dst, src1);
-    imul(dst, src2);
+    if (kSmiValueSize == 32) {
+      SmiToInteger64(dst, src1);
+      imul(dst, src2);
+    } else {
+      ASSERT(kSmiValueSize == 31);
+      SmiToInteger32(dst, src1);
+      imull(dst, src2);
+    }
     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 (kSmiValueSize == 31) {
+      movsxlq(dst, dst);
+    }
   }
 }
 
 
 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;
-  testl(rax, Immediate(0x7fffffff));
+  if (kSmiValueSize == 32) {
+    testl(rax, Immediate(0x7fffffff));
+  } else {
+    ASSERT(kSmiValueSize == 31);
+    testl(rax, Immediate(0x3fffffff));
+  }
   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 (kSmiValueSize == 32) {
   // Set tag and padding bits before negating, so that they are zero afterwards.
-  movl(kScratchRegister, Immediate(~0));
+    movl(kScratchRegister, Immediate(~0));
+  } else {
+    ASSERT(kSmiValueSize == 31);
+    movl(kScratchRegister, Immediate(1));
+  }
   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 71 matching lines @@
       shl(dst, Immediate(kSmiShift));
     } else {
       UNIMPLEMENTED();  // Not used.
     }
   }
 }
 
 
 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));
+                                          int shift_value,
+                                          SmiFunctionInvoker& invoker) {
+  if (kSmiValueSize == 32) {
+    if (!dst.is(src)) {
+      movq(dst, src);
+    }
+    if (shift_value > 0) {
+      shl(dst, Immediate(shift_value));
+    }
+  } else {
+    ASSERT(kSmiValueSize == 31);
+    if (dst.is(src)) {
+      ASSERT(!invoker.reserve_source_operands());
+    } else {
+      movq(dst, src);
+    }
+    if (shift_value > 0) {
+      SmiToInteger32(dst, dst);
+      shll(dst, Immediate(shift_value));
+      if (invoker.on_not_smi_result() != NULL) {
+        JumpIfNotValidSmiValue(dst, invoker.on_not_smi_result());
+      } else {
+        Label done;
+        JumpIfValidSmiValue(dst, &done, Label::kNear);
+        invoker.Bailout();
+        bind(&done);
+      }
+      Integer32ToSmi(dst, dst);
+    }
   }
 }
 
 
 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) {
-      testq(dst, dst);
+      if (kSmiValueSize == 32) {
+        testq(dst, dst);
+      } else {
+        ASSERT(kSmiValueSize == 31);
+        testl(dst, dst);
+      }
       j(negative, on_not_smi_result, near_jump);
     }
-    shr(dst, Immediate(shift_value + kSmiShift));
-    shl(dst, Immediate(kSmiShift));
+    if (kSmiValueSize == 32) {
+      shr(dst, Immediate(shift_value + kSmiShift));
+      shl(dst, Immediate(kSmiShift));
+    } else {
+      ASSERT(kSmiValueSize == 31);
+      SmiToInteger32(dst, dst);
+      shrl(dst, Immediate(shift_value));
+      JumpIfUIntNotValidSmiValue(dst, on_not_smi_result, near_jump);
+      shll(dst, Immediate(kSmiShift));
+    }
   }
 }
 
 
 void MacroAssembler::SmiShiftLeft(Register dst,
                                   Register src1,
-                                  Register src2) {
-  ASSERT(!dst.is(rcx));
-  // Untag shift amount.
-  if (!dst.is(src1)) {
-    movq(dst, src1);
+                                  Register src2,
+                                  Label* on_not_smi_result) {
+  if (kSmiValueSize == 32) {
+    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 {
+    ASSERT(kSmiValueSize == 31);
+    ASSERT(!dst.is(kScratchRegister));
+    ASSERT(!src1.is(kScratchRegister));
+    ASSERT(!src2.is(kScratchRegister));
+    ASSERT(!dst.is(rcx));
+    Label result_ok;
+
+    if (dst.is(src1)) {
+      UNIMPLEMENTED();  // Not used.
+    } else {
+      if (src1.is(rcx) || src2.is(rcx)) {
+        movq(kScratchRegister, rcx);
+      }
+      movq(dst, src1);
+      SmiToInteger32(dst, dst);
+      // Untag shift amount.
+      SmiToInteger32(rcx, src2);
+      // Shift amount specified by lower 5 bits, not six as the shl opcode.
+      andl(rcx, Immediate(0x1f));
+      shll_cl(dst);
+      JumpIfValidSmiValue(dst, &result_ok, Label::kNear);
+      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);
+    }
   }
-  SmiToInteger32(rcx, src2);
-  // Shift amount specified by lower 5 bits, not six as the shl opcode.
-  and_(rcx, Immediate(0x1f));
-  shl_cl(dst);
 }
 
 
 void MacroAssembler::SmiShiftLogicalRight(Register dst,
                                           Register src1,
                                           Register src2,
                                           Label* on_not_smi_result,
                                           Label::Distance near_jump) {
   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)) {
+  Label result_ok;
+
+  if (dst.is(src1)) {
+    UNIMPLEMENTED();  // Not used.
+  } else {
+    if (src1.is(rcx) || src2.is(rcx)) {
+      movq(kScratchRegister, rcx);
+    }
     movq(dst, src1);
-  }
-  SmiToInteger32(rcx, src2);
-  orl(rcx, Immediate(kSmiShift));
-  shr_cl(dst);  // Shift is rcx modulo 0x1f + 32.
-  shl(dst, Immediate(kSmiShift));
-  testq(dst, dst);
-  if (src1.is(rcx) || src2.is(rcx)) {
-    Label positive_result;
-    j(positive, &positive_result, Label::kNear);
-    if (src1.is(rcx)) {
-      movq(src1, kScratchRegister);
-    } else {
-      movq(src2, kScratchRegister);
+    SmiToInteger32(dst, dst);
+    SmiToInteger32(rcx, src2);
+    shrl_cl(dst);
+    JumpIfUIntValidSmiValue(dst, &result_ok, Label::kNear);
+    if (src1.is(rcx) || src2.is(rcx)) {
+      if (src1.is(rcx)) {
+        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);
+    jmp(on_not_smi_result);
+    bind(&result_ok);
+    Integer32ToSmi(dst, dst);
   }
 }
 
 
 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);
-  orl(rcx, Immediate(kSmiShift));
-  sar_cl(dst);  // Shift 32 + original rcx & 0x1f.
-  shl(dst, Immediate(kSmiShift));
+  if (kSmiValueSize == 32) {
+    orl(rcx, Immediate(kSmiShift));
+    sar_cl(dst);  // Shift 32 + original rcx & 0x1f.
+  } else {
+    ASSERT(kSmiValueSize == 31);
+    SmiToInteger32(dst, dst);
+    sarl_cl(dst);
+  }
+  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 (shift < kSmiShift) {
-    sar(dst, Immediate(kSmiShift - shift));
+  if (kSmiValueSize == 32) {
+    if (shift < kSmiShift) {
+      sar(dst, Immediate(kSmiShift - shift));
+    } else {
+      shl(dst, Immediate(shift - kSmiShift));
+    }
+    return SmiIndex(dst, times_1);
   } else {
-    shl(dst, Immediate(shift - kSmiShift));
+    ASSERT(kSmiValueSize == 31);
+    if (shift == times_1) {
+      sar(dst, Immediate(kSmiShift));
+      return SmiIndex(dst, times_1);
+    }
+    return SmiIndex(dst, static_cast<ScaleFactor>(shift - 1));
   }
-  return SmiIndex(dst, times_1);
 }
 
+
 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 (shift < kSmiShift) {
-    sar(dst, Immediate(kSmiShift - shift));
+  if (kSmiValueSize == 32) {
+    if (shift < kSmiShift) {
+      sar(dst, Immediate(kSmiShift - shift));
+    } else {
+      shl(dst, Immediate(shift - kSmiShift));
+    }
+    return SmiIndex(dst, times_1);
   } else {
-    shl(dst, Immediate(shift - kSmiShift));
+    ASSERT(kSmiValueSize == 31);
+    if (shift == times_1) {
+      sar(dst, Immediate(kSmiShift));
+      return SmiIndex(dst, times_1);
+    }
+    return SmiIndex(dst, static_cast<ScaleFactor>(shift - 1));
   }
-  return SmiIndex(dst, times_1);
 }
 
 
 void MacroAssembler::AddSmiField(Register dst, const Operand& src) {
-  ASSERT_EQ(0, kSmiShift % kBitsPerByte);
-  addl(dst, Operand(src, kSmiShift / kBitsPerByte));
+  if (kSmiValueSize == 32) {
+    ASSERT_EQ(0, kSmiShift % kBitsPerByte);
+    addl(dst, Operand(src, kSmiShift / kBitsPerByte));
+  } else {
+    ASSERT(kSmiValueSize == 31);
+    SmiToInteger32(kScratchRegister, src);
+    addl(dst, kScratchRegister);
+  }
 }
 
 
+void MacroAssembler::Test(const Operand& src, Smi* source) {
+  if (kSmiValueSize == 32) {
+    testl(Operand(src, kIntSize), Immediate(source->value()));
+  } else {
+    ASSERT(kSmiValueSize == 31);
+    testl(src, SmiToImmediate(source));
+  }
+}
+
+
+void MacroAssembler::TestBit(const Operand& src, int bits) {
+  int byte_offset = bits / kBitsPerByte;
+  int bit_in_byte = bits & (kBitsPerByte - 1);
+  testb(Operand(src, byte_offset), Immediate(1 << bit_in_byte));
+}
+
+
+void MacroAssembler::PushInt64AsTwoSmis(Register src, Register scratch) {
+  movq(scratch, src);
+  // High bits.
+  shr(src, Immediate(64 - kSmiShift));
+  shl(src, Immediate(kSmiShift));
+  push(src);
+  // Low bits.
+  shl(scratch, Immediate(kSmiShift));
+  push(scratch);
+}
+
+
+void MacroAssembler::PopInt64AsTwoSmis(Register dst, Register scratch) {
+  pop(scratch);
+  // Low bits.
+  shr(scratch, Immediate(kSmiShift));
+  pop(dst);
+  shr(dst, Immediate(kSmiShift));
+  // High bits.
+  shl(dst, Immediate(64 - kSmiShift));
+  or_(dst, scratch);
+}
+
+
+bool MacroAssembler::IsUnsafeSmiOperator(Token::Value op) {
+  return (op == Token::ADD || op == Token::SUB || op == Token::MUL ||
+          op == Token::DIV || (kSmiValueSize == 31 && op == Token::SHL) ||
+          op == Token::SHR);
+}
+
+
+// End of smi tagging, untagging and tag detection.
+// ----------------------------------------------------------------------------
+
+
 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);
   j(above_equal, not_string, near_jump);
 }
 
@@ skipping 237 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) {
-  testl(Operand(src, kIntSize), Immediate(source->value()));
-}
-
-
-void MacroAssembler::TestBit(const Operand& src, int bits) {
-  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);
 }
 
 
 void MacroAssembler::Jump(Address destination, RelocInfo::Mode rmode) {
   movq(kScratchRegister, destination, rmode);
   jmp(kScratchRegister);
 }
@@ skipping 2190 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