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

src/x64/debug-x64.cc

Index: src/x64/debug-x64.cc
diff --git a/src/x64/debug-x64.cc b/src/x64/debug-x64.cc
index a337b0d052f7252ea1baa0e3b1d0bfe608fd87a7..226553c977e41c88dbbb6831e312bc716e2d6249 100644
--- a/src/x64/debug-x64.cc
+++ b/src/x64/debug-x64.cc
@@ -127,11 +127,20 @@ static void Generate_DebugBreakCallHelper(MacroAssembler* masm,
       // Store the 64-bit value as two smis.
       if ((non_object_regs & (1 << r)) != 0) {
         __ movq(kScratchRegister, reg);

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

Watch out. You have change the semantic here slightly, since 64-bits can be
encoded in two 31-bit values.  However, in practice, all the uses of this code
actually only expect integers (32 bits) to be encoded, so I this you can change
the semantic to only pack the 32 lower bits sign extended.

I think this code sequence (and the restore sequence in this file) should be
moved into the macro assembler:

__ PushInt32AsTwoSmis(reg, kScratchRegister)
__ PopInt32AsTwoSmis(reg, kScratchRegister);

and then hide the smi size check in the macro assembler.

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

Done. I used the name PushInt64AsTwoSmis and PopInt64AsTwoSmis.

-        __ Integer32ToSmi(reg, reg);
-        __ push(reg);
-        __ sar(kScratchRegister, Immediate(32));
-        __ Integer32ToSmi(kScratchRegister, kScratchRegister);
-        __ push(kScratchRegister);
+        if (kSmiValueSize == 32) {
+          __ Integer32ToSmi(reg, reg);
+          __ push(reg);
+          __ sar(kScratchRegister, Immediate(32));
+          __ Integer32ToSmi(kScratchRegister, kScratchRegister);
+          __ push(kScratchRegister);
+        } else {
+          ASSERT(kSmiValueSize == 31);
+          __ shr(reg, Immediate(63));
+          __ shll(reg, Immediate(1));
+          __ push(reg);
+          __ shl(kScratchRegister, Immediate(1));
+          __ push(kScratchRegister);
+        }
       }
     }
 
@@ -157,11 +166,19 @@ static void Generate_DebugBreakCallHelper(MacroAssembler* masm,
       // Reconstruct the 64-bit value from two smis.
       if ((non_object_regs & (1 << r)) != 0) {
         __ pop(kScratchRegister);
-        __ SmiToInteger32(kScratchRegister, kScratchRegister);
-        __ shl(kScratchRegister, Immediate(32));
-        __ pop(reg);
-        __ SmiToInteger32(reg, reg);
-        __ or_(reg, kScratchRegister);
+        if (kSmiValueSize == 32) {
+          __ SmiToInteger32(kScratchRegister, kScratchRegister);
+          __ shl(kScratchRegister, Immediate(32));
+          __ pop(reg);
+          __ SmiToInteger32(reg, reg);
+          __ or_(reg, kScratchRegister);
+        } else {
+          ASSERT(kSmiValueSize == 31);
+          __ shr(kScratchRegister, Immediate(1));
+          __ pop(reg);
+          __ shl(reg, Immediate(62));
+          __ or_(reg, kScratchRegister);
+        }
       }
     }