Compress deoptimization information by sharing common suffixes.

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 10 matching lines @@
 namespace dart {
 
 // Forward declarations.
 #define DEFINE_FORWARD_DECLARATION(clazz)                                      \
   class clazz;
 CLASS_LIST(DEFINE_FORWARD_DECLARATION)
 #undef DEFINE_FORWARD_DECLARATION
 class Api;
 class Assembler;
 class Code;
+class DeoptInstr;
 class LocalScope;
 class Symbols;
 
 #define OBJECT_IMPLEMENTATION(object, super)                                   \
  public:  /* NOLINT */                                                         \
   Raw##object* raw() const { return reinterpret_cast<Raw##object*>(raw_); }    \
   void operator=(Raw##object* value) {                                         \
     initializeHandle(this, value);                                             \
   }                                                                            \
   bool Is##object() const { return true; }                                     \
@@ skipping 2280 matching lines @@
  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,
   };
 
  public:
+  // The number of instructions.
   intptr_t Length() const;
 
+  // The number of real (non-suffix) instructions needed to execute the
+  // deoptimization translation.
+  intptr_t TranslationLength() 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(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;
+
  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 &raw_ptr()->data_[data_index];
   }
 
   void SetLength(intptr_t value) const;
 
   HEAP_OBJECT_IMPLEMENTATION(DeoptInfo, Object);
@@ skipping 3367 matching lines @@
     if (this->CharAt(i) != str.CharAt(begin_index + i)) {
       return false;
     }
   }
   return true;
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_