Compress deoptimization information by sharing common suffixes.

runtime/vm/object.cc

 // 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.
 
 #include "vm/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
@@ skipping 6762 matching lines @@
     index += OS::SNPrint((buffer + index),
                          (len - index),
                          kFormat,
                          TryIndex(i),
                          HandlerPC(i));
   }
   return buffer;
 }
 
 
-intptr_t DeoptInfo::Length() const {
+intptr_t DeoptInfo::GetLength() const {
   return Smi::Value(raw_ptr()->length_);
 }
 
 
 intptr_t DeoptInfo::FromIndex(intptr_t index) const {
   return *(EntryAddr(index, kFromIndex));
 }
 
 
 intptr_t DeoptInfo::Instruction(intptr_t index) const {
   return *(EntryAddr(index, kInstruction));
 }
 
 
+intptr_t DeoptInfo::TranslationLength() const {
+  intptr_t length = GetLength();
+  if (Instruction(length - 1) != DeoptInstr::kSuffix)  return length;
+
+  // If the last command is a suffix, add in the length of the suffix and
+  // do not count the suffix command as a translation command.
+  intptr_t ignored = 0;
+  intptr_t suffix_length =
+      DeoptInstr::DecodeSuffix(FromIndex(length - 1), &ignored);
+  return length + suffix_length - 1;
+}
+
+
+void DeoptInfo::ToInstructions(const Array& table,
+                               GrowableArray<DeoptInstr*>* instructions) const {
+  ASSERT(instructions->is_empty());
+  Smi& offset = Smi::Handle();
+  DeoptInfo& info = DeoptInfo::Handle(raw());
+  Smi& reason = Smi::Handle();
+  intptr_t index = 0;
+  intptr_t length = TranslationLength();
+  while (index < length) {
+    intptr_t instruction = info.Instruction(index);
+    intptr_t from_index = info.FromIndex(index);
+    if (instruction == DeoptInstr::kSuffix) {
+      // Suffix instructions cause us to 'jump' to another translation,
+      // changing info, length and index.
+      intptr_t info_number = 0;
+      intptr_t suffix_length =
+          DeoptInstr::DecodeSuffix(from_index, &info_number);
+      DeoptTable::GetEntry(table, info_number, &offset, &info, &reason);
+      length = info.TranslationLength();
+      index = length - suffix_length;
+    } else {
+      instructions->Add(DeoptInstr::Create(instruction, from_index));
+      ++index;
+    }
+  }
+}
+
+
 const char* DeoptInfo::ToCString() const {
-  if (Length() == 0) {
+  if (GetLength() == 0) {
     return "No DeoptInfo";
   }
   // Convert to DeoptInstr.
-  GrowableArray<DeoptInstr*> deopt_instrs(Length());
-  for (intptr_t i = 0; i < Length(); i++) {
+  GrowableArray<DeoptInstr*> deopt_instrs(GetLength());
+  for (intptr_t i = 0; i < GetLength(); i++) {
     deopt_instrs.Add(DeoptInstr::Create(Instruction(i), FromIndex(i)));
   }
   // Compute the buffer size required.
   intptr_t len = 1;  // Trailing '\0'.
-  for (intptr_t i = 0; i < Length(); i++) {
+  for (intptr_t i = 0; i < GetLength(); i++) {
     len += OS::SNPrint(NULL, 0, "[%s]", deopt_instrs[i]->ToCString());
   }
   // Allocate the buffer.
   char* buffer = Isolate::Current()->current_zone()->Alloc<char>(len);
   // Layout the fields in the buffer.
   intptr_t index = 0;
-  for (intptr_t i = 0; i < Length(); i++) {
+  for (intptr_t i = 0; i < GetLength(); i++) {
     index += OS::SNPrint((buffer + index),
                          (len - index),
                          "[%s]",
                          deopt_instrs[i]->ToCString());
   }
   return buffer;
 }
 
 
 RawDeoptInfo* DeoptInfo::New(intptr_t num_commands) {
@@ skipping 5342 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart