Specify descriptor kind to iterate on.

runtime/vm/debugger.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/debugger.h"
 
 #include "include/dart_api.h"
 
 #include "vm/code_generator.h"
 #include "vm/code_patcher.h"
@@ skipping 341 matching lines @@
     ASSERT(!pc_desc_.IsNull());
   }
 }
 
 
 // Compute token_pos_ and pc_desc_index_.
 intptr_t ActivationFrame::TokenPos() {
   if (token_pos_ < 0) {
     token_pos_ = Scanner::kNoSourcePos;
     GetPcDescriptors();
-    PcDescriptors::Iterator iter(pc_desc_);
+    PcDescriptors::Iterator iter(pc_desc_, RawPcDescriptors::kAnyKind);
     while (iter.HasNext()) {
       const RawPcDescriptors::PcDescriptorRec& rec = iter.Next();
       if (rec.pc == pc_) {
         desc_rec_ = &rec;
         token_pos_ = rec.token_pos;
         break;
       }
     }
   }
   return token_pos_;
@@ skipping 541 matching lines @@
 
 
 
 void DebuggerStackTrace::AddActivation(ActivationFrame* frame) {
   if (FLAG_show_invisible_frames || frame->function().is_visible()) {
     trace_.Add(frame);
   }
 }
 
 
-static bool IsSafeDescKind(int8_t kind) {
-  return ((kind == RawPcDescriptors::kIcCall) ||
-          (kind == RawPcDescriptors::kOptStaticCall) ||
-          (kind == RawPcDescriptors::kUnoptStaticCall) ||
-          (kind == RawPcDescriptors::kClosureCall) ||
-          (kind == RawPcDescriptors::kRuntimeCall));
+const uint8_t kSafepointKind =
+    RawPcDescriptors::kIcCall |  RawPcDescriptors::kOptStaticCall |
+    RawPcDescriptors::kUnoptStaticCall | RawPcDescriptors::kClosureCall |
+    RawPcDescriptors::kRuntimeCall;
+
+
+static bool HasTokenPos(const RawPcDescriptors::PcDescriptorRec& rec) {
+  return rec.token_pos != Scanner::kNoSourcePos;
 }
 
 
-static bool IsSafePoint(const RawPcDescriptors::PcDescriptorRec& rec) {
-  return IsSafeDescKind(rec.kind()) && (rec.token_pos != Scanner::kNoSourcePos);
-}
-
-
 CodeBreakpoint::CodeBreakpoint(const Code& code,
                                const RawPcDescriptors::PcDescriptorRec& rec)
     : code_(code.raw()),
       token_pos_(rec.token_pos),
       pc_(rec.pc),
       line_number_(-1),
       is_enabled_(false),
       src_bpt_(NULL),
       next_(NULL),
       breakpoint_kind_(rec.kind()),
       saved_value_(0) {
   ASSERT(!code.IsNull());
   ASSERT(token_pos_ > 0);
   ASSERT(pc_ != 0);
-  ASSERT(IsSafeDescKind(breakpoint_kind_));
+  ASSERT((breakpoint_kind_ & kSafepointKind) != 0);
 }
 
 
 CodeBreakpoint::~CodeBreakpoint() {
   // Make sure we don't leave patched code behind.
   ASSERT(!IsEnabled());
   // Poison the data so we catch use after free errors.
 #ifdef DEBUG
   code_ = Code::null();
   pc_ = 0ul;
@@ skipping 232 matching lines @@
       return;
     }
   }
   // Hang on to the code object before deoptimizing, in case deoptimization
   // might cause the GC to run.
   Code& code = Code::Handle(isolate, target_function.unoptimized_code());
   ASSERT(!code.IsNull());
   DeoptimizeWorld();
   ASSERT(!target_function.HasOptimizedCode());
   PcDescriptors& desc = PcDescriptors::Handle(isolate, code.pc_descriptors());
-  PcDescriptors::Iterator iter(desc);
+  PcDescriptors::Iterator iter(desc, kSafepointKind);
   while (iter.HasNext()) {
     const RawPcDescriptors::PcDescriptorRec& rec = iter.Next();
-    if (IsSafePoint(rec)) {
+    if (HasTokenPos(rec)) {
       CodeBreakpoint* bpt = GetCodeBreakpoint(rec.pc);
       if (bpt != NULL) {
         // There is already a breakpoint for this address. Make sure
         // it is enabled.
         bpt->Enable();
         continue;
       }
       bpt = new CodeBreakpoint(code, rec);
       RegisterCodeBreakpoint(bpt);
       bpt->Enable();
@@ skipping 27 matching lines @@
       new ActivationFrame(pc, frame->fp(), frame->sp(), code,
                           deopt_frame, deopt_frame_offset);
 
   // Is there a closure call at the current PC?
   //
   // We can't just check the callee_activation to see if it is a
   // closure function, because it may not be on the stack yet.
   bool is_closure_call = false;
   const PcDescriptors& pc_desc =
       PcDescriptors::Handle(isolate, code.pc_descriptors());
-  PcDescriptors::Iterator iter(pc_desc);
+  PcDescriptors::Iterator iter(pc_desc, RawPcDescriptors::kClosureCall);
   while (iter.HasNext()) {
     const RawPcDescriptors::PcDescriptorRec& rec = iter.Next();
-    if ((rec.pc == pc) && (rec.kind() == RawPcDescriptors::kClosureCall)) {
+    if (rec.pc == pc) {
       is_closure_call = true;
       break;
     }
   }
 
   // Recover the context for this frame.
   if (is_closure_call) {
     // If the callee is a closure, we should have stored the context
     // in the current frame before making the call.
     const Context& closure_call_ctx =
@@ skipping 275 matching lines @@
 
   Code& code = Code::Handle(func.unoptimized_code());
   ASSERT(!code.IsNull());
   PcDescriptors& desc = PcDescriptors::Handle(code.pc_descriptors());
   intptr_t best_fit_pos = INT_MAX;
   const RawPcDescriptors::PcDescriptorRec* best_fit_rec = NULL;
   uword lowest_pc = kUwordMax;
   const RawPcDescriptors::PcDescriptorRec* lowest_pc_rec = NULL;
 
   const RawPcDescriptors::PcDescriptorRec* rec = NULL;
-  PcDescriptors::Iterator iter(desc);
+  PcDescriptors::Iterator iter(desc, kSafepointKind);
   while (iter.HasNext()) {
     rec = &iter.Next();
     intptr_t desc_token_pos = rec->token_pos;
     ASSERT(desc_token_pos >= 0);
-    if (IsSafePoint(*rec)) {
+    if (HasTokenPos(*rec)) {
       if ((desc_token_pos < requested_token_pos) ||
           (desc_token_pos > last_token_pos)) {
         // This descriptor is outside the desired token range.
         continue;
       }
       if (desc_token_pos < best_fit_pos) {
         // So far, this descriptor has the lowest token position after
         // the first acceptable token position.
         best_fit_pos = desc_token_pos;
         best_fit_rec = rec;
@@ skipping 27 matching lines @@
 void Debugger::MakeCodeBreakpointAt(const Function& func,
                                     SourceBreakpoint* bpt) {
   ASSERT((bpt != NULL) && bpt->IsResolved());
   ASSERT(!func.HasOptimizedCode());
   Code& code = Code::Handle(func.unoptimized_code());
   ASSERT(!code.IsNull());
   PcDescriptors& desc = PcDescriptors::Handle(code.pc_descriptors());
   uword lowest_pc = kUwordMax;
   // Find the safe point with the lowest compiled code address
   // that maps to the token position of the source breakpoint.
-  PcDescriptors::Iterator iter(desc);
+  PcDescriptors::Iterator iter(desc, kSafepointKind);
   const RawPcDescriptors::PcDescriptorRec* lowest_rec = NULL;
   while (iter.HasNext()) {
     const RawPcDescriptors::PcDescriptorRec& rec = iter.Next();
     intptr_t desc_token_pos = rec.token_pos;
-    if ((desc_token_pos == bpt->token_pos_) && IsSafePoint(rec)) {
+    if ((desc_token_pos == bpt->token_pos_) && HasTokenPos(rec)) {
       if (rec.pc < lowest_pc) {
         lowest_pc = rec.pc;
         lowest_rec = &rec;
       }
     }
   }
   if (lowest_rec == NULL) {
     return;
   }
   CodeBreakpoint* code_bpt = GetCodeBreakpoint(lowest_rec->pc);
@@ skipping 954 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart