Pass new pool pointer to the JumpToException stub instead of reloading in through the frame's 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 "platform/address_sanitizer.h"
 
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
@@ skipping 126 matching lines @@
 
 
 // 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(Thread* thread,
                                  uword* handler_pc,
                                  uword* handler_sp,
                                  uword* handler_fp,
+                                 uword** handler_pp_slot,
                                  bool* needs_stacktrace) {
   StackFrameIterator frames(StackFrameIterator::kDontValidateFrames);
   StackFrame* frame = frames.NextFrame();
   if (frame == NULL) return false;  // No Dart frame.
   bool handler_pc_set = false;
   *needs_stacktrace = false;
   bool is_catch_all = false;
   uword temp_handler_pc = kUwordMax;
+  uword* saved_pp_slot = 0;
   while (!frame->IsEntryFrame()) {
     if (frame->IsDartFrame()) {
       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();
+          *handler_pp_slot = saved_pp_slot;
         }
         if (*needs_stacktrace || is_catch_all) {
           return true;
         }
       }
     }  // if frame->IsDartFrame
+#if !defined(TARGET_ARCH_IA32) && !defined(TARGET_ARCH_DBC)
+    saved_pp_slot = frame->saved_caller_pp_slot();
+#endif
     frame = frames.NextFrame();
     ASSERT(frame != NULL);
   }  // while !frame->IsEntryFrame
   ASSERT(frame->IsEntryFrame());
   if (!handler_pc_set) {
     *handler_pc = frame->pc();
     *handler_sp = frame->sp();
     *handler_fp = frame->fp();
+    *handler_pp_slot = saved_pp_slot;
   }
   // No catch-all encountered, needs stacktrace.
   *needs_stacktrace = true;
   return handler_pc_set;
 }
 
 
 static void FindErrorHandler(uword* handler_pc,
                              uword* handler_sp,
-                             uword* handler_fp) {
+                             uword* handler_fp,
+                             uword** handler_pp_slot) {
   // TODO(turnidge): Is there a faster way to get the next entry frame?
   StackFrameIterator frames(StackFrameIterator::kDontValidateFrames);
   StackFrame* frame = frames.NextFrame();
   ASSERT(frame != NULL);
+  uword* saved_pp_slot = NULL;
   while (!frame->IsEntryFrame()) {
+#if !defined(TARGET_ARCH_IA32) && !defined(TARGET_ARCH_DBC)
+    saved_pp_slot = frame->saved_caller_pp_slot();
+#endif
     frame = frames.NextFrame();
     ASSERT(frame != NULL);
   }
   ASSERT(frame->IsEntryFrame());
   *handler_pc = frame->pc();
   *handler_sp = frame->sp();
   *handler_fp = frame->fp();
+  *handler_pp_slot = saved_pp_slot;
 }
 
 
 static void JumpToExceptionHandler(Thread* thread,
                                    uword program_counter,
                                    uword stack_pointer,
                                    uword frame_pointer,
+                                   uword* pool_pointer_slot,
                                    const Object& exception_object,
                                    const Object& stacktrace_object) {
   // The no_gc StackResource is unwound through the tear down of
   // stack resources below.
   NoSafepointScope no_safepoint;
   RawObject* raw_exception = exception_object.raw();
   RawObject* raw_stacktrace = stacktrace_object.raw();
 
+#if !defined(TARGET_ARCH_IA32) && !defined(TARGET_ARCH_DBC)
+  ASSERT(pool_pointer_slot != NULL);
+  uword pool_pointer = *pool_pointer_slot;
+  // TODO(rmacnak): Lazy deopt without patching alters pc and pp here.
+#else
+  uword pool_pointer = 0;
+#endif
+
 #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.
 
   Simulator::Current()->Longjmp(program_counter, stack_pointer, frame_pointer,
-                                raw_exception, raw_stacktrace, thread);
+                                pool_pointer, raw_exception, raw_stacktrace,
+                                thread);
 #else
   // Prepare for unwinding frames by destroying all the stack resources
   // in the previous frames.
   StackResource::Unwind(thread);
 
   // Call a stub to set up the exception object in kExceptionObjectReg,
   // to set up the stacktrace object in kStackTraceObjectReg, and to
   // continue execution at the given pc in the given frame.
   typedef void (*ExcpHandler)(uword, uword, uword, RawObject*, RawObject*,
-                              Thread*);
+                              Thread*, uword);
   ExcpHandler func = reinterpret_cast<ExcpHandler>(
       StubCode::JumpToExceptionHandler_entry()->EntryPoint());
 
   // Unpoison the stack before we tear it down in the generated stub code.
   uword current_sp = Thread::GetCurrentStackPointer() - 1024;
   ASAN_UNPOISON(reinterpret_cast<void*>(current_sp),
                 stack_pointer - current_sp);
 
   func(program_counter, stack_pointer, frame_pointer,
-       raw_exception, raw_stacktrace, thread);
+       raw_exception, raw_stacktrace, thread, pool_pointer);
 #endif
   UNREACHABLE();
 }
 
 
 static RawField* LookupStacktraceField(const Instance& instance) {
   if (instance.GetClassId() < kNumPredefinedCids) {
     // 'class Error' is not a predefined class.
     return Field::null();
   }
@@ skipping 52 matching lines @@
   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;
+  uword* handler_pp_slot = 0;
   Instance& stacktrace = Instance::Handle(zone);
   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(thread,
                                           &handler_pc,
                                           &handler_sp,
                                           &handler_fp,
+                                          &handler_pp_slot,
                                           &handler_needs_stacktrace);
     if (handler_pc == 0) {
       // No Dart frame.
       ASSERT(incoming_exception.raw() ==
              isolate->object_store()->out_of_memory());
       const UnhandledException& error = UnhandledException::Handle(
           zone, isolate->object_store()->preallocated_unhandled_exception());
       thread->long_jump_base()->Jump(1, error);
       UNREACHABLE();
     }
     if (handler_needs_stacktrace) {
       BuildStackTrace(&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(zone, LookupStacktraceField(exception));
 
     // Find the exception handler and determine if the handler needs a
     // stacktrace.
     handler_exists = FindExceptionHandler(thread,
                                           &handler_pc,
                                           &handler_sp,
                                           &handler_fp,
+                                          &handler_pp_slot,
                                           &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() ||
              (exception.GetField(stacktrace_field) != Object::null()));
       stacktrace = existing_stacktrace.raw();
     } else if (!stacktrace_field.IsNull() || handler_needs_stacktrace) {
@@ skipping 17 matching lines @@
   if (FLAG_print_stacktrace_at_throw) {
     THR_Print("Exception '%s' thrown:\n", exception.ToCString());
     THR_Print("%s\n", stacktrace.ToCString());
   }
   if (handler_exists) {
     // Found a dart handler for the exception, jump to it.
     JumpToExceptionHandler(thread,
                            handler_pc,
                            handler_sp,
                            handler_fp,
+                           handler_pp_slot,
                            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(
         zone, UnhandledException::New(exception, stacktrace));
     stacktrace = Stacktrace::null();
     JumpToExceptionHandler(thread,
                            handler_pc,
                            handler_sp,
                            handler_fp,
+                           handler_pp_slot,
                            unhandled_exception,
                            stacktrace);
   }
   UNREACHABLE();
 }
 
 
 // Static helpers for allocating, initializing, and throwing an error instance.
 
 // Return the script of the Dart function that called the native entry or the
@@ skipping 163 matching lines @@
     const Instance& exc = Instance::Handle(zone, uhe.exception());
     const Instance& stk = Instance::Handle(zone, uhe.stacktrace());
     Exceptions::ReThrow(thread, 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(thread, handler_pc, handler_sp, handler_fp, error,
-                           Stacktrace::Handle(zone));  // Null stacktrace.
+    uword* handler_pp_slot = NULL;
+    const Stacktrace& stacktrace = Stacktrace::Handle(zone);  // null
+    FindErrorHandler(&handler_pc, &handler_sp, &handler_fp, &handler_pp_slot);
+    JumpToExceptionHandler(thread, handler_pc, handler_sp, handler_fp,
+                           handler_pp_slot, error, stacktrace);
   }
   UNREACHABLE();
 }
 
 
 void Exceptions::ThrowByType(ExceptionType type, const Array& arguments) {
   Thread* thread = Thread::Current();
   const Object& result =
       Object::Handle(thread->zone(), Create(type, arguments));
   if (result.IsError()) {
@@ skipping 133 matching lines @@
   }
 
   return DartLibraryCalls::InstanceCreate(library,
                                           *class_name,
                                           *constructor_name,
                                           arguments);
 }
 
 
 }  // namespace dart