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

src/x64/full-codegen-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 2268 matching lines @@
          expr->BinaryOperationFeedbackId());
   patch_site.EmitPatchInfo();
   __ jmp(&done, Label::kNear);
 
   __ bind(&smi_case);
   switch (op) {
     case Token::SAR:
       __ SmiShiftArithmeticRight(rax, rdx, rcx);
       break;
     case Token::SHL:
-      __ SmiShiftLeft(rax, rdx, rcx);
+      __ SmiShiftLeft(rax, rdx, rcx, &stub_call);
       break;
     case Token::SHR:
       __ SmiShiftLogicalRight(rax, rdx, rcx, &stub_call);
       break;
     case Token::ADD:
       __ SmiAdd(rax, rdx, rcx, &stub_call);
       break;
     case Token::SUB:
       __ SmiSub(rax, rdx, rcx, &stub_call);
       break;
@@ skipping 2146 matching lines @@
       }
     }
   }
 
   // Inline smi case if we are in a loop.
   Label done, stub_call;
   JumpPatchSite patch_site(masm_);
 
   if (ShouldInlineSmiCase(expr->op())) {
     if (expr->op() == Token::INC) {
       __ SmiAddConstant(rax, rax, Smi::FromInt(1));

[danno, 2013/08/01 16:45:41]

Handle the overflow case inside the macro assembler, passing the stub-call label
always

[haitao.feng, 2013/08/02 09:35:51]

I am OK to change this but this might affect performance. For the SmiAddConstant
with overflow checking, we will movq(kScratchRegister, rax);
add(kScratchRegister, LoadSmiRegister(1)); j(overflow, fail, near_jump);
movq(rax, kScratchRegister). We need 4 instructions in the normal case than 2
(add, check overflow) inside a loop.

+      if (kSmiValueSize == 31) {
+        // positive overflow
+        __ testl(rax, Immediate(0x80000000));
+        __ j(not_zero, &stub_call, Label::kNear);
+      }
     } else {
       __ SmiSubConstant(rax, rax, Smi::FromInt(1));
+      if (kSmiValueSize == 31) {
+        // negative overflow
+        __ testl(rax, Immediate(0x80000000));
+        __ j(zero, &stub_call, Label::kNear);
+      }
     }
-    __ j(overflow, &stub_call, Label::kNear);
+    if (kSmiValueSize == 32) {
+      __ j(overflow, &stub_call, Label::kNear);
+    }
     // We could eliminate this smi check if we split the code at
     // the first smi check before calling ToNumber.
     patch_site.EmitJumpIfSmi(rax, &done, Label::kNear);
 
     __ bind(&stub_call);
     // Call stub. Undo operation first.
     if (expr->op() == Token::INC) {
       __ SmiSubConstant(rax, rax, Smi::FromInt(1));
     } else {
       __ SmiAddConstant(rax, rax, Smi::FromInt(1));
@@ skipping 434 matching lines @@
   *context_length = 0;
   return previous_;
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_X64