Delta encode pc descriptors.

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/cpu.h"
@@ skipping 609 matching lines @@
     Array::initializeHandle(
         zero_array_,
         reinterpret_cast<RawArray*>(address + kHeapObjectTag));
     zero_array_->StoreSmi(&zero_array_->raw_ptr()->length_, Smi::New(1));
     smi = Smi::New(0);
     zero_array_->SetAt(0, smi);
   }
 
   // Allocate and initialize the empty_descriptors instance.
   {
-    uword address = heap->Allocate(
-        PcDescriptors::InstanceSize(0, RawPcDescriptors::kCompressedRecSize),
-        Heap::kOld);
+    uword address = heap->Allocate(PcDescriptors::InstanceSize(0), Heap::kOld);
     InitializeObject(address, kPcDescriptorsCid,
-        PcDescriptors::InstanceSize(0, RawPcDescriptors::kCompressedRecSize));
+                     PcDescriptors::InstanceSize(0));
     PcDescriptors::initializeHandle(
         empty_descriptors_,
         reinterpret_cast<RawPcDescriptors*>(address + kHeapObjectTag));
     empty_descriptors_->StoreNonPointer(&empty_descriptors_->raw_ptr()->length_,
                                         0);
   }
 
   // Allocate and initialize the canonical empty variable descriptor object.
   {
     uword address =
@@ skipping 9899 matching lines @@
 const char* Instructions::ToCString() const {
   return "Instructions";
 }
 
 
 void Instructions::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Object::PrintJSONImpl(stream, ref);
 }
 
 
+// Encode integer in SLEB128 format.
+void PcDescriptors::EncodeInteger(GrowableArray<uint8_t>* data,
+                                  intptr_t value) {
+  bool is_last_part = false;
+  while (!is_last_part) {
+    intptr_t part = value & 0x7f;
+    value >>= 7;
+    if ((value == 0 && (part & 0x40) == 0) ||
+        (value == -1 && (part & 0x40) != 0)) {
+      is_last_part = true;
+    } else {
+      part |= 0x80;
+    }
+    data->Add(part);
+  }
+}
+
+
+// Decode SLEB128 encoded integer. Update byte_index to the next integer.
+intptr_t PcDescriptors::DecodeInteger(intptr_t* byte_index) const {
+  NoSafepointScope no_safepoint;
+  const uint8_t* data = raw_ptr()->data();
+  ASSERT(*byte_index < Length());
+  uword shift = 0;
+  intptr_t value = 0;
+  intptr_t part = 0;
+  do {
+    part = data[(*byte_index)++];
+    value |= (part & 0x7f) << shift;
+    shift += 7;
+  } while ((part & 0x80) != 0);
+
+  if (shift < sizeof(value) * 8 && (part & 0x40) != 0) {
+    value |= -(1 << shift);
+  }
+  return value;
+}
+
+
 intptr_t PcDescriptors::Length() const {
   return raw_ptr()->length_;
 }
 
 
 void PcDescriptors::SetLength(intptr_t value) const {
   StoreNonPointer(&raw_ptr()->length_, value);
 }
 
 
-intptr_t PcDescriptors::RecordSizeInBytes() const {
-  return raw_ptr()->record_size_in_bytes_;
+void PcDescriptors::CopyData(GrowableArray<uint8_t>* delta_encoded_data) {
+  NoSafepointScope no_safepoint;
+  uint8_t* data = UnsafeMutableNonPointer(&raw_ptr()->data()[0]);
+  for (intptr_t i = 0; i < delta_encoded_data->length(); ++i) {
+    data[i] = (*delta_encoded_data)[i];
+  }
 }
 
 
-void PcDescriptors::SetRecordSizeInBytes(intptr_t value) const {
-  StoreNonPointer(&raw_ptr()->record_size_in_bytes_, value);
-}
-
-
-RawPcDescriptors* PcDescriptors::New(intptr_t num_descriptors,
-                                     bool has_try_index) {
+RawPcDescriptors* PcDescriptors::New(GrowableArray<uint8_t>* data) {
   ASSERT(Object::pc_descriptors_class() != Class::null());
-  if (num_descriptors < 0 || num_descriptors > kMaxElements) {
-    // This should be caught before we reach here.
-    FATAL1("Fatal error in PcDescriptors::New: "
-           "invalid num_descriptors %" Pd "\n", num_descriptors);
-  }
   PcDescriptors& result = PcDescriptors::Handle();
   {
-    const intptr_t rec_size =  RawPcDescriptors::RecordSize(has_try_index);
-    uword size = PcDescriptors::InstanceSize(num_descriptors, rec_size);
+    uword size = PcDescriptors::InstanceSize(data->length());
     RawObject* raw = Object::Allocate(PcDescriptors::kClassId,
                                       size,
                                       Heap::kOld);
     NoSafepointScope no_safepoint;
     result ^= raw;
-    result.SetLength(num_descriptors);
-    result.SetRecordSizeInBytes(rec_size);
+    result.SetLength(data->length());
+    result.CopyData(data);
   }
   return result.raw();
 }
 
 
 const char* PcDescriptors::KindAsStr(RawPcDescriptors::Kind kind) {
   switch (kind) {
     case RawPcDescriptors::kDeopt:           return "deopt        ";
     case RawPcDescriptors::kIcCall:          return "ic-call      ";
     case RawPcDescriptors::kOptStaticCall:   return "opt-call     ";
@@ skipping 10121 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart