More PcDescriptor cleanups.

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 642 matching lines @@
     InitializeObject(address, kArrayCid, Array::InstanceSize(1));
     Array::initializeHandle(
         zero_array_,
         reinterpret_cast<RawArray*>(address + kHeapObjectTag));
     zero_array_->raw_ptr()->length_ = Smi::New(1);
     zero_array_->raw_ptr()->data()[0] = Smi::New(0);
   }
 
   // Allocate and initialize the empty_descriptors instance.
   {
-    uword address = heap->Allocate(PcDescriptors::InstanceSize(0), Heap::kOld);
+    uword address = heap->Allocate(
+        PcDescriptors::InstanceSize(0, RawPcDescriptors::kCompressedRecSize),
+        Heap::kOld);
     InitializeObject(address, kPcDescriptorsCid,
-                     PcDescriptors::InstanceSize(0));
+        PcDescriptors::InstanceSize(0, RawPcDescriptors::kCompressedRecSize));
     PcDescriptors::initializeHandle(
         empty_descriptors_,
         reinterpret_cast<RawPcDescriptors*>(address + kHeapObjectTag));
     empty_descriptors_->raw_ptr()->length_ = 0;
   }
 
 
   cls = Class::New<Instance>(kDynamicCid);
   cls.set_is_abstract();
   cls.set_num_type_arguments(0);
@@ skipping 9536 matching lines @@
 intptr_t PcDescriptors::Length() const {
   return raw_ptr()->length_;
 }
 
 
 void PcDescriptors::SetLength(intptr_t value) const {
   raw_ptr()->length_ = value;
 }
 
 
-RawPcDescriptors* PcDescriptors::New(intptr_t num_descriptors) {
+intptr_t PcDescriptors::RecordSizeInBytes() const {
+  return raw_ptr()->record_size_in_bytes_;
+}
+
+
+void PcDescriptors::SetRecordSizeInBytes(intptr_t value) const {
+  raw_ptr()->record_size_in_bytes_ = value;
+}
+
+
+RawPcDescriptors* PcDescriptors::New(intptr_t num_descriptors,
+                                     bool has_try_index) {
   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();
   {
-    uword size = PcDescriptors::InstanceSize(num_descriptors);
+    uword size = PcDescriptors::InstanceSize(num_descriptors,
+        has_try_index ? RawPcDescriptors::kFullRecSize
+                      : RawPcDescriptors::kCompressedRecSize);
     RawObject* raw = Object::Allocate(PcDescriptors::kClassId,
                                       size,
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
     result.SetLength(num_descriptors);
+    if (has_try_index) {
+      result.SetRecordSizeInBytes(RawPcDescriptors::kFullRecSize);
+    } else {
+      result.SetRecordSizeInBytes(RawPcDescriptors::kCompressedRecSize);
+    }
   }
   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 28 matching lines @@
   // "*" in a printf format specifier tells it to read the field width from
   // the printf argument list.
   const char* kFormat =
       "%#-*" Px "\t%s\t%" Pd "\t\t%" Pd "\t%" Pd "\n";
   // First compute the buffer size required.
   intptr_t len = 1;  // Trailing '\0'.
   Iterator iter(*this, RawPcDescriptors::kAnyKind);
   while (iter.HasNext()) {
     const RawPcDescriptors::PcDescriptorRec& rec = iter.Next();
     len += OS::SNPrint(NULL, 0, kFormat, addr_width,
-                       rec.pc,
+                       rec.pc(),
                        KindAsStr(rec.kind()),
-                       rec.deopt_id,
-                       rec.token_pos,
-                       rec.try_index);
+                       rec.deopt_id(),
+                       rec.token_pos(),
+                       rec.try_index());
   }
   // Allocate the buffer.
   char* buffer = Isolate::Current()->current_zone()->Alloc<char>(len);
   // Layout the fields in the buffer.
   intptr_t index = 0;
   Iterator iter2(*this, RawPcDescriptors::kAnyKind);
   while (iter2.HasNext()) {
     const RawPcDescriptors::PcDescriptorRec& rec = iter2.Next();
     index += OS::SNPrint((buffer + index), (len - index), kFormat, addr_width,
-                         rec.pc,
+                         rec.pc(),
                          KindAsStr(rec.kind()),
-                         rec.deopt_id,
-                         rec.token_pos,
-                         rec.try_index);
+                         rec.deopt_id(),
+                         rec.token_pos(),
+                         rec.try_index());
   }
   return buffer;
 }
 
 
 void PcDescriptors::PrintToJSONObject(JSONObject* jsobj) const {
   jsobj->AddProperty("type", JSONType(false));
   // TODO(johnmccutchan): Generate a valid ID.
   // PcDescriptors hang off a Code object but do not have a back reference to
   // generate an ID. Currently we only print PcDescriptors inline with a Code.
   jsobj->AddProperty("id", "");
   JSONArray members(jsobj, "members");
   Iterator iter(*this, RawPcDescriptors::kAnyKind);
   while (iter.HasNext()) {
     const RawPcDescriptors::PcDescriptorRec& rec = iter.Next();
     JSONObject descriptor(&members);
-    descriptor.AddPropertyF("pc", "%" Px "", rec.pc);
+    descriptor.AddPropertyF("pc", "%" Px "", rec.pc());
     descriptor.AddProperty("kind", KindAsStr(rec.kind()));
-    descriptor.AddProperty("deoptId",  static_cast<intptr_t>(rec.deopt_id));
-    descriptor.AddProperty("tokenPos",  static_cast<intptr_t>(rec.token_pos));
-    descriptor.AddProperty("tryIndex",  static_cast<intptr_t>(rec.try_index));
+    descriptor.AddProperty("deoptId",  static_cast<intptr_t>(rec.deopt_id()));
+    descriptor.AddProperty("tokenPos",  static_cast<intptr_t>(rec.token_pos()));
+    descriptor.AddProperty("tryIndex",  static_cast<intptr_t>(rec.try_index()));
   }
 }
 
 
 void PcDescriptors::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   PrintToJSONObject(&jsobj);
 }
 
 
@@ skipping 16 matching lines @@
   if (!function.IsOptimizable()) {
     return;
   }
   Iterator iter(*this, RawPcDescriptors::kDeopt | RawPcDescriptors::kIcCall);
   while (iter.HasNext()) {
     const RawPcDescriptors::PcDescriptorRec& rec = iter.Next();
     RawPcDescriptors::Kind kind = rec.kind();
     // 'deopt_id' is set for kDeopt and kIcCall and must be unique for one kind.
     intptr_t deopt_id = Isolate::kNoDeoptId;
 
-    deopt_id = rec.deopt_id;
+    deopt_id = rec.deopt_id();
     if (Isolate::IsDeoptAfter(deopt_id)) {
       // TODO(vegorov): some instructions contain multiple calls and have
       // multiple "after" targets recorded. Right now it is benign but might
       // lead to issues in the future. Fix that and enable verification.
       continue;
     }
 
     Iterator nested(iter);
     while (nested.HasNext()) {
       const RawPcDescriptors::PcDescriptorRec& nested_rec = nested.Next();
       if (kind == nested_rec.kind()) {
         if (deopt_id != Isolate::kNoDeoptId) {
-          ASSERT(nested_rec.deopt_id != deopt_id);
+          ASSERT(nested_rec.deopt_id() != deopt_id);
         }
       }
     }
   }
 #endif  // DEBUG
 }
 
 
 uword PcDescriptors::GetPcForKind(RawPcDescriptors::Kind kind) const {
   Iterator iter(*this, RawPcDescriptors::kAnyKind);
   while (iter.HasNext()) {
     const RawPcDescriptors::PcDescriptorRec& rec = iter.Next();
     if (rec.kind() == kind) {
-      return rec.pc;
+      return rec.pc();
     }
   }
   return 0;
 }
 
 
 bool Stackmap::GetBit(intptr_t bit_index) const {
   ASSERT(InRange(bit_index));
   int byte_index = bit_index >> kBitsPerByteLog2;
   int bit_remainder = bit_index & (kBitsPerByte - 1);
@@ skipping 1480 matching lines @@
   }
   return Code::null();
 }
 
 
 intptr_t Code::GetTokenIndexOfPC(uword pc) const {
   const PcDescriptors& descriptors = PcDescriptors::Handle(pc_descriptors());
   PcDescriptors::Iterator iter(descriptors, RawPcDescriptors::kAnyKind);
   while (iter.HasNext()) {
     const RawPcDescriptors::PcDescriptorRec& rec = iter.Next();
-    if (rec.pc == pc) {
-      return rec.token_pos;
+    if (rec.pc() == pc) {
+      return rec.token_pos();
     }
   }
   return -1;
 }
 
 
 uword Code::GetPcForDeoptId(intptr_t deopt_id,
                             RawPcDescriptors::Kind kind) const {
   const PcDescriptors& descriptors = PcDescriptors::Handle(pc_descriptors());
   PcDescriptors::Iterator iter(descriptors, kind);
   while (iter.HasNext()) {
     const RawPcDescriptors::PcDescriptorRec& rec = iter.Next();
-    if (rec.deopt_id == deopt_id) {
-      uword pc = rec.pc;
+    if (rec.deopt_id() == deopt_id) {
+      uword pc = rec.pc();
       ASSERT(ContainsInstructionAt(pc));
       return pc;
     }
   }
   return 0;
 }
 
 
 intptr_t Code::GetDeoptIdForOsr(uword pc) const {
   const PcDescriptors& descriptors = PcDescriptors::Handle(pc_descriptors());
   PcDescriptors::Iterator iter(descriptors, RawPcDescriptors::kOsrEntry);
   while (iter.HasNext()) {
     const RawPcDescriptors::PcDescriptorRec& rec = iter.Next();
-    if (rec.pc == pc) {
-      return rec.deopt_id;
+    if (rec.pc() == pc) {
+      return rec.deopt_id();
     }
   }
   return Isolate::kNoDeoptId;
 }
 
 
 const char* Code::ToCString() const {
   const char* kFormat = "Code entry:%p";
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, EntryPoint()) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
@@ skipping 7150 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart