Introduce HTransitionElementsKind instruction.

src/ia32/lithium-codegen-ia32.cc

Index: src/ia32/lithium-codegen-ia32.cc
diff --git a/src/ia32/lithium-codegen-ia32.cc b/src/ia32/lithium-codegen-ia32.cc
index 9e1fd34af3347c4ffbfe6fb4df1496094859a8fb..9e48f9e8d37c763759b4dd273919b98832fb7c5b 100644
--- a/src/ia32/lithium-codegen-ia32.cc
+++ b/src/ia32/lithium-codegen-ia32.cc
@@ -3303,6 +3303,51 @@ void LCodeGen::DoStoreKeyedGeneric(LStoreKeyedGeneric* instr) {
 }
 
 
+void LCodeGen::DoTransitionElementsKind(LTransitionElementsKind* instr) {
+  Register object_reg = ToRegister(instr->object());
+  Register new_map_reg = ToRegister(instr->new_map_reg());
+
+  Handle<Map> from_map = instr->original_map();
+  Handle<Map> to_map = instr->transitioned_map();
+  ElementsKind from_elements = from_map->elements_kind();
+  ElementsKind to_elements = to_map->elements_kind();
+
+  Label not_applicable;
+  __ cmp(FieldOperand(object_reg, HeapObject::kMapOffset), from_map);
+  __ j(not_equal, &not_applicable);
+  __ push(object_reg);

[danno, 2011/10/17 12:36:05]

You always push object_reg, even if it isn't needed after the Transition. You
should have the register allocate help you more here. If you have object_reg as
a UseTempRegister _and_  TempRegister(edx), plus add a move between object_reg
and edx before the call, I think you get what you want and the register can do a
better job of rematerializing the value from the stack slot if it can. You
probably should ask Kevin if he knows some better trick.

[Jakob Kummerow, 2011/10/18 08:13:09]

Done.

[danno, 2011/10/18 08:57:03]

Done.

+  __ mov(new_map_reg, to_map);

[danno, 2011/10/17 12:36:05]

You only need this is the FAST_SMI_ONLY_ELEMENTS -> FAST_DOUBLE_ELEMENTS and
FAST_DOUBLE_ELEMENTS -> FAST_ELEMENTS cases. Can you save the move in the
FAST_SMI_ONLY_ELEMENTS -> FAST_ELEMENTS case?

[Jakob Kummerow, 2011/10/18 08:13:09]

Nope, I really do need it in all cases (due to the write barrier, which expects
the written value in a register).

+  if (from_elements == FAST_SMI_ONLY_ELEMENTS) {
+    if (to_elements == FAST_DOUBLE_ELEMENTS) {
+      ASSERT(object_reg.is(edx));
+      ASSERT(new_map_reg.is(ebx));
+      Handle<Code> stub =
+          isolate()->builtins()->TransitionElementsSmiToDouble();
+      CallCode(stub, RelocInfo::CODE_TARGET, instr);
+    } else if (to_elements == FAST_ELEMENTS) {
+      __ mov(FieldOperand(object_reg, HeapObject::kMapOffset), new_map_reg);
+      // Write barrier.
+      ASSERT_NE(instr->temp_reg(), NULL);
+      __ RecordWriteField(object_reg, HeapObject::kMapOffset, new_map_reg,
+                          ToRegister(instr->temp_reg()), kDontSaveFPRegs);
+    } else {
+      UNREACHABLE();
+    }
+  } else if (from_elements == FAST_DOUBLE_ELEMENTS &&
+      to_elements == FAST_ELEMENTS) {
+    ASSERT(object_reg.is(edx));
+    ASSERT(new_map_reg.is(ebx));
+    Handle<Code> stub =
+        isolate()->builtins()->TransitionElementsDoubleToObject();
+    CallCode(stub, RelocInfo::CODE_TARGET, instr);
+  } else {
+    UNREACHABLE();
+  }
+  __ pop(object_reg);

[danno, 2011/10/17 12:36:05]

The register allocator should be able to help you here.

[Jakob Kummerow, 2011/10/18 08:13:09]

Done.

+  __ bind(&not_applicable);
+}
+
+
 void LCodeGen::DoStringCharCodeAt(LStringCharCodeAt* instr) {
   class DeferredStringCharCodeAt: public LDeferredCode {
    public: