Allow the debugger to inspect local variables from optimized and

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"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
+#include "vm/deopt_instructions.h"
 #include "vm/flags.h"
 #include "vm/globals.h"
 #include "vm/longjump.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/os.h"
 #include "vm/port.h"
 #include "vm/stack_frame.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 #include "vm/visitor.h"
 
 
 namespace dart {
 
 DEFINE_FLAG(bool, verbose_debug, false, "Verbose debugger messages");
+DEFINE_FLAG(bool, use_new_stacktrace, true,
+            "Use new stacktrace creation");
 
 
 Debugger::EventHandler* Debugger::event_handler_ = NULL;
 
 
 class RemoteObjectCache : public ZoneAllocated {
  public:
   explicit RemoteObjectCache(intptr_t initial_size);
   intptr_t AddObject(const Object& obj);
   RawObject* GetObj(intptr_t obj_id) const;
@@ skipping 87 matching lines @@
 
 ActivationFrame::ActivationFrame(uword pc, uword fp, uword sp, const Code& code)
     : pc_(pc), fp_(fp), sp_(sp),
       ctx_(Context::ZoneHandle()),
       code_(Code::ZoneHandle(code.raw())),
       function_(Function::ZoneHandle(code.function())),
       token_pos_(-1),
       pc_desc_index_(-1),
       line_number_(-1),
       context_level_(-1),
+      deopt_frame_(Array::ZoneHandle()),
+      deopt_frame_offset_(0),
       vars_initialized_(false),
       var_descriptors_(LocalVarDescriptors::ZoneHandle()),
       desc_indices_(8),
       pc_desc_(PcDescriptors::ZoneHandle()) {
 }
 
 
 void Debugger::SignalIsolateEvent(EventType type) {
   if (event_handler_ != NULL) {
     Debugger* debugger = Isolate::Current()->debugger();
@@ skipping 92 matching lines @@
     pc_desc_ = code().pc_descriptors();
     ASSERT(!pc_desc_.IsNull());
   }
 }
 
 
 // Compute token_pos_ and pc_desc_index_.
 intptr_t ActivationFrame::TokenPos() {
   if (token_pos_ < 0) {
     GetPcDescriptors();
-    for (int i = 0; i < pc_desc_.Length(); i++) {
+    for (intptr_t i = 0; i < pc_desc_.Length(); i++) {
       if (pc_desc_.PC(i) == pc_) {
         pc_desc_index_ = i;
         token_pos_ = pc_desc_.TokenPos(i);
         break;
       }
     }
   }
   return token_pos_;
 }
 
@@ skipping 55 matching lines @@
     if (pc_desc_.DescriptorKind(pc_desc_idx) == PcDescriptors::kReturn) {
       // Special case: the context chain has already been deallocated.
       // The context level is 0.
       return context_level_;
     }
     intptr_t innermost_begin_pos = 0;
     intptr_t activation_token_pos = TokenPos();
     ASSERT(activation_token_pos >= 0);
     GetVarDescriptors();
     intptr_t var_desc_len = var_descriptors_.Length();
-    for (int cur_idx = 0; cur_idx < var_desc_len; cur_idx++) {
+    for (intptr_t cur_idx = 0; cur_idx < var_desc_len; cur_idx++) {
       RawLocalVarDescriptors::VarInfo var_info;
       var_descriptors_.GetInfo(cur_idx, &var_info);
       if ((var_info.kind == RawLocalVarDescriptors::kContextLevel) &&
           (var_info.begin_pos <= activation_token_pos) &&
           (activation_token_pos < var_info.end_pos)) {
         // This var_descriptors_ entry is a context scope which is in scope
         // of the current token position. Now check whether it is shadowing
         // the previous context scope.
         if (innermost_begin_pos < var_info.begin_pos) {
           innermost_begin_pos = var_info.begin_pos;
           context_level_ = var_info.index;
         }
       }
     }
     ASSERT(context_level_ >= 0);
   }
   return context_level_;
 }
 
 
 // Get the caller's context, or return ctx if the function does not
 // save the caller's context on entry.
 RawContext* ActivationFrame::GetSavedEntryContext(const Context& ctx) {
   GetVarDescriptors();
   intptr_t var_desc_len = var_descriptors_.Length();
-  for (int i = 0; i < var_desc_len; i++) {
+  for (intptr_t i = 0; i < var_desc_len; i++) {
     RawLocalVarDescriptors::VarInfo var_info;
     var_descriptors_.GetInfo(i, &var_info);
     if (var_info.kind == RawLocalVarDescriptors::kSavedEntryContext) {
-      return reinterpret_cast<RawContext*>(GetLocalVarValue(var_info.index));
+      return GetLocalContextVar(var_info.index);
     }
   }
   return ctx.raw();
 }
 
 
+RawContext* ActivationFrame::GetSavedEntryContextNew() {
+  if (ctx_.IsNull()) {
+    // We have bailed on providing a context for this frame.  Bail for
+    // the caller as well.
+    return Context::null();
+  }
+
+  // Attempt to find a saved context.
+  GetVarDescriptors();
+  intptr_t var_desc_len = var_descriptors_.Length();
+  for (intptr_t i = 0; i < var_desc_len; i++) {
+    RawLocalVarDescriptors::VarInfo var_info;
+    var_descriptors_.GetInfo(i, &var_info);
+    if (var_info.kind == RawLocalVarDescriptors::kSavedEntryContext) {
+      return GetLocalContextVar(var_info.index);
+    }
+  }
+
+  // No saved context.  Return the current context.
+  return ctx_.raw();
+}
+
+
 // Get the saved context if the callee of this activation frame is a
 // closure function.
 RawContext* ActivationFrame::GetSavedCurrentContext() {
   GetVarDescriptors();
   intptr_t var_desc_len = var_descriptors_.Length();
-  for (int i = 0; i < var_desc_len; i++) {
+  for (intptr_t i = 0; i < var_desc_len; i++) {
     RawLocalVarDescriptors::VarInfo var_info;
     var_descriptors_.GetInfo(i, &var_info);
     if (var_info.kind == RawLocalVarDescriptors::kSavedCurrentContext) {
-      return reinterpret_cast<RawContext*>(GetLocalVarValue(var_info.index));
+      return GetLocalContextVar(var_info.index);
     }
   }
   return Context::null();
 }
 
 
 ActivationFrame* DebuggerStackTrace::GetHandlerFrame(
     const Instance& exc_obj) const {
   ExceptionHandlers& handlers = ExceptionHandlers::Handle();
   Array& handled_types = Array::Handle();
   AbstractType& type = Type::Handle();
   const TypeArguments& no_instantiator = TypeArguments::Handle();
-  for (int frame_index = 0; frame_index < UnfilteredLength(); frame_index++) {
+  for (intptr_t frame_index = 0;
+       frame_index < UnfilteredLength();
+       frame_index++) {
     ActivationFrame* frame = UnfilteredFrameAt(frame_index);
     intptr_t try_index = frame->TryIndex();
     if (try_index < 0) continue;
     handlers = frame->code().exception_handlers();
     ASSERT(!handlers.IsNull());
     intptr_t num_handlers_checked = 0;
     while (try_index >= 0) {
       // Detect circles in the exception handler data.
       num_handlers_checked++;
       ASSERT(num_handlers_checked <= handlers.Length());
       handled_types = handlers.GetHandledTypes(try_index);
       const intptr_t num_types = handled_types.Length();
-      for (int k = 0; k < num_types; k++) {
+      for (intptr_t k = 0; k < num_types; k++) {
         type ^= handled_types.At(k);
         ASSERT(!type.IsNull());
         // Uninstantiated types are not added to ExceptionHandlers data.
         ASSERT(type.IsInstantiated());
         if (type.IsDynamicType()) return frame;
         if (type.IsMalformed()) continue;
         if (exc_obj.IsInstanceOf(type, no_instantiator, NULL)) {
           return frame;
         }
       }
       try_index = handlers.OuterTryIndex(try_index);
     }
   }
   return NULL;
 }
 
 
 void ActivationFrame::GetDescIndices() {
   if (vars_initialized_) {
     return;
   }
   GetVarDescriptors();
 
   // We don't trust variable descriptors in optimized code.
   // Rather than potentially displaying incorrect values, we
   // pretend that there are no variables in the frame.
   // We should be more clever about this in the future.
-  if (code().is_optimized()) {
+  if (!FLAG_use_new_stacktrace && code().is_optimized()) {
     vars_initialized_ = true;
     return;
   }
 
   intptr_t activation_token_pos = TokenPos();
   if (activation_token_pos < 0) {
     // We don't have a token position for this frame, so can't determine
     // which variables are visible.
     vars_initialized_ = true;
     return;
   }
 
   GrowableArray<String*> var_names(8);
   intptr_t var_desc_len = var_descriptors_.Length();
-  for (int cur_idx = 0; cur_idx < var_desc_len; cur_idx++) {
+  for (intptr_t cur_idx = 0; cur_idx < var_desc_len; cur_idx++) {
     ASSERT(var_names.length() == desc_indices_.length());
     RawLocalVarDescriptors::VarInfo var_info;
     var_descriptors_.GetInfo(cur_idx, &var_info);
     if ((var_info.kind != RawLocalVarDescriptors::kStackVar) &&
         (var_info.kind != RawLocalVarDescriptors::kContextVar)) {
       continue;
     }
     if ((var_info.begin_pos <= activation_token_pos) &&
         (activation_token_pos <= var_info.end_pos)) {
       if ((var_info.kind == RawLocalVarDescriptors::kContextVar) &&
           (ContextLevel() < var_info.scope_id)) {
         // The variable is textually in scope but the context level
         // at the activation frame's PC is lower than the context
         // level of the variable. The context containing the variable
         // has already been removed from the chain. This can happen when we
         // break at a return statement, since the contexts get discarded
         // before the debugger gets called.
         continue;
       }
       // The current variable is textually in scope. Now check whether
       // there is another local variable with the same name that shadows
       // or is shadowed by this variable.
       String& var_name = String::Handle(var_descriptors_.GetName(cur_idx));
       intptr_t indices_len = desc_indices_.length();
       bool name_match_found = false;
-      for (int i = 0; i < indices_len; i++) {
+      for (intptr_t i = 0; i < indices_len; i++) {
         if (var_name.Equals(*var_names[i])) {
           // Found two local variables with the same name. Now determine
           // which one is shadowed.
           name_match_found = true;
           RawLocalVarDescriptors::VarInfo i_var_info;
           var_descriptors_.GetInfo(desc_indices_[i], &i_var_info);
           if (i_var_info.begin_pos < var_info.begin_pos) {
             // The variable we found earlier is in an outer scope
             // and is shadowed by the current variable. Replace the
             // descriptor index of the previously found variable
@@ skipping 17 matching lines @@
   }
   vars_initialized_ = true;
 }
 
 
 intptr_t ActivationFrame::NumLocalVariables() {
   GetDescIndices();
   return desc_indices_.length();
 }
 
+// TODO(hausner): Handle captured variables.
+RawObject* ActivationFrame::GetLocalVar(intptr_t slot_index) {
+  if (deopt_frame_.IsNull()) {
+    uword var_address = fp() + slot_index * kWordSize;
+    return reinterpret_cast<RawObject*>(
+        *reinterpret_cast<uword*>(var_address));
+  } else {
+    return deopt_frame_.At(deopt_frame_offset_ + slot_index);
+  }
+}
+
+
+RawInstance* ActivationFrame::GetLocalInstanceVar(intptr_t slot_index) {
+  Instance& instance = Instance::Handle();
+  instance ^= GetLocalVar(slot_index);
+  return instance.raw();
+}
+
+
+RawContext* ActivationFrame::GetLocalContextVar(intptr_t slot_index) {
+  Context& context = Context::Handle();
+  context ^= GetLocalVar(slot_index);
+  return context.raw();
+}
+
 
 void ActivationFrame::VariableAt(intptr_t i,
                                  String* name,
                                  intptr_t* token_pos,
                                  intptr_t* end_pos,
                                  Instance* value) {
   GetDescIndices();
   ASSERT(i < desc_indices_.length());
   intptr_t desc_index = desc_indices_[i];
   ASSERT(name != NULL);
   *name ^= var_descriptors_.GetName(desc_index);
   RawLocalVarDescriptors::VarInfo var_info;
   var_descriptors_.GetInfo(desc_index, &var_info);
   ASSERT(token_pos != NULL);
   *token_pos = var_info.begin_pos;
   ASSERT(end_pos != NULL);
   *end_pos = var_info.end_pos;
   ASSERT(value != NULL);
   if (var_info.kind == RawLocalVarDescriptors::kStackVar) {
-    *value = GetLocalVarValue(var_info.index);
+    *value = GetLocalInstanceVar(var_info.index);
   } else {
     ASSERT(var_info.kind == RawLocalVarDescriptors::kContextVar);
     // The context level at the PC/token index of this activation frame.
     intptr_t frame_ctx_level = ContextLevel();
     if (ctx_.IsNull()) {
       *value = Symbols::New("<unknown>");
       return;
     }
     // The context level of the variable.
     intptr_t var_ctx_level = var_info.scope_id;
@@ skipping 26 matching lines @@
   }
 }
 
 
 RawArray* ActivationFrame::GetLocalVariables() {
   GetDescIndices();
   intptr_t num_variables = desc_indices_.length();
   String& var_name = String::Handle();
   Instance& value = Instance::Handle();
   const Array& list = Array::Handle(Array::New(2 * num_variables));
-  for (int i = 0; i < num_variables; i++) {
+  for (intptr_t i = 0; i < num_variables; i++) {
     intptr_t ignore;
     VariableAt(i, &var_name, &ignore, &ignore, &value);
     list.SetAt(2 * i, var_name);
     list.SetAt((2 * i) + 1, value);
   }
   return list.raw();
 }
 
 
 const char* ActivationFrame::ToCString() {
@@ skipping 175 matching lines @@
 
 
 RemoteObjectCache::RemoteObjectCache(intptr_t initial_size) {
   objs_ = &GrowableObjectArray::ZoneHandle(
               GrowableObjectArray::New(initial_size));
 }
 
 
 intptr_t RemoteObjectCache::AddObject(const Object& obj) {
   intptr_t len = objs_->Length();
-  for (int i = 0; i < len; i++) {
+  for (intptr_t i = 0; i < len; i++) {
     if (objs_->At(i) == obj.raw()) {
       return i;
     }
   }
   objs_->Add(obj);
   return len;
 }
 
 
 RawObject* RemoteObjectCache::GetObj(intptr_t obj_id) const {
@@ skipping 135 matching lines @@
     // adding breakpoints to target.
     if (!target_function.HasCode()) {
       return;
     }
   }
   DeoptimizeWorld();
   ASSERT(!target_function.HasOptimizedCode());
   Code& code = Code::Handle(target_function.unoptimized_code());
   ASSERT(!code.IsNull());
   PcDescriptors& desc = PcDescriptors::Handle(code.pc_descriptors());
-  for (int i = 0; i < desc.Length(); i++) {
+  for (intptr_t i = 0; i < desc.Length(); i++) {
     CodeBreakpoint* bpt = GetCodeBreakpoint(desc.PC(i));
     if (bpt != NULL) {
       // There is already a breakpoint for this address. Make sure
       // it is enabled.
       bpt->Enable();
       continue;
     }
     if (IsSafePoint(desc.DescriptorKind(i))) {
       bpt = new CodeBreakpoint(target_function, i);
       RegisterCodeBreakpoint(bpt);
       bpt->Enable();
     }
   }
 }
 
 
 void Debugger::SignalBpResolved(SourceBreakpoint* bpt) {
   if (event_handler_ != NULL) {
     DebuggerEvent event;
     event.type = kBreakpointResolved;
     event.breakpoint = bpt;
     (*event_handler_)(&event);
   }
 }
 
 
+static void PrintStackTraceError(const char* message,
+                                 ActivationFrame* current_activation,
+                                 ActivationFrame* callee_activation) {
+  const Function& current = current_activation->function();
+  const Function& callee = callee_activation->function();
+  const Script& script =
+      Script::Handle(Class::Handle(current.Owner()).script());
+  intptr_t line, col;
+  script.GetTokenLocation(current_activation->TokenPos(), &line, &col);
+  OS::PrintErr("Error building stack trace: %s:"
+               "current function '%s' callee_function '%s' "
+               " line %" Pd " column %" Pd "\n",
+               message,
+               current.ToFullyQualifiedCString(),
+               callee.ToFullyQualifiedCString(),
+               line, col);
+}
+
+
+ActivationFrame* Debugger::CollectDartFrame(Isolate* isolate,
+                                            uword pc,
+                                            StackFrame* frame,
+                                            const Code& code,
+                                            bool optimized,
+                                            ActivationFrame* callee_activation,
+                                            const Context& entry_ctx) {
+  // We never provide both a callee activation and an entry context.
+  ASSERT((callee_activation == NULL) || entry_ctx.IsNull());
+  ActivationFrame* activation =
+      new ActivationFrame(pc, frame->fp(), frame->sp(), code);
+
+  // Recover the context for this frame.
+  if (optimized) {
+    // Bail out for optimized frames for now.
+    activation->SetContext(Context::Handle(isolate));
+
+  } else if (callee_activation == NULL) {
+    // No callee.  Use incoming entry context.  Could be from
+    // isolate's top context or from an entry frame.
+    activation->SetContext(entry_ctx);
+
+  } else if (callee_activation->function().IsClosureFunction()) {
+    // 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 =
+        Context::Handle(isolate, activation->GetSavedCurrentContext());
+    activation->SetContext(closure_call_ctx);
+
+    // Sometimes there is no saved context. This is a bug.
+    // https://code.google.com/p/dart/issues/detail?id=12767
+    if (FLAG_verbose_debug && closure_call_ctx.IsNull()) {
+      PrintStackTraceError(
+          "Expected to find saved context for call to closure function",
+          activation, callee_activation);
+    }
+
+  } else {
+    // Use the context provided by our callee.  This is either the
+    // callee's context or a context that was saved in the callee's
+    // frame.
+    const Context& callee_ctx =
+        Context::Handle(isolate, callee_activation->GetSavedEntryContextNew());
+    activation->SetContext(callee_ctx);
+  }
+  return activation;
+}
+
+
+RawArray* Debugger::DeoptimizeToArray(Isolate* isolate,
+                                      StackFrame* frame,
+                                      const Code& code) {
+  ASSERT(code.is_optimized());
+
+  // Create the DeoptContext for this deoptimization.
+  DeoptContext* deopt_context =
+      new DeoptContext(frame, code,
+                       DeoptContext::kDestIsAllocated,
+                       NULL, NULL);
+  isolate->set_deopt_context(deopt_context);
+
+  deopt_context->FillDestFrame();
+  deopt_context->MaterializeDeferredObjects();
+  const Array& dest_frame = Array::Handle(deopt_context->DestFrameAsArray());
+
+  isolate->set_deopt_context(NULL);
+  delete deopt_context;
+
+  return dest_frame.raw();
+}
+
+
+DebuggerStackTrace* Debugger::CollectStackTraceNew() {
+  Isolate* isolate = Isolate::Current();
+  DebuggerStackTrace* stack_trace = new DebuggerStackTrace(8);
+  StackFrameIterator iterator(false);
+  ActivationFrame* current_activation = NULL;
+  Context& entry_ctx = Context::Handle(isolate->top_context());
+  Code& code = Code::Handle(isolate);
+  Code& inlined_code = Code::Handle(isolate);
+  Array& deopt_frame = Array::Handle(isolate);
+
+  for (StackFrame* frame = iterator.NextFrame();
+       frame != NULL;
+       frame = iterator.NextFrame()) {
+    ASSERT(frame->IsValid());
+    if (frame->IsEntryFrame()) {
+      current_activation = NULL;
+      entry_ctx = reinterpret_cast<EntryFrame*>(frame)->SavedContext();
+
+    } else if (frame->IsDartFrame()) {
+      code = frame->LookupDartCode();
+      if (code.is_optimized()) {
+        deopt_frame = DeoptimizeToArray(isolate, frame, code);
+        for (InlinedFunctionsIterator it(code, frame->pc());
+             !it.Done();
+             it.Advance()) {
+          inlined_code = it.code();
+          intptr_t deopt_frame_offset = it.GetDeoptFpOffset();
+          current_activation = CollectDartFrame(isolate,
+                                                it.pc(),
+                                                frame,
+                                                inlined_code,
+                                                true,
+                                                current_activation,
+                                                entry_ctx);
+          current_activation->SetDeoptFrame(deopt_frame, deopt_frame_offset);
+          stack_trace->AddActivation(current_activation);
+          entry_ctx = Context::null();  // Only use entry context once.
+        }
+      } else {
+        current_activation = CollectDartFrame(isolate,
+                                              frame->pc(),
+                                              frame,
+                                              code,
+                                              false,
+                                              current_activation,
+                                              entry_ctx);
+        stack_trace->AddActivation(current_activation);
+        entry_ctx = Context::null();  // Only use entry context once.
+      }
+    }
+  }
+  return stack_trace;
+}
+
+
+
 DebuggerStackTrace* Debugger::CollectStackTrace() {
+  if (FLAG_use_new_stacktrace) {
+    // Guard new stack trace generation under a flag in case there are
+    // problems rolling it out.
+    return CollectStackTraceNew();
+  }
   Isolate* isolate = Isolate::Current();
   DebuggerStackTrace* stack_trace = new DebuggerStackTrace(8);
   Context& ctx = Context::Handle(isolate->top_context());
   Code& code = Code::Handle(isolate);
   StackFrameIterator iterator(false);
   ActivationFrame* callee_activation = NULL;
   bool optimized_frame_found = false;
   for (StackFrame* frame = iterator.NextFrame();
        frame != NULL;
        frame = iterator.NextFrame()) {
@@ skipping 137 matching lines @@
                                         intptr_t last_token_pos) {
   ASSERT(func.HasCode());
   ASSERT(!func.HasOptimizedCode());
   Code& code = Code::Handle(func.unoptimized_code());
   ASSERT(!code.IsNull());
   PcDescriptors& desc = PcDescriptors::Handle(code.pc_descriptors());
   intptr_t best_fit_index = -1;
   intptr_t best_fit = INT_MAX;
   uword lowest_pc = kUwordMax;
   intptr_t lowest_pc_index = -1;
-  for (int i = 0; i < desc.Length(); i++) {
+  for (intptr_t i = 0; i < desc.Length(); i++) {
     intptr_t desc_token_pos = desc.TokenPos(i);
     ASSERT(desc_token_pos >= 0);
     if (desc_token_pos < first_token_pos) {
       // This descriptor is before the given range.
       continue;
     }
     if (IsSafePoint(desc.DescriptorKind(i))) {
       if ((desc_token_pos - first_token_pos) < best_fit) {
         // So far, this descriptor has the closest token position to the
         // beginning of the range.
@@ skipping 25 matching lines @@
 }
 
 
 void Debugger::MakeCodeBreakpointsAt(const Function& func,
                                      intptr_t token_pos,
                                      SourceBreakpoint* bpt) {
   ASSERT(!func.HasOptimizedCode());
   Code& code = Code::Handle(func.unoptimized_code());
   ASSERT(!code.IsNull());
   PcDescriptors& desc = PcDescriptors::Handle(code.pc_descriptors());
-  for (int i = 0; i < desc.Length(); i++) {
+  for (intptr_t i = 0; i < desc.Length(); i++) {
     intptr_t desc_token_pos = desc.TokenPos(i);
     if ((desc_token_pos == token_pos) && IsSafePoint(desc.DescriptorKind(i))) {
       CodeBreakpoint* code_bpt = GetCodeBreakpoint(desc.PC(i));
       if (code_bpt == NULL) {
         // No code breakpoint for this code exists; create one.
         code_bpt = new CodeBreakpoint(func, i);
         RegisterCodeBreakpoint(code_bpt);
       }
       code_bpt->set_src_bpt(bpt);
     }
@@ skipping 106 matching lines @@
                        target_function.end_token_pos());
 }
 
 
 SourceBreakpoint* Debugger::SetBreakpointAtLine(const String& script_url,
                                           intptr_t line_number) {
   Library& lib = Library::Handle(isolate_);
   Script& script = Script::Handle(isolate_);
   const GrowableObjectArray& libs =
       GrowableObjectArray::Handle(isolate_->object_store()->libraries());
-  for (int i = 0; i < libs.Length(); i++) {
+  for (intptr_t i = 0; i < libs.Length(); i++) {
     lib ^= libs.At(i);
     script = lib.LookupScript(script_url);
     if (!script.IsNull()) {
       break;
     }
   }
   if (script.IsNull()) {
     if (FLAG_verbose_debug) {
       OS::Print("Failed to find script with url '%s'\n",
                 script_url.ToCString());
@@ skipping 126 matching lines @@
   Class& cls = Class::Handle(obj.clazz());
   Array& fields = Array::Handle();
   Field& field = Field::Handle();
   const GrowableObjectArray& field_list =
       GrowableObjectArray::Handle(GrowableObjectArray::New(8));
   String& field_name = String::Handle();
   Object& field_value = Object::Handle();
   // Iterate over fields in class hierarchy to count all instance fields.
   while (!cls.IsNull()) {
     fields = cls.fields();
-    for (int i = 0; i < fields.Length(); i++) {
+    for (intptr_t i = 0; i < fields.Length(); i++) {
       field ^= fields.At(i);
       if (!field.is_static()) {
         field_name = field.name();
         field_list.Add(field_name);
         field_value = GetInstanceField(cls, field_name, obj);
         field_list.Add(field_value);
       }
     }
     cls = cls.SuperClass();
   }
   return Array::MakeArray(field_list);
 }
 
 
 RawArray* Debugger::GetStaticFields(const Class& cls) {
   const GrowableObjectArray& field_list =
       GrowableObjectArray::Handle(GrowableObjectArray::New(8));
   Array& fields = Array::Handle(cls.fields());
   Field& field = Field::Handle();
   String& field_name = String::Handle();
   Object& field_value = Object::Handle();
-  for (int i = 0; i < fields.Length(); i++) {
+  for (intptr_t i = 0; i < fields.Length(); i++) {
     field ^= fields.At(i);
     if (field.is_static()) {
       field_name = field.name();
       field_value = GetStaticField(cls, field_name);
       field_list.Add(field_name);
       field_list.Add(field_value);
     }
   }
   return Array::MakeArray(field_list);
 }
@@ skipping 39 matching lines @@
 }
 
 
 RawArray* Debugger::GetGlobalFields(const Library& lib) {
   const GrowableObjectArray& field_list =
       GrowableObjectArray::Handle(GrowableObjectArray::New(8));
   String& prefix_name = String::Handle(isolate_);
   CollectLibraryFields(field_list, lib, prefix_name, true);
   Library& imported = Library::Handle(isolate_);
   intptr_t num_imports = lib.num_imports();
-  for (int i = 0; i < num_imports; i++) {
+  for (intptr_t i = 0; i < num_imports; i++) {
     imported = lib.ImportLibraryAt(i);
     ASSERT(!imported.IsNull());
     CollectLibraryFields(field_list, imported, prefix_name, false);
   }
   LibraryPrefix& prefix = LibraryPrefix::Handle(isolate_);
   LibraryPrefixIterator it(lib);
   while (it.HasNext()) {
     prefix = it.GetNext();
     prefix_name = prefix.name();
     ASSERT(!prefix_name.IsNull());
     prefix_name = String::Concat(prefix_name, Symbols::Dot());
-    for (int i = 0; i < prefix.num_imports(); i++) {
+    for (intptr_t i = 0; i < prefix.num_imports(); i++) {
       imported = prefix.GetLibrary(i);
       CollectLibraryFields(field_list, imported, prefix_name, false);
     }
   }
   return Array::MakeArray(field_list);
 }
 
 
 void Debugger::VisitObjectPointers(ObjectPointerVisitor* visitor) {
   ASSERT(visitor != NULL);
@@ skipping 346 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart