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

src/x64/code-stubs-x64.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 585 matching lines @@
   // One of first or second must be non-Smi when entering.
   static void NumbersToSmis(MacroAssembler* masm,
                             Register first,
                             Register second,
                             Register scratch1,
                             Register scratch2,
                             Register scratch3,
                             Label* on_success,
                             Label* on_not_smis,
                             ConvertUndefined convert_undefined);
+
+  // Checks that |operand| has an int32 value. If |int32_result| is different
+  // from |scratch|, it will contain that int32 value.
+  static void CheckSSE2OperandIsInt32(MacroAssembler* masm,
+                                      Label* non_int32,
+                                      XMMRegister operand,
+                                      Register int32_result,
+                                      Register scratch,
+                                      XMMRegister xmm_scratch);
 };
 
 
 void DoubleToIStub::Generate(MacroAssembler* masm) {
     Register input_reg = this->source();
     Register final_result_reg = this->destination();
     ASSERT(is_truncating());
 
     Label check_negative, process_64_bits, done;
 
@@ skipping 98 matching lines @@
 
 static void BinaryOpStub_GenerateSmiCode(
     MacroAssembler* masm,
     Label* slow,
     BinaryOpStub::SmiCodeGenerateHeapNumberResults allow_heapnumber_results,
     Token::Value op) {
 
   // Arguments to BinaryOpStub are in rdx and rax.
   const Register left = rdx;
   const Register right = rax;
+  const Register shift_op_result = (SmiValuesAre32Bits()  || op == Token::SAR) ?
+                                   left : r9;
 
-  // We only generate heapnumber answers for overflowing calculations
-  // for the four basic arithmetic operations and logical right shift by 0.
+  // We only generate heapnumber answers for overflowing calculations.
   bool generate_inline_heapnumber_results =
       (allow_heapnumber_results == BinaryOpStub::ALLOW_HEAPNUMBER_RESULTS) &&
-      (op == Token::ADD || op == Token::SUB ||
-       op == Token::MUL || op == Token::DIV || op == Token::SHR);
+      MacroAssembler::IsUnsafeSmiOperator(op);
 
   // Smi check of both operands.  If op is BIT_OR, the check is delayed
   // until after the OR operation.
   Label not_smis;
   Label use_fp_on_smis;
   Label fail;
 
   if (op != Token::BIT_OR) {
     Comment smi_check_comment(masm, "-- Smi check arguments");
     __ JumpIfNotBothSmi(left, right, &not_smis);
   }
 
   Label smi_values;
   __ bind(&smi_values);
   // Perform the operation.
   Comment perform_smi(masm, "-- Perform smi operation");
+  MacroAssembler::StrictSmiInstructionWrapper wrapper(masm, &use_fp_on_smis);
   switch (op) {
     case Token::ADD:
       ASSERT(right.is(rax));
-      __ SmiAdd(right, right, left, &use_fp_on_smis);  // ADD is commutative.
+      __ SmiAdd(right, right, left, wrapper);  // ADD is commutative.
       break;
 
     case Token::SUB:
-      __ SmiSub(left, left, right, &use_fp_on_smis);
+      __ SmiSub(left, left, right, wrapper);
       __ movq(rax, left);
       break;
 
     case Token::MUL:
       ASSERT(right.is(rax));
       __ SmiMul(right, right, left, &use_fp_on_smis);  // MUL is commutative.
       break;
 
     case Token::DIV:
       // SmiDiv will not accept left in rdx or right in rax.
@@ skipping 18 matching lines @@
       ASSERT(right.is(rax));
       __ SmiXor(right, right, left);  // BIT_XOR is commutative.
       break;
 
     case Token::BIT_AND:
       ASSERT(right.is(rax));
       __ SmiAnd(right, right, left);  // BIT_AND is commutative.
       break;
 
     case Token::SHL:
-      __ SmiShiftLeft(left, left, right);
-      __ movq(rax, left);
+      __ SmiShiftLeft(shift_op_result, left, right, &use_fp_on_smis);
+      __ movq(rax, shift_op_result);
       break;
 
     case Token::SAR:
-      __ SmiShiftArithmeticRight(left, left, right);
-      __ movq(rax, left);
+      __ SmiShiftArithmeticRight(shift_op_result, left, right);
+      __ movq(rax, shift_op_result);
       break;
 
     case Token::SHR:
-      __ SmiShiftLogicalRight(left, left, right, &use_fp_on_smis);
-      __ movq(rax, left);
+      __ SmiShiftLogicalRight(shift_op_result, left, right, &use_fp_on_smis);
+      __ movq(rax, shift_op_result);
       break;
 
     default:
       UNREACHABLE();
   }
 
   // 5. Emit return of result in rax.  Some operations have registers pushed.
   __ ret(0);
 
   if (use_fp_on_smis.is_linked()) {
     // 6. For some operations emit inline code to perform floating point
     //    operations on known smis (e.g., if the result of the operation
     //    overflowed the smi range).
     __ bind(&use_fp_on_smis);
     if (op == Token::DIV || op == Token::MOD) {
       // Restore left and right to rdx and rax.
       __ movq(rdx, rcx);
       __ movq(rax, rbx);
     }
 
     if (generate_inline_heapnumber_results) {
       __ AllocateHeapNumber(rcx, rbx, slow);
       Comment perform_float(masm, "-- Perform float operation on smis");
       if (op == Token::SHR) {
-        __ SmiToInteger32(left, left);
-        __ cvtqsi2sd(xmm0, left);
+        if (SmiValuesAre32Bits()) {
+          __ SmiToInteger32(shift_op_result, shift_op_result);
+        }
+        __ cvtqsi2sd(xmm0, shift_op_result);
+      } else if (op == Token::SHL) {
+        ASSERT(SmiValuesAre31Bits());
+        __ cvtlsi2sd(xmm0, shift_op_result);
       } else {
         FloatingPointHelper::LoadSSE2SmiOperands(masm);
         switch (op) {
-        case Token::ADD: __ addsd(xmm0, xmm1); break;
-        case Token::SUB: __ subsd(xmm0, xmm1); break;
-        case Token::MUL: __ mulsd(xmm0, xmm1); break;
-        case Token::DIV: __ divsd(xmm0, xmm1); break;
-        default: UNREACHABLE();
+          case Token::ADD: __ addsd(xmm0, xmm1); break;
+          case Token::SUB: __ subsd(xmm0, xmm1); break;
+          case Token::MUL: __ mulsd(xmm0, xmm1); break;
+          case Token::DIV: __ divsd(xmm0, xmm1); break;
+          default: UNREACHABLE();
         }
       }
       __ movsd(FieldOperand(rcx, HeapNumber::kValueOffset), xmm0);
       __ movq(rax, rcx);
       __ ret(0);
     } else {
       __ jmp(&fail);
     }
   }
 
@@ skipping 20 matching lines @@
   __ jmp(&smi_values);
   __ bind(&fail);
 }
 
 
 static void BinaryOpStub_GenerateHeapResultAllocation(MacroAssembler* masm,
                                                       Label* alloc_failure,
                                                       OverwriteMode mode);
 
 
-static void BinaryOpStub_GenerateFloatingPointCode(MacroAssembler* masm,
-                                                   Label* allocation_failure,
-                                                   Label* non_numeric_failure,
-                                                   Token::Value op,
-                                                   OverwriteMode mode) {
+static void BinaryOpStub_GenerateFloatingPointCode(
+    MacroAssembler* masm,
+    Label* allocation_failure,
+    Label* non_numeric_failure,
+    Token::Value op,
+    BinaryOpIC::TypeInfo result_type,
+    Label* non_int32_failure,
+    OverwriteMode mode) {
   switch (op) {
     case Token::ADD:
     case Token::SUB:
     case Token::MUL:
     case Token::DIV: {
       FloatingPointHelper::LoadSSE2UnknownOperands(masm, non_numeric_failure);
 
       switch (op) {
         case Token::ADD: __ addsd(xmm0, xmm1); break;
         case Token::SUB: __ subsd(xmm0, xmm1); break;
         case Token::MUL: __ mulsd(xmm0, xmm1); break;
         case Token::DIV: __ divsd(xmm0, xmm1); break;
         default: UNREACHABLE();
       }
+
+      if (SmiValuesAre31Bits() && non_int32_failure != NULL) {
+        if (result_type <= BinaryOpIC::INT32) {
+          FloatingPointHelper::CheckSSE2OperandIsInt32(
+              masm, non_int32_failure, xmm0, rcx, rcx, xmm2);
+        }
+      }
+
       BinaryOpStub_GenerateHeapResultAllocation(
           masm, allocation_failure, mode);
       __ movsd(FieldOperand(rax, HeapNumber::kValueOffset), xmm0);
       __ ret(0);
       break;
     }
     case Token::MOD: {
       // For MOD we jump to the allocation_failure label, to call runtime.
       __ jmp(allocation_failure);
       break;
     }
     case Token::BIT_OR:
     case Token::BIT_AND:
     case Token::BIT_XOR:
     case Token::SAR:
     case Token::SHL:
     case Token::SHR: {
-      Label non_smi_shr_result;
+      Label non_smi_result;
       Register heap_number_map = r9;
+      Register saved_right = r11;
+      if (SmiValuesAre31Bits() || (SmiValuesAre32Bits() && op == Token::SHR)) {
+        __ movq(saved_right, rax);
+      }
       __ LoadRoot(heap_number_map, Heap::kHeapNumberMapRootIndex);
       FloatingPointHelper::LoadAsIntegers(masm, non_numeric_failure,
                                           heap_number_map);
       switch (op) {
         case Token::BIT_OR:  __ orl(rax, rcx); break;
         case Token::BIT_AND: __ andl(rax, rcx); break;
         case Token::BIT_XOR: __ xorl(rax, rcx); break;
         case Token::SAR: __ sarl_cl(rax); break;
         case Token::SHL: __ shll_cl(rax); break;
-        case Token::SHR: {
-          __ shrl_cl(rax);
-          // Check if result is negative. This can only happen for a shift
-          // by zero.
-          __ testl(rax, rax);
-          __ j(negative, &non_smi_shr_result);
-          break;
-        }
+        case Token::SHR: __ shrl_cl(rax); break;
         default: UNREACHABLE();
       }
-      STATIC_ASSERT(kSmiValueSize == 32);
+
+      if (op == Token::SHR) {
+        __ JumpIfUIntNotValidSmiValue(rax, &non_smi_result, Label::kNear);
+      } else {
+        if (SmiValuesAre31Bits()) {
+          __ JumpIfNotValidSmiValue(rax, &non_smi_result, Label::kNear);
+        }
+      }
+
       // Tag smi result and return.
       __ Integer32ToSmi(rax, rax);
       __ Ret();
 
-      // Logical shift right can produce an unsigned int32 that is not
-      // an int32, and so is not in the smi range.  Allocate a heap number
-      // in that case.
-      if (op == Token::SHR) {
-        __ bind(&non_smi_shr_result);
+      if (SmiValuesAre31Bits() || (SmiValuesAre32Bits() && op == Token::SHR)) {
+        __ bind(&non_smi_result);
+        __ movl(rbx, rax);  // rbx holds result value.
         Label allocation_failed;
-        __ movl(rbx, rax);  // rbx holds result value (uint32 value as int64).
-        // Allocate heap number in new space.
-        // Not using AllocateHeapNumber macro in order to reuse
-        // already loaded heap_number_map.
-        __ Allocate(HeapNumber::kSize, rax, rdx, no_reg, &allocation_failed,
-                    TAG_OBJECT);
-        // Set the map.
-        __ AssertRootValue(heap_number_map,
-                           Heap::kHeapNumberMapRootIndex,
-                           kHeapNumberMapRegisterClobbered);
-        __ movq(FieldOperand(rax, HeapObject::kMapOffset),
-                heap_number_map);
-        __ cvtqsi2sd(xmm0, rbx);
+        Label skip_allocation;
+        // Allocate heap number in new space if we could not overwrite
+        // the left or right operand. Not using AllocateHeapNumber macro
+        // in order to reuse already loaded heap_number_map.
+        switch (mode) {
+          case OVERWRITE_LEFT:
+            __ movq(rax, rdx);
+            __ JumpIfNotSmi(rax, &skip_allocation);
+            __ Allocate(HeapNumber::kSize, rax, no_reg, no_reg,
+                        &allocation_failed, TAG_OBJECT);
+            // Set the map.
+            __ AssertRootValue(heap_number_map,
+                               Heap::kHeapNumberMapRootIndex,
+                               kHeapNumberMapRegisterClobbered);
+            __ movq(FieldOperand(rax, HeapObject::kMapOffset),
+                    heap_number_map);
+            __ bind(&skip_allocation);
+            break;
+          case OVERWRITE_RIGHT:
+            __ movq(rax, saved_right);
+            __ JumpIfNotSmi(rax, &skip_allocation);
+            // Fall through!
+          case NO_OVERWRITE:
+            __ Allocate(HeapNumber::kSize, rax, no_reg, no_reg,
+                        &allocation_failed, TAG_OBJECT);
+            // Set the map.
+            __ AssertRootValue(heap_number_map,
+                               Heap::kHeapNumberMapRootIndex,
+                               kHeapNumberMapRegisterClobbered);
+            __ movq(FieldOperand(rax, HeapObject::kMapOffset),
+                    heap_number_map);
+            __ bind(&skip_allocation);
+            break;
+          default: UNREACHABLE();
+        }
+
+        if (op == Token::SHR) {
+          // Logical shift right can produce an unsigned int32 that is not
+          // an int32, or an int32 not in the smi range for 31 bits SMI value.
+          __ cvtqsi2sd(xmm0, rbx);
+        } else {
+          // All other operations returns a signed int32, so we
+          // use lsi2sd here to retain the sign bit.
+          ASSERT(SmiValuesAre31Bits());
+          __ cvtlsi2sd(xmm0, rbx);
+        }
         __ movsd(FieldOperand(rax, HeapNumber::kValueOffset), xmm0);
         __ Ret();
 
         __ bind(&allocation_failed);
         // We need tagged values in rdx and rax for the following code,
-        // not int32 in rax and rcx.
-        __ Integer32ToSmi(rax, rcx);
-        __ Integer32ToSmi(rdx, rbx);
+        // rdx is un-changed and rax is saved at beginning.
+        __ movq(rax, saved_right);
         __ jmp(allocation_failure);
       }
       break;
     }
     default: UNREACHABLE(); break;
   }
   // No fall-through from this generated code.
   if (FLAG_debug_code) {
     __ Abort(kUnexpectedFallThroughInBinaryStubGenerateFloatingPointCode);
   }
@@ skipping 76 matching lines @@
       FrameScope scope(masm, StackFrame::INTERNAL);
       GenerateRegisterArgsPush(masm);
       GenerateCallRuntime(masm);
     }
     __ Ret();
   }
 }
 
 
 void BinaryOpStub::GenerateInt32Stub(MacroAssembler* masm) {
-  // The int32 case is identical to the Smi case.  We avoid creating this
-  // ic state on x64.
-  UNREACHABLE();
+  ASSERT(SmiValuesAre31Bits());
+  ASSERT(Max(left_type_, right_type_) == BinaryOpIC::INT32);
+
+  Label gc_required, not_number, not_int32;
+  BinaryOpStub_GenerateFloatingPointCode(masm, &gc_required, &not_number, op_,
+      result_type_, &not_int32, mode_);
+
+  __ bind(&not_number);
+  __ bind(&not_int32);
+  GenerateTypeTransition(masm);
+
+  __ bind(&gc_required);
+  {
+    FrameScope scope(masm, StackFrame::INTERNAL);
+    GenerateRegisterArgsPush(masm);
+    GenerateCallRuntime(masm);
+  }
+  __ Ret();
 }
 
 
 void BinaryOpStub::GenerateBothStringStub(MacroAssembler* masm) {
   Label call_runtime;
   ASSERT(left_type_ == BinaryOpIC::STRING && right_type_ == BinaryOpIC::STRING);
   ASSERT(op_ == Token::ADD);
   // If both arguments are strings, call the string add stub.
   // Otherwise, do a transition.
 
@@ skipping 85 matching lines @@
   // or the right operand. For precise type feedback, patch the IC
   // again if this changes.
   if (left_type_ == BinaryOpIC::SMI) {
     BinaryOpStub_CheckSmiInput(masm, rdx, &not_number);
   }
   if (right_type_ == BinaryOpIC::SMI) {
     BinaryOpStub_CheckSmiInput(masm, rax, &not_number);
   }
 
   BinaryOpStub_GenerateFloatingPointCode(
-      masm, &gc_required, &not_number, op_, mode_);
+      masm, &gc_required, &not_number, op_, result_type_, NULL, mode_);
 
   __ bind(&not_number);
   GenerateTypeTransition(masm);
 
   __ bind(&gc_required);
   {
     FrameScope scope(masm, StackFrame::INTERNAL);
     GenerateRegisterArgsPush(masm);
     GenerateCallRuntime(masm);
   }
   __ Ret();
 }
 
 
 void BinaryOpStub::GenerateGeneric(MacroAssembler* masm) {
   Label call_runtime, call_string_add_or_runtime;
 
   BinaryOpStub_GenerateSmiCode(
       masm, &call_runtime, ALLOW_HEAPNUMBER_RESULTS, op_);
 
   BinaryOpStub_GenerateFloatingPointCode(
-      masm, &call_runtime, &call_string_add_or_runtime, op_, mode_);
+      masm, &call_runtime, &call_string_add_or_runtime, op_,
+      result_type_, NULL, mode_);
 
   __ bind(&call_string_add_or_runtime);
   if (op_ == Token::ADD) {
     GenerateAddStrings(masm);
   }
 
   __ bind(&call_runtime);
   {
     FrameScope scope(masm, StackFrame::INTERNAL);
     GenerateRegisterArgsPush(masm);
@@ skipping 530 matching lines @@
   // Convert HeapNumber to smi if possible.
   __ movsd(xmm0, FieldOperand(first, HeapNumber::kValueOffset));
   __ movq(scratch2, xmm0);
   __ cvttsd2siq(smi_result, xmm0);
   // Check if conversion was successful by converting back and
   // comparing to the original double's bits.
   __ cvtlsi2sd(xmm1, smi_result);
   __ movq(kScratchRegister, xmm1);
   __ cmpq(scratch2, kScratchRegister);
   __ j(not_equal, on_not_smis);
+  __ JumpIfNotValidSmiValue(smi_result, on_not_smis);
   __ Integer32ToSmi(first, smi_result);
 
   __ bind(&first_done);
   __ JumpIfSmi(second, (on_success != NULL) ? on_success : &done);
   __ bind(&first_smi);
   __ AssertNotSmi(second);
   __ cmpq(FieldOperand(second, HeapObject::kMapOffset), heap_number_map);
   __ j(not_equal,
        (convert_undefined == CONVERT_UNDEFINED_TO_ZERO)
            ? &maybe_undefined_second
            : on_not_smis);
   // Convert second to smi, if possible.
   __ movsd(xmm0, FieldOperand(second, HeapNumber::kValueOffset));
   __ movq(scratch2, xmm0);
   __ cvttsd2siq(smi_result, xmm0);
   __ cvtlsi2sd(xmm1, smi_result);
   __ movq(kScratchRegister, xmm1);
   __ cmpq(scratch2, kScratchRegister);
   __ j(not_equal, on_not_smis);
+  __ JumpIfNotValidSmiValue(smi_result, on_not_smis);
   __ Integer32ToSmi(second, smi_result);
   if (on_success != NULL) {
     __ jmp(on_success);
   } else {
     __ jmp(&done);
   }
 
   __ bind(&maybe_undefined_first);
   __ CompareRoot(first, Heap::kUndefinedValueRootIndex);
   __ j(not_equal, on_not_smis);
   __ xor_(first, first);
   __ jmp(&first_done);
 
   __ bind(&maybe_undefined_second);
   __ CompareRoot(second, Heap::kUndefinedValueRootIndex);
   __ j(not_equal, on_not_smis);
   __ xor_(second, second);
   if (on_success != NULL) {
     __ jmp(on_success);
   }
   // Else: fall through.
 
   __ bind(&done);
 }
 
 
+void FloatingPointHelper::CheckSSE2OperandIsInt32(MacroAssembler* masm,
+                                                  Label* non_int32,
+                                                  XMMRegister operand,
+                                                  Register int32_result,
+                                                  Register scratch,
+                                                  XMMRegister xmm_scratch) {
+  __ cvttsd2si(int32_result, operand);
+  __ cvtlsi2sd(xmm_scratch, int32_result);
+  __ pcmpeqd(xmm_scratch, operand);
+  __ movmskps(scratch, xmm_scratch);
+  // Two least significant bits should be both set.
+  __ notl(scratch);
+  __ testl(scratch, Immediate(3));
+  __ j(not_zero, non_int32);
+}
+
+
 void MathPowStub::Generate(MacroAssembler* masm) {
   const Register exponent = rdx;
   const Register base = rax;
   const Register scratch = rcx;
   const XMMRegister double_result = xmm3;
   const XMMRegister double_base = xmm2;
   const XMMRegister double_exponent = xmm1;
   const XMMRegister double_scratch = xmm4;
 
   Label call_runtime, done, exponent_not_smi, int_exponent;
@@ skipping 2762 matching lines @@
   // by the code above.
   if ((flags_ & STRING_ADD_CHECK_BOTH) != STRING_ADD_CHECK_BOTH) {
     __ movq(r8, FieldOperand(rax, HeapObject::kMapOffset));
     __ movq(r9, FieldOperand(rdx, HeapObject::kMapOffset));
   }
   // Get the instance types of the two strings as they will be needed soon.
   __ movzxbl(r8, FieldOperand(r8, Map::kInstanceTypeOffset));
   __ movzxbl(r9, FieldOperand(r9, Map::kInstanceTypeOffset));
 
   // Look at the length of the result of adding the two strings.
-  STATIC_ASSERT(String::kMaxLength <= Smi::kMaxValue / 2);
-  __ SmiAdd(rbx, rbx, rcx);
+  MacroAssembler::StrictSmiInstructionWrapper wrapper(masm, &call_runtime);
+  __ SmiAdd(rbx, rbx, rcx, wrapper);
+
   // Use the string table when adding two one character strings, as it
   // helps later optimizations to return an internalized string here.
   __ SmiCompare(rbx, Smi::FromInt(2));
   __ j(not_equal, &longer_than_two);
 
   // Check that both strings are non-external ASCII strings.
   __ JumpIfBothInstanceTypesAreNotSequentialAscii(r8, r9, rbx, rcx,
                                                   &call_runtime);
 
   // Get the two characters forming the sub string.
@@ skipping 2227 matching lines @@
   __ bind(&fast_elements_case);
   GenerateCase(masm, FAST_ELEMENTS);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_X64