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

test/cctest/test-macro-assembler-x64.cc

 // Copyright 2009 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 868 matching lines @@
   __ SmiSubConstant(r9, rcx, Smi::FromInt(second), exit);
   __ cmpq(r9, r8);
   __ j(not_equal, exit);
 
   __ incq(rax);  // Test 5.
   __ SmiSubConstant(rcx, rcx, Smi::FromInt(second), exit);
   __ cmpq(rcx, r8);
   __ j(not_equal, exit);
 }
 
+
 static void SmiSubOverflowTest(MacroAssembler* masm,
                                Label* exit,
                                int id,
                                int x) {
   // Subtracts a Smi from x so that the subtraction overflows.
   ASSERT(x != -1);  // Can't overflow by subtracting a Smi.
   int y_max = (x < 0) ? (Smi::kMaxValue + 0) : (Smi::kMinValue + 0);
   int y_min = (x < 0) ? (Smi::kMaxValue + x + 2) : (Smi::kMinValue + x);
 
   __ movl(rax, Immediate(id));
@@ skipping 135 matching lines @@
   __ ret(0);
 
   CodeDesc desc;
   masm->GetCode(&desc);
   // Call the function from C++.
   int result = FUNCTION_CAST<F0>(buffer)();
   CHECK_EQ(0, result);
 }
 
 
-
 void TestSmiMul(MacroAssembler* masm, Label* exit, int id, int x, int y) {
   int64_t result = static_cast<int64_t>(x) * static_cast<int64_t>(y);
   bool negative_zero = (result == 0) && (x < 0 || y < 0);
   __ Move(rcx, Smi::FromInt(x));
   __ movq(r11, rcx);
   __ Move(rdx, Smi::FromInt(y));
   if (Smi::IsValid(result) && !negative_zero) {
     __ movl(rax, Immediate(id));
     __ Move(r8, Smi::FromIntptr(result));
     __ SmiMul(r9, rcx, rdx, exit);
@@ skipping 769 matching lines @@
 
 
 void TestSmiShiftLeft(MacroAssembler* masm, Label* exit, int id, int x) {
   const int shifts[] = { 0, 1, 7, 24, kSmiValueSize - 1};
   const int kNumShifts = 5;
   __ movl(rax, Immediate(id));
   for (int i = 0; i < kNumShifts; i++) {
     // rax == id + i * 10.
     int shift = shifts[i];
     int result = x << shift;
+#if !V8_USE_31_BITS_SMI_VALUE
     CHECK(Smi::IsValid(result));
     __ Move(r8, Smi::FromInt(result));
     __ Move(rcx, Smi::FromInt(x));
     __ SmiShiftLeftConstant(r9, rcx, shift);
 
     __ incq(rax);
     __ cmpq(r9, r8);
     __ j(not_equal, exit);
 
     __ incq(rax);
@@ skipping 25 matching lines @@
     __ incq(rax);
     __ Move(rdx, Smi::FromInt(x));
     __ Move(r11, Smi::FromInt(shift));
     __ SmiShiftLeft(rdx, rdx, r11);
 
     __ incq(rax);
     __ cmpq(rdx, r8);
     __ j(not_equal, exit);
 
     __ incq(rax);
+#else
+    if (Smi::IsValid(result)) {
+      __ Move(r8, Smi::FromInt(result));
+      __ Move(rcx, Smi::FromInt(x));
+      __ SmiShiftLeftConstant(r9, rcx, shift, exit);
+
+      __ incq(rax);
+      __ cmpq(r9, r8);
+      __ j(not_equal, exit);
+
+      __ incq(rax);
+      __ Move(rcx, Smi::FromInt(x));
+      __ SmiShiftLeftConstant(rcx, rcx, shift, exit);
+
+      __ incq(rax);
+      __ cmpq(rcx, r8);
+      __ j(not_equal, exit);
+
+      __ incq(rax);
+      __ Move(rdx, Smi::FromInt(x));
+      __ Move(rcx, Smi::FromInt(shift));
+      __ SmiShiftLeft(r9, rdx, rcx, exit);
+
+      __ incq(rax);
+      __ cmpq(r9, r8);
+      __ j(not_equal, exit);
+
+      __ incq(rax);
+      __ Move(rdx, Smi::FromInt(x));
+      __ Move(r11, Smi::FromInt(shift));
+      __ SmiShiftLeft(r9, rdx, r11, exit);
+
+      __ incq(rax);
+      __ cmpq(r9, r8);
+      __ j(not_equal, exit);
+
+      __ incq(rax);
+      __ Move(rdx, Smi::FromInt(x));
+      __ Move(r11, Smi::FromInt(shift));
+      __ SmiShiftLeft(rdx, rdx, r11, exit);
+
+      __ incq(rax);
+      __ cmpq(rdx, r8);
+      __ j(not_equal, exit);
+
+      __ incq(rax);
+    } else {
+      __ Move(rdx, Smi::FromInt(x));
+      __ Move(rcx, Smi::FromInt(shift));
+      __ movq(r11, rcx);
+      Label fail_ok1;
+      __ SmiShiftLeft(r9, rdx, rcx, &fail_ok1);
+      __ jmp(exit);
+      __ bind(&fail_ok1);
+
+      __ incq(rax);
+      __ cmpq(rcx, r11);
+      __ j(not_equal, exit);
+
+      __ incq(rax);
+      __ Move(rcx, Smi::FromInt(x));
+      __ Move(rdx, Smi::FromInt(shift));
+      __ movq(r11, rcx);
+      Label fail_ok2;
+      __ SmiShiftLeft(r9, rcx, rdx, &fail_ok2);
+      __ jmp(exit);
+      __ bind(&fail_ok2);
+
+      __ incq(rax);
+      __ cmpq(rcx, r11);
+      __ j(not_equal, exit);
+
+      __ addq(rax, Immediate(7));
+    }
+#endif
   }
 }
 
 
 TEST(SmiShiftLeft) {
   v8::internal::V8::Initialize(NULL);
   // Allocate an executable page of memory.
   size_t actual_size;
   byte* buffer =
       static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize * 4,
@@ skipping 626 matching lines @@
   CodeDesc desc;
   masm->GetCode(&desc);
   // Call the function from C++.
   int result = FUNCTION_CAST<F0>(buffer)();
   CHECK_EQ(0, result);
 }
 
 
 
 #undef __