Compress deopt instructions in memory using variable length encoding.

runtime/vm/object.h

 // Copyright (c) 2012, 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_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 3524 matching lines @@
 // of two parts:
 //  - first a prefix consiting of kMaterializeObject instructions describing
 //    objects which had their allocation removed as part of AllocationSinking
 //    pass and have to be materialized;
 //  - followed by a list of DeoptInstr objects, specifying transformation
 //    information for each slot in unoptimized frame(s).
 // Arguments for object materialization (class of instance to be allocated and
 // field-value pairs) are added as artificial slots to the expression stack
 // of the bottom-most frame. They are removed from the stack at the very end
 // of deoptimization by the deoptimization stub.
-class DeoptInfo : public Object {
- private:
-  // Describes the layout of deopt info data. The index of a deopt-info entry
-  // is implicitly the target slot in which the value is written into.
-  enum {
-    kInstruction = 0,
-    kFromIndex,
-    kNumberOfEntries,
-  };
+class DeoptInfo : public AllStatic {
+ public:
+  // Size of the frame part of the translation not counting kMaterializeObject
+  // instructions in the prefix.
+  static intptr_t FrameSize(const TypedData& packed);
 
- public:
-  // The number of instructions.
-  intptr_t Length() const;
+  // Returns the number of kMaterializeObject instructions in the prefix.
+  static intptr_t NumMaterializations(const GrowableArray<DeoptInstr*>&);
 
-  // The number of real (non-suffix) instructions needed to execute the
-  // deoptimization translation.
-  intptr_t TranslationLength() const;
+  // Unpack the entire translation into an array of deoptimization
+  // instructions.  This copies any shared suffixes into the array.
+  static void Unpack(const Array& table,
+                     const TypedData& packed,
+                     GrowableArray<DeoptInstr*>* instructions);
 
   // Size of the frame part of the translation not counting kMaterializeObject
   // instructions in the prefix.
-  intptr_t FrameSize() const;
-
-  // Returns the number of kMaterializeObject instructions in the prefix.
-  intptr_t NumMaterializations() const;
-
-  static RawDeoptInfo* New(intptr_t num_commands);
-
-  static const intptr_t kBytesPerElement = (kNumberOfEntries * kWordSize);
-  static const intptr_t kMaxElements = kSmiMax / kBytesPerElement;
-
-  static intptr_t InstanceSize() {
-    ASSERT(sizeof(RawDeoptInfo) ==
-           OFFSET_OF_RETURNED_VALUE(RawDeoptInfo, data));
-    return 0;
-  }
-
-  static intptr_t InstanceSize(intptr_t len) {
-    ASSERT(0 <= len && len <= kMaxElements);
-    return RoundedAllocationSize(sizeof(RawDeoptInfo) +
-                                 (len * kBytesPerElement));
-  }
-
-  // 'index' corresponds to target, to-index.
-  void SetAt(intptr_t index,
-             intptr_t instr_kind,
-             intptr_t from_index) const;
-
-  intptr_t Instruction(intptr_t index) const;
-  intptr_t FromIndex(intptr_t index) const;
-  intptr_t ToIndex(intptr_t index) const {
-    return index;
-  }
-
-  // Unpack the entire translation into an array of deoptimization
-  // instructions.  This copies any shared suffixes into the array.
-  void ToInstructions(const Array& table,
-                      GrowableArray<DeoptInstr*>* instructions) const;
-
+  static const char* ToCString(const Array& table,
+                               const TypedData& packed);
 
   // Returns true iff decompression yields the same instructions as the
   // original.
-  bool VerifyDecompression(const GrowableArray<DeoptInstr*>& original,
-                           const Array& deopt_table) const;
+  static bool VerifyDecompression(const GrowableArray<DeoptInstr*>& original,
+                                  const Array& deopt_table,
+                                  const TypedData& packed);
+
 
  private:
-  intptr_t* EntryAddr(intptr_t index, intptr_t entry_offset) const {
-    ASSERT((index >=0) && (index < Length()));
-    intptr_t data_index = (index * kNumberOfEntries) + entry_offset;
-    return &UnsafeMutableNonPointer(raw_ptr()->data())[data_index];
-  }
-
-  void SetLength(intptr_t value) const;
-
-  FINAL_HEAP_OBJECT_IMPLEMENTATION(DeoptInfo, Object);
-  friend class Class;
+  static void UnpackInto(const Array& table,
+                         const TypedData& packed,
+                         GrowableArray<DeoptInstr*>* instructions,
+                         intptr_t length);
 };
 
 
 // Object holding information about an IC: test classes and their
 // corresponding targets.
 class ICData : public Object {
  public:
   RawFunction* owner() const {
     return raw_ptr()->owner_;
   }
@@ skipping 375 matching lines @@
     kSCallTableFunctionEntry = 1,
     kSCallTableCodeEntry = 2,
     kSCallTableEntryLength = 3,
   };
 
   void set_static_calls_target_table(const Array& value) const;
   RawArray* static_calls_target_table() const {
     return raw_ptr()->static_calls_target_table_;
   }
 
-  RawDeoptInfo* GetDeoptInfoAtPc(uword pc,
+  RawTypedData* GetDeoptInfoAtPc(uword pc,
                                  ICData::DeoptReasonId* deopt_reason,
                                  uint32_t* deopt_flags) const;
 
   // Returns null if there is no static call at 'pc'.
   RawFunction* GetStaticCallTargetFunctionAt(uword pc) const;
   // Returns null if there is no static call at 'pc'.
   RawCode* GetStaticCallTargetCodeAt(uword pc) const;
   // Aborts if there is no static call at 'pc'.
   void SetStaticCallTargetCodeAt(uword pc, const Code& code) const;
   void SetStubCallTargetCodeAt(uword pc, const Code& code) const;
@@ skipping 3811 matching lines @@
 
 
 RawObject* MegamorphicCache::GetTargetFunction(const Array& array,
                                                intptr_t index) {
   return array.At((index * kEntryLength) + kTargetFunctionIndex);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_