Iterate over PcDescriptors only via iterators, not via an index. (preparation for more compression …

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 10177 matching lines @@
                                       size,
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
     result.SetLength(num_descriptors);
   }
   return result.raw();
 }
 
 
-const char* PcDescriptors::KindAsStr(intptr_t index) const {
-  switch (DescriptorKind(index)) {
-    case PcDescriptors::kDeopt:           return "deopt        ";
-    case PcDescriptors::kIcCall:          return "ic-call      ";
-    case PcDescriptors::kOptStaticCall:   return "opt-call     ";
-    case PcDescriptors::kUnoptStaticCall: return "unopt-call   ";
-    case PcDescriptors::kClosureCall:     return "closure-call ";
-    case PcDescriptors::kRuntimeCall:     return "runtime-call ";
-    case PcDescriptors::kOsrEntry:        return "osr-entry    ";
-    case PcDescriptors::kOther:           return "other        ";
+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     ";
+    case RawPcDescriptors::kUnoptStaticCall: return "unopt-call   ";
+    case RawPcDescriptors::kClosureCall:     return "closure-call ";
+    case RawPcDescriptors::kRuntimeCall:     return "runtime-call ";
+    case RawPcDescriptors::kOsrEntry:        return "osr-entry    ";
+    case RawPcDescriptors::kOther:           return "other        ";
   }
   UNREACHABLE();
   return "";
 }
 
 
 void PcDescriptors::PrintHeaderString() {
   // 4 bits per hex digit + 2 for "0x".
   const int addr_width = (kBitsPerWord / 4) + 2;
   // "*" in a printf format specifier tells it to read the field width from
   // the printf argument list.
   OS::Print("%-*s\tkind    \tdeopt-id\ttok-ix\ttry-ix\n",
             addr_width, "pc");
 }
 
 
 const char* PcDescriptors::ToCString() const {
   if (Length() == 0) {
     return "No pc descriptors\n";
   }
   // 4 bits per hex digit.
   const int addr_width = kBitsPerWord / 4;
   // "*" 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'.
-  for (intptr_t i = 0; i < Length(); i++) {
+  Iterator iter(*this);
+  while (iter.HasNext()) {
+    const RawPcDescriptors::PcDescriptorRec& rec = iter.Next();
     len += OS::SNPrint(NULL, 0, kFormat, addr_width,
-                       PC(i),
-                       KindAsStr(i),
-                       DeoptId(i),
-                       TokenPos(i),
-                       TryIndex(i));
+                       rec.pc,
+                       KindAsStr(rec.kind()),
+                       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;
-  for (intptr_t i = 0; i < Length(); i++) {
+  Iterator iter2(*this);
+  while (iter2.HasNext()) {
+    const RawPcDescriptors::PcDescriptorRec& rec = iter2.Next();
     index += OS::SNPrint((buffer + index), (len - index), kFormat, addr_width,
-                         PC(i),
-                         KindAsStr(i),
-                         DeoptId(i),
-                         TokenPos(i),
-                         TryIndex(i));
+                         rec.pc,
+                         KindAsStr(rec.kind()),
+                         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");
-  for (intptr_t i = 0; i < Length(); i++) {
+  Iterator iter(*this);
+  while (iter.HasNext()) {
+    const RawPcDescriptors::PcDescriptorRec& rec = iter.Next();
     JSONObject descriptor(&members);
-    descriptor.AddPropertyF("pc", "%" Px "", PC(i));
-    descriptor.AddProperty("kind", KindAsStr(i));
-    descriptor.AddProperty("deoptId", DeoptId(i));
-    descriptor.AddProperty("tokenPos", TokenPos(i));
-    descriptor.AddProperty("tryIndex", TryIndex(i));
+    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));
   }
 }
 
 
 void PcDescriptors::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   PrintToJSONObject(&jsobj);
 }
 
 
 // Verify assumptions (in debug mode only).
 // - No two deopt descriptors have the same deoptimization id.
 // - No two ic-call descriptors have the same deoptimization id (type feedback).
 // A function without unique ids is marked as non-optimizable (e.g., because of
 // finally blocks).
 void PcDescriptors::Verify(const Function& function) const {
 #if defined(DEBUG)
   // TODO(srdjan): Implement a more efficient way to check, currently drop
   // the check for too large number of descriptors.
   if (Length() > 3000) {
     if (FLAG_trace_compiler) {
       OS::Print("Not checking pc decriptors, length %" Pd "\n", Length());
     }
     return;
   }
   // Only check ids for unoptimized code that is optimizable.
-  if (!function.IsOptimizable()) return;
-  for (intptr_t i = 0; i < Length(); i++) {
-    PcDescriptors::Kind kind = DescriptorKind(i);
+  if (!function.IsOptimizable()) {
+    return;
+  }
+  Iterator iter(*this);
+  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;
-    if ((DescriptorKind(i) != PcDescriptors::kDeopt) ||
-        (DescriptorKind(i) != PcDescriptors::kIcCall)) {
+    if ((kind != RawPcDescriptors::kDeopt) ||
+        (kind != RawPcDescriptors::kIcCall)) {
       continue;
     }
 
-    deopt_id = DeoptId(i);
+    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;
     }
 
-    for (intptr_t k = i + 1; k < Length(); k++) {
-      if (kind == DescriptorKind(k)) {
+    Iterator nested(iter);
+    while (iter.HasNext()) {
+      const RawPcDescriptors::PcDescriptorRec& nested_rec = nested.Next();
+      if (kind == nested_rec.kind()) {
         if (deopt_id != Isolate::kNoDeoptId) {
-          ASSERT(DeoptId(k) != deopt_id);
+          ASSERT(nested_rec.deopt_id != deopt_id);
         }
       }
     }
   }
 #endif  // DEBUG
 }
 
 
-uword PcDescriptors::GetPcForKind(Kind kind) const {
-  for (intptr_t i = 0; i < Length(); i++) {
-    if (DescriptorKind(i) == kind) {
-      return PC(i);
+uword PcDescriptors::GetPcForKind(RawPcDescriptors::Kind kind) const {
+  Iterator iter(*this);
+  while (iter.HasNext()) {
+    const RawPcDescriptors::PcDescriptorRec& rec = iter.Next();
+    if (rec.kind() == kind) {
+      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 1476 matching lines @@
   if (!code.IsNull() && (code.compile_timestamp() == timestamp) &&
       (code.EntryPoint() == pc)) {
     // Found code in VM isolate.
     return code.raw();
   }
   return Code::null();
 }
 
 
 intptr_t Code::GetTokenIndexOfPC(uword pc) const {
-  intptr_t token_pos = -1;
   const PcDescriptors& descriptors = PcDescriptors::Handle(pc_descriptors());
-  for (intptr_t i = 0; i < descriptors.Length(); i++) {
-    if (descriptors.PC(i) == pc) {
-      token_pos = descriptors.TokenPos(i);
-      break;
+  PcDescriptors::Iterator iter(descriptors);
+  while (iter.HasNext()) {
+    const RawPcDescriptors::PcDescriptorRec& rec = iter.Next();
+    if (rec.pc == pc) {
+      return rec.token_pos;
     }
   }
-  return token_pos;
+  return -1;
 }
 
 
-uword Code::GetPcForDeoptId(intptr_t deopt_id, PcDescriptors::Kind kind) const {
+uword Code::GetPcForDeoptId(intptr_t deopt_id,
+                            RawPcDescriptors::Kind kind) const {
   const PcDescriptors& descriptors = PcDescriptors::Handle(pc_descriptors());
-  for (intptr_t i = 0; i < descriptors.Length(); i++) {
-    if ((descriptors.DeoptId(i) == deopt_id) &&
-        (descriptors.DescriptorKind(i) == kind)) {
-      uword pc = descriptors.PC(i);
+  PcDescriptors::Iterator iter(descriptors);
+  while (iter.HasNext()) {
+    const RawPcDescriptors::PcDescriptorRec& rec = iter.Next();
+    if ((rec.deopt_id == deopt_id) && (rec.kind() == kind)) {
+      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());
-  for (intptr_t i = 0; i < descriptors.Length(); ++i) {
-    if ((descriptors.PC(i) == pc) &&
-        (descriptors.DescriptorKind(i) == PcDescriptors::kOsrEntry)) {
-      return descriptors.DeoptId(i);
+  PcDescriptors::Iterator iter(descriptors);
+  while (iter.HasNext()) {
+    const RawPcDescriptors::PcDescriptorRec& rec = iter.Next();
+    if ((rec.pc == pc) && (rec.kind() == RawPcDescriptors::kOsrEntry)) {
+      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 7165 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart