Merge JumpToErrorHandler and JumpToExceptionHandler stubs on all architectures.

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 189 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 JumpToHandler(uword program_counter,
-                          uword stack_pointer,
-                          uword frame_pointer,
-                          RawObject* raw_exception,
-                          RawObject* raw_stacktrace) {
+static void JumpToExceptionHandler(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();
+
 #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 (if not NULL) in the kStackTraceObjectReg register.
+  // object (may be raw null) in the kStackTraceObjectReg register.
   Simulator::Current()->Longjmp(program_counter, stack_pointer, frame_pointer,
                                 raw_exception, raw_stacktrace);
 #else
   // Prepare for unwinding frames by destroying all the stack resources
   // in the previous frames.
   Isolate* isolate = Isolate::Current();
   while (isolate->top_resource() != NULL &&
          (reinterpret_cast<uword>(isolate->top_resource()) < stack_pointer)) {
     isolate->top_resource()->~StackResource();
   }
 
-  // TODO(regis): Can we safely merge both stubs and pass NULL as
-  // stacktrace_object in the case of an error handler?
-
-  // A NULL raw_stacktrace indicates that we are jumping to an ErrorHandler,
-  // rather than to an ExceptionHandler. TODO(regis): Merge these two cases.
-  if (raw_stacktrace == NULL) {
-    // Call a stub to set up the error object in kExceptionObjectReg and to
-    // continue execution at the given pc in the given frame.
-    typedef void (*ErrorHandler)(uword, uword, uword, RawObject*);
-    ErrorHandler func = reinterpret_cast<ErrorHandler>(
-        StubCode::JumpToErrorHandlerEntryPoint());
-    func(program_counter, stack_pointer, frame_pointer, raw_exception);
-  } else {
-    // 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*);
-    ExcpHandler func = reinterpret_cast<ExcpHandler>(
-        StubCode::JumpToExceptionHandlerEntryPoint());
-    func(program_counter, stack_pointer, frame_pointer,
-         raw_exception, raw_stacktrace);
-  }
+  // 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*);
+  ExcpHandler func = reinterpret_cast<ExcpHandler>(
+      StubCode::JumpToExceptionHandlerEntryPoint());
+  func(program_counter, stack_pointer, frame_pointer,
+       raw_exception, raw_stacktrace);
 #endif
   UNREACHABLE();
 }
 
 
-static void JumpToExceptionHandler(uword program_counter,
-                                   uword stack_pointer,
-                                   uword frame_pointer,
-                                   const Instance& exception_object,
-                                   const Instance& 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();
-
-  JumpToHandler(program_counter, stack_pointer, frame_pointer,
-                raw_exception, raw_stacktrace);
-
-  UNREACHABLE();
-}
-
-
-static void JumpToErrorHandler(uword program_counter,
-                               uword stack_pointer,
-                               uword frame_pointer,
-                               const Error& error_object) {
-  // The no_gc StackResource is unwound through the tear down of
-  // stack resources below.
-  NoGCScope no_gc;
-  ASSERT(!error_object.IsNull());
-  RawObject* raw_error = error_object.raw();
-
-  JumpToHandler(
-      program_counter, stack_pointer, frame_pointer, raw_error, NULL);
-
-  UNREACHABLE();
-}
-
-
 static void ThrowExceptionHelper(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()) {
@@ skipping 76 matching lines @@
     }
     // 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));
-    JumpToErrorHandler(handler_pc, handler_sp, handler_fp, unhandled_exception);
+    stacktrace = Stacktrace::null();
+    JumpToExceptionHandler(handler_pc,
+                           handler_sp,
+                           handler_fp,
+                           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
 // runtime entry. The frame iterator points to the callee.
 RawScript* Exceptions::GetCallerScript(DartFrameIterator* iterator) {
@@ skipping 143 matching lines @@
     const Instance& stk = Instance::Handle(uhe.stacktrace());
     Exceptions::ReThrow(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);
-    JumpToErrorHandler(handler_pc, handler_sp, handler_fp, error);
+    JumpToExceptionHandler(handler_pc, handler_sp, handler_fp, error,
+                           Stacktrace::Handle());  // Null stacktrace.
   }
   UNREACHABLE();
 }
 
 
 void Exceptions::ThrowByType(ExceptionType type, const Array& arguments) {
   const Object& result = Object::Handle(Create(type, arguments));
   if (result.IsError()) {
     // We got an error while constructing the exception object.
     // Propagate the error instead of throwing the exception.
@@ skipping 60 matching lines @@
       break;
   }
 
   return DartLibraryCalls::ExceptionCreate(library,
                                            *class_name,
                                            *constructor_name,
                                            arguments);
 }
 
 }  // namespace dart