Refactor some deoptimization 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"
+#include "vm/deferred_objects.h"
 #include "vm/growable_array.h"
 #include "vm/object.h"
 
 namespace dart {
 
 class Location;
 class Value;
 class MaterializeObjectInstr;
 
 // Holds all data relevant for execution of deoptimization instructions.
-class DeoptimizationContext : public ValueObject {
+class DeoptContext {
  public:
-  // 'to_frame_start' points to the fixed size portion of the frame under sp.
   // 'num_args' is 0 if there are no arguments or if there are optional
   // arguments.
-  DeoptimizationContext(intptr_t* to_frame_start,
-                        intptr_t to_frame_size,
-                        const Array& object_table,
-                        intptr_t num_args,
-                        DeoptReasonId deopt_reason);
+  DeoptContext(const Array& object_table,
+               intptr_t num_args,
+               DeoptReasonId deopt_reason);
+
+  ~DeoptContext();

[srdjan, 2013/09/27 17:04:54]

virtual, just in case?

[turnidge, 2013/09/30 17:40:22]

Done.

+
+  // 'start' points to the fixed size portion of the frame under sp.
+  //
+  // DeoptContext does not claim ownership of the frame memory.
+  void SetToFrame(intptr_t* start, intptr_t size);
+
+  // DeoptContext does not claim ownership of the frame memory.
+  void SetFromFrame(intptr_t* start, intptr_t size);
+
+  // DeoptContext does not claim ownership of the memory used for the
+  // saved registers.
+  void SetSavedRegisters(fpu_register_t* fpu_registers,
+                         intptr_t* cpu_registers);
+
+  intptr_t* from_frame() const { return from_frame_; }
+  fpu_register_t* fpu_registers() const { return fpu_registers_; }
+  intptr_t* cpu_registers() const { return cpu_registers_; }
 
   intptr_t* GetFromFrameAddressAt(intptr_t index) const {
+    ASSERT(from_frame_ != NULL);
     ASSERT((0 <= index) && (index < from_frame_size_));
     return &from_frame_[index];
   }
 
   intptr_t* GetToFrameAddressAt(intptr_t index) const {
+    ASSERT(to_frame_ != NULL);
     ASSERT((0 <= index) && (index < to_frame_size_));
     return &to_frame_[index];
   }
 
   intptr_t GetFromFp() const;
   intptr_t GetFromPp() const;
   intptr_t GetFromPc() const;
 
   intptr_t GetCallerFp() const;
   void SetCallerFp(intptr_t callers_fp);
 
   RawObject* ObjectAt(intptr_t index) const {
-    return object_table_.At(index);
+    const Array& object_table = Array::Handle(object_table_);
+    return object_table.At(index);
   }
 
   intptr_t RegisterValue(Register reg) const {
-    return registers_copy_[reg];
+    return cpu_registers_[reg];
   }
 
   double FpuRegisterValue(FpuRegister reg) const {
-    return *reinterpret_cast<double*>(&fpu_registers_copy_[reg]);
+    return *reinterpret_cast<double*>(&fpu_registers_[reg]);
   }
 
   int64_t FpuRegisterValueAsInt64(FpuRegister reg) const {
-    return *reinterpret_cast<int64_t*>(&fpu_registers_copy_[reg]);
+    return *reinterpret_cast<int64_t*>(&fpu_registers_[reg]);
   }
 
   simd128_value_t FpuRegisterValueAsSimd128(FpuRegister reg) const {
-    const float* address = reinterpret_cast<float*>(&fpu_registers_copy_[reg]);
+    const float* address = reinterpret_cast<float*>(&fpu_registers_[reg]);
     return simd128_value_t().readFrom(address);
   }
 
   Isolate* isolate() const { return isolate_; }
 
   intptr_t from_frame_size() const { return from_frame_size_; }
 
   DeoptReasonId deopt_reason() const { return deopt_reason_; }
 
+  void VisitObjectPointers(ObjectPointerVisitor* visitor);
+
+  void PrepareForDeferredMaterialization(intptr_t count) {
+    if (count > 0) {
+      deferred_objects_ = new DeferredObject*[count];
+      deferred_objects_count_ = count;
+    }
+  }
+
+  DeferredObject* GetDeferredObject(intptr_t idx) const {
+    return deferred_objects_[idx];
+  }
+
+  // Sets the materialized value for some deferred object.
+  //
+  // Claims ownership of the memory for 'object'.
+  void SetDeferredObjectAt(intptr_t idx, DeferredObject* object) {
+    deferred_objects_[idx] = object;
+  }
+
+  intptr_t DeferredObjectsCount() const {
+    return deferred_objects_count_;
+  }
+
+  void DeferMaterializedObjectRef(intptr_t idx, intptr_t* slot) {
+    deferred_object_refs_ = new DeferredObjectRef(
+        idx,
+        reinterpret_cast<RawInstance**>(slot),
+        deferred_object_refs_);
+  }
+
+  void DeferDoubleMaterialization(double value, RawDouble** slot) {
+    deferred_boxes_ = new DeferredDouble(
+        value,
+        reinterpret_cast<RawInstance**>(slot),
+        deferred_boxes_);
+  }
+
+  void DeferMintMaterialization(int64_t value, RawMint** slot) {
+    deferred_boxes_ = new DeferredMint(
+        value,
+        reinterpret_cast<RawInstance**>(slot),
+        deferred_boxes_);
+  }
+
+  void DeferFloat32x4Materialization(simd128_value_t value,
+                                     RawFloat32x4** slot) {
+    deferred_boxes_ = new DeferredFloat32x4(
+        value,
+        reinterpret_cast<RawInstance**>(slot),
+        deferred_boxes_);
+  }
+
+  void DeferUint32x4Materialization(simd128_value_t value,
+                                    RawUint32x4** slot) {
+    deferred_boxes_ = new DeferredUint32x4(
+        value,
+        reinterpret_cast<RawInstance**>(slot),
+        deferred_boxes_);
+  }
+
+  // Materializes all deferred objects.  Returns the total number of
+  // artificial arguments used during deoptimization.
+  intptr_t MaterializeDeferredObjects();
+
  private:
-  const Array& object_table_;
+  RawArray* object_table_;
   intptr_t* to_frame_;
-  const intptr_t to_frame_size_;
+  intptr_t to_frame_size_;
   intptr_t* from_frame_;
   intptr_t from_frame_size_;
-  intptr_t* registers_copy_;
-  fpu_register_t* fpu_registers_copy_;
+  intptr_t* cpu_registers_;
+  fpu_register_t* fpu_registers_;
   const intptr_t num_args_;
   const DeoptReasonId deopt_reason_;
   intptr_t caller_fp_;
   Isolate* isolate_;
 
-  DISALLOW_COPY_AND_ASSIGN(DeoptimizationContext);
+  DeferredSlot* deferred_boxes_;
+  DeferredSlot* deferred_object_refs_;
+
+  intptr_t deferred_objects_count_;
+  DeferredObject** deferred_objects_;
+
+  DISALLOW_COPY_AND_ASSIGN(DeoptContext);
 };
 
 
 
 // Represents one deopt instruction, e.g, setup return address, store object,
 // store register, etc. The target is defined by instruction's position in
 // the deopt-info array.
 class DeoptInstr : public ZoneAllocated {
  public:
   enum Kind {
@@ skipping 19 matching lines @@
     kMaterializeObject
   };
 
   static DeoptInstr* Create(intptr_t kind_as_int, intptr_t from_index);
 
   DeoptInstr() {}
   virtual ~DeoptInstr() {}
 
   virtual const char* ToCString() const = 0;
 
-  virtual void Execute(DeoptimizationContext* deopt_context,
-                       intptr_t* to_addr) = 0;
+  virtual void Execute(DeoptContext* deopt_context, intptr_t* to_addr) = 0;
 
   virtual DeoptInstr::Kind kind() const = 0;
 
   bool Equals(const DeoptInstr& other) const {
     return (kind() == other.kind()) && (from_index() == other.from_index());
   }
 
   // Decode the payload of a suffix command.  Return the suffix length and
   // set the output parameter info_number to the index of the shared suffix.
   static intptr_t DecodeSuffix(intptr_t from_index, intptr_t* info_number);
@@ skipping 125 matching lines @@
                        DeoptInfo* info,
                        Smi* reason);
 
  private:
   static const intptr_t kEntrySize = 3;
 };
 
 }  // namespace dart
 
 #endif  // VM_DEOPT_INSTRUCTIONS_H_