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

src/x64/lithium-codegen-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 393 matching lines @@
 }
 
 
 bool LCodeGen::IsTaggedConstant(LConstantOperand* op) const {
   return op->IsConstantOperand() &&
       chunk_->LookupLiteralRepresentation(op).IsTagged();
 }
 
 
 int32_t LCodeGen::ToInteger32(LConstantOperand* op) const {
-  HConstant* constant = chunk_->LookupConstant(op);
-  return constant->Integer32Value();
+  return ToRepresentation(op, Representation::Integer32());
 }
 
 
+int32_t LCodeGen::ToRepresentation(LConstantOperand* op,
+                                   const Representation& r) const {
+  HConstant* constant = chunk_->LookupConstant(op);
+  int32_t value = constant->Integer32Value();
+  if (r.IsInteger32()) return value;
+  ASSERT(r.IsSmiOrTagged());
+  return static_cast<int32_t>(reinterpret_cast<intptr_t>(Smi::FromInt(value)));
+}
+
+
 Smi* LCodeGen::ToSmi(LConstantOperand* op) const {
   HConstant* constant = chunk_->LookupConstant(op);
   return Smi::FromInt(constant->Integer32Value());
 }
 
 
 double LCodeGen::ToDouble(LConstantOperand* op) const {
   HConstant* constant = chunk_->LookupConstant(op);
   ASSERT(constant->HasDoubleValue());
   return constant->DoubleValue();
@@ skipping 865 matching lines @@
         default:
           __ imull(left, left, Immediate(right_value));
           break;
       }
     } else {
       __ imull(left, left, Immediate(right_value));
     }
   } else if (right->IsStackSlot()) {
     if (instr->hydrogen_value()->representation().IsSmi()) {
       __ SmiToInteger32(left, left);
-      __ imul(left, ToOperand(right));
+      if (kSmiValueSize == 32) {
+        __ imul(left, ToOperand(right));

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

Move this switching into the macro assembler, you will need to introduce __
SmiIMul, etc.

+      } else {
+        ASSERT(kSmiValueSize == 31);
+        __ imull(left, ToOperand(right));
+      }
     } else {
       __ imull(left, ToOperand(right));
     }
   } else {
     if (instr->hydrogen_value()->representation().IsSmi()) {
       __ SmiToInteger32(left, left);
-      __ imul(left, ToRegister(right));
+      if (kSmiValueSize == 32) {
+        __ imul(left, ToOperand(right));
+      } else {
+        ASSERT(kSmiValueSize == 31);
+        __ imull(left, ToOperand(right));
+      }
     } else {
       __ imull(left, ToRegister(right));
     }
   }
 
   if (can_overflow) {
     DeoptimizeIf(overflow, instr->environment());
   }
 
+  if (kSmiValueSize == 31 &&
+      instr->hydrogen_value()->representation().IsSmi()) {
+    __ movsxlq(left, left);
+  }
+
   if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
     // Bail out if the result is supposed to be negative zero.
     Label done;
     __ testl(left, left);
     __ j(not_zero, &done, Label::kNear);
     if (right->IsConstantOperand()) {
       if (ToInteger32(LConstantOperand::cast(right)) < 0) {
         DeoptimizeIf(no_condition, instr->environment());
       } else if (ToInteger32(LConstantOperand::cast(right)) == 0) {
         __ cmpl(kScratchRegister, Immediate(0));
@@ skipping 12 matching lines @@
 }
 
 
 void LCodeGen::DoBitI(LBitI* instr) {
   LOperand* left = instr->left();
   LOperand* right = instr->right();
   ASSERT(left->Equals(instr->result()));
   ASSERT(left->IsRegister());
 
   if (right->IsConstantOperand()) {
-    int right_operand = ToInteger32(LConstantOperand::cast(right));
+    int right_operand = ToRepresentation(LConstantOperand::cast(right),
+                                         instr->hydrogen()->representation());
     switch (instr->op()) {
       case Token::BIT_AND:
-        __ andl(ToRegister(left), Immediate(right_operand));
+        if (instr->hydrogen()->representation().IsSmi()) {
+          __ and_(ToRegister(left), Immediate(right_operand));
+        } else {
+          __ andl(ToRegister(left), Immediate(right_operand));
+        }
         break;
       case Token::BIT_OR:
-        __ orl(ToRegister(left), Immediate(right_operand));
+        if (instr->hydrogen()->representation().IsSmi()) {
+          __ or_(ToRegister(left), Immediate(right_operand));
+        } else {
+          __ orl(ToRegister(left), Immediate(right_operand));
+        }
         break;
       case Token::BIT_XOR:
-        __ xorl(ToRegister(left), Immediate(right_operand));
+        if (instr->hydrogen()->representation().IsSmi()) {
+          __ xor_(ToRegister(left), Immediate(right_operand));
+        } else {
+          __ xorl(ToRegister(left), Immediate(right_operand));
+        }
         break;
       default:
         UNREACHABLE();
         break;
     }
   } else if (right->IsStackSlot()) {
     switch (instr->op()) {
       case Token::BIT_AND:
         __ and_(ToRegister(left), ToOperand(right));
         break;
@@ skipping 95 matching lines @@
 }
 
 
 void LCodeGen::DoSubI(LSubI* instr) {
   LOperand* left = instr->left();
   LOperand* right = instr->right();
   ASSERT(left->Equals(instr->result()));
 
   if (right->IsConstantOperand()) {
     __ subl(ToRegister(left),
-            Immediate(ToInteger32(LConstantOperand::cast(right))));
+            Immediate(ToRepresentation(LConstantOperand::cast(right),
+                                       instr->hydrogen()->representation())));
   } else if (right->IsRegister()) {
     if (instr->hydrogen_value()->representation().IsSmi()) {
-      __ subq(ToRegister(left), ToRegister(right));
+      if (kSmiValueSize == 32) {
+        __ subq(ToRegister(left), ToRegister(right));
+      } else {
+        ASSERT(kSmiValueSize == 31);
+        __ subl(ToRegister(left), ToRegister(right));
+      }
     } else {
       __ subl(ToRegister(left), ToRegister(right));
     }
   } else {
     if (instr->hydrogen_value()->representation().IsSmi()) {
-      __ subq(ToRegister(left), ToOperand(right));
+      if (kSmiValueSize == 32) {
+        __ subq(ToRegister(left), ToOperand(right));
+      } else {
+        ASSERT(kSmiValueSize == 31);
+        __ subl(ToRegister(left), ToOperand(right));
+      }
     } else {
       __ subl(ToRegister(left), ToOperand(right));
     }
   }
 
   if (instr->hydrogen()->CheckFlag(HValue::kCanOverflow)) {
     DeoptimizeIf(overflow, instr->environment());
   }
+
+  if (kSmiValueSize == 31 &&
+      instr->hydrogen_value()->representation().IsSmi()) {
+    __ movsxlq(ToRegister(left), ToRegister(left));
+  }
 }
 
 
 void LCodeGen::DoConstantI(LConstantI* instr) {
   __ Set(ToRegister(instr->result()), instr->value());
 }
 
 
 void LCodeGen::DoConstantS(LConstantS* instr) {
   __ Move(ToRegister(instr->result()), instr->value());
@@ skipping 150 matching lines @@
   }
 }
 
 
 void LCodeGen::DoAddI(LAddI* instr) {
   LOperand* left = instr->left();
   LOperand* right = instr->right();
 
   if (LAddI::UseLea(instr->hydrogen()) && !left->Equals(instr->result())) {
     if (right->IsConstantOperand()) {
-      int32_t offset = ToInteger32(LConstantOperand::cast(right));
-      __ leal(ToRegister(instr->result()),
-              MemOperand(ToRegister(left), offset));
+      int32_t offset = ToRepresentation(LConstantOperand::cast(right),
+                                        instr->hydrogen()->representation());
+      if (instr->hydrogen()->representation().IsSmi()) {
+        __ lea(ToRegister(instr->result()),
+               MemOperand(ToRegister(left), offset));
+      } else {
+        __ leal(ToRegister(instr->result()),
+                MemOperand(ToRegister(left), offset));
+      }
     } else {
       Operand address(ToRegister(left), ToRegister(right), times_1, 0);
       if (instr->hydrogen()->representation().IsSmi()) {
         __ lea(ToRegister(instr->result()), address);
       } else {
         __ leal(ToRegister(instr->result()), address);
       }
     }
   } else {
     if (right->IsConstantOperand()) {
       __ addl(ToRegister(left),
-              Immediate(ToInteger32(LConstantOperand::cast(right))));
+              Immediate(ToRepresentation(LConstantOperand::cast(right),
+                                         instr->hydrogen()->representation())));
     } else if (right->IsRegister()) {
       if (instr->hydrogen_value()->representation().IsSmi()) {
-        __ addq(ToRegister(left), ToRegister(right));
+        if (kSmiValueSize == 32) {
+          __ addq(ToRegister(left), ToRegister(right));
+        } else {
+          ASSERT(kSmiValueSize == 31);
+          __ addl(ToRegister(left), ToRegister(right));
+        }
       } else {
         __ addl(ToRegister(left), ToRegister(right));
       }
     } else {
       if (instr->hydrogen_value()->representation().IsSmi()) {
-        __ addq(ToRegister(left), ToOperand(right));
+        if (kSmiValueSize == 32) {
+          __ addq(ToRegister(left), ToOperand(right));
+        } else {
+          ASSERT(kSmiValueSize == 31);
+          __ addl(ToRegister(left), ToOperand(right));
+        }
       } else {
         __ addl(ToRegister(left), ToOperand(right));
       }
     }
     if (instr->hydrogen()->CheckFlag(HValue::kCanOverflow)) {
       DeoptimizeIf(overflow, instr->environment());
     }
+
+    if (kSmiValueSize == 31 &&
+        instr->hydrogen_value()->representation().IsSmi()) {
+      __ movsxlq(ToRegister(left), ToRegister(left));
+    }
   }
 }
 
 
 void LCodeGen::DoMathMinMax(LMathMinMax* instr) {
   LOperand* left = instr->left();
   LOperand* right = instr->right();
   ASSERT(left->Equals(instr->result()));
   HMathMinMax::Operation operation = instr->hydrogen()->operation();
   if (instr->hydrogen()->representation().IsSmiOrInteger32()) {
     Label return_left;
     Condition condition = (operation == HMathMinMax::kMathMin)
         ? less_equal
         : greater_equal;
     Register left_reg = ToRegister(left);
     if (right->IsConstantOperand()) {
       Immediate right_imm =
-          Immediate(ToInteger32(LConstantOperand::cast(right)));
-      ASSERT(!instr->hydrogen_value()->representation().IsSmi());
+          Immediate(ToRepresentation(LConstantOperand::cast(right),
+                                     instr->hydrogen()->representation()));
       __ cmpl(left_reg, right_imm);
       __ j(condition, &return_left, Label::kNear);
       __ movq(left_reg, right_imm);
     } else if (right->IsRegister()) {
       Register right_reg = ToRegister(right);
       if (instr->hydrogen_value()->representation().IsSmi()) {
         __ cmpq(left_reg, right_reg);
       } else {
         __ cmpl(left_reg, right_reg);
       }
@@ skipping 1177 matching lines @@
 void LCodeGen::DoLoadKeyedExternalArray(LLoadKeyed* instr) {
   ElementsKind elements_kind = instr->elements_kind();
   LOperand* key = instr->key();
   if (!key->IsConstantOperand()) {
     Register key_reg = ToRegister(key);
     // Even though the HLoad/StoreKeyed (in this case) instructions force
     // the input representation for the key to be an integer, the input
     // gets replaced during bound check elimination with the index argument
     // to the bounds check, which can be tagged, so that case must be
     // handled here, too.
-    if (instr->hydrogen()->IsDehoisted()) {
+    if (kSmiValueSize == 31 &&
+        instr->hydrogen()->key()->representation().IsSmi()) {
+      __ SmiToInteger64(key_reg, key_reg);
+    } else if (instr->hydrogen()->IsDehoisted()) {
       // Sign extend key because it could be a 32 bit negative value
       // and the dehoisted address computation happens in 64 bits
       __ movsxlq(key_reg, key_reg);
     }
   }
   Operand operand(BuildFastArrayOperand(
       instr->elements(),
       key,
       elements_kind,
       0,
@@ skipping 50 matching lines @@
 
 void LCodeGen::DoLoadKeyedFixedDoubleArray(LLoadKeyed* instr) {
   XMMRegister result(ToDoubleRegister(instr->result()));
   LOperand* key = instr->key();
   if (!key->IsConstantOperand()) {
     Register key_reg = ToRegister(key);
     // Even though the HLoad/StoreKeyed instructions force the input
     // representation for the key to be an integer, the input gets replaced
     // during bound check elimination with the index argument to the bounds
     // check, which can be tagged, so that case must be handled here, too.
-    if (instr->hydrogen()->IsDehoisted()) {
+    if (kSmiValueSize == 31 &&
+        instr->hydrogen()->key()->representation().IsSmi()) {
+      __ SmiToInteger64(key_reg, key_reg);
+    } else if (instr->hydrogen()->IsDehoisted()) {
       // Sign extend key because it could be a 32 bit negative value
       // and the dehoisted address computation happens in 64 bits
       __ movsxlq(key_reg, key_reg);
     }
   }
 
   if (instr->hydrogen()->RequiresHoleCheck()) {
     int offset = FixedDoubleArray::kHeaderSize - kHeapObjectTag +
         sizeof(kHoleNanLower32);
     Operand hole_check_operand = BuildFastArrayOperand(
@@ skipping 19 matching lines @@
 void LCodeGen::DoLoadKeyedFixedArray(LLoadKeyed* instr) {
   Register result = ToRegister(instr->result());
   LOperand* key = instr->key();
   if (!key->IsConstantOperand()) {
     Register key_reg = ToRegister(key);
     // Even though the HLoad/StoreKeyedFastElement instructions force
     // the input representation for the key to be an integer, the input
     // gets replaced during bound check elimination with the index
     // argument to the bounds check, which can be tagged, so that
     // case must be handled here, too.
-    if (instr->hydrogen()->IsDehoisted()) {
+    if (kSmiValueSize == 31 &&
+        instr->hydrogen()->key()->representation().IsSmi()) {
+      __ SmiToInteger64(key_reg, key_reg);
+    } else if (instr->hydrogen()->IsDehoisted()) {
       // Sign extend key because it could be a 32 bit negative value
       // and the dehoisted address computation happens in 64 bits
       __ movsxlq(key_reg, key_reg);
     }
   }
 
   // Load the result.
   __ movq(result,
           BuildFastArrayOperand(instr->elements(),
                                 key,
@@ skipping 1055 matching lines @@
 void LCodeGen::DoStoreKeyedExternalArray(LStoreKeyed* instr) {
   ElementsKind elements_kind = instr->elements_kind();
   LOperand* key = instr->key();
   if (!key->IsConstantOperand()) {
     Register key_reg = ToRegister(key);
     // Even though the HLoad/StoreKeyedFastElement instructions force
     // the input representation for the key to be an integer, the input
     // gets replaced during bound check elimination with the index
     // argument to the bounds check, which can be tagged, so that case
     // must be handled here, too.
-    if (instr->hydrogen()->IsDehoisted()) {
+    if (kSmiValueSize == 31 &&
+        instr->hydrogen()->key()->representation().IsSmi()) {
+      __ SmiToInteger64(key_reg, key_reg);
+    } else if (instr->hydrogen()->IsDehoisted()) {
       // Sign extend key because it could be a 32 bit negative value
       // and the dehoisted address computation happens in 64 bits
       __ movsxlq(key_reg, key_reg);
     }
   }
   Operand operand(BuildFastArrayOperand(
       instr->elements(),
       key,
       elements_kind,
       0,
@@ skipping 41 matching lines @@
 void LCodeGen::DoStoreKeyedFixedDoubleArray(LStoreKeyed* instr) {
   XMMRegister value = ToDoubleRegister(instr->value());
   LOperand* key = instr->key();
   if (!key->IsConstantOperand()) {
     Register key_reg = ToRegister(key);
     // Even though the HLoad/StoreKeyedFastElement instructions force
     // the input representation for the key to be an integer, the
     // input gets replaced during bound check elimination with the index
     // argument to the bounds check, which can be tagged, so that case
     // must be handled here, too.
-    if (instr->hydrogen()->IsDehoisted()) {
+    if (kSmiValueSize == 31 &&
+        instr->hydrogen()->key()->representation().IsSmi()) {
+      __ SmiToInteger64(key_reg, key_reg);
+    } else if (instr->hydrogen()->IsDehoisted()) {
       // Sign extend key because it could be a 32 bit negative value
       // and the dehoisted address computation happens in 64 bits
       __ movsxlq(key_reg, key_reg);
     }
   }
 
   if (instr->NeedsCanonicalization()) {
     Label have_value;
 
     __ ucomisd(value, value);
@@ skipping 20 matching lines @@
 void LCodeGen::DoStoreKeyedFixedArray(LStoreKeyed* instr) {
   Register elements = ToRegister(instr->elements());
   LOperand* key = instr->key();
   if (!key->IsConstantOperand()) {
     Register key_reg = ToRegister(key);
     // Even though the HLoad/StoreKeyedFastElement instructions force
     // the input representation for the key to be an integer, the
     // input gets replaced during bound check elimination with the index
     // argument to the bounds check, which can be tagged, so that case
     // must be handled here, too.
-    if (instr->hydrogen()->IsDehoisted()) {
+    if (kSmiValueSize == 31 &&
+        instr->hydrogen()->key()->representation().IsSmi()) {
+      __ SmiToInteger64(key_reg, key_reg);
+    } else if (instr->hydrogen()->IsDehoisted()) {
       // Sign extend key because it could be a 32 bit negative value
       // and the dehoisted address computation happens in 64 bits
       __ movsxlq(key_reg, key_reg);
     }
   }
 
   Operand operand =
       BuildFastArrayOperand(instr->elements(),
                             key,
                             FAST_ELEMENTS,
@@ skipping 265 matching lines @@
   LOperand* output = instr->result();
   LOperand* temp = instr->temp();
 
   __ LoadUint32(ToDoubleRegister(output),
                 ToRegister(input),
                 ToDoubleRegister(temp));
 }
 
 
 void LCodeGen::DoNumberTagI(LNumberTagI* instr) {
-  LOperand* input = instr->value();
-  ASSERT(input->IsRegister() && input->Equals(instr->result()));
-  Register reg = ToRegister(input);
+  if (kSmiValueSize == 32) {
+    LOperand* input = instr->value();
+    ASSERT(input->IsRegister() && input->Equals(instr->result()));
+    Register reg = ToRegister(input);
 
-  __ Integer32ToSmi(reg, reg);
+    __ Integer32ToSmi(reg, reg);
+  } else {
+    ASSERT(kSmiValueSize == 31);
+    class DeferredNumberTagI: public LDeferredCode {
+     public:
+      DeferredNumberTagI(LCodeGen* codegen, LNumberTagI* instr)
+          : LDeferredCode(codegen), instr_(instr) { }
+      virtual void Generate() {
+        codegen()->DoDeferredNumberTagI(instr_);
+      }
+      virtual LInstruction* instr() { return instr_; }
+     private:
+      LNumberTagI* instr_;
+    };
+
+    LOperand* input = instr->value();
+    ASSERT(input->IsRegister() && input->Equals(instr->result()));
+    Register reg = ToRegister(input);
+
+    DeferredNumberTagI* deferred = new(zone()) DeferredNumberTagI(this, instr);
+    __ shll(reg, Immediate(kSmiTagSize + kSmiShiftSize));
+    __ j(overflow, deferred->entry());
+    __ movsxlq(reg, reg);
+    __ bind(deferred->exit());
+  }
 }
 
 
+void LCodeGen::DoDeferredNumberTagI(LNumberTagI* instr) {
+  Label slow;
+  Register reg = ToRegister(instr->value());
+  Register tmp = reg.is(rax) ? kScratchRegister : rax;
+
+  // Preserve the value of all registers.
+  PushSafepointRegistersScope scope(this);
+
+  Label done;
+  // There was overflow, so bits 30 and 31 of the original integer
+  // disagree. Try to allocate a heap number in new space and store
+  // the value in there. If that fails, call the runtime system.
+  __ SmiToInteger32(reg, reg);
+  __ xorl(reg, Immediate(0x80000000));
+  __ cvtlsi2sd(xmm1, reg);
+
+  if (FLAG_inline_new) {
+    __ AllocateHeapNumber(reg, tmp, &slow);
+    __ jmp(&done, Label::kNear);
+  }
+
+  // Slow case: Call the runtime system to do the number allocation.
+  __ bind(&slow);
+
+  // Put a valid pointer value in the stack slot where the result
+  // register is stored, as this register is in the pointer map, but contains an
+  // integer value.
+  __ StoreToSafepointRegisterSlot(reg, Immediate(0));
+  CallRuntimeFromDeferred(Runtime::kAllocateHeapNumber, 0, instr);
+  // Set the pointer to the new heap number in tmp.
+  if (!reg.is(rax)) __ movq(reg, rax);
+
+  // Heap number allocated. Put the value in xmm0 into the value of the
+  // allocated heap number.
+  __ bind(&done);
+  __ movsd(FieldOperand(reg, HeapNumber::kValueOffset), xmm1);
+  __ StoreToSafepointRegisterSlot(reg, reg);
+}
+
+
 void LCodeGen::DoNumberTagU(LNumberTagU* instr) {
   class DeferredNumberTagU: public LDeferredCode {
    public:
     DeferredNumberTagU(LCodeGen* codegen, LNumberTagU* instr)
         : LDeferredCode(codegen), instr_(instr) { }
     virtual void Generate() {
       codegen()->DoDeferredNumberTagU(instr_);
     }
     virtual LInstruction* instr() { return instr_; }
    private:
@@ skipping 1052 matching lines @@
                                FixedArray::kHeaderSize - kPointerSize));
   __ bind(&done);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_X64