VM: Add infrastructure to support deferred generation of unoptimized code.

runtime/vm/deopt_instructions.h

 // 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.
 
 #ifndef VM_DEOPT_INSTRUCTIONS_H_
 #define VM_DEOPT_INSTRUCTIONS_H_
 
 #include "vm/allocation.h"
 #include "vm/assembler.h"
 #include "vm/code_generator.h"
@@ skipping 67 matching lines @@
     ASSERT(reg < kNumberOfFpuRegisters);
     const float* address = reinterpret_cast<float*>(&fpu_registers_[reg]);
     return simd128_value_t().readFrom(address);
   }
 
   void set_dest_frame(intptr_t* dest_frame) {
     ASSERT(dest_frame != NULL && dest_frame_ == NULL);
     dest_frame_ = dest_frame;
   }
 
+  Thread* thread() const { return thread_; }
   Zone* zone() const { return thread_->zone(); }
 
   intptr_t source_frame_size() const { return source_frame_size_; }
   intptr_t dest_frame_size() const { return dest_frame_size_; }
 
   RawCode* code() const { return code_; }
 
   ICData::DeoptReasonId deopt_reason() const { return deopt_reason_; }
   bool HasDeoptFlag(ICData::DeoptFlags flag) {
     return (deopt_flags_ & flag) != 0;
@@ skipping 48 matching lines @@
         deferred_slots_);
   }
 
   void DeferMaterialization(simd128_value_t value, RawInt32x4** slot) {
     deferred_slots_ = new DeferredInt32x4(
         value,
         reinterpret_cast<RawObject**>(slot),
         deferred_slots_);
   }
 
+  void DeferRetAddrMaterialization(intptr_t index,
+                                   intptr_t deopt_id,
+                                   intptr_t* slot) {
+    deferred_slots_ = new DeferredRetAddr(
+        index,
+        deopt_id,
+        reinterpret_cast<RawObject**>(slot),
+        deferred_slots_);
+  }
+
+  void DeferPcMarkerMaterialization(intptr_t index, intptr_t* slot) {
+    deferred_slots_ = new DeferredPcMarker(
+        index,
+        reinterpret_cast<RawObject**>(slot),
+        deferred_slots_);
+  }
+
+  void DeferPpMaterialization(intptr_t index, RawObject** slot) {
+    deferred_slots_ = new DeferredPp(index, slot, deferred_slots_);
+  }
+
   DeferredObject* GetDeferredObject(intptr_t idx) const {
     return deferred_objects_[idx];
   }
 
  private:
   intptr_t* GetDestFrameAddressAt(intptr_t index) const {
     ASSERT(dest_frame_ != NULL);
     ASSERT((0 <= index) && (index < dest_frame_size_));
     return &dest_frame_[index];
   }
@@ skipping 236 matching lines @@
 // the heap and reset the builder's internal state for the next DeoptInfo.
 class DeoptInfoBuilder : public ValueObject {
  public:
   DeoptInfoBuilder(Zone* zone, const intptr_t num_args);
 
   // 'object_table' holds all objects referred to by DeoptInstr in
   // all DeoptInfo instances for a single Code object.
   const GrowableObjectArray& object_table() { return object_table_; }
 
   // Return address before instruction.
-  void AddReturnAddress(const Code& code,
+  void AddReturnAddress(const Function& function,
                         intptr_t deopt_id,
                         intptr_t dest_index);
 
   // Copy from optimized frame to unoptimized.
   void AddCopy(Value* value, const Location& source_loc, intptr_t dest_index);
-  void AddPcMarker(const Code& code, intptr_t dest_index);
-  void AddPp(const Code& code, intptr_t dest_index);
+  void AddPcMarker(const Function& function, intptr_t dest_index);
+  void AddPp(const Function& function, intptr_t dest_index);
   void AddCallerFp(intptr_t dest_index);
   void AddCallerPp(intptr_t dest_index);
   void AddCallerPc(intptr_t dest_index);
 
   // Add object to be materialized. Emit kMaterializeObject instruction.
   void AddMaterialization(MaterializeObjectInstr* mat);
 
   // For every materialized object emit instructions describing data required
   // for materialization: class of the instance to allocate and field-value
   // pairs for initialization.
@@ skipping 88 matching lines @@
   class ReasonField : public BitField<ICData::DeoptReasonId, 0, 8> { };
   class FlagsField : public BitField<uint32_t, 8, 8> { };
 
  private:
   static const intptr_t kEntrySize = 3;
 };
 
 }  // namespace dart
 
 #endif  // VM_DEOPT_INSTRUCTIONS_H_