Refactor deopt_instructions.cc to minimize boilerplate and duplication.

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/locations.h"
 #include "vm/object.h"
 
 namespace dart {
 
 class Location;
 class Value;
 class MaterializeObjectInstr;
 class StackFrame;
 
 // Holds all data relevant for execution of deoptimization instructions.
@@ skipping 40 matching lines @@
     return cpu_registers_[reg];
   }
 
   double FpuRegisterValue(FpuRegister reg) const {
     ASSERT(fpu_registers_ != NULL);
     ASSERT(reg >= 0);
     ASSERT(reg < kNumberOfFpuRegisters);
     return *reinterpret_cast<double*>(&fpu_registers_[reg]);
   }
 
-  int64_t FpuRegisterValueAsInt64(FpuRegister reg) const {
-    ASSERT(fpu_registers_ != NULL);
-    ASSERT(reg >= 0);
-    ASSERT(reg < kNumberOfFpuRegisters);
-    return *reinterpret_cast<int64_t*>(&fpu_registers_[reg]);
-  }
-
   simd128_value_t FpuRegisterValueAsSimd128(FpuRegister reg) const {
     ASSERT(fpu_registers_ != NULL);
     ASSERT(reg >= 0);
     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);
@@ skipping 23 matching lines @@
 
   void VisitObjectPointers(ObjectPointerVisitor* visitor);
 
   void DeferMaterializedObjectRef(intptr_t idx, intptr_t* slot) {
     deferred_slots_ = new DeferredObjectRef(
         idx,
         reinterpret_cast<RawInstance**>(slot),
         deferred_slots_);
   }
 
-  void DeferDoubleMaterialization(double value, RawDouble** slot) {
+  void DeferMaterialization(double value, RawDouble** slot) {
     deferred_slots_ = new DeferredDouble(
         value,
         reinterpret_cast<RawInstance**>(slot),
         deferred_slots_);
   }
 
   void DeferMintMaterialization(int64_t value, RawMint** slot) {
     deferred_slots_ = new DeferredMint(
         value,
         reinterpret_cast<RawInstance**>(slot),
         deferred_slots_);
   }
 
-  void DeferFloat32x4Materialization(simd128_value_t value,
-                                     RawFloat32x4** slot) {
+  void DeferMaterialization(simd128_value_t value, RawFloat32x4** slot) {
     deferred_slots_ = new DeferredFloat32x4(
         value,
         reinterpret_cast<RawInstance**>(slot),
         deferred_slots_);
   }
 
-  void DeferFloat64x2Materialization(simd128_value_t value,
-                                     RawFloat64x2** slot) {
+  void DeferMaterialization(simd128_value_t value, RawFloat64x2** slot) {
     deferred_slots_ = new DeferredFloat64x2(
         value,
         reinterpret_cast<RawInstance**>(slot),
         deferred_slots_);
   }
 
-  void DeferInt32x4Materialization(simd128_value_t value,
-                                    RawInt32x4** slot) {
+  void DeferMaterialization(simd128_value_t value, RawInt32x4** slot) {
     deferred_slots_ = new DeferredInt32x4(
         value,
         reinterpret_cast<RawInstance**>(slot),
         deferred_slots_);
   }
 
   DeferredObject* GetDeferredObject(intptr_t idx) const {
     return deferred_objects_[idx];
   }
 
@@ skipping 49 matching lines @@
 
 
 // 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 {
     kRetAddress,
     kConstant,
-    kRegister,
-    kFpuRegister,
-    kFloat32x4FpuRegister,
-    kFloat64x2FpuRegister,
-    kInt32x4FpuRegister,
-    kStackSlot,
-    kDoubleStackSlot,
-    kFloat32x4StackSlot,
-    kFloat64x2StackSlot,
-    kInt32x4StackSlot,
+    kWord,
+    kDouble,
+    kFloat32x4,
+    kFloat64x2,
+    kInt32x4,
     // Mints are split into low and high words. Each word can be in a register
     // or stack slot. Note Mints are only used on 32-bit architectures.
-    kMintRegisterPair,
-    kMintStackSlotPair,
-    kMintStackSlotRegister,
-    kUint32Register,
-    kUint32StackSlot,
+    kMintPair,
+    kUint32,
     kPcMarker,
     kPp,
     kCallerFp,
     kCallerPp,
     kCallerPc,
     kSuffix,
     kMaterializedObjectRef,
     kMaterializeObject
   };
 
   static DeoptInstr* Create(intptr_t kind_as_int, intptr_t source_index);
 
   DeoptInstr() {}
   virtual ~DeoptInstr() {}
 
-  virtual const char* ToCString() const = 0;
+  virtual const char* ToCString() const {
+    const char* args = ArgumentsToCString();
+    if (args != NULL) {
+      return Isolate::Current()->current_zone()->PrintToString(
+          "%s(%s)", KindToCString(kind()), args);
+    } else {
+      return KindToCString(kind());
+    }
+  }
 
   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()) && (source_index() == other.source_index());
   }
 
   // Decode the payload of a suffix command.  Return the suffix length and
@@ skipping 11 matching lines @@
   static intptr_t GetFieldCount(DeoptInstr* instr) {
     ASSERT(instr->kind() == DeoptInstr::kMaterializeObject);
     return instr->source_index();
   }
 
  protected:
   friend class DeoptInfoBuilder;
 
   virtual intptr_t source_index() const = 0;
 
+  virtual const char* ArgumentsToCString() const {
+    return NULL;
+  }
+
  private:
+  static const char* KindToCString(Kind kind);
+
   DISALLOW_COPY_AND_ASSIGN(DeoptInstr);
 };
 
 
+template<typename RegisterType, typename DestinationType> struct SourceReader;
+
+template<typename T>
+struct SourceReader<Register, T> {
+  static intptr_t Read(DeoptContext* context, Register reg) {
+    return context->RegisterValue(reg);
+  }
+};
+
+template<>
+struct SourceReader<FpuRegister, double> {
+  static double Read(DeoptContext* context, FpuRegister reg) {
+    return context->FpuRegisterValue(reg);
+  }
+};
+
+
+template<>
+struct SourceReader<FpuRegister, simd128_value_t> {
+  static simd128_value_t Read(DeoptContext* context, FpuRegister reg) {
+    return context->FpuRegisterValueAsSimd128(reg);
+  }
+};
+
+
+template<typename RegisterType>
+class GenericDeoptSource {
+ public:
+  enum Kind {
+    kStackSlot = 0,
+    kRegister = 1
+  };
+
+  explicit GenericDeoptSource(intptr_t source_index)

[Florian Schneider, 2014/08/22 17:05:45]

Is this constructor used at all, or is is dead code?

[Vyacheslav Egorov (Google), 2014/08/23 00:26:45]

It is used when deserializing deopt instructions.

+      : source_index_(source_index) { }
+
+  GenericDeoptSource(Kind kind, intptr_t index)
+      : source_index_(IsRegister::encode(kind) | RawIndex::encode(index)) {
+  }
+
+  template<typename T>
+  T Value(DeoptContext* context) const {
+    if (is_register()) {
+      return static_cast<T>(SourceReader<RegisterType, T>::Read(
+        context, reg()));
+    } else {
+      return *reinterpret_cast<T*>(context->GetSourceFrameAddressAt(
+          context->source_frame_size() - raw_index() - 1));
+    }
+  }
+
+  intptr_t source_index() const { return source_index_; }
+
+  const char* ToCString() const {
+    if (is_register()) {
+      return Name(reg());
+    } else {
+      return Isolate::Current()->current_zone()->PrintToString(
+          "s%" Pd "", raw_index());
+    }
+  }
+
+ private:
+  class IsRegister : public BitField<intptr_t, 0, 1> { };
+  class RawIndex : public BitField<intptr_t, 1, kBitsPerWord - 1> { };
+
+  bool is_register() const {
+    return IsRegister::decode(source_index_) == kRegister;
+  }
+  intptr_t raw_index() const { return RawIndex::decode(source_index_); }
+
+  RegisterType reg() const { return static_cast<RegisterType>(raw_index()); }
+
+  static const char* Name(Register reg) {
+    return Assembler::RegisterName(reg);
+  }
+
+  static const char* Name(FpuRegister fpu_reg) {
+    return Assembler::FpuRegisterName(fpu_reg);
+  }
+
+  const intptr_t source_index_;
+};
+
+
+typedef GenericDeoptSource<Register> MachineWordSource;
+typedef GenericDeoptSource<FpuRegister> MachineFpuSource;
+
+
 // 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:
   DeoptInfoBuilder(Isolate* isolate, const intptr_t num_args);
 
   // 'object_table' holds all objects referred to by DeoptInstr in
@@ skipping 32 matching lines @@
   // 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;
 
+  MachineWordSource ToMachineWordSource(const Location& loc);
+  MachineFpuSource ToMachineFpuSource(const Location& loc,
+                                      Location::Kind expected_stack_slot_kind);
+
   intptr_t FindOrAddObjectInTable(const Object& obj) const;
   intptr_t FindMaterialization(MaterializeObjectInstr* mat) 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 dest_index);
 
@@ skipping 43 matching lines @@
                        DeoptInfo* info,
                        Smi* reason);
 
  private:
   static const intptr_t kEntrySize = 3;
 };
 
 }  // namespace dart
 
 #endif  // VM_DEOPT_INSTRUCTIONS_H_