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 740 matching lines @@
 }
 
 
 
 
 static void SmiAddTest(MacroAssembler* masm,
                        Label* exit,
                        int id,
                        int first,
                        int second) {
+  MacroAssembler::StrictSmiInstructionWrapper wrapper(masm, exit);
   __ movl(rcx, Immediate(first));
   __ Integer32ToSmi(rcx, rcx);
   __ movl(rdx, Immediate(second));
   __ Integer32ToSmi(rdx, rdx);
   __ movl(r8, Immediate(first + second));
   __ Integer32ToSmi(r8, r8);
 
   __ movl(rax, Immediate(id));  // Test number.
-  __ SmiAdd(r9, rcx, rdx, exit);
+  __ SmiAdd(r9, rcx, rdx, wrapper);
   __ cmpq(r9, r8);
   __ j(not_equal, exit);
 
   __ incq(rax);
-  __ SmiAdd(rcx, rcx, rdx, exit);                              \
+  __ SmiAdd(rcx, rcx, rdx, wrapper);
   __ cmpq(rcx, r8);
   __ j(not_equal, exit);
 
   __ movl(rcx, Immediate(first));
   __ Integer32ToSmi(rcx, rcx);
 
   __ incq(rax);
   __ SmiAddConstant(r9, rcx, Smi::FromInt(second));
   __ cmpq(r9, r8);
   __ j(not_equal, exit);
 
   __ SmiAddConstant(rcx, rcx, Smi::FromInt(second));
   __ cmpq(rcx, r8);
   __ j(not_equal, exit);
 
   __ movl(rcx, Immediate(first));
   __ Integer32ToSmi(rcx, rcx);
 
   __ incq(rax);
-  __ SmiAddConstant(r9, rcx, Smi::FromInt(second), exit);
+  __ SmiAddConstant(r9, rcx, Smi::FromInt(second), wrapper);
   __ cmpq(r9, r8);
   __ j(not_equal, exit);
 
   __ incq(rax);
-  __ SmiAddConstant(rcx, rcx, Smi::FromInt(second), exit);
+  __ SmiAddConstant(rcx, rcx, Smi::FromInt(second), wrapper);
   __ cmpq(rcx, r8);
   __ j(not_equal, exit);
 }
 
 
 TEST(SmiAdd) {
   v8::internal::V8::Initialize(NULL);
   // Allocate an executable page of memory.
   size_t actual_size;
   byte* buffer = static_cast<byte*>(OS::Allocate(Assembler::kMinimalBufferSize,
@@ skipping 30 matching lines @@
   int result = FUNCTION_CAST<F0>(buffer)();
   CHECK_EQ(0, result);
 }
 
 
 static void SmiSubTest(MacroAssembler* masm,
                       Label* exit,
                       int id,
                       int first,
                       int second) {
+  MacroAssembler::StrictSmiInstructionWrapper wrapper(masm, exit);
   __ Move(rcx, Smi::FromInt(first));
   __ Move(rdx, Smi::FromInt(second));
   __ Move(r8, Smi::FromInt(first - second));
 
   __ movl(rax, Immediate(id));  // Test 0.
-  __ SmiSub(r9, rcx, rdx, exit);
+  __ SmiSub(r9, rcx, rdx, wrapper);
   __ cmpq(r9, r8);
   __ j(not_equal, exit);
 
   __ incq(rax);  // Test 1.
-  __ SmiSub(rcx, rcx, rdx, exit);
+  __ SmiSub(rcx, rcx, rdx, wrapper);
   __ cmpq(rcx, r8);
   __ j(not_equal, exit);
 
   __ Move(rcx, Smi::FromInt(first));
 
   __ incq(rax);  // Test 2.
   __ SmiSubConstant(r9, rcx, Smi::FromInt(second));
   __ cmpq(r9, r8);
   __ j(not_equal, exit);
 
   __ incq(rax);  // Test 3.
   __ SmiSubConstant(rcx, rcx, Smi::FromInt(second));
   __ cmpq(rcx, r8);
   __ j(not_equal, exit);
 
   __ Move(rcx, Smi::FromInt(first));
 
   __ incq(rax);  // Test 4.
-  __ SmiSubConstant(r9, rcx, Smi::FromInt(second), exit);
+  __ SmiSubConstant(r9, rcx, Smi::FromInt(second), wrapper);
   __ cmpq(r9, r8);
   __ j(not_equal, exit);
 
   __ incq(rax);  // Test 5.
-  __ SmiSubConstant(rcx, rcx, Smi::FromInt(second), exit);
+  __ SmiSubConstant(rcx, rcx, Smi::FromInt(second), wrapper);
   __ 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));
   __ Move(rcx, Smi::FromInt(x));
   __ movq(r11, rcx);  // Store original Smi value of x in r11.
   __ Move(rdx, Smi::FromInt(y_min));
   {
     Label overflow_ok;
-    __ SmiSub(r9, rcx, rdx, &overflow_ok);
+    MacroAssembler::StrictSmiInstructionWrapper wrapper(masm, &overflow_ok);
+    __ SmiSub(r9, rcx, rdx, wrapper);
     __ jmp(exit);
     __ bind(&overflow_ok);
     __ incq(rax);
     __ cmpq(rcx, r11);
     __ j(not_equal, exit);
   }
 
   {
     Label overflow_ok;
+    MacroAssembler::StrictSmiInstructionWrapper wrapper(masm, &overflow_ok);
     __ incq(rax);
-    __ SmiSub(rcx, rcx, rdx, &overflow_ok);
+    __ SmiSub(rcx, rcx, rdx, wrapper);
     __ jmp(exit);
     __ bind(&overflow_ok);
     __ incq(rax);
     __ cmpq(rcx, r11);
     __ j(not_equal, exit);
   }
 
   __ movq(rcx, r11);
   {
     Label overflow_ok;
+    MacroAssembler::StrictSmiInstructionWrapper wrapper(masm, &overflow_ok);
     __ incq(rax);
-    __ SmiSubConstant(r9, rcx, Smi::FromInt(y_min), &overflow_ok);
+    __ SmiSubConstant(r9, rcx, Smi::FromInt(y_min), wrapper);
     __ jmp(exit);
     __ bind(&overflow_ok);
     __ incq(rax);
     __ cmpq(rcx, r11);
     __ j(not_equal, exit);
   }
 
   {
     Label overflow_ok;
+    MacroAssembler::StrictSmiInstructionWrapper wrapper(masm, &overflow_ok);
     __ incq(rax);
-    __ SmiSubConstant(rcx, rcx, Smi::FromInt(y_min), &overflow_ok);
+    __ SmiSubConstant(rcx, rcx, Smi::FromInt(y_min), wrapper);
     __ jmp(exit);
     __ bind(&overflow_ok);
     __ incq(rax);
     __ cmpq(rcx, r11);
     __ j(not_equal, exit);
   }
 
   __ Move(rdx, Smi::FromInt(y_max));
 
   {
     Label overflow_ok;
+    MacroAssembler::StrictSmiInstructionWrapper wrapper(masm, &overflow_ok);
     __ incq(rax);
-    __ SmiSub(r9, rcx, rdx, &overflow_ok);
+    __ SmiSub(r9, rcx, rdx, wrapper);
     __ jmp(exit);
     __ bind(&overflow_ok);
     __ incq(rax);
     __ cmpq(rcx, r11);
     __ j(not_equal, exit);
   }
 
   {
     Label overflow_ok;
+    MacroAssembler::StrictSmiInstructionWrapper wrapper(masm, &overflow_ok);
     __ incq(rax);
-    __ SmiSub(rcx, rcx, rdx, &overflow_ok);
+    __ SmiSub(rcx, rcx, rdx, wrapper);
     __ jmp(exit);
     __ bind(&overflow_ok);
     __ incq(rax);
     __ cmpq(rcx, r11);
     __ j(not_equal, exit);
   }
 
   __ movq(rcx, r11);
   {
     Label overflow_ok;
+    MacroAssembler::StrictSmiInstructionWrapper wrapper(masm, &overflow_ok);
     __ incq(rax);
-    __ SmiSubConstant(r9, rcx, Smi::FromInt(y_max), &overflow_ok);
+    __ SmiSubConstant(r9, rcx, Smi::FromInt(y_max), wrapper);
     __ jmp(exit);
     __ bind(&overflow_ok);
     __ incq(rax);
     __ cmpq(rcx, r11);
     __ j(not_equal, exit);
   }
 
   {
     Label overflow_ok;
+    MacroAssembler::StrictSmiInstructionWrapper wrapper(masm, &overflow_ok);
     __ incq(rax);
-    __ SmiSubConstant(rcx, rcx, Smi::FromInt(y_max), &overflow_ok);
+    __ SmiSubConstant(rcx, rcx, Smi::FromInt(y_max), wrapper);
     __ jmp(exit);
     __ bind(&overflow_ok);
     __ incq(rax);
     __ cmpq(rcx, r11);
     __ j(not_equal, exit);
   }
 }
 
 
 TEST(SmiSub) {
@@ skipping 38 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 765 matching lines @@
   // Call the function from C++.
   int result = FUNCTION_CAST<F0>(buffer)();
   CHECK_EQ(0, result);
 }
 
 
 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));
+  MacroAssembler::StrictSmiInstructionWrapper wrapper(masm, exit);
   for (int i = 0; i < kNumShifts; i++) {
     // rax == id + i * 10.
     int shift = shifts[i];
     int result = x << shift;
-    CHECK(Smi::IsValid(result));
-    __ Move(r8, Smi::FromInt(result));
-    __ Move(rcx, Smi::FromInt(x));
-    __ SmiShiftLeftConstant(r9, rcx, shift);
+    if (Smi::IsValid(result)) {
+      __ Move(r8, Smi::FromInt(result));
+      __ Move(rcx, Smi::FromInt(x));
+      __ SmiShiftLeftConstant(r9, rcx, shift, wrapper);
 
-    __ incq(rax);
-    __ cmpq(r9, r8);
-    __ j(not_equal, exit);
+      __ incq(rax);
+      __ cmpq(r9, r8);
+      __ j(not_equal, exit);
 
-    __ incq(rax);
-    __ Move(rcx, Smi::FromInt(x));
-    __ SmiShiftLeftConstant(rcx, rcx, shift);
+      __ incq(rax);
+      __ Move(rcx, Smi::FromInt(x));
+      if (kSmiValueSize == 32) {
+        __ SmiShiftLeftConstant(rcx, rcx, shift, wrapper);
+      } else {
+        ASSERT(kSmiValueSize == 31);
+        __ SmiShiftLeftConstant(r9, rcx, shift, wrapper);
+        __ movq(rcx, r9);
+      }
 
-    __ incq(rax);
-    __ cmpq(rcx, r8);
-    __ j(not_equal, 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);
+      __ 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);
+      __ cmpq(r9, r8);
+      __ j(not_equal, exit);
 
-    __ incq(rax);
-    __ Move(rdx, Smi::FromInt(x));
-    __ Move(r11, Smi::FromInt(shift));
-    __ SmiShiftLeft(r9, rdx, r11);
+      __ 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);
+      __ cmpq(r9, r8);
+      __ j(not_equal, exit);
 
-    __ incq(rax);
-    __ Move(rdx, Smi::FromInt(x));
-    __ Move(r11, Smi::FromInt(shift));
-    __ SmiShiftLeft(rdx, rdx, r11);
+      __ incq(rax);
+      __ Move(rdx, Smi::FromInt(x));
+      __ Move(r11, Smi::FromInt(shift));
+      if (kSmiValueSize == 32) {
+        __ SmiShiftLeft(rdx, rdx, r11, exit);
+      } else {
+        __ SmiShiftLeft(r9, rdx, r11, exit);
+        __ movq(rdx, r9);
+      }
+      __ incq(rax);
+      __ cmpq(rdx, r8);
+      __ j(not_equal, 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);
+      __ 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));
+    }
   }
 }
 
 
 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 __