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 2263 matching lines @@
 
   __ bind(&stub_call);
   __ movq(rax, rcx);
   BinaryOpStub stub(op, mode);
   CallIC(stub.GetCode(isolate()), RelocInfo::CODE_TARGET,
          expr->BinaryOperationFeedbackId());
   patch_site.EmitPatchInfo();
   __ jmp(&done, Label::kNear);
 
   __ bind(&smi_case);
+  MacroAssembler::StrictSmiInstructionWrapper wrapper(masm_, &stub_call);
   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);
+      __ SmiAdd(rax, rdx, rcx, wrapper);
       break;
     case Token::SUB:
-      __ SmiSub(rax, rdx, rcx, &stub_call);
+      __ SmiSub(rax, rdx, rcx, wrapper);
       break;
     case Token::MUL:
       __ SmiMul(rax, rdx, rcx, &stub_call);
       break;
     case Token::BIT_OR:
       __ SmiOr(rax, rdx, rcx);
       break;
     case Token::BIT_AND:
       __ SmiAnd(rax, rdx, rcx);
       break;
@@ skipping 2134 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/19 21:47:44]

Shouldn't overflow also be handled in SmiAddConstant by passing in a wrapper?

[haitao.feng, 2013/08/20 15:09:30]

I will address this in https://codereview.chromium.org/22935005/.

+      if (SmiValuesAre31Bits()) {
+        // positive overflow
+        __ testl(rax, Immediate(0x80000000));
+        __ j(not_zero, &stub_call, Label::kNear);
+      }
     } else {
       __ SmiSubConstant(rax, rax, Smi::FromInt(1));
+      if (SmiValuesAre31Bits()) {
+        // negative overflow
+        __ testl(rax, Immediate(0x80000000));
+        __ j(zero, &stub_call, Label::kNear);
+      }
     }
-    __ j(overflow, &stub_call, Label::kNear);
+    if (SmiValuesAre32Bits()) {
+      __ 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