One more iteration of PcDescriptor iterator improvement: do not copy record but access individual …

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 10340 matching lines @@
   }
   // 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'.
   Iterator iter(*this, RawPcDescriptors::kAnyKind);
   while (iter.HasNext()) {

[hausner, 2014/07/17 23:22:56]

See other comment. This loop would become:

while (iter.HasNext()) {
  iter.MoveNext();
  uword pc = iter.pc();
  len += OS::SNPrint(NULL, 0, kFormat, addr_width,
              pc,
              KindAsStr(iter.kind()),
              iter.deopt_id(),
              iter.token_pos(),
              iter.try_index());
}

[srdjan, 2014/07/18 18:16:45]

Good suggestion, changed to:

while (iter.MoveNext()) {
  ...iter.Pc(), iter.Kind()...
}

-    RawPcDescriptors::PcDescriptorRec rec;
-    iter.NextRec(&rec);
+    uword pc = iter.NextPc();
     len += OS::SNPrint(NULL, 0, kFormat, addr_width,
-                       rec.pc(),
-                       KindAsStr(rec.kind()),
-                       rec.deopt_id(),
-                       rec.token_pos(),
-                       rec.try_index());
+                       pc,
+                       KindAsStr(iter.current_kind()),
+                       iter.current_deopt_id(),
+                       iter.current_token_pos(),
+                       iter.current_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()) {
-    RawPcDescriptors::PcDescriptorRec rec;
-    iter2.NextRec(&rec);
+    uword pc = iter2.NextPc();
     index += OS::SNPrint((buffer + index), (len - index), kFormat, addr_width,
-                         rec.pc(),
-                         KindAsStr(rec.kind()),
-                         rec.deopt_id(),
-                         rec.token_pos(),
-                         rec.try_index());
+                         pc,
+                         KindAsStr(iter.current_kind()),
+                         iter.current_deopt_id(),
+                         iter.current_token_pos(),
+                         iter.current_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()) {
-    RawPcDescriptors::PcDescriptorRec rec;
-    iter.NextRec(&rec);
+    uword pc = iter.NextPc();
     JSONObject descriptor(&members);
-    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.AddPropertyF("pc", "%" Px "", pc);
+    descriptor.AddProperty("kind", KindAsStr(iter.current_kind()));
+    descriptor.AddProperty("deoptId", iter.current_deopt_id());
+    descriptor.AddProperty("tokenPos", iter.current_token_pos());
+    descriptor.AddProperty("tryIndex", iter.current_try_index());
   }
 }
 
 
 void PcDescriptors::PrintJSONImpl(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
   PrintToJSONObject(&jsobj);
 }
 
 
@@ skipping 11 matching lines @@
       OS::Print("Not checking pc decriptors, length %" Pd "\n", Length());
     }
     return;
   }
   // Only check ids for unoptimized code that is optimizable.
   if (!function.IsOptimizable()) {
     return;
   }
   Iterator iter(*this, RawPcDescriptors::kDeopt | RawPcDescriptors::kIcCall);
   while (iter.HasNext()) {
-    RawPcDescriptors::PcDescriptorRec rec;
-    iter.NextRec(&rec);
+    const intptr_t deopt_id = iter.NextDeoptId();
     // 'deopt_id' is set for kDeopt and kIcCall and must be unique for one kind.
 
-    if (Isolate::IsDeoptAfter(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()) {
-      RawPcDescriptors::PcDescriptorRec nested_rec;
-      nested.NextRec(&nested_rec);
-      if (rec.kind() == nested_rec.kind()) {
-        ASSERT(nested_rec.deopt_id() != rec.deopt_id());
+      intptr_t nested_deopt_id = nested.NextDeoptId();
+      if (iter.current_kind() == nested.current_kind()) {
+        ASSERT(nested_deopt_id != iter.current_deopt_id());
       }
     }
   }
 #endif  // DEBUG
 }
 
 
 uword PcDescriptors::GetPcForKind(RawPcDescriptors::Kind kind) const {
   Iterator iter(*this, kind);
   if (iter.HasNext()) {
@@ skipping 1489 matching lines @@
     return code.raw();
   }
   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()) {
-    RawPcDescriptors::PcDescriptorRec rec;
-    iter.NextRec(&rec);
-    if (rec.pc() == pc) {
-      return rec.token_pos();
+    const uword current_pc = iter.NextPc();
+    if (current_pc == pc) {
+      return iter.current_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()) {
-    RawPcDescriptors::PcDescriptorRec rec;
-    iter.NextRec(&rec);
-    if (rec.deopt_id() == deopt_id) {
-      uword pc = rec.pc();
+    const intptr_t current_deopt_id = iter.NextDeoptId();
+    if (current_deopt_id == deopt_id) {
+      uword pc = iter.current_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()) {
-    RawPcDescriptors::PcDescriptorRec rec;
-    iter.NextRec(&rec);
-    if (rec.pc() == pc) {
-      return rec.deopt_id();
+    const uword current_pc = iter.NextPc();
+    if (current_pc == pc) {
+      return iter.current_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 7166 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart