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

src/arm/lithium-codegen-arm.cc

Index: src/arm/lithium-codegen-arm.cc
diff --git a/src/arm/lithium-codegen-arm.cc b/src/arm/lithium-codegen-arm.cc
index 33733fb4636c70213747b857058496763cb36cd1..0aa7c93f97a9885103e8b4976b94d32afe34697c 100644
--- a/src/arm/lithium-codegen-arm.cc
+++ b/src/arm/lithium-codegen-arm.cc
@@ -4014,6 +4014,59 @@ void LCodeGen::DoCheckMap(LCheckMap* instr) {
 }
 
 
+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)) {