A change in the way we place TransitionElementKinds in the tree.

src/ia32/lithium-codegen-ia32.cc

 // Copyright 2012 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 577 matching lines @@
 }
 
 
 void LCodeGen::CallCode(Handle<Code> code,
                         RelocInfo::Mode mode,
                         LInstruction* instr) {
   CallCodeGeneric(code, mode, instr, RECORD_SIMPLE_SAFEPOINT);
 }
 
 
+void LCodeGen::CallCodeFromDeferred(Handle<Code> code,
+                        RelocInfo::Mode mode,
+                        LInstruction* instr) {
+  //CallCodeGeneric(code, mode, instr, RECORD_SIMPLE_SAFEPOINT);
+
+  ASSERT(instr != NULL);
+  LPointerMap* pointers = instr->pointer_map();
+  RecordPosition(pointers->position());
+  __ call(code, mode);
+  RecordSafepointWithRegisters(
+      instr->pointer_map(), 0, Safepoint::kNoLazyDeopt);
+
+  // Signal that we don't inline smi code before these stubs in the
+  // optimizing code generator.
+  if (code->kind() == Code::BINARY_OP_IC ||
+      code->kind() == Code::COMPARE_IC) {
+    __ nop();
+  }
+}
+
+
 void LCodeGen::CallRuntime(const Runtime::Function* fun,
                            int argc,
                            LInstruction* instr) {
   ASSERT(instr != NULL);
   ASSERT(instr->HasPointerMap());
   LPointerMap* pointers = instr->pointer_map();
   RecordPosition(pointers->position());
 
   __ CallRuntime(fun, argc);
 
@@ skipping 18 matching lines @@
   } else {
     UNREACHABLE();
   }
 
   __ CallRuntimeSaveDoubles(id);
   RecordSafepointWithRegisters(
       instr->pointer_map(), argc, Safepoint::kNoLazyDeopt);
 }
 
 
+void LCodeGen::CallRuntimeFromDeferred(Runtime::FunctionId id,
+                                       int argc,
+                                       LInstruction* instr) {
+  __ mov(esi, Operand(ebp, StandardFrameConstants::kContextOffset));  
+  __ CallRuntimeSaveDoubles(id);
+  RecordSafepointWithRegisters(
+      instr->pointer_map(), argc, Safepoint::kNoLazyDeopt);
+}
+
+
 void LCodeGen::RegisterEnvironmentForDeoptimization(
     LEnvironment* environment, Safepoint::DeoptMode mode) {
   if (!environment->HasBeenRegistered()) {
     // Physical stack frame layout:
     // -x ............. -4  0 ..................................... y
     // [incoming arguments] [spill slots] [pushed outgoing arguments]
 
     // Layout of the environment:
     // 0 ..................................................... size-1
     // [parameters] [locals] [expression stack including arguments]
@@ skipping 3404 matching lines @@
   ASSERT(ToRegister(instr->key()).is(ecx));
   ASSERT(ToRegister(instr->value()).is(eax));
 
   Handle<Code> ic = (instr->strict_mode_flag() == kStrictMode)
       ? isolate()->builtins()->KeyedStoreIC_Initialize_Strict()
       : isolate()->builtins()->KeyedStoreIC_Initialize();
   CallCode(ic, RelocInfo::CODE_TARGET, instr);
 }
 
 
+class DeferredTransitionElementsKind: public LDeferredCode {
+ public:
+  DeferredTransitionElementsKind(LCodeGen* codegen, LTransitionElementsKind* instr)
+      : LDeferredCode(codegen), instr_(instr) { }
+  virtual void Generate() { codegen()->DoDeferredTransitionElementsKind(instr_); }
+  virtual LInstruction* instr() { return instr_; }
+ private:
+  LTransitionElementsKind* instr_;
+};
+
+
+void LCodeGen::DoDeferredTransitionElementsKind(LTransitionElementsKind* instr) {
+  Register object_reg = ToRegister(instr->object());
+  Handle<Map> to_map = instr->transitioned_map();
+  ElementsKind to_kind = to_map->elements_kind();
+  
+  PushSafepointRegistersScope scope(this);
+
+  /*
+    Handle<Code> code = IsFastDoubleElementsKind(to_kind)
+    ? isolate()->builtins()->TransitionElementsSmiToDouble()
+    : isolate()->builtins()->TransitionElementsDoubleToObject();
+      
+    __ mov(ebx, to_map);
+    if (!edx.is(object_reg)) {
+    __ mov(edx, object_reg);
+    }
+
+
+    CallCodeFromDeferred(code,
+    RelocInfo::CODE_TARGET,
+    instr);
+    // RECORD_SAFEPOINT_WITH_REGISTERS_AND_NO_ARGUMENTS);
+    */
+
+  Runtime::FunctionId function_id = IsFastDoubleElementsKind(to_kind)
+      ? Runtime::kTransitionElementsSmiToDouble
+      : Runtime::kTransitionElementsDoubleToObject;
+
+  __ push(object_reg);
+  CallRuntimeFromDeferred(function_id, 1, instr);
+
+  // __ AssertSmi(eax);
+  // __ SmiUntag(eax);
+  __ StoreToSafepointRegisterSlot(object_reg, eax);
+}
+
+
 void LCodeGen::DoTransitionElementsKind(LTransitionElementsKind* instr) {
   Register object_reg = ToRegister(instr->object());
   Register new_map_reg = ToRegister(instr->new_map_temp());
 
   Handle<Map> from_map = instr->original_map();
   Handle<Map> to_map = instr->transitioned_map();
   ElementsKind from_kind = from_map->elements_kind();
   ElementsKind to_kind = to_map->elements_kind();
 
   Label not_applicable;
   bool is_simple_map_transition =
       IsSimpleMapChangeTransition(from_kind, to_kind);
   Label::Distance branch_distance =
       is_simple_map_transition ? Label::kNear : Label::kFar;
   __ cmp(FieldOperand(object_reg, HeapObject::kMapOffset), from_map);
   __ j(not_equal, &not_applicable, branch_distance);
+
   if (is_simple_map_transition) {
     Register object_reg = ToRegister(instr->object());
     Handle<Map> map = instr->hydrogen()->transitioned_map();
     __ mov(FieldOperand(object_reg, HeapObject::kMapOffset),
            Immediate(map));
     // Write barrier.
     ASSERT_NE(instr->temp(), NULL);
     __ RecordWriteForMap(object_reg, to_map, new_map_reg,
                          ToRegister(instr->temp()),
                          kDontSaveFPRegs);
-  } else if (IsFastSmiElementsKind(from_kind) &&
-             IsFastDoubleElementsKind(to_kind)) {
-    __ mov(new_map_reg, to_map);
-    Register fixed_object_reg = ToRegister(instr->temp());
-    ASSERT(fixed_object_reg.is(edx));
-    ASSERT(new_map_reg.is(ebx));
-    __ mov(fixed_object_reg, object_reg);
-    CallCode(isolate()->builtins()->TransitionElementsSmiToDouble(),
-             RelocInfo::CODE_TARGET, instr);
-  } else if (IsFastDoubleElementsKind(from_kind) &&
-             IsFastObjectElementsKind(to_kind)) {
-    __ mov(new_map_reg, to_map);
-    Register fixed_object_reg = ToRegister(instr->temp());
-    ASSERT(fixed_object_reg.is(edx));
-    ASSERT(new_map_reg.is(ebx));
-    __ mov(fixed_object_reg, object_reg);
-    CallCode(isolate()->builtins()->TransitionElementsDoubleToObject(),
-             RelocInfo::CODE_TARGET, instr);
+  } else if ((IsFastSmiElementsKind(from_kind) &&
+              IsFastDoubleElementsKind(to_kind)) ||
+             (IsFastDoubleElementsKind(from_kind) &&
+              IsFastObjectElementsKind(to_kind))) {
+    DeferredTransitionElementsKind* deferred =
+        new(zone()) DeferredTransitionElementsKind(this, instr);
+    __ jmp(deferred->entry());
+    __ bind(deferred->exit());
   } else {
     UNREACHABLE();
   }
   __ bind(&not_applicable);
 }
 
 
 void LCodeGen::DoStringCharCodeAt(LStringCharCodeAt* instr) {
   class DeferredStringCharCodeAt: public LDeferredCode {
    public:
@@ skipping 1044 matching lines @@
       }
     } else {
       UNREACHABLE();
     }
   }
 }
 
 
 void LCodeGen::DoFastLiteral(LFastLiteral* instr) {
   ASSERT(ToRegister(instr->context()).is(esi));
-  int size = instr->hydrogen()->total_size();
-  ElementsKind boilerplate_elements_kind =
-      instr->hydrogen()->boilerplate()->GetElementsKind();
+  Handle<JSObject> result = instr->hydrogen()->boilerplate();
 
-  // Deopt if the literal boilerplate ElementsKind is of a type different than
-  // the expected one. The check isn't necessary if the boilerplate has already
-  // already been converted to TERMINAL_FAST_ELEMENTS_KIND.
-  if (CanTransitionToMoreGeneralFastElementsKind(
-          boilerplate_elements_kind, true)) {
-    __ LoadHeapObject(ebx, instr->hydrogen()->boilerplate());
-    __ mov(ecx, FieldOperand(ebx, HeapObject::kMapOffset));
-    // Load the map's "bit field 2". We only need the first byte,
-    // but the following masking takes care of that anyway.
-    __ mov(ecx, FieldOperand(ecx, Map::kBitField2Offset));
-    // Retrieve elements_kind from bit field 2.
-    __ and_(ecx, Map::kElementsKindMask);
-    __ cmp(ecx, boilerplate_elements_kind << Map::kElementsKindShift);
-    DeoptimizeIf(not_equal, instr->environment());
+  if (instr->hydrogen()->TransitionRequested()) {
+    ElementsKind to_kind = instr->hydrogen()->TransitionTo();
+    result = Runtime::DeepCopyBoilerplate(isolate(),
+                                          instr->hydrogen()->boilerplate());
+    CHECK(!result.is_null());
+    // Now transition the copy
+    CHECK(!JSObject::TransitionElementsKind(result, to_kind).is_null());
+  } else {
+    // Deopt if the literal boilerplate ElementsKind is of a type different than
+    // the expected one. The check isn't necessary if the boilerplate has
+    // already already been converted to TERMINAL_FAST_ELEMENTS_KIND.
+    ElementsKind boilerplate_elements_kind = result->GetElementsKind();
+    if (CanTransitionToMoreGeneralFastElementsKind(
+            boilerplate_elements_kind, true)) {
+      __ LoadHeapObject(ebx, result);
+      __ mov(ecx, FieldOperand(ebx, HeapObject::kMapOffset));
+      // Load the map's "bit field 2". We only need the first byte,
+      // but the following masking takes care of that anyway.
+      __ mov(ecx, FieldOperand(ecx, Map::kBitField2Offset));
+      // Retrieve elements_kind from bit field 2.
+      __ and_(ecx, Map::kElementsKindMask);
+      __ cmp(ecx, boilerplate_elements_kind << Map::kElementsKindShift);
+      DeoptimizeIf(not_equal, instr->environment());
+    }
   }
 
-  // Allocate all objects that are part of the literal in one big
+  // We need to compute the size now.
+  int size = 0;
+  int max_properties = HFastLiteral::kMaxLiteralProperties;
+  HFastLiteral::IsFastLiteral(result,
+                              HFastLiteral::kMaxLiteralDepth,
+                              &max_properties,
+                              &size);
+
   // allocation. This avoids multiple limit checks.
   Label allocated, runtime_allocate;
   __ AllocateInNewSpace(size, eax, ecx, edx, &runtime_allocate, TAG_OBJECT);
   __ jmp(&allocated);
 
   __ bind(&runtime_allocate);
   __ push(Immediate(Smi::FromInt(size)));
   CallRuntime(Runtime::kAllocateInNewSpace, 1, instr);
 
   __ bind(&allocated);
   int offset = 0;
-  __ LoadHeapObject(ebx, instr->hydrogen()->boilerplate());
-  EmitDeepCopy(instr->hydrogen()->boilerplate(), eax, ebx, &offset);
+  __ LoadHeapObject(ebx, result);
+  EmitDeepCopy(result, eax, ebx, &offset);
   ASSERT_EQ(size, offset);
 }
 
 
 void LCodeGen::DoObjectLiteral(LObjectLiteral* instr) {
   ASSERT(ToRegister(instr->context()).is(esi));
   Handle<FixedArray> literals(instr->environment()->closure()->literals());
   Handle<FixedArray> constant_properties =
       instr->hydrogen()->constant_properties();
 
@@ skipping 446 matching lines @@
                               FixedArray::kHeaderSize - kPointerSize));
   __ bind(&done);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_IA32