Implement a variation of scalar replacement for non-escaping allocations.

runtime/vm/deopt_instructions.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/deopt_instructions.h"
 
 #include "vm/assembler.h"
 #include "vm/code_patcher.h"
 #include "vm/intermediate_language.h"
 #include "vm/locations.h"
@@ skipping 54 matching lines @@
  public:
   explicit DeoptStackSlotInstr(intptr_t from_index)
       : stack_slot_index_(from_index) {
     ASSERT(stack_slot_index_ >= 0);
   }
 
   virtual intptr_t from_index() const { return stack_slot_index_; }
   virtual DeoptInstr::Kind kind() const { return kStackSlot; }
 
   virtual const char* ToCString() const {
-    const char* format = "s%"Pd"";
-    intptr_t len = OS::SNPrint(NULL, 0, format, stack_slot_index_);
-    char* chars = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
-    OS::SNPrint(chars, len + 1, format, stack_slot_index_);
-    return chars;
+    return Isolate::Current()->current_zone()->PrintToString(
+        "s%"Pd"", stack_slot_index_);
   }
 
-  void Execute(DeoptimizationContext* deopt_context, intptr_t to_index) {
+  void Execute(DeoptimizationContext* deopt_context, intptr_t* to_addr) {
     intptr_t from_index =
        deopt_context->from_frame_size() - stack_slot_index_ - 1;
     intptr_t* from_addr = deopt_context->GetFromFrameAddressAt(from_index);
-    intptr_t* to_addr = deopt_context->GetToFrameAddressAt(to_index);
     *to_addr = *from_addr;
   }
 
  private:
   const intptr_t stack_slot_index_;  // First argument is 0, always >= 0.
 
   DISALLOW_COPY_AND_ASSIGN(DeoptStackSlotInstr);
 };
 
 
 class DeoptDoubleStackSlotInstr : public DeoptInstr {
  public:
   explicit DeoptDoubleStackSlotInstr(intptr_t from_index)
       : stack_slot_index_(from_index) {
     ASSERT(stack_slot_index_ >= 0);
   }
 
   virtual intptr_t from_index() const { return stack_slot_index_; }
   virtual DeoptInstr::Kind kind() const { return kDoubleStackSlot; }
 
   virtual const char* ToCString() const {
-    const char* format = "ds%"Pd"";
-    intptr_t len = OS::SNPrint(NULL, 0, format, stack_slot_index_);
-    char* chars = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
-    OS::SNPrint(chars, len + 1, format, stack_slot_index_);
-    return chars;
+    return Isolate::Current()->current_zone()->PrintToString(
+        "ds%"Pd"", stack_slot_index_);
   }
 
-  void Execute(DeoptimizationContext* deopt_context, intptr_t to_index) {
+  void Execute(DeoptimizationContext* deopt_context, intptr_t* to_addr) {
     intptr_t from_index =
        deopt_context->from_frame_size() - stack_slot_index_ - 1;
     double* from_addr = reinterpret_cast<double*>(
         deopt_context->GetFromFrameAddressAt(from_index));
-    intptr_t* to_addr = deopt_context->GetToFrameAddressAt(to_index);
     *reinterpret_cast<RawSmi**>(to_addr) = Smi::New(0);
     Isolate::Current()->DeferDoubleMaterialization(
         *from_addr, reinterpret_cast<RawDouble**>(to_addr));
   }
 
  private:
   const intptr_t stack_slot_index_;  // First argument is 0, always >= 0.
 
   DISALLOW_COPY_AND_ASSIGN(DeoptDoubleStackSlotInstr);
 };
 
 
 class DeoptInt64StackSlotInstr : public DeoptInstr {
  public:
   explicit DeoptInt64StackSlotInstr(intptr_t from_index)
       : stack_slot_index_(from_index) {
     ASSERT(stack_slot_index_ >= 0);
   }
 
   virtual intptr_t from_index() const { return stack_slot_index_; }
   virtual DeoptInstr::Kind kind() const { return kInt64StackSlot; }
 
   virtual const char* ToCString() const {
-    const char* format = "ms%"Pd"";
-    intptr_t len = OS::SNPrint(NULL, 0, format, stack_slot_index_);
-    char* chars = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
-    OS::SNPrint(chars, len + 1, format, stack_slot_index_);
-    return chars;
+    return Isolate::Current()->current_zone()->PrintToString(
+        "ms%"Pd"", stack_slot_index_);
   }
 
-  void Execute(DeoptimizationContext* deopt_context, intptr_t to_index) {
+  void Execute(DeoptimizationContext* deopt_context, intptr_t* to_addr) {
     intptr_t from_index =
        deopt_context->from_frame_size() - stack_slot_index_ - 1;
     int64_t* from_addr = reinterpret_cast<int64_t*>(
         deopt_context->GetFromFrameAddressAt(from_index));
-    intptr_t* to_addr = deopt_context->GetToFrameAddressAt(to_index);
     *reinterpret_cast<RawSmi**>(to_addr) = Smi::New(0);
     if (Smi::IsValid64(*from_addr)) {
       *to_addr = reinterpret_cast<intptr_t>(
           Smi::New(static_cast<intptr_t>(*from_addr)));
     } else {
       Isolate::Current()->DeferMintMaterialization(
           *from_addr, reinterpret_cast<RawMint**>(to_addr));
     }
   }
 
  private:
   const intptr_t stack_slot_index_;  // First argument is 0, always >= 0.
 
   DISALLOW_COPY_AND_ASSIGN(DeoptInt64StackSlotInstr);
 };
 
 
 class DeoptFloat32x4StackSlotInstr : public DeoptInstr {
  public:
   explicit DeoptFloat32x4StackSlotInstr(intptr_t from_index)
       : stack_slot_index_(from_index) {
     ASSERT(stack_slot_index_ >= 0);
   }
 
   virtual intptr_t from_index() const { return stack_slot_index_; }
   virtual DeoptInstr::Kind kind() const { return kFloat32x4StackSlot; }
 
   virtual const char* ToCString() const {
-    const char* format = "f32x4s%"Pd"";
-    intptr_t len = OS::SNPrint(NULL, 0, format, stack_slot_index_);
-    char* chars = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
-    OS::SNPrint(chars, len + 1, format, stack_slot_index_);
-    return chars;
+    return Isolate::Current()->current_zone()->PrintToString(
+        "f32x4s%"Pd"", stack_slot_index_);
   }
 
-  void Execute(DeoptimizationContext* deopt_context, intptr_t to_index) {
+  void Execute(DeoptimizationContext* deopt_context, intptr_t* to_addr) {
     intptr_t from_index =
        deopt_context->from_frame_size() - stack_slot_index_ - 1;
     simd128_value_t* from_addr = reinterpret_cast<simd128_value_t*>(
         deopt_context->GetFromFrameAddressAt(from_index));
-    intptr_t* to_addr = deopt_context->GetToFrameAddressAt(to_index);
     *reinterpret_cast<RawSmi**>(to_addr) = Smi::New(0);
     Isolate::Current()->DeferFloat32x4Materialization(
         *from_addr, reinterpret_cast<RawFloat32x4**>(to_addr));
   }
 
  private:
   const intptr_t stack_slot_index_;  // First argument is 0, always >= 0.
 
   DISALLOW_COPY_AND_ASSIGN(DeoptFloat32x4StackSlotInstr);
 };
 
 
 class DeoptUint32x4StackSlotInstr : public DeoptInstr {
  public:
   explicit DeoptUint32x4StackSlotInstr(intptr_t from_index)
       : stack_slot_index_(from_index) {
     ASSERT(stack_slot_index_ >= 0);
   }
 
   virtual intptr_t from_index() const { return stack_slot_index_; }
   virtual DeoptInstr::Kind kind() const { return kUint32x4StackSlot; }
 
   virtual const char* ToCString() const {
-    const char* format = "ui32x4s%"Pd"";
-    intptr_t len = OS::SNPrint(NULL, 0, format, stack_slot_index_);
-    char* chars = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
-    OS::SNPrint(chars, len + 1, format, stack_slot_index_);
-    return chars;
+    return Isolate::Current()->current_zone()->PrintToString(
+        "ui32x4s%"Pd"", stack_slot_index_);
   }
 
-  void Execute(DeoptimizationContext* deopt_context, intptr_t to_index) {
+  void Execute(DeoptimizationContext* deopt_context, intptr_t* to_addr) {
     intptr_t from_index =
        deopt_context->from_frame_size() - stack_slot_index_ - 1;
     simd128_value_t* from_addr = reinterpret_cast<simd128_value_t*>(
         deopt_context->GetFromFrameAddressAt(from_index));
-    intptr_t* to_addr = deopt_context->GetToFrameAddressAt(to_index);
     *reinterpret_cast<RawSmi**>(to_addr) = Smi::New(0);
     Isolate::Current()->DeferUint32x4Materialization(
         *from_addr, reinterpret_cast<RawUint32x4**>(to_addr));
   }
 
  private:
   const intptr_t stack_slot_index_;  // First argument is 0, always >= 0.
 
   DISALLOW_COPY_AND_ASSIGN(DeoptUint32x4StackSlotInstr);
 };
@@ skipping 19 matching lines @@
         DeoptId::encode(deopt_id_);
   }
 
   virtual DeoptInstr::Kind kind() const { return kRetAddress; }
 
   virtual const char* ToCString() const {
     return Isolate::Current()->current_zone()->PrintToString(
         "ret oti:%"Pd"(%"Pd")", object_table_index_, deopt_id_);
   }
 
-  void Execute(DeoptimizationContext* deopt_context, intptr_t to_index) {
+  void Execute(DeoptimizationContext* deopt_context, intptr_t* to_addr) {
     Function& function = Function::Handle(deopt_context->isolate());
     function ^= deopt_context->ObjectAt(object_table_index_);
     const Code& code =
         Code::Handle(deopt_context->isolate(), function.unoptimized_code());
     ASSERT(!code.IsNull());
     uword continue_at_pc = code.GetPcForDeoptId(deopt_id_,
                                                 PcDescriptors::kDeopt);
     ASSERT(continue_at_pc != 0);
-    intptr_t* to_addr = deopt_context->GetToFrameAddressAt(to_index);
     *to_addr = continue_at_pc;
 
     uword pc = code.GetPcForDeoptId(deopt_id_, PcDescriptors::kIcCall);
     if (pc != 0) {
       // If the deoptimization happened at an IC call, update the IC data
       // to avoid repeated deoptimization at the same site next time around.
       ICData& ic_data = ICData::Handle();
       CodePatcher::GetInstanceCallAt(pc, code, &ic_data, NULL);
       if (!ic_data.IsNull()) {
         ic_data.set_deopt_reason(deopt_context->deopt_reason());
@@ skipping 21 matching lines @@
  public:
   explicit DeoptConstantInstr(intptr_t object_table_index)
       : object_table_index_(object_table_index) {
     ASSERT(object_table_index >= 0);
   }
 
   virtual intptr_t from_index() const { return object_table_index_; }
   virtual DeoptInstr::Kind kind() const { return kConstant; }
 
   virtual const char* ToCString() const {
-    const char* format = "const oti:%"Pd"";
-    intptr_t len = OS::SNPrint(NULL, 0, format, object_table_index_);
-    char* chars = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
-    OS::SNPrint(chars, len + 1, format, object_table_index_);
-    return chars;
+    return Isolate::Current()->current_zone()->PrintToString(
+        "const oti:%"Pd"", object_table_index_);
   }
 
-  void Execute(DeoptimizationContext* deopt_context, intptr_t to_index) {
+  void Execute(DeoptimizationContext* deopt_context, intptr_t* to_addr) {
     const Object& obj = Object::Handle(
         deopt_context->isolate(), deopt_context->ObjectAt(object_table_index_));
-    RawObject** to_addr = reinterpret_cast<RawObject**>(
-        deopt_context->GetToFrameAddressAt(to_index));
-    *to_addr = obj.raw();
+    *reinterpret_cast<RawObject**>(to_addr) = obj.raw();
   }
 
  private:
   const intptr_t object_table_index_;
 
   DISALLOW_COPY_AND_ASSIGN(DeoptConstantInstr);
 };
 
 
 // Deoptimization instruction moving a CPU register.
 class DeoptRegisterInstr: public DeoptInstr {
  public:
   explicit DeoptRegisterInstr(intptr_t reg_as_int)
       : reg_(static_cast<Register>(reg_as_int)) {}
 
   virtual intptr_t from_index() const { return static_cast<intptr_t>(reg_); }
   virtual DeoptInstr::Kind kind() const { return kRegister; }
 
   virtual const char* ToCString() const {
     return Assembler::RegisterName(reg_);
   }
 
-  void Execute(DeoptimizationContext* deopt_context, intptr_t to_index) {
-    intptr_t value = deopt_context->RegisterValue(reg_);
-    intptr_t* to_addr = deopt_context->GetToFrameAddressAt(to_index);
-    *to_addr = value;
+  void Execute(DeoptimizationContext* deopt_context, intptr_t* to_addr) {
+    *to_addr = deopt_context->RegisterValue(reg_);
   }
 
  private:
   const Register reg_;
 
   DISALLOW_COPY_AND_ASSIGN(DeoptRegisterInstr);
 };
 
 
 // Deoptimization instruction moving an XMM register.
 class DeoptFpuRegisterInstr: public DeoptInstr {
  public:
   explicit DeoptFpuRegisterInstr(intptr_t reg_as_int)
       : reg_(static_cast<FpuRegister>(reg_as_int)) {}
 
   virtual intptr_t from_index() const { return static_cast<intptr_t>(reg_); }
   virtual DeoptInstr::Kind kind() const { return kFpuRegister; }
 
   virtual const char* ToCString() const {
     return Assembler::FpuRegisterName(reg_);
   }
 
-  void Execute(DeoptimizationContext* deopt_context, intptr_t to_index) {
+  void Execute(DeoptimizationContext* deopt_context, intptr_t* to_addr) {
     double value = deopt_context->FpuRegisterValue(reg_);
-    intptr_t* to_addr = deopt_context->GetToFrameAddressAt(to_index);
     *reinterpret_cast<RawSmi**>(to_addr) = Smi::New(0);
     Isolate::Current()->DeferDoubleMaterialization(
         value, reinterpret_cast<RawDouble**>(to_addr));
   }
 
  private:
   const FpuRegister reg_;
 
   DISALLOW_COPY_AND_ASSIGN(DeoptFpuRegisterInstr);
 };
 
 
 class DeoptInt64FpuRegisterInstr: public DeoptInstr {
  public:
   explicit DeoptInt64FpuRegisterInstr(intptr_t reg_as_int)
       : reg_(static_cast<FpuRegister>(reg_as_int)) {}
 
   virtual intptr_t from_index() const { return static_cast<intptr_t>(reg_); }
   virtual DeoptInstr::Kind kind() const { return kInt64FpuRegister; }
 
   virtual const char* ToCString() const {
-    const char* format = "%s(m)";
-    intptr_t len =
-        OS::SNPrint(NULL, 0, format, Assembler::FpuRegisterName(reg_));
-    char* chars = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
-    OS::SNPrint(chars, len + 1, format, Assembler::FpuRegisterName(reg_));
-    return chars;
+    return Isolate::Current()->current_zone()->PrintToString(
+        "%s(m)", Assembler::FpuRegisterName(reg_));
   }
 
-  void Execute(DeoptimizationContext* deopt_context, intptr_t to_index) {
+  void Execute(DeoptimizationContext* deopt_context, intptr_t* to_addr) {
     int64_t value = deopt_context->FpuRegisterValueAsInt64(reg_);
-    intptr_t* to_addr = deopt_context->GetToFrameAddressAt(to_index);
     *reinterpret_cast<RawSmi**>(to_addr) = Smi::New(0);
     if (Smi::IsValid64(value)) {
       *to_addr = reinterpret_cast<intptr_t>(
           Smi::New(static_cast<intptr_t>(value)));
     } else {
       Isolate::Current()->DeferMintMaterialization(
           value, reinterpret_cast<RawMint**>(to_addr));
     }
   }
 
  private:
   const FpuRegister reg_;
 
   DISALLOW_COPY_AND_ASSIGN(DeoptInt64FpuRegisterInstr);
 };
 
 
 // Deoptimization instruction moving an XMM register.
 class DeoptFloat32x4FpuRegisterInstr: public DeoptInstr {
  public:
   explicit DeoptFloat32x4FpuRegisterInstr(intptr_t reg_as_int)
       : reg_(static_cast<FpuRegister>(reg_as_int)) {}
 
   virtual intptr_t from_index() const { return static_cast<intptr_t>(reg_); }
   virtual DeoptInstr::Kind kind() const { return kFloat32x4FpuRegister; }
 
   virtual const char* ToCString() const {
-    const char* format = "%s(f32x4)";
-    intptr_t len =
-        OS::SNPrint(NULL, 0, format, Assembler::FpuRegisterName(reg_));
-    char* chars = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
-    OS::SNPrint(chars, len + 1, format, Assembler::FpuRegisterName(reg_));
-    return chars;
+    return Isolate::Current()->current_zone()->PrintToString(
+        "%s(f32x4)", Assembler::FpuRegisterName(reg_));
   }
 
-  void Execute(DeoptimizationContext* deopt_context, intptr_t to_index) {
+  void Execute(DeoptimizationContext* deopt_context, intptr_t* to_addr) {
     simd128_value_t value = deopt_context->FpuRegisterValueAsSimd128(reg_);
-    intptr_t* to_addr = deopt_context->GetToFrameAddressAt(to_index);
     *reinterpret_cast<RawSmi**>(to_addr) = Smi::New(0);
     Isolate::Current()->DeferFloat32x4Materialization(
         value, reinterpret_cast<RawFloat32x4**>(to_addr));
   }
 
  private:
   const FpuRegister reg_;
 
   DISALLOW_COPY_AND_ASSIGN(DeoptFloat32x4FpuRegisterInstr);
 };
 
 
 // Deoptimization instruction moving an XMM register.
 class DeoptUint32x4FpuRegisterInstr: public DeoptInstr {
  public:
   explicit DeoptUint32x4FpuRegisterInstr(intptr_t reg_as_int)
       : reg_(static_cast<FpuRegister>(reg_as_int)) {}
 
   virtual intptr_t from_index() const { return static_cast<intptr_t>(reg_); }
   virtual DeoptInstr::Kind kind() const { return kFloat32x4FpuRegister; }
 
   virtual const char* ToCString() const {
-    const char* format = "%s(f32x4)";
-    intptr_t len =
-        OS::SNPrint(NULL, 0, format, Assembler::FpuRegisterName(reg_));
-    char* chars = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
-    OS::SNPrint(chars, len + 1, format, Assembler::FpuRegisterName(reg_));
-    return chars;
+    return Isolate::Current()->current_zone()->PrintToString(
+        "%s(f32x4)", Assembler::FpuRegisterName(reg_));
   }
 
-  void Execute(DeoptimizationContext* deopt_context, intptr_t to_index) {
+  void Execute(DeoptimizationContext* deopt_context, intptr_t* to_addr) {
     simd128_value_t value = deopt_context->FpuRegisterValueAsSimd128(reg_);
-    intptr_t* to_addr = deopt_context->GetToFrameAddressAt(to_index);
     *reinterpret_cast<RawSmi**>(to_addr) = Smi::New(0);
     Isolate::Current()->DeferUint32x4Materialization(
         value, reinterpret_cast<RawUint32x4**>(to_addr));
   }
 
  private:
   const FpuRegister reg_;
 
   DISALLOW_COPY_AND_ASSIGN(DeoptUint32x4FpuRegisterInstr);
 };
 
 
 // Deoptimization instruction creating a PC marker for the code of
 // function at 'object_table_index'.
 class DeoptPcMarkerInstr : public DeoptInstr {
  public:
   explicit DeoptPcMarkerInstr(intptr_t object_table_index)
       : object_table_index_(object_table_index) {
     ASSERT(object_table_index >= 0);
   }
 
   virtual intptr_t from_index() const { return object_table_index_; }
   virtual DeoptInstr::Kind kind() const { return kPcMarker; }
 
   virtual const char* ToCString() const {
-    const char* format = "pcmark oti:%"Pd"";
-    intptr_t len = OS::SNPrint(NULL, 0, format, object_table_index_);
-    char* chars = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
-    OS::SNPrint(chars, len + 1, format, object_table_index_);
-    return chars;
+    return Isolate::Current()->current_zone()->PrintToString(
+        "pcmark oti:%"Pd"", object_table_index_);
   }
 
-  void Execute(DeoptimizationContext* deopt_context, intptr_t to_index) {
+  void Execute(DeoptimizationContext* deopt_context, intptr_t* to_addr) {
     Function& function = Function::Handle(deopt_context->isolate());
     function ^= deopt_context->ObjectAt(object_table_index_);
     const Code& code =
         Code::Handle(deopt_context->isolate(), function.unoptimized_code());
     ASSERT(!code.IsNull());
     intptr_t pc_marker = code.EntryPoint() +
                          Assembler::kOffsetOfSavedPCfromEntrypoint;
-    intptr_t* to_addr = deopt_context->GetToFrameAddressAt(to_index);
     *to_addr = pc_marker;
     // Increment the deoptimization counter. This effectively increments each
     // function occurring in the optimized frame.
     function.set_deoptimization_counter(function.deoptimization_counter() + 1);
     if (FLAG_trace_deoptimization) {
       OS::PrintErr("Deoptimizing %s (count %d)\n",
           function.ToFullyQualifiedCString(),
           function.deoptimization_counter());
     }
     // Clear invocation counter so that hopefully the function gets reoptimized
@@ skipping 14 matching lines @@
  public:
   DeoptCallerFpInstr() {}
 
   virtual intptr_t from_index() const { return 0; }
   virtual DeoptInstr::Kind kind() const { return kCallerFp; }
 
   virtual const char* ToCString() const {
     return "callerfp";
   }
 
-  void Execute(DeoptimizationContext* deopt_context, intptr_t to_index) {
-    intptr_t from = deopt_context->GetCallerFp();
-    intptr_t* to_addr = deopt_context->GetToFrameAddressAt(to_index);
-    *to_addr = from;
+  void Execute(DeoptimizationContext* deopt_context, intptr_t* to_addr) {
+    *to_addr = deopt_context->GetCallerFp();
     deopt_context->SetCallerFp(reinterpret_cast<intptr_t>(to_addr));
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DeoptCallerFpInstr);
 };
 
 
 // Deoptimization instruction copying the caller return address from optimized
 // frame.
 class DeoptCallerPcInstr : public DeoptInstr {
  public:
   DeoptCallerPcInstr() {}
 
   virtual intptr_t from_index() const { return 0; }
   virtual DeoptInstr::Kind kind() const { return kCallerPc; }
 
   virtual const char* ToCString() const {
     return "callerpc";
   }
 
-  void Execute(DeoptimizationContext* deopt_context, intptr_t to_index) {
-    intptr_t from = deopt_context->GetFromPc();
-    intptr_t* to_addr = deopt_context->GetToFrameAddressAt(to_index);
-    *to_addr = from;
+  void Execute(DeoptimizationContext* deopt_context, intptr_t* to_addr) {
+    *to_addr = deopt_context->GetFromPc();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DeoptCallerPcInstr);
 };
 
 
 // Deoptimization instruction that indicates the rest of this DeoptInfo is a
 // suffix of another one.  The suffix contains the info number (0 based
 // index in the deopt table of the DeoptInfo to share) and the length of the
@@ skipping 11 matching lines @@
         suffix_length_(SuffixLength::decode(from_index)) {
   }
 
   virtual intptr_t from_index() const {
     return InfoNumber::encode(info_number_) |
         SuffixLength::encode(suffix_length_);
   }
   virtual DeoptInstr::Kind kind() const { return kSuffix; }
 
   virtual const char* ToCString() const {
-    const char* format = "suffix %"Pd":%"Pd;
-    intptr_t len = OS::SNPrint(NULL, 0, format, info_number_, suffix_length_);
-    char* chars = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
-    OS::SNPrint(chars, len + 1, format, info_number_, suffix_length_);
-    return chars;
+    return Isolate::Current()->current_zone()->PrintToString(
+        "suffix %"Pd":%"Pd, info_number_, suffix_length_);
   }
 
-  void Execute(DeoptimizationContext* deopt_context, intptr_t to_index) {
+  void Execute(DeoptimizationContext* deopt_context, intptr_t* to_addr) {
     // The deoptimization info is uncompressed by translating away suffixes
     // before executing the instructions.
     UNREACHABLE();
   }
 
  private:
   // Static decoder functions in DeoptInstr have access to the bitfield
   // definitions.
   friend class DeoptInstr;
 
   static const intptr_t kFieldWidth = kBitsPerWord / 2;
   class InfoNumber : public BitField<intptr_t, 0, kFieldWidth> { };
   class SuffixLength : public BitField<intptr_t, kFieldWidth, kFieldWidth> { };
 
   const intptr_t info_number_;
   const intptr_t suffix_length_;
 
   DISALLOW_COPY_AND_ASSIGN(DeoptSuffixInstr);
 };
 
 
+// Write reference to a materialized object with the given index into the
+// stack slot.
+class DeoptMaterializedObjectRefInstr : public DeoptInstr {
+ public:
+  explicit DeoptMaterializedObjectRefInstr(intptr_t index)
+      : index_(index) {
+    ASSERT(index >= 0);
+  }
+
+  virtual intptr_t from_index() const { return index_; }
+  virtual DeoptInstr::Kind kind() const { return kMaterializedObjectRef; }
+
+  virtual const char* ToCString() const {
+    return Isolate::Current()->current_zone()->PrintToString(
+        "mat ref #%"Pd"", index_);
+  }
+
+  void Execute(DeoptimizationContext* deopt_context, intptr_t* to_addr) {
+    *reinterpret_cast<RawSmi**>(to_addr) = Smi::New(0);
+    Isolate::Current()->DeferMaterializedObjectRef(
+        index_, to_addr);
+  }
+
+ private:
+  intptr_t index_;
+
+  DISALLOW_COPY_AND_ASSIGN(DeoptMaterializedObjectRefInstr);
+};
+
+
+// Materialize object with the given number of fields.
+// Arguments for materialization (class and field-value pairs) are pushed
+// to the expression stack of the bottom-most frame.
+class DeoptMaterializeObjectInstr : public DeoptInstr {
+ public:
+  explicit DeoptMaterializeObjectInstr(intptr_t field_count)
+      : field_count_(field_count) {
+    ASSERT(field_count >= 0);
+  }
+
+  virtual intptr_t from_index() const { return field_count_; }
+  virtual DeoptInstr::Kind kind() const { return kMaterializeObject; }
+
+  virtual const char* ToCString() const {
+    return Isolate::Current()->current_zone()->PrintToString(
+        "mat obj len:%"Pd"", field_count_);
+  }
+
+  void Execute(DeoptimizationContext* deopt_context, intptr_t* to_addr) {
+    // This instructions are executed manually by the DeoptimizeWithDeoptInfo.
+    UNREACHABLE();
+  }
+
+ private:
+  intptr_t field_count_;
+
+  DISALLOW_COPY_AND_ASSIGN(DeoptMaterializeObjectInstr);
+};
+
+
 intptr_t DeoptInstr::DecodeSuffix(intptr_t from_index, intptr_t* info_number) {
   *info_number = DeoptSuffixInstr::InfoNumber::decode(from_index);
   return DeoptSuffixInstr::SuffixLength::decode(from_index);
 }
 
 
 uword DeoptInstr::GetRetAddress(DeoptInstr* instr,
                                 const Array& object_table,
                                 Function* func) {
   ASSERT(instr->kind() == kRetAddress);
@@ skipping 28 matching lines @@
     case kFpuRegister: return new DeoptFpuRegisterInstr(from_index);
     case kInt64FpuRegister: return new DeoptInt64FpuRegisterInstr(from_index);
     case kFloat32x4FpuRegister:
         return new DeoptFloat32x4FpuRegisterInstr(from_index);
     case kUint32x4FpuRegister:
         return new DeoptUint32x4FpuRegisterInstr(from_index);
     case kPcMarker: return new DeoptPcMarkerInstr(from_index);
     case kCallerFp: return new DeoptCallerFpInstr();
     case kCallerPc: return new DeoptCallerPcInstr();
     case kSuffix: return new DeoptSuffixInstr(from_index);
+    case kMaterializedObjectRef:
+        return new DeoptMaterializedObjectRefInstr(from_index);
+    case kMaterializeObject: return new DeoptMaterializeObjectInstr(from_index);
   }
   UNREACHABLE();
   return NULL;
 }
 
 
 class DeoptInfoBuilder::TrieNode : public ZoneAllocated {
  public:
   // Construct the root node representing the implicit "shared" terminator
   // at the end of each deopt info.
@@ skipping 23 matching lines @@
 
   GrowableArray<TrieNode*> children_;
 };
 
 
 DeoptInfoBuilder::DeoptInfoBuilder(const intptr_t num_args)
     : instructions_(),
       object_table_(GrowableObjectArray::Handle(GrowableObjectArray::New())),
       num_args_(num_args),
       trie_root_(new TrieNode()),
-      current_info_number_(0) {
+      current_info_number_(0),
+      frame_start_(-1),
+      materializations_() {
 }
 
 
 intptr_t DeoptInfoBuilder::FindOrAddObjectInTable(const Object& obj) const {
   for (intptr_t i = 0; i < object_table_.Length(); i++) {
     if (object_table_.At(i) == obj.raw()) {
       return i;
     }
   }
   // Add object.
@@ skipping 14 matching lines @@
                                         intptr_t deopt_id,
                                         intptr_t to_index) {
   // Check that deopt_id exists.
   // TODO(vegorov): verify after deoptimization targets as well.
 #ifdef DEBUG
   const Code& code = Code::Handle(function.unoptimized_code());
   ASSERT(Isolate::IsDeoptAfter(deopt_id) ||
       (code.GetPcForDeoptId(deopt_id, PcDescriptors::kDeopt) != 0));
 #endif
   const intptr_t object_table_index = FindOrAddObjectInTable(function);
-  ASSERT(to_index == instructions_.length());
+  ASSERT(to_index == FrameSize());
   instructions_.Add(new DeoptRetAddressInstr(object_table_index, deopt_id));
 }
 
 
 void DeoptInfoBuilder::AddPcMarker(const Function& function,
                                    intptr_t to_index) {
   // Function object was already added by AddReturnAddress, find it.
   intptr_t from_index = FindOrAddObjectInTable(function);
-  ASSERT(to_index == instructions_.length());
+  ASSERT(to_index == FrameSize());
   instructions_.Add(new DeoptPcMarkerInstr(from_index));
 }
 
 
 void DeoptInfoBuilder::AddCopy(Value* value,
                                const Location& from_loc,
                                const intptr_t to_index) {
   DeoptInstr* deopt_instr = NULL;
   if (from_loc.IsConstant()) {
     intptr_t object_table_index = FindOrAddObjectInTable(from_loc.constant());
@@ skipping 25 matching lines @@
       deopt_instr = new DeoptInt64StackSlotInstr(from_index);
     }
   } else if (from_loc.IsQuadStackSlot()) {
     intptr_t from_index = CalculateStackIndex(from_loc);
     if (value->definition()->representation() == kUnboxedFloat32x4) {
       deopt_instr = new DeoptFloat32x4StackSlotInstr(from_index);
     } else {
       ASSERT(value->definition()->representation() == kUnboxedUint32x4);
       deopt_instr = new DeoptUint32x4StackSlotInstr(from_index);
     }
+  } else if (from_loc.IsInvalid() &&
+             value->definition()->IsMaterializeObject()) {
+    const intptr_t index = FindMaterialization(
+        value->definition()->AsMaterializeObject());
+    ASSERT(index >= 0);
+    deopt_instr = new DeoptMaterializedObjectRefInstr(index);
   } else {
     UNREACHABLE();
   }
-  ASSERT(to_index == instructions_.length());
+  ASSERT(to_index == FrameSize());
   ASSERT(deopt_instr != NULL);
   instructions_.Add(deopt_instr);
 }
 
 
 void DeoptInfoBuilder::AddCallerFp(intptr_t to_index) {
-  ASSERT(to_index == instructions_.length());
+  ASSERT(to_index == FrameSize());
   instructions_.Add(new DeoptCallerFpInstr());
 }
 
 
 void DeoptInfoBuilder::AddCallerPc(intptr_t to_index) {
-  ASSERT(to_index == instructions_.length());
+  ASSERT(to_index == FrameSize());
   instructions_.Add(new DeoptCallerPcInstr());
 }
 
 
+void DeoptInfoBuilder::AddConstant(const Object& obj, intptr_t to_index) {
+  ASSERT(to_index == FrameSize());
+  intptr_t object_table_index = FindOrAddObjectInTable(obj);
+  instructions_.Add(new DeoptConstantInstr(object_table_index));
+}
+
+
+void DeoptInfoBuilder::AddMaterialization(MaterializeObjectInstr* mat) {
+  const intptr_t index = FindMaterialization(mat);
+  if (index >= 0) {
+    return;  // Already added.
+  }
+  materializations_.Add(mat);
+
+  // Count initialized fields and emit kMaterializeObject instruction.
+  // There is no need to write nulls into fields because object is null
+  // initialized by default.
+  intptr_t non_null_fields = 0;
+  for (intptr_t i = 0; i < mat->InputCount(); i++) {
+    if (!mat->InputAt(i)->BindsToConstantNull()) {
+      non_null_fields++;
+    }
+  }
+
+  instructions_.Add(new DeoptMaterializeObjectInstr(non_null_fields));
+}
+
+
+intptr_t DeoptInfoBuilder::EmitMaterializationArguments() {
+  intptr_t slot_idx = 1;  // Return address is emitted at 0.
+  for (intptr_t i = 0; i < materializations_.length(); i++) {
+    MaterializeObjectInstr* mat = materializations_[i];
+    AddConstant(mat->cls(), slot_idx++);  // Class of the instance to allocate.
+    for (intptr_t i = 0; i < mat->InputCount(); i++) {
+      if (!mat->InputAt(i)->BindsToConstantNull()) {
+        // Emit field-value pair.
+        AddConstant(mat->FieldAt(i), slot_idx++);
+        AddCopy(mat->InputAt(i), mat->LocationAt(i), slot_idx++);
+      }
+    }
+  }
+  return slot_idx;
+}
+
+
+intptr_t DeoptInfoBuilder::FindMaterialization(
+    MaterializeObjectInstr* mat) const {
+  for (intptr_t i = 0; i < materializations_.length(); i++) {
+    if (materializations_[i] == mat) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+
 RawDeoptInfo* DeoptInfoBuilder::CreateDeoptInfo() {
+  // TODO(vegorov): enable compression of deoptimization info containing object
+  // materialization instructions.
+  const bool disable_compression =
+      (instructions_[0]->kind() == DeoptInstr::kMaterializeObject);
+
   intptr_t length = instructions_.length();
 
   // Count the number of instructions that are a shared suffix of some deopt
   // info already written.
   TrieNode* suffix = trie_root_;
   intptr_t suffix_length = 0;
-  if (FLAG_compress_deopt_info) {
+  if (FLAG_compress_deopt_info && !disable_compression) {
     for (intptr_t i = length - 1; i >= 0; --i) {
       TrieNode* node = suffix->FindChild(*instructions_[i]);
       if (node == NULL) break;
       suffix = node;
       ++suffix_length;
     }
   }
 
   // Allocate space for the translation.  If the shared suffix is longer
   // than one instruction, we replace it with a single suffix instruction.
@@ skipping 12 matching lines @@
   }
   suffix->AddChild(node);
 
   if (suffix_length > 1) {
     DeoptInstr* instr =
         new DeoptSuffixInstr(suffix->info_number(), suffix_length);
     deopt_info.SetAt(length - 1, instr->kind(), instr->from_index());
   }
 
   instructions_.Clear();
+  materializations_.Clear();
+  frame_start_ = -1;
+
   ++current_info_number_;
   return deopt_info.raw();
 }
 
 
 intptr_t DeoptTable::SizeFor(intptr_t length) {
   return length * kEntrySize;
 }
 
 void DeoptTable::SetEntry(const Array& table,
@@ skipping 20 matching lines @@
                           Smi* offset,
                           DeoptInfo* info,
                           Smi* reason) {
   intptr_t i = index * kEntrySize;
   *offset ^= table.At(i);
   *info ^= table.At(i + 1);
   *reason ^= table.At(i + 2);
 }
 
 }  // namespace dart