Introduce HTransitionElementsKind instruction.

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 3285 matching lines @@
   ASSERT(ToRegister(instr->key()).is(ecx));
   ASSERT(ToRegister(instr->value()).is(eax));
 
   Handle<Code> ic = instr->strict_mode()
       ? isolate()->builtins()->KeyedStoreIC_Initialize_Strict()
       : isolate()->builtins()->KeyedStoreIC_Initialize();
   CallCode(ic, RelocInfo::CODE_TARGET, 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:
     DeferredStringCharCodeAt(LCodeGen* codegen, LStringCharCodeAt* instr)
         : LDeferredCode(codegen), instr_(instr) { }
     virtual void Generate() { codegen()->DoDeferredStringCharCodeAt(instr_); }
     virtual LInstruction* instr() { return instr_; }
    private:
     LStringCharCodeAt* instr_;
   };
@@ skipping 1173 matching lines @@
                                          env->deoptimization_index());
   __ InvokeBuiltin(Builtins::IN, CALL_FUNCTION, safepoint_generator);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_IA32