Crankshaft support for FixedDoubleArrays

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 2415 matching lines @@
 
   // Check for the hole value.
   if (instr->hydrogen()->RequiresHoleCheck()) {
     __ LoadRoot(scratch, Heap::kTheHoleValueRootIndex);
     __ cmp(result, scratch);
     DeoptimizeIf(eq, instr->environment());
   }
 }
 
 
+void LCodeGen::DoLoadKeyedFastDoubleElement(
+    LLoadKeyedFastDoubleElement* instr) {
+  Register elements = ToRegister(instr->elements());
+  bool key_is_constant = instr->key()->IsConstantOperand();
+  Register key = no_reg;
+  DwVfpRegister result = ToDoubleRegister(instr->result());
+  Register scratch1 = scratch0();

[Mads Ager (chromium), 2011/07/19 08:03:51]

scratch1 -> scratch?

[danno, 2011/07/19 12:50:17]

Done.

+
+  int shift_size =
+      ElementsKindToShiftSize(JSObject::FAST_DOUBLE_ELEMENTS);
+  int constant_key = 0;
+  if (key_is_constant) {
+    constant_key = ToInteger32(LConstantOperand::cast(instr->key()));
+    if (constant_key & 0xF0000000) {
+      Abort("array index constant value too big.");
+    }
+  } else {
+    key = ToRegister(instr->key());
+  }
+
+  Operand operand(key_is_constant ? Operand(constant_key * (1 << shift_size))

[Mads Ager (chromium), 2011/07/19 08:03:51]

Use "operand = expression" instead of "operand(expression)" here?

[danno, 2011/07/19 12:50:17]

Done.

+                  : Operand(key, LSL, shift_size));
+  __ add(elements, elements, operand);

[Alexandre, 2011/07/18 16:22:14]

If key is constant this add instruction can be merged with the one below.

[Mads Ager (chromium), 2011/07/19 08:03:51]

I'm fine with tweaking stuff like this later. I think if the instruction does
not require hole checks and the key is a constant, the element register does not
need to be writable and we can use UseRegisterAtStart. Starting with the current
structure is fine to keep it simple. Then we can measure the impact of these
tweaks once this lands.

[danno, 2011/07/19 12:50:17]

Done.

+
+  if (instr->hydrogen()->RequiresHoleCheck()) {
+    int offset =
+        FixedDoubleArray::kHeaderSize + sizeof(kHoleNanLower32);
+    __ ldr(scratch1, FieldMemOperand(elements, offset));
+    __ cmp(scratch1, Operand(kHoleNanUpper32));
+    DeoptimizeIf(eq, instr->environment());
+  }
+
+  __ add(elements, elements,
+         Operand(FixedDoubleArray::kHeaderSize - kSmiTagMask));

[Mads Ager (chromium), 2011/07/19 08:03:51]

kSmiTagMask -> kHeapObjectTag?

[danno, 2011/07/19 12:50:17]

Done.

+  __ vldr(result, elements, 0);
+}
+
+
 void LCodeGen::DoLoadKeyedSpecializedArrayElement(
     LLoadKeyedSpecializedArrayElement* instr) {
   Register external_pointer = ToRegister(instr->external_pointer());
   Register key = no_reg;
   JSObject::ElementsKind elements_kind = instr->elements_kind();
   bool key_is_constant = instr->key()->IsConstantOperand();
   int constant_key = 0;
   if (key_is_constant) {
     constant_key = ToInteger32(LConstantOperand::cast(instr->key()));
     if (constant_key & 0xF0000000) {
@@ skipping 790 matching lines @@
   }
 
   if (instr->hydrogen()->NeedsWriteBarrier()) {
     // Compute address of modified element and store it into key register.
     __ add(key, scratch, Operand(FixedArray::kHeaderSize));
     __ RecordWrite(elements, key, value);
   }
 }
 
 
+void LCodeGen::DoStoreKeyedFastDoubleElement(
+    LStoreKeyedFastDoubleElement* instr) {
+  DwVfpRegister value = ToDoubleRegister(instr->value());
+  Register elements = ToRegister(instr->elements());
+  Register key = no_reg;
+  bool key_is_constant = instr->key()->IsConstantOperand();
+  int constant_key = 0;
+  Label not_nan;
+
+  // Calculate the effective address of the slot in the array to store the
+  // double value.
+  if (key_is_constant) {
+    constant_key = ToInteger32(LConstantOperand::cast(instr->key()));
+    if (constant_key & 0xF0000000) {
+      Abort("array index constant value too big.");
+    }
+  } else {
+    key = ToRegister(instr->key());
+  }
+  int shift_size = ElementsKindToShiftSize(JSObject::FAST_DOUBLE_ELEMENTS);
+  Operand operand(key_is_constant ? Operand(constant_key * (1 << shift_size))

[Mads Ager (chromium), 2011/07/19 08:03:51]

I would use '=' here.

[danno, 2011/07/19 12:50:17]

Done.

+                  : Operand(key, LSL, shift_size));
+  __ add(elements, elements, operand);

[Alexandre, 2011/07/18 16:22:14]

If the key is constant, these two add instructions can be merged into one.

[Mads Ager (chromium), 2011/07/19 08:03:51]

Instead of writing to elements here, can you use the scratch register? That way
i think you can avoid writing to elements and you can get away with using
UseRegisterAtStart instead of UseTempRegister?

[danno, 2011/07/19 12:50:17]

Done.

[danno, 2011/07/19 12:50:17]

Done.

+  __ add(elements, elements,
+         Operand(FixedDoubleArray::kHeaderSize - kSmiTagMask));

[Mads Ager (chromium), 2011/07/19 08:03:51]

kHeapObjectTag

[danno, 2011/07/19 12:50:17]

Done.

+
+  // Check for NaN. All NaNs must be canonicalized.
+  __ VFPCompareAndSetFlags(value, value);
+  __ b(vc, &not_nan);
+
+  __ Vmov(value, FixedDoubleArray::canonical_not_the_hole_nan_as_double());

[Alexandre, 2011/07/18 16:22:14]

You can spare the previous branch by making this vmov conditional.

[danno, 2011/07/19 12:50:17]

Done.

+
+  __ bind(&not_nan);
+  __ vstr(value, elements, 0);
+}
+
+
 void LCodeGen::DoStoreKeyedSpecializedArrayElement(
     LStoreKeyedSpecializedArrayElement* instr) {
 
   Register external_pointer = ToRegister(instr->external_pointer());
   Register key = no_reg;
   JSObject::ElementsKind elements_kind = instr->elements_kind();
   bool key_is_constant = instr->key()->IsConstantOperand();
   int constant_key = 0;
   if (key_is_constant) {
     constant_key = ToInteger32(LConstantOperand::cast(instr->key()));
@@ skipping 1144 matching lines @@
   ASSERT(osr_pc_offset_ == -1);
   osr_pc_offset_ = masm()->pc_offset();
 }
 
 
 
 
 #undef __
 
 } }  // namespace v8::internal