Preparation for moving reusable handles to thread and more cleanups: isolate -> thread based handle…

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 "platform/address_sanitizer.h"
 
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
@@ skipping 114 matching lines @@
     }
     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(Isolate* isolate,
+static bool FindExceptionHandler(Thread* thread,
                                  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(isolate,
+      if (frame->FindExceptionHandler(thread,
                                       &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) {
@@ skipping 144 matching lines @@
   }
   uword handler_pc = 0;
   uword handler_sp = 0;
   uword handler_fp = 0;
   Instance& stacktrace = Instance::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(isolate,
+    handler_exists = FindExceptionHandler(thread,
                                           &handler_pc,
                                           &handler_sp,
                                           &handler_fp,
                                           &handler_needs_stacktrace);
     if (handler_needs_stacktrace) {
       BuildStackTrace(isolate, &frame_builder);
     }
   } else {
     // Get stacktrace field of class Error. This is needed to determine whether
     // we have a subclass of Error which carries around its stack trace.
     const Field& stacktrace_field =
         Field::Handle(isolate, LookupStacktraceField(exception));
 
     // Find the exception handler and determine if the handler needs a
     // stacktrace.
-    handler_exists = FindExceptionHandler(isolate,
+    handler_exists = FindExceptionHandler(thread,
                                           &handler_pc,
                                           &handler_sp,
                                           &handler_fp,
                                           &handler_needs_stacktrace);
     if (!existing_stacktrace.IsNull()) {
       // If we have an existing stack trace then this better be a rethrow. The
       // reverse is not necessarily true (e.g. Dart_PropagateError can cause
       // a rethrow being called without an existing stacktrace.)
       ASSERT(is_rethrow);
       ASSERT(stacktrace_field.IsNull() ||
@@ skipping 330 matching lines @@
 
 // Throw JavascriptCompatibilityError exception.
 void Exceptions::ThrowJavascriptCompatibilityError(const char* msg) {
   const Array& exc_args = Array::Handle(Array::New(1));
   const String& msg_str = String::Handle(String::New(msg));
   exc_args.SetAt(0, msg_str);
   Exceptions::ThrowByType(Exceptions::kJavascriptCompatibilityError, exc_args);
 }
 
 }  // namespace dart