Pass around the current isolate in exception handling code.

runtime/vm/exceptions.cc

 // Copyright (c) 2011, 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/exceptions.h"
 
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
 #include "vm/flags.h"
@@ skipping 145 matching lines @@
       stacktrace_.SetPcOffsetAtFrame(prev, frame_offset);
     }
     cur_index_ = (Stacktrace::kPreallocatedStackdepth - 1);
   }
   stacktrace_.SetCodeAtFrame(cur_index_, code);
   stacktrace_.SetPcOffsetAtFrame(cur_index_, offset);
   cur_index_ += 1;
 }
 
 
-static void BuildStackTrace(StacktraceBuilder* builder) {
+static void BuildStackTrace(Isolate* isolate, StacktraceBuilder* builder) {
   StackFrameIterator frames(StackFrameIterator::kDontValidateFrames);
   StackFrame* frame = frames.NextFrame();
   ASSERT(frame != NULL);  // We expect to find a dart invocation frame.
   Code& code = Code::Handle();
   Smi& offset = Smi::Handle();
   bool dart_handler_found = false;
   bool handler_pc_set = false;
   while (frame != NULL) {
     while (!frame->IsEntryFrame()) {
       if (frame->IsDartFrame()) {
         code = frame->LookupDartCode();
         offset = Smi::New(frame->pc() - code.EntryPoint());
         builder->AddFrame(code, offset, dart_handler_found);
         bool needs_stacktrace = false;
         bool is_catch_all = false;
         uword handler_pc = kUwordMax;
         if (!handler_pc_set &&
-            frame->FindExceptionHandler(&handler_pc,
+            frame->FindExceptionHandler(isolate,
+                                        &handler_pc,
                                         &needs_stacktrace,
                                         &is_catch_all)) {
           handler_pc_set = true;
           dart_handler_found = true;
           if (!builder->FullStacktrace()) {
             return;
           }
         }
       }
       frame = frames.NextFrame();
       ASSERT(frame != NULL);
     }
     ASSERT(frame->IsEntryFrame());
     if (!handler_pc_set) {
       handler_pc_set = true;
       if (!builder->FullStacktrace()) {
         return;
       }
     }
     frame = frames.NextFrame();
   }
 }
 
 
 // Iterate through the stack frames and try to find a frame with an
 // exception handler. Once found, set the pc, sp and fp so that execution
 // can continue in that frame. Sets 'needs_stacktrace' if there is no
 // cath-all handler or if a stack-trace is specified in the catch.
-static bool FindExceptionHandler(uword* handler_pc,
+static bool FindExceptionHandler(Isolate* isolate,
+                                 uword* handler_pc,
                                  uword* handler_sp,
                                  uword* handler_fp,
                                  bool* needs_stacktrace) {
   StackFrameIterator frames(StackFrameIterator::kDontValidateFrames);
   StackFrame* frame = frames.NextFrame();
   ASSERT(frame != NULL);  // We expect to find a dart invocation frame.
   bool handler_pc_set = false;
   *needs_stacktrace = false;
   bool is_catch_all = false;
   uword temp_handler_pc = kUwordMax;
   while (!frame->IsEntryFrame()) {
     if (frame->IsDartFrame()) {
-      if (frame->FindExceptionHandler(&temp_handler_pc,
+      if (frame->FindExceptionHandler(isolate,
+                                      &temp_handler_pc,
                                       needs_stacktrace,
                                       &is_catch_all)) {
         if (!handler_pc_set) {
           handler_pc_set = true;
           *handler_pc = temp_handler_pc;
           *handler_sp = frame->sp();
           *handler_fp = frame->fp();
         }
         if (*needs_stacktrace || is_catch_all) {
           return true;
@@ skipping 26 matching lines @@
     frame = frames.NextFrame();
     ASSERT(frame != NULL);
   }
   ASSERT(frame->IsEntryFrame());
   *handler_pc = frame->pc();
   *handler_sp = frame->sp();
   *handler_fp = frame->fp();
 }
 
 
-static void JumpToExceptionHandler(uword program_counter,
+static void JumpToExceptionHandler(Isolate* isolate,
+                                   uword program_counter,
                                    uword stack_pointer,
                                    uword frame_pointer,
                                    const Object& exception_object,
                                    const Object& stacktrace_object) {
   // The no_gc StackResource is unwound through the tear down of
   // stack resources below.
   NoGCScope no_gc;
   RawObject* raw_exception = exception_object.raw();
   RawObject* raw_stacktrace = stacktrace_object.raw();
-  Isolate* isolate = Isolate::Current();
 
 #if defined(USING_SIMULATOR)
   // Unwinding of the C++ frames and destroying of their stack resources is done
   // by the simulator, because the target stack_pointer is a simulated stack
   // pointer and not the C++ stack pointer.
 
   // Continue simulating at the given pc in the given frame after setting up the
   // exception object in the kExceptionObjectReg register and the stacktrace
   // object (may be raw null) in the kStackTraceObjectReg register.
   isolate->set_vm_tag(VMTag::kScriptTagId);
@@ skipping 55 matching lines @@
     test_class = type.type_class();
   }
   UNREACHABLE();
   return Field::null();
 }
 
 
 RawStacktrace* Exceptions::CurrentStacktrace() {
   Isolate* isolate = Isolate::Current();
   RegularStacktraceBuilder frame_builder(true);
-  BuildStackTrace(&frame_builder);
+  BuildStackTrace(isolate, &frame_builder);
 
   // Create arrays for code and pc_offset tuples of each frame.
   const Array& full_code_array = Array::Handle(isolate,
       Array::MakeArray(frame_builder.code_list()));
   const Array& full_pc_offset_array = Array::Handle(isolate,
       Array::MakeArray(frame_builder.pc_offset_list()));
   const Array& full_catch_code_array = Array::Handle(isolate,
       Array::MakeArray(frame_builder.catch_code_list()));
   const Array& full_catch_pc_offset_array = Array::Handle(isolate,
       Array::MakeArray(frame_builder.catch_pc_offset_list()));
   const Stacktrace& full_stacktrace = Stacktrace::Handle(
       Stacktrace::New(full_code_array, full_pc_offset_array));
   full_stacktrace.SetCatchStacktrace(full_catch_code_array,
                                      full_catch_pc_offset_array);
   return full_stacktrace.raw();
 }
 
 
-static void ThrowExceptionHelper(const Instance& incoming_exception,
+static void ThrowExceptionHelper(Isolate* isolate,
+                                 const Instance& incoming_exception,
                                  const Instance& existing_stacktrace) {
   bool use_preallocated_stacktrace = false;
-  Isolate* isolate = Isolate::Current();
   Instance& exception = Instance::Handle(isolate, incoming_exception.raw());
   if (exception.IsNull()) {
     exception ^= Exceptions::Create(Exceptions::kNullThrown,
                                     Object::empty_array());
   } else if (exception.raw() == isolate->object_store()->out_of_memory() ||
              exception.raw() == isolate->object_store()->stack_overflow()) {
     use_preallocated_stacktrace = true;
   }
   uword handler_pc = 0;
   uword handler_sp = 0;
   uword handler_fp = 0;
   Stacktrace& stacktrace = Stacktrace::Handle(isolate);
   bool handler_exists = false;
   bool handler_needs_stacktrace = false;
   if (use_preallocated_stacktrace) {
     stacktrace ^= isolate->object_store()->preallocated_stack_trace();
     PreallocatedStacktraceBuilder frame_builder(stacktrace);
-    handler_exists = FindExceptionHandler(&handler_pc,
+    handler_exists = FindExceptionHandler(isolate,
+                                          &handler_pc,
                                           &handler_sp,
                                           &handler_fp,
                                           &handler_needs_stacktrace);
     if (handler_needs_stacktrace) {
-      BuildStackTrace(&frame_builder);
+      BuildStackTrace(isolate, &frame_builder);
     }
   } else {
     // Get stacktrace field of class Error.
     const Field& stacktrace_field =
         Field::Handle(isolate, LookupStacktraceField(exception));
-    handler_exists = FindExceptionHandler(&handler_pc,
+    handler_exists = FindExceptionHandler(isolate,
+                                          &handler_pc,
                                           &handler_sp,
                                           &handler_fp,
                                           &handler_needs_stacktrace);
     Array& code_array = Array::Handle(isolate, Object::empty_array().raw());
     Array& pc_offset_array =
         Array::Handle(isolate, Object::empty_array().raw());
     // If we have an error with a stacktrace field then collect the full stack
     // trace and store it into the field.
     if (!stacktrace_field.IsNull()) {
       if (exception.GetField(stacktrace_field) == Object::null()) {
         // This is an error object and we need to capture the full stack trace
-        // here implicitly, so we set up the stack trace. The stack trace field
-        // is set only once, it is not overriden.
+        // here implicitly, so we set up the stack trace. The stack trace
+        // field is set only once, it is not overriden.
         const Stacktrace& full_stacktrace =
             Stacktrace::Handle(isolate, Exceptions::CurrentStacktrace());
         exception.SetField(stacktrace_field, full_stacktrace);
       }
     }
     if (handler_needs_stacktrace) {
       RegularStacktraceBuilder frame_builder(false);
-      BuildStackTrace(&frame_builder);
+      BuildStackTrace(isolate, &frame_builder);
 
       // Create arrays for code and pc_offset tuples of each frame.
       code_array = Array::MakeArray(frame_builder.code_list());
       pc_offset_array = Array::MakeArray(frame_builder.pc_offset_list());
     }
     if (existing_stacktrace.IsNull()) {
       stacktrace = Stacktrace::New(code_array, pc_offset_array);
     } else {
       stacktrace ^= existing_stacktrace.raw();
       if (pc_offset_array.Length() != 0) {
@@ skipping 11 matching lines @@
   // stack as Exceptions::Throw should happen only after a dart
   // invocation has been done.
   ASSERT(handler_pc != 0);
 
   if (FLAG_print_stacktrace_at_throw) {
     OS::Print("Exception '%s' thrown:\n", exception.ToCString());
     OS::Print("%s\n", stacktrace.ToCString());
   }
   if (handler_exists) {
     // Found a dart handler for the exception, jump to it.
-    JumpToExceptionHandler(handler_pc,
+    JumpToExceptionHandler(isolate,
+                           handler_pc,
                            handler_sp,
                            handler_fp,
                            exception,
                            stacktrace);
   } else {
     // No dart exception handler found in this invocation sequence,
     // so we create an unhandled exception object and return to the
     // invocation stub so that it returns this unhandled exception
     // object. The C++ code which invoked this dart sequence can check
     // and do the appropriate thing (rethrow the exception to the
     // dart invocation sequence above it, print diagnostics and terminate
     // the isolate etc.).
     const UnhandledException& unhandled_exception = UnhandledException::Handle(
-        UnhandledException::New(exception, stacktrace));
+        isolate, UnhandledException::New(exception, stacktrace));
     stacktrace = Stacktrace::null();
-    JumpToExceptionHandler(handler_pc,
+    JumpToExceptionHandler(isolate,
+                           handler_pc,
                            handler_sp,
                            handler_fp,
                            unhandled_exception,
                            stacktrace);
   }
   UNREACHABLE();
 }
 
 
 // Static helpers for allocating, initializing, and throwing an error instance.
@@ skipping 72 matching lines @@
     } else {
       OS::Print("type error.\n");
     }
   }
   // Throw TypeError or CastError instance.
   Exceptions::ThrowByType(exception_type, args);
   UNREACHABLE();
 }
 
 
-void Exceptions::Throw(const Instance& exception) {
-  Isolate* isolate = Isolate::Current();
+void Exceptions::Throw(Isolate* isolate, const Instance& exception) {
   isolate->debugger()->SignalExceptionThrown(exception);
   // Null object is a valid exception object.
-  ThrowExceptionHelper(exception, Instance::Handle(isolate));
+  ThrowExceptionHelper(isolate, exception, Instance::Handle(isolate));
 }
 
 
-void Exceptions::ReThrow(const Instance& exception,
+void Exceptions::ReThrow(Isolate* isolate,
+                         const Instance& exception,
                          const Instance& stacktrace) {
   // Null object is a valid exception object.
-  ThrowExceptionHelper(exception, stacktrace);
+  ThrowExceptionHelper(isolate, exception, stacktrace);
 }
 
 
 void Exceptions::PropagateError(const Error& error) {
-  ASSERT(Isolate::Current()->top_exit_frame_info() != 0);
+  Isolate* isolate = Isolate::Current();
+  ASSERT(isolate->top_exit_frame_info() != 0);
   if (error.IsUnhandledException()) {
     // If the error object represents an unhandled exception, then
     // rethrow the exception in the normal fashion.
     const UnhandledException& uhe = UnhandledException::Cast(error);
-    const Instance& exc = Instance::Handle(uhe.exception());
-    const Instance& stk = Instance::Handle(uhe.stacktrace());
-    Exceptions::ReThrow(exc, stk);
+    const Instance& exc = Instance::Handle(isolate, uhe.exception());
+    const Instance& stk = Instance::Handle(isolate, uhe.stacktrace());
+    Exceptions::ReThrow(isolate, exc, stk);
   } else {
     // Return to the invocation stub and return this error object.  The
     // C++ code which invoked this dart sequence can check and do the
     // appropriate thing.
     uword handler_pc = 0;
     uword handler_sp = 0;
     uword handler_fp = 0;
     FindErrorHandler(&handler_pc, &handler_sp, &handler_fp);
-    JumpToExceptionHandler(handler_pc, handler_sp, handler_fp, error,
-                           Stacktrace::Handle());  // Null stacktrace.
+    JumpToExceptionHandler(isolate, handler_pc, handler_sp, handler_fp, error,
+                           Stacktrace::Handle(isolate));  // Null stacktrace.
   }
   UNREACHABLE();
 }
 
 
 void Exceptions::ThrowByType(ExceptionType type, const Array& arguments) {
-  const Object& result = Object::Handle(Create(type, arguments));
+  Isolate* isolate = Isolate::Current();
+  const Object& result = Object::Handle(isolate, Create(type, arguments));
   if (result.IsError()) {
     // We got an error while constructing the exception object.
     // Propagate the error instead of throwing the exception.
     PropagateError(Error::Cast(result));
   } else {
     ASSERT(result.IsInstance());
-    Throw(Instance::Cast(result));
+    Throw(isolate, Instance::Cast(result));
   }
 }
 
 
 void Exceptions::ThrowOOM() {
   Isolate* isolate = Isolate::Current();
   const Instance& oom = Instance::Handle(
       isolate, isolate->object_store()->out_of_memory());
-  Throw(oom);
+  Throw(isolate, oom);
 }
 
 
 void Exceptions::ThrowStackOverflow() {
   Isolate* isolate = Isolate::Current();
   const Instance& stack_overflow = Instance::Handle(
       isolate, isolate->object_store()->stack_overflow());
-  Throw(stack_overflow);
+  Throw(isolate, stack_overflow);
 }
 
 
 void Exceptions::ThrowArgumentError(const Instance& arg) {
   const Array& args = Array::Handle(Array::New(1));
   args.SetAt(0, arg);
   Exceptions::ThrowByType(Exceptions::kArgument, args);
 }
 
 
@@ skipping 166 matching lines @@
     char* msg = reinterpret_cast<char*>(malloc(len + 1));
     va_copy(args_copy, args);
     OS::VSNPrint(msg, len + 1, format, args_copy);
     va_end(args_copy);
     trace_warning.AddProperty("message", msg);
   }
   trace_buffer->Trace(micros, js.ToCString(), true);  // Already escaped.
 }
 
 }  // namespace dart