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);
 
-  intptr_t* GetFromFrameAddressAt(intptr_t index) const {
-    ASSERT((0 <= index) && (index < from_frame_size_));
-    return &from_frame_[index];
+  virtual ~DeoptContext();
+
+  // Sets the sources (frame and registers) for this deoptimization.
+  //
+  // if 'frame_is_copy' is true, DeoptContext will delete the frame
+  // when it is done.
+  void SetSourceArgs(intptr_t* frame_start,
+                     intptr_t frame_size,
+                     fpu_register_t* fpu_registers,
+                     intptr_t* cpu_registers,
+                     bool frame_is_copy);
+
+  // Sets the destination fraem for this deoptimization.
+  //
+  // 'frame_start' oints to the fixed size portion of the frame under
+  // sp.
+  //
+  // DeoptContext does not claim ownership of the frame memory.
+  void SetDestArgs(intptr_t* frame_start, intptr_t frame_size);
+
+  intptr_t* GetSourceFrameAddressAt(intptr_t index) const {
+    ASSERT(source_frame_ != NULL);
+    ASSERT((0 <= index) && (index < source_frame_size_));
+    return &source_frame_[index];
   }
 
-  intptr_t* GetToFrameAddressAt(intptr_t index) const {
-    ASSERT((0 <= index) && (index < to_frame_size_));
-    return &to_frame_[index];
+  intptr_t* GetDestFrameAddressAt(intptr_t index) const {
+    ASSERT(dest_frame_ != NULL);
+    ASSERT((0 <= index) && (index < dest_frame_size_));
+    return &dest_frame_[index];
   }
 
-  intptr_t GetFromFp() const;
-  intptr_t GetFromPp() const;
-  intptr_t GetFromPc() const;
+  intptr_t GetSourceFp() const;
+  intptr_t GetSourcePp() const;
+  intptr_t GetSourcePc() 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_; }
+  intptr_t source_frame_size() const { return source_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_;
-  intptr_t* to_frame_;
-  const intptr_t to_frame_size_;
-  intptr_t* from_frame_;
-  intptr_t from_frame_size_;
-  intptr_t* registers_copy_;
-  fpu_register_t* fpu_registers_copy_;
+  RawArray* object_table_;
+  intptr_t* dest_frame_;
+  intptr_t dest_frame_size_;
+  bool source_frame_is_copy_;
+  intptr_t* source_frame_;
+  intptr_t source_frame_size_;
+  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 12 matching lines @@
     kPcMarker,
     kPp,
     kCallerFp,
     kCallerPp,
     kCallerPc,
     kSuffix,
     kMaterializedObjectRef,
     kMaterializeObject
   };
 
-  static DeoptInstr* Create(intptr_t kind_as_int, intptr_t from_index);
+  static DeoptInstr* Create(intptr_t kind_as_int, intptr_t source_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* dest_addr) = 0;
 
   virtual DeoptInstr::Kind kind() const = 0;
 
   bool Equals(const DeoptInstr& other) const {
-    return (kind() == other.kind()) && (from_index() == other.from_index());
+    return (kind() == other.kind()) && (source_index() == other.source_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);
+  static intptr_t DecodeSuffix(intptr_t source_index, intptr_t* info_number);
 
   // Get the function and return address which is encoded in this
   // kRetAfterAddress deopt instruction.
   static uword GetRetAddress(DeoptInstr* instr,
                              const Array& object_table,
                              Function* func);
 
   // Return number of initialized fields in the object that will be
   // materialized by kMaterializeObject instruction.
   static intptr_t GetFieldCount(DeoptInstr* instr) {
     ASSERT(instr->kind() == DeoptInstr::kMaterializeObject);
-    return instr->from_index();
+    return instr->source_index();
   }
 
  protected:
   friend class DeoptInfoBuilder;
 
-  virtual intptr_t from_index() const = 0;
+  virtual intptr_t source_index() const = 0;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DeoptInstr);
 };
 
 
 // Builds a deoptimization info table, one DeoptInfo at a time.  Call AddXXX
 // methods in the order of their target, starting wih deoptimized code
 // continuation pc and ending with the first argument of the deoptimized
 // code.  Call CreateDeoptInfo to write the accumulated instructions into
 // the heap and reset the builder's internal state for the next DeoptInfo.
 class DeoptInfoBuilder : public ValueObject {
  public:
   explicit DeoptInfoBuilder(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 Function& function,
                         intptr_t deopt_id,
-                        intptr_t to_index);
+                        intptr_t dest_index);
 
   // Copy from optimized frame to unoptimized.
-  void AddCopy(Value* value, const Location& from_loc, intptr_t to_index);
-  void AddPcMarker(const Function& function, intptr_t to_index);
-  void AddPp(const Function& function, intptr_t to_index);
-  void AddCallerFp(intptr_t to_index);
-  void AddCallerPp(intptr_t to_index);
-  void AddCallerPc(intptr_t to_index);
+  void AddCopy(Value* value, const Location& source_loc, 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.
   // Emitted instructions are expected to follow fixed size section of frame
   // emitted first. This way they become a part of the bottom-most deoptimized
   // frame and are discoverable by GC.
   // At deoptimization they will be removed by the stub at the very end:
   // after they were used to materialize objects.
   // Returns the index of the next stack slot. Used for verification.
-  intptr_t EmitMaterializationArguments(intptr_t to_index);
+  intptr_t EmitMaterializationArguments(intptr_t dest_index);
 
   RawDeoptInfo* CreateDeoptInfo(const Array& deopt_table);
 
   // Mark the actual start of the frame description after all materialization
   // instructions were emitted. Used for verification purposes.
   void MarkFrameStart() {
     ASSERT(frame_start_ == -1);
     frame_start_ = instructions_.length();
   }
 
  private:
   class TrieNode;
 
   intptr_t FindOrAddObjectInTable(const Object& obj) const;
   intptr_t FindMaterialization(MaterializeObjectInstr* mat) const;
-  intptr_t CalculateStackIndex(const Location& from_loc) const;
+  intptr_t CalculateStackIndex(const Location& source_loc) const;
 
   intptr_t FrameSize() const {
     return instructions_.length() - frame_start_;
   }
 
-  void AddConstant(const Object& obj, intptr_t to_index);
+  void AddConstant(const Object& obj, intptr_t dest_index);
 
   GrowableArray<DeoptInstr*> instructions_;
   const GrowableObjectArray& object_table_;
   const intptr_t num_args_;
 
   // Used to compress entries by sharing suffixes.
   TrieNode* trie_root_;
   intptr_t current_info_number_;
 
   intptr_t frame_start_;
@@ skipping 30 matching lines @@
                        DeoptInfo* info,
                        Smi* reason);
 
  private:
   static const intptr_t kEntrySize = 3;
 };
 
 }  // namespace dart
 
 #endif  // VM_DEOPT_INSTRUCTIONS_H_