Prevent deopt when assigning double values to typed arrays

src/ia32/lithium-codegen-ia32.cc

 // Copyright 2011 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 265 matching lines @@
 
 
 XMMRegister LCodeGen::ToDoubleRegister(LOperand* op) const {
   ASSERT(op->IsDoubleRegister());
   return ToDoubleRegister(op->index());
 }
 
 
 int LCodeGen::ToInteger32(LConstantOperand* op) const {
   Handle<Object> value = chunk_->LookupLiteral(op);
-  ASSERT(chunk_->LookupLiteralRepresentation(op).IsInteger32());
+  ASSERT(chunk_->LookupLiteralRepresentation(op).IsInteger());
   ASSERT(static_cast<double>(static_cast<int32_t>(value->Number())) ==
       value->Number());
   return static_cast<int32_t>(value->Number());
 }
 
 
 Immediate LCodeGen::ToImmediate(LOperand* op) {
   LConstantOperand* const_op = LConstantOperand::cast(op);
   Handle<Object> literal = chunk_->LookupLiteral(const_op);
   Representation r = chunk_->LookupLiteralRepresentation(const_op);
-  if (r.IsInteger32()) {
+  if (r.IsInteger()) {
     ASSERT(literal->IsNumber());
-    return Immediate(static_cast<int32_t>(literal->Number()));
+    if (r.IsClampedRoundedInteger8()) {
+      return Immediate(ClampToUInt8(literal->Number()));
+    } else {
+      return Immediate(static_cast<int32_t>(literal->Number()));
+    }
   } else if (r.IsDouble()) {
     Abort("unsupported double immediate");
   }
   ASSERT(r.IsTagged());
   return Immediate(literal);
 }
 
 
 Operand LCodeGen::ToOperand(LOperand* op) const {
   if (op->IsRegister()) return Operand(ToRegister(op));
@@ skipping 966 matching lines @@
     __ jmp(chunk_->GetAssemblyLabel(right_block));
   }
 }
 
 
 void LCodeGen::DoBranch(LBranch* instr) {
   int true_block = chunk_->LookupDestination(instr->true_block_id());
   int false_block = chunk_->LookupDestination(instr->false_block_id());
 
   Representation r = instr->hydrogen()->representation();
-  if (r.IsInteger32()) {
+  if (r.IsInteger()) {
     Register reg = ToRegister(instr->InputAt(0));
     __ test(reg, Operand(reg));
     EmitBranch(true_block, false_block, not_zero);
   } else if (r.IsDouble()) {
     XMMRegister reg = ToDoubleRegister(instr->InputAt(0));
     __ xorpd(xmm0, xmm0);
     __ ucomisd(reg, xmm0);
     EmitBranch(true_block, false_block, not_equal);
   } else {
     ASSERT(r.IsTagged());
@@ skipping 1361 matching lines @@
 
   ASSERT(instr->InputAt(0)->Equals(instr->result()));
   Representation r = instr->hydrogen()->value()->representation();
 
   if (r.IsDouble()) {
     XMMRegister  scratch = xmm0;
     XMMRegister input_reg = ToDoubleRegister(instr->InputAt(0));
     __ pxor(scratch, scratch);
     __ subsd(scratch, input_reg);
     __ pand(input_reg, scratch);
-  } else if (r.IsInteger32()) {
+  } else if (r.IsInteger()) {
     EmitIntegerMathAbs(instr);
   } else {  // Tagged case.
     DeferredMathAbsTaggedHeapNumber* deferred =
         new DeferredMathAbsTaggedHeapNumber(this, instr);
     Register input_reg = ToRegister(instr->InputAt(0));
     // Smi check.
     __ test(input_reg, Immediate(kSmiTagMask));
     __ j(not_zero, deferred->entry());
     EmitIntegerMathAbs(instr);
     __ bind(deferred->exit());
@@ skipping 94 matching lines @@
   Representation exponent_type = instr->hydrogen()->right()->representation();
 
   if (exponent_type.IsDouble()) {
     // It is safe to use ebx directly since the instruction is marked
     // as a call.
     __ PrepareCallCFunction(4, ebx);
     __ movdbl(Operand(esp, 0 * kDoubleSize), ToDoubleRegister(left));
     __ movdbl(Operand(esp, 1 * kDoubleSize), ToDoubleRegister(right));
     __ CallCFunction(ExternalReference::power_double_double_function(isolate()),
                      4);
-  } else if (exponent_type.IsInteger32()) {
+  } else if (exponent_type.IsInteger()) {
     // It is safe to use ebx directly since the instruction is marked
     // as a call.
     ASSERT(!ToRegister(right).is(ebx));
     __ PrepareCallCFunction(4, ebx);
     __ movdbl(Operand(esp, 0 * kDoubleSize), ToDoubleRegister(left));
     __ mov(Operand(esp, 1 * kDoubleSize), ToRegister(right));
     __ CallCFunction(ExternalReference::power_double_int_function(isolate()),
                      4);
   } else {
     ASSERT(exponent_type.IsTagged());
@@ skipping 250 matching lines @@
   Register external_pointer = ToRegister(instr->external_pointer());
   Register key = ToRegister(instr->key());
   ExternalArrayType array_type = instr->array_type();
   if (array_type == kExternalFloatArray) {
     __ cvtsd2ss(xmm0, ToDoubleRegister(instr->value()));
     __ movss(Operand(external_pointer, key, times_4, 0), xmm0);
   } else {
     Register value = ToRegister(instr->value());
     switch (array_type) {
       case kExternalPixelArray: {
-        // Clamp the value to [0..255].
-        Register temp = ToRegister(instr->TempAt(0));
-        // The dec_b below requires that the clamped value is in a byte
-        // register. eax is an arbitrary choice to satisfy this requirement, we
-        // hinted the register allocator to give us eax when building the
-        // instruction.
-        ASSERT(temp.is(eax));
-        __ mov(temp, ToRegister(instr->value()));
-        NearLabel done;
-        __ test(temp, Immediate(0xFFFFFF00));
-        __ j(zero, &done);
-        __ setcc(negative, temp);  // 1 if negative, 0 if positive.
-        __ dec_b(temp);  // 0 if negative, 255 if positive.
-        __ bind(&done);
-        __ mov_b(Operand(external_pointer, key, times_1, 0), temp);
+        ASSERT(value.is(eax));
+        __ mov_b(Operand(external_pointer, key, times_1, 0), value);
         break;
       }
       case kExternalByteArray:
       case kExternalUnsignedByteArray:
         __ mov_b(Operand(external_pointer, key, times_1, 0), value);
         break;
       case kExternalShortArray:
       case kExternalUnsignedShortArray:
         __ mov_w(Operand(external_pointer, key, times_2, 0), value);
         break;
@@ skipping 196 matching lines @@
     DeferredStringCharFromCode(LCodeGen* codegen, LStringCharFromCode* instr)
         : LDeferredCode(codegen), instr_(instr) { }
     virtual void Generate() { codegen()->DoDeferredStringCharFromCode(instr_); }
    private:
     LStringCharFromCode* instr_;
   };
 
   DeferredStringCharFromCode* deferred =
       new DeferredStringCharFromCode(this, instr);
 
-  ASSERT(instr->hydrogen()->value()->representation().IsInteger32());
+  ASSERT(instr->hydrogen()->value()->representation().IsInteger());
   Register char_code = ToRegister(instr->char_code());
   Register result = ToRegister(instr->result());
   ASSERT(!char_code.is(result));
 
   __ cmp(char_code, String::kMaxAsciiCharCode);
   __ j(above, deferred->entry());
   __ Set(result, Immediate(factory()->single_character_string_cache()));
   __ mov(result, FieldOperand(result,
                               char_code, times_pointer_size,
                               FixedArray::kHeaderSize));
@@ skipping 45 matching lines @@
 
 void LCodeGen::DoInteger32ToDouble(LInteger32ToDouble* instr) {
   LOperand* input = instr->InputAt(0);
   ASSERT(input->IsRegister() || input->IsStackSlot());
   LOperand* output = instr->result();
   ASSERT(output->IsDoubleRegister());
   __ cvtsi2sd(ToDoubleRegister(output), ToOperand(input));
 }
 
 
+void LCodeGen::DoInteger32ToClamped(LInteger32ToClamped* instr) {
+  LOperand* input = instr->InputAt(0);
+  ASSERT(input->IsRegister());
+  Register reg = ToRegister(input);
+  ASSERT(reg.is(ToRegister(instr->result())));
+  __ ClampUInt8(reg);
+}
+
+
 void LCodeGen::DoNumberTagI(LNumberTagI* instr) {
   class DeferredNumberTagI: public LDeferredCode {
    public:
     DeferredNumberTagI(LCodeGen* codegen, LNumberTagI* instr)
         : LDeferredCode(codegen), instr_(instr) { }
     virtual void Generate() { codegen()->DoDeferredNumberTagI(instr_); }
    private:
     LNumberTagI* instr_;
   };
 
@@ skipping 93 matching lines @@
 }
 
 
 void LCodeGen::DoSmiUntag(LSmiUntag* instr) {
   LOperand* input = instr->InputAt(0);
   ASSERT(input->IsRegister() && input->Equals(instr->result()));
   if (instr->needs_check()) {
     __ test(ToRegister(input), Immediate(kSmiTagMask));
     DeoptimizeIf(not_zero, instr->environment());
   }
-  __ SmiUntag(ToRegister(input));
+  Register input_reg = ToRegister(input);
+  __ SmiUntag(input_reg);
+
+  if (instr->should_clamp()) {
+    __ ClampUInt8(input_reg);
+  }
 }
 
 
 void LCodeGen::EmitNumberUntagD(Register input_reg,
                                 XMMRegister result_reg,
                                 LEnvironment* env) {
   NearLabel load_smi, heap_number, done;
 
   // Smi check.
   __ test(input_reg, Immediate(kSmiTagMask));
@@ skipping 30 matching lines @@
  public:
   DeferredTaggedToI(LCodeGen* codegen, LTaggedToI* instr)
       : LDeferredCode(codegen), instr_(instr) { }
   virtual void Generate() { codegen()->DoDeferredTaggedToI(instr_); }
  private:
   LTaggedToI* instr_;
 };
 
 
 void LCodeGen::DoDeferredTaggedToI(LTaggedToI* instr) {
-  NearLabel done, heap_number;
+  NearLabel done;
   Register input_reg = ToRegister(instr->InputAt(0));
 
   // Heap number map check.
   __ cmp(FieldOperand(input_reg, HeapObject::kMapOffset),
          factory()->heap_number_map());
 
-  if (instr->truncating()) {
+  Representation r = instr->hydrogen()->representation();
+  if (r.IsClampedRoundedInteger8()) {
+    NearLabel heap_number;
     __ j(equal, &heap_number);
     // Check for undefined. Undefined is converted to zero for truncating
     // conversions.
+    __ cmp(input_reg, factory()->undefined_value());
+    DeoptimizeIf(not_equal, instr->environment());
+    __ mov(input_reg, 0);
+    __ jmp(&done);
+
+    __ bind(&heap_number);
+    XMMRegister xmm_temp = ToDoubleRegister(instr->TempAt(0));
+    __ movdbl(xmm_temp, FieldOperand(input_reg, HeapNumber::kValueOffset));
+    __ ClampDoubleToUInt8(xmm_temp, input_reg);
+  } else if (r.IsTruncatedInteger32()) {
+    NearLabel heap_number;
+    __ j(equal, &heap_number);
+    // Check for undefined. Undefined is converted to zero for truncating
+    // conversions.
     __ cmp(input_reg, factory()->undefined_value());
     DeoptimizeIf(not_equal, instr->environment());
     __ mov(input_reg, 0);
     __ jmp(&done);
 
     __ bind(&heap_number);
     if (CpuFeatures::IsSupported(SSE3)) {
       CpuFeatures::Scope scope(SSE3);
       NearLabel convert;
       // Use more powerful conversion when sse3 is available.
@@ skipping 64 matching lines @@
   Register input_reg = ToRegister(input);
 
   DeferredTaggedToI* deferred = new DeferredTaggedToI(this, instr);
 
   // Smi check.
   __ test(input_reg, Immediate(kSmiTagMask));
   __ j(not_zero, deferred->entry());
 
   // Smi to int32 conversion
   __ SmiUntag(input_reg);  // Untag smi.
+  Representation r = instr->hydrogen()->representation();
+  if (r.IsClampedRoundedInteger8()) {
+    __ ClampUInt8(input_reg);
+  }
 
   __ bind(deferred->exit());
 }
 
 
 void LCodeGen::DoNumberUntagD(LNumberUntagD* instr) {
   LOperand* input = instr->InputAt(0);
   ASSERT(input->IsRegister());
   LOperand* result = instr->result();
   ASSERT(result->IsDoubleRegister());
 
   Register input_reg = ToRegister(input);
   XMMRegister result_reg = ToDoubleRegister(result);
 
   EmitNumberUntagD(input_reg, result_reg, instr->environment());
 }
 
 
 void LCodeGen::DoDoubleToI(LDoubleToI* instr) {
   LOperand* input = instr->InputAt(0);
   ASSERT(input->IsDoubleRegister());
   LOperand* result = instr->result();
   ASSERT(result->IsRegister());
 
   XMMRegister input_reg = ToDoubleRegister(input);
   Register result_reg = ToRegister(result);
 
-  if (instr->truncating()) {
+  Representation r = instr->hydrogen()->representation();
+  if (r.IsClampedRoundedInteger8()) {
+    __ ClampDoubleToUInt8(input_reg, result_reg);
+  } else if (r.IsTruncatedInteger32()) {
     // Performs a truncating conversion of a floating point number as used by
     // the JS bitwise operations.
     __ cvttsd2si(result_reg, Operand(input_reg));
     __ cmp(result_reg, 0x80000000u);
     if (CpuFeatures::IsSupported(SSE3)) {
       // This will deoptimize if the exponent of the input in out of range.
       CpuFeatures::Scope scope(SSE3);
       NearLabel convert, done;
       __ j(not_equal, &done);
       __ sub(Operand(esp), Immediate(kDoubleSize));
@@ skipping 560 matching lines @@
   ASSERT(osr_pc_offset_ == -1);
   osr_pc_offset_ = masm()->pc_offset();
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_IA32