Support conversion of clamped double values for pixel arrays in Crankshaft.

src/arm/lithium-codegen-arm.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 3335 matching lines @@
       __ vstr(value, scratch0(), 0);
     }
   } else {
     Register value(ToRegister(instr->value()));
     MemOperand mem_operand(key_is_constant
         ? MemOperand(external_pointer, constant_key * (1 << shift_size))
         : MemOperand(external_pointer, key, LSL, shift_size));
     switch (array_type) {
       case kExternalPixelArray:
         // Clamp the value to [0..255].
         __ Usat(value, 8, Operand(value));

[Kevin Millikin (Chromium), 2011/05/16 07:06:35]

Should this be removed?

[danno, 2011/05/16 14:13:43]

Done.

         // Fall through to the next case for the store instruction:
       case kExternalByteArray:
       case kExternalUnsignedByteArray:
         __ strb(value, mem_operand);
         break;
       case kExternalShortArray:
       case kExternalUnsignedShortArray:
         __ strh(value, mem_operand);
         break;
       case kExternalIntArray:
@@ skipping 640 matching lines @@
   Register scratch = scratch0();
   LOperand* input = instr->InputAt(0);
   ASSERT(input->IsRegister());
   Register reg = ToRegister(input);
   __ ldr(scratch, FieldMemOperand(reg, HeapObject::kMapOffset));
   __ cmp(scratch, Operand(instr->hydrogen()->map()));
   DeoptimizeIf(ne, instr->environment());
 }
 
 
+void LCodeGen::DoClampDoubleToUint8(LClampDoubleToUint8* instr) {
+  DoubleRegister value_reg = ToDoubleRegister(instr->unclamped());
+  Register result_reg = ToRegister(instr->result());
+  DoubleRegister temp_reg = ToDoubleRegister(instr->TempAt(0));
+  __ ClampDoubleToUint8(result_reg, value_reg, temp_reg);
+}
+
+
+void LCodeGen::DoClampIToUint8(LClampIToUint8* instr) {
+  Register unclamped_reg = ToRegister(instr->unclamped());
+  Register result_reg = ToRegister(instr->result());
+  __ ClampUint8(result_reg, unclamped_reg);
+}
+
+
+void LCodeGen::DoClampTaggedToUint8(LClampTaggedToUint8* instr) {
+  Register scratch = scratch0();
+  Register input_reg = ToRegister(instr->unclamped());
+  Register result_reg = ToRegister(instr->result());
+  DoubleRegister temp_reg = ToDoubleRegister(instr->TempAt(0));
+  Label is_smi, done, heap_number;
+
+  // Both smi and heap number cases are handled.
+  __ JumpIfSmi(input_reg, &is_smi);
+
+  // Check for heap number
+  __ ldr(scratch, FieldMemOperand(input_reg, HeapObject::kMapOffset));
+  __ cmp(scratch, Operand(factory()->heap_number_map()));
+  __ b(eq, &heap_number);
+
+  // Check for undefined. Undefined is converted to zero for clamping
+  // conversions.
+  __ cmp(input_reg, Operand(factory()->undefined_value()));
+  DeoptimizeIf(ne, instr->environment());
+  __ movt(input_reg, 0);
+  __ b(al, &done);

[Kevin Millikin (Chromium), 2011/05/16 07:06:35]

There is __ jmp(&done) for ARM, which just emits __b(al, &done).  I find it
clearer when reading ARM code but I'm not sure if everyone agrees with that.

[danno, 2011/05/16 14:13:43]

Done.

+
+  // Heap number
+  __ bind(&heap_number);
+  __ sub(scratch0(), input_reg, Operand(kHeapObjectTag));
+  __ vldr(double_scratch0(), scratch0(), HeapNumber::kValueOffset);

[Kevin Millikin (Chromium), 2011/05/16 07:06:35]

Someone has kindly implemented vldr to take a MemOperand!  So you should be able
to get rid of the sub and the scratch0 register use and write:

__ vldr(double_scratch0(), FieldMemOperand(input_reg,
HeapNumber::kValueOffset));

I guess this code was copied from somewhere, so you could change it there too.

[danno, 2011/05/16 14:13:43]

Done.

+  __ ClampDoubleToUint8(result_reg, double_scratch0(), temp_reg);
+  __ b(al, &done);
+
+  // smi
+  __ bind(&is_smi);
+  __ SmiUntag(result_reg, input_reg);
+  __ ClampUint8(result_reg, result_reg);
+
+  __ bind(&done);
+}
+
+
 void LCodeGen::LoadHeapObject(Register result,
                               Handle<HeapObject> object) {
   if (heap()->InNewSpace(*object)) {
     Handle<JSGlobalPropertyCell> cell =
         factory()->NewJSGlobalPropertyCell(object);
     __ mov(result, Operand(cell));
     __ ldr(result, FieldMemOperand(result, JSGlobalPropertyCell::kValueOffset));
   } else {
     __ mov(result, Operand(object));
   }
@@ skipping 389 matching lines @@
   ASSERT(osr_pc_offset_ == -1);
   osr_pc_offset_ = masm()->pc_offset();
 }
 
 
 
 
 #undef __
 
 } }  // namespace v8::internal