Remove isolate argument from handle allocation: Part I

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 292 matching lines @@
 
   if (FLAG_steal_breakpoints && event->IsPauseEvent()) {
     // We allow the embedder's default breakpoint handler to be overridden.
     isolate_->PauseEventHandler();
   } else if (event_handler_ != NULL) {
     (*event_handler_)(event);
   }
 
   if (ServiceNeedsDebuggerEvent(event->type()) && event->IsPauseEvent()) {
     // If we were paused, notify the service that we have resumed.
-    const Error& error =
-        Error::Handle(isolate_, isolate_->object_store()->sticky_error());
+    const Error& error = Error::Handle(zone(),
+        isolate_->object_store()->sticky_error());
     ASSERT(error.IsNull() || error.IsUnwindError());
 
     // Only send a resume event when the isolate is not unwinding.
     if (!error.IsUnwindError()) {
       ServiceEvent service_event(event->isolate(), ServiceEvent::kResume);
       service_event.set_top_frame(event->top_frame());
       Service::HandleEvent(&service_event);
     }
   }
 }
@@ skipping 33 matching lines @@
                   "\tisolate:    %s\n", isolate_->name());
       }
       const String& msg =
           String::Handle(String::New("isolate terminated by embedder"));
       return UnwindError::New(msg);
     }
   }
 
   // If any error occurred while in the debug message loop, return it here.
   const Error& error =
-      Error::Handle(isolate_, isolate_->object_store()->sticky_error());
+      Error::Handle(zone(), isolate_->object_store()->sticky_error());
   ASSERT(error.IsNull() || error.IsUnwindError());
   isolate_->object_store()->clear_sticky_error();
   return error.raw();
 }
 
 
 // The vm service handles breakpoint notifications in a different way
 // than the regular debugger breakpoint notifications.
 static void SendServiceBreakpointEvent(ServiceEvent::EventKind kind,
                                        Breakpoint* bpt) {
@@ skipping 88 matching lines @@
   return false;
 }
 
 
 bool Debugger::HasBreakpoint(const Function& func) {
   if (!func.HasCode()) {
     // If the function is not compiled yet, just check whether there
     // is a user-defined breakpoint that falls into the token
     // range of the function. This may be a false positive: the breakpoint
     // might be inside a local closure.
-    Script& script = Script::Handle(isolate_);
+    Script& script = Script::Handle(zone());
     BreakpointLocation* sbpt = breakpoint_locations_;
     while (sbpt != NULL) {
       script = sbpt->script();
       if (FunctionContains(func, script, sbpt->token_pos())) {
         return true;
       }
       sbpt = sbpt->next_;
     }
     return false;
   }
@@ skipping 937 matching lines @@
     const Context& ctx = activation->GetSavedCurrentContext();
     OS::PrintErr("\tUsing saved context: %s\n", ctx.ToCString());
   }
   if (FLAG_trace_debugger_stacktrace) {
     OS::PrintErr("\tLine number: %" Pd "\n", activation->LineNumber());
   }
   return activation;
 }
 
 
-RawArray* Debugger::DeoptimizeToArray(Isolate* isolate,
+RawArray* Debugger::DeoptimizeToArray(Thread* thread,
                                       StackFrame* frame,
                                       const Code& code) {
   ASSERT(code.is_optimized());
-
+  Isolate* isolate = thread->isolate();
   // Create the DeoptContext for this deoptimization.
   DeoptContext* deopt_context =
       new DeoptContext(frame, code,
                        DeoptContext::kDestIsAllocated,
                        NULL,
                        NULL,
                        true);
   isolate->set_deopt_context(deopt_context);
 
   deopt_context->FillDestFrame();
   deopt_context->MaterializeDeferredObjects();
-  const Array& dest_frame = Array::Handle(isolate,
+  const Array& dest_frame = Array::Handle(thread->zone(),
                                           deopt_context->DestFrameAsArray());
 
   isolate->set_deopt_context(NULL);
   delete deopt_context;
 
   return dest_frame.raw();
 }
 
 
 DebuggerStackTrace* Debugger::CollectStackTrace() {
-  Isolate* isolate = Isolate::Current();
+  Thread* thread = Thread::Current();
+  Zone* zone = thread->zone();
+  Isolate* isolate = thread->isolate();
   DebuggerStackTrace* stack_trace = new DebuggerStackTrace(8);
   StackFrameIterator iterator(false);
-  Code& code = Code::Handle(isolate);
-  Code& inlined_code = Code::Handle(isolate);
-  Array& deopt_frame = Array::Handle(isolate);
+  Code& code = Code::Handle(zone);
+  Code& inlined_code = Code::Handle(zone);
+  Array& deopt_frame = Array::Handle(zone);
 
   for (StackFrame* frame = iterator.NextFrame();
        frame != NULL;
        frame = iterator.NextFrame()) {
     ASSERT(frame->IsValid());
     if (FLAG_trace_debugger_stacktrace) {
       OS::PrintErr("CollectStackTrace: visiting frame:\n\t%s\n",
                    frame->ToCString());
     }
     if (frame->IsDartFrame()) {
       code = frame->LookupDartCode();
       if (code.is_optimized() && !Compiler::always_optimize()) {
-        deopt_frame = DeoptimizeToArray(isolate, frame, code);
+        deopt_frame = DeoptimizeToArray(thread, frame, code);
         for (InlinedFunctionsIterator it(code, frame->pc());
              !it.Done();
              it.Advance()) {
           inlined_code = it.code();
           if (FLAG_trace_debugger_stacktrace) {
             const Function& function =
-                Function::Handle(isolate, inlined_code.function());
+                Function::Handle(zone, inlined_code.function());
             ASSERT(!function.IsNull());
             OS::PrintErr("CollectStackTrace: visiting inlined function: %s\n",
                          function.ToFullyQualifiedCString());
           }
           intptr_t deopt_frame_offset = it.GetDeoptFpOffset();
           stack_trace->AddActivation(CollectDartFrame(isolate,
                                                       it.pc(),
                                                       frame,
                                                       inlined_code,
                                                       deopt_frame,
@@ skipping 12 matching lines @@
   return stack_trace;
 }
 
 
 ActivationFrame* Debugger::TopDartFrame() const {
   StackFrameIterator iterator(false);
   StackFrame* frame = iterator.NextFrame();
   while ((frame != NULL) && !frame->IsDartFrame()) {
     frame = iterator.NextFrame();
   }
-  Code& code = Code::Handle(isolate_, frame->LookupDartCode());
+  Code& code = Code::Handle(zone(), frame->LookupDartCode());
   ActivationFrame* activation =
       new ActivationFrame(frame->pc(), frame->fp(), frame->sp(), code,
                           Object::null_array(), 0);
   return activation;
 }
 
 
 DebuggerStackTrace* Debugger::StackTrace() {
   return (stack_trace_ != NULL) ? stack_trace_ : CollectStackTrace();
 }
@@ skipping 326 matching lines @@
   if (loc->AnyEnabled()) {
     code_bpt->Enable();
   }
 }
 
 
 void Debugger::FindCompiledFunctions(const Script& script,
                                      intptr_t start_pos,
                                      intptr_t end_pos,
                                      GrowableObjectArray* function_list) {
-  Class& cls = Class::Handle(isolate_);
-  Array& functions = Array::Handle(isolate_);
-  GrowableObjectArray& closures = GrowableObjectArray::Handle(isolate_);
-  Function& function = Function::Handle(isolate_);
+  Zone* zn = zone();
+  Class& cls = Class::Handle(zn);
+  Array& functions = Array::Handle(zn);
+  GrowableObjectArray& closures = GrowableObjectArray::Handle(zn);
+  Function& function = Function::Handle(zn);
 
   const ClassTable& class_table = *isolate_->class_table();
   const intptr_t num_classes = class_table.NumCids();
   for (intptr_t i = 1; i < num_classes; i++) {
     if (class_table.HasValidClassAt(i)) {
       cls = class_table.At(i);
       // If the class is not finalized, e.g. if it hasn't been parsed
       // yet entirely, we can ignore it. If it contains a function with
       // an unresolved breakpoint, we will detect it if and when the
       // function gets compiled.
@@ skipping 59 matching lines @@
     if ((func->token_pos() > best_fit->token_pos()) &&
         ((func->end_token_pos() <= best_fit->end_token_pos()))) {
       *best_fit = func->raw();
     }
   }
 }
 
 
 RawFunction* Debugger::FindBestFit(const Script& script,
                                    intptr_t token_pos) {
-  Class& cls = Class::Handle(isolate_);
-  Array& functions = Array::Handle(isolate_);
-  GrowableObjectArray& closures = GrowableObjectArray::Handle(isolate_);
-  Function& function = Function::Handle(isolate_);
-  Function& best_fit = Function::Handle(isolate_);
-  Error& error = Error::Handle(isolate_);
+  Zone* zn = zone();
+  Class& cls = Class::Handle(zn);
+  Array& functions = Array::Handle(zn);
+  GrowableObjectArray& closures = GrowableObjectArray::Handle(zn);
+  Function& function = Function::Handle(zn);
+  Function& best_fit = Function::Handle(zn);
+  Error& error = Error::Handle(zn);
 
   const ClassTable& class_table = *isolate_->class_table();
   const intptr_t num_classes = class_table.NumCids();
   for (intptr_t i = 1; i < num_classes; i++) {
     if (class_table.HasValidClassAt(i)) {
       cls = class_table.At(i);
       // Note: if this class has been parsed and finalized already,
       // we need to check the functions of this class even if
       // it is defined in a differenct 'script'. There could
       // be mixin functions from the given script in this class.
@@ skipping 38 matching lines @@
   }
   return best_fit.raw();
 }
 
 
 BreakpointLocation* Debugger::SetBreakpoint(const Script& script,
                                             intptr_t token_pos,
                                             intptr_t last_token_pos,
                                             intptr_t requested_line,
                                             intptr_t requested_column) {
-  Function& func = Function::Handle(isolate_);
+  Function& func = Function::Handle(zone());
   func = FindBestFit(script, token_pos);
   if (func.IsNull()) {
     return NULL;
   }
   // There may be more than one function object for a given function
   // in source code. There may be implicit closure functions, and
   // there may be copies of mixin functions. Collect all compiled
   // functions whose source code range matches exactly the best fit
   // function we found.
   GrowableObjectArray& functions =
@@ skipping 171 matching lines @@
     return loc->AddRepeated(this);
   }
   return NULL;
 }
 
 
 BreakpointLocation* Debugger::BreakpointLocationAtLineCol(
     const String& script_url,
     intptr_t line_number,
     intptr_t column_number) {
-  Library& lib = Library::Handle(isolate_);
-  Script& script = Script::Handle(isolate_);
+  Library& lib = Library::Handle(zone());
+  Script& script = Script::Handle(zone());
   const GrowableObjectArray& libs =
       GrowableObjectArray::Handle(isolate_->object_store()->libraries());
   const GrowableObjectArray& scripts =
-    GrowableObjectArray::Handle(isolate_, GrowableObjectArray::New());
+    GrowableObjectArray::Handle(zone(), GrowableObjectArray::New());
   for (intptr_t i = 0; i < libs.Length(); i++) {
     lib ^= libs.At(i);
     script = lib.LookupScript(script_url);
     if (!script.IsNull()) {
       scripts.Add(script);
     }
   }
   if (scripts.Length() == 0) {
     // No script found with given url. Create a latent breakpoint which
     // will be set if the url is loaded later.
@@ skipping 169 matching lines @@
   }
   return Array::MakeArray(field_list);
 }
 
 
 void Debugger::CollectLibraryFields(const GrowableObjectArray& field_list,
                                     const Library& lib,
                                     const String& prefix,
                                     bool include_private_fields) {
   DictionaryIterator it(lib);
-  Object& entry = Object::Handle(isolate_);
-  Field& field = Field::Handle(isolate_);
-  String& field_name = String::Handle(isolate_);
-  PassiveObject& field_value = PassiveObject::Handle(isolate_);
+  Object& entry = Object::Handle(isolate_->current_zone());
+  Field& field = Field::Handle(zone());
+  String& field_name = String::Handle(zone());
+  PassiveObject& field_value = PassiveObject::Handle(isolate_->current_zone());
   while (it.HasNext()) {
     entry = it.GetNext();
     if (entry.IsField()) {
       field ^= entry.raw();
       ASSERT(field.is_static());
       field_name = field.name();
       if ((field_name.CharAt(0) == '_') && !include_private_fields) {
         // Skip library-private field.
         continue;
       }
@@ skipping 12 matching lines @@
       field_list.Add(field_name);
       field_list.Add(field_value);
     }
   }
 }
 
 
 RawArray* Debugger::GetLibraryFields(const Library& lib) {
   const GrowableObjectArray& field_list =
       GrowableObjectArray::Handle(GrowableObjectArray::New(8));
-  CollectLibraryFields(field_list, lib, String::Handle(isolate_), true);
+  CollectLibraryFields(field_list, lib, String::Handle(zone()), true);
   return Array::MakeArray(field_list);
 }
 
 
 RawArray* Debugger::GetGlobalFields(const Library& lib) {
   const GrowableObjectArray& field_list =
       GrowableObjectArray::Handle(GrowableObjectArray::New(8));
-  String& prefix_name = String::Handle(isolate_);
+  String& prefix_name = String::Handle(zone());
   CollectLibraryFields(field_list, lib, prefix_name, true);
-  Library& imported = Library::Handle(isolate_);
+  Library& imported = Library::Handle(zone());
   intptr_t num_imports = lib.num_imports();
   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_);
+  LibraryPrefix& prefix = LibraryPrefix::Handle(zone());
   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 (int32_t i = 0; i < prefix.num_imports(); i++) {
       imported = prefix.GetLibrary(i);
       CollectLibraryFields(field_list, imported, prefix_name, false);
     }
@@ skipping 188 matching lines @@
   }
 
   ASSERT(stack_trace_ == NULL);
   stack_trace_ = CollectStackTrace();
   SignalPausedEvent(frame, NULL);
   HandleSteppingRequest(stack_trace_);
   stack_trace_ = NULL;
 
   // If any error occurred while in the debug message loop, return it here.
   const Error& error =
-      Error::Handle(isolate_, isolate_->object_store()->sticky_error());
+      Error::Handle(zone(), isolate_->object_store()->sticky_error());
   isolate_->object_store()->clear_sticky_error();
   return error.raw();
 }
 
 
 RawError* Debugger::SignalBpReached() {
   // We ignore this breakpoint when the VM is executing code invoked
   // by the debugger to evaluate variables values, or when we see a nested
   // breakpoint or exception event.
   if (ignore_breakpoints_ || IsPaused() || !HasEventHandler()) {
@@ skipping 68 matching lines @@
   stack_trace_ = stack_trace;
   SignalPausedEvent(top_frame, bpt_hit);
   HandleSteppingRequest(stack_trace_);
   stack_trace_ = NULL;
   if (cbpt->IsInternal()) {
     RemoveInternalBreakpoints();
   }
 
   // If any error occurred while in the debug message loop, return it here.
   const Error& error =
-      Error::Handle(isolate_, isolate_->object_store()->sticky_error());
+      Error::Handle(zone(), isolate_->object_store()->sticky_error());
   isolate_->object_store()->clear_sticky_error();
   return error.raw();
 }
 
 
 void Debugger::BreakHere(const String& msg) {
   // We ignore this breakpoint when the VM is executing code invoked
   // by the debugger to evaluate variables values, or when we see a nested
   // breakpoint or exception event.
   if (ignore_breakpoints_ || IsPaused() || !HasEventHandler()) {
@@ skipping 36 matching lines @@
   if (!ServiceIsolate::IsServiceIsolateDescendant(isolate_)) {
     SignalIsolateEvent(DebuggerEvent::kIsolateCreated);
   }
 }
 
 
 // Return innermost closure contained in 'function' that contains
 // the given token position.
 RawFunction* Debugger::FindInnermostClosure(const Function& function,
                                             intptr_t token_pos) {
-  const Class& owner = Class::Handle(isolate_, function.Owner());
+  const Class& owner = Class::Handle(zone(), function.Owner());
   if (owner.closures() == GrowableObjectArray::null()) {
     return Function::null();
   }
   // Note that we need to check that the closure is in the same
   // script as the outer function. We could have closures originating
   // in mixin classes whose source code is contained in a different
   // script.
-  const Script& outer_origin = Script::Handle(isolate_, function.script());
+  const Script& outer_origin = Script::Handle(zone(), function.script());
   const GrowableObjectArray& closures =
-     GrowableObjectArray::Handle(isolate_, owner.closures());
+     GrowableObjectArray::Handle(zone(), owner.closures());
   const intptr_t num_closures = closures.Length();
-  Function& closure = Function::Handle(isolate_);
-  Function& best_fit = Function::Handle(isolate_);
+  Function& closure = Function::Handle(zone());
+  Function& best_fit = Function::Handle(zone());
   for (intptr_t i = 0; i < num_closures; i++) {
     closure ^= closures.At(i);
     if ((function.token_pos() < closure.token_pos()) &&
         (closure.end_token_pos() < function.end_token_pos()) &&
         (closure.token_pos() <= token_pos) &&
         (token_pos <= closure.end_token_pos()) &&
         (closure.script() == outer_origin.raw())) {
       SelectBestFit(&best_fit, &closure);
     }
   }
   return best_fit.raw();
 }
 
 
 void Debugger::NotifyCompilation(const Function& func) {
   if (breakpoint_locations_ == NULL) {
     // Return with minimal overhead if there are no breakpoints.
     return;
   }
   if (!func.is_debuggable()) {
     // Nothing to do if the function is not debuggable. If there is
     // a pending breakpoint in an inner function (that is debuggable),
     // we'll resolve the breakpoint when the inner function is compiled.
     return;
   }
   // Iterate over all source breakpoints to check whether breakpoints
   // need to be set in the newly compiled function.
-  Script& script = Script::Handle(isolate_);
+  Script& script = Script::Handle(zone());
   for (BreakpointLocation* loc = breakpoint_locations_;
       loc != NULL;
       loc = loc->next()) {
     script = loc->script();
     if (FunctionContains(func, script, loc->token_pos())) {
-      Function& inner_function = Function::Handle(isolate_);
+      Function& inner_function = Function::Handle(zone());
       inner_function = FindInnermostClosure(func, loc->token_pos());
       if (!inner_function.IsNull()) {
         // The local function of a function we just compiled cannot
         // be compiled already.
         ASSERT(!inner_function.HasCode());
         if (FLAG_verbose_debug) {
           OS::Print("Pending BP remains unresolved in inner function '%s'\n",
                     inner_function.ToFullyQualifiedCString());
         }
         continue;
@@ skipping 60 matching lines @@
     }
   }
 }
 
 
 void Debugger::NotifyDoneLoading() {
   if (latent_locations_ == NULL) {
     // Common, fast path.
     return;
   }
-  Library& lib = Library::Handle(isolate_);
-  Script& script = Script::Handle(isolate_);
-  String& url = String::Handle(isolate_);
+  Zone* zn = zone();
+  Library& lib = Library::Handle(zn);
+  Script& script = Script::Handle(zn);
+  String& url = String::Handle(zn);
   BreakpointLocation* loc = latent_locations_;
   BreakpointLocation* prev_loc = NULL;
   const GrowableObjectArray& libs =
       GrowableObjectArray::Handle(isolate_->object_store()->libraries());
   while (loc != NULL) {
     url = loc->url();
     bool found_match = false;
     for (intptr_t i = 0; i < libs.Length(); i++) {
       lib ^= libs.At(i);
       script = lib.LookupScript(url);
@@ skipping 252 matching lines @@
     loc = loc->next();
   }
   return NULL;
 }
 
 
 BreakpointLocation* Debugger::GetLatentBreakpoint(const String& url,
                                                   intptr_t line,
                                                   intptr_t column) {
   BreakpointLocation* bpt = latent_locations_;
-  String& bpt_url = String::Handle(isolate_);
+  String& bpt_url = String::Handle(zone());
   while (bpt != NULL) {
     bpt_url = bpt->url();
     if (bpt_url.Equals(url) &&
         (bpt->requested_line_number() == line) &&
         (bpt->requested_column_number() == column)) {
       return bpt;
     }
     bpt = bpt->next();
   }
   // No breakpoint for this location requested. Allocate new one.
@@ skipping 11 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart