Fix issue 1968, replace usage of inline 'asm' constructs in 'stack alignment', 'jump to exception h…

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/cpu.h"
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
 #include "vm/flags.h"
 #include "vm/object.h"
 #include "vm/stack_frame.h"
+#include "vm/stub_code.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, print_stack_trace_at_throw, false,
     "Prints a stack trace everytime a throw occurs.");
 
 // 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.
 static bool FindExceptionHandler(uword* handler_pc,
@@ skipping 34 matching lines @@
     frame = frames.NextFrame();
     ASSERT(frame != NULL);
   }
   ASSERT(frame->IsEntryFrame());
   *handler_pc = frame->pc();
   *handler_sp = frame->sp();
   *handler_fp = frame->fp();
 }
 
 
+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;
+  RawInstance* exception = exception_object.raw();
+  RawInstance* stacktrace = stacktrace_object.raw();
+
+  // 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();
+  }
+
+  // Set up the appropriate register state and jump to the handler.
+  typedef void (*ExcpHandler)(uword, uword, uword, RawInstance*, RawInstance*);
+  ExcpHandler func = reinterpret_cast<ExcpHandler>(
+      StubCode::JumpToExceptionHandlerEntryPoint());
+  func(program_counter, stack_pointer, frame_pointer, exception, stacktrace);
+  UNREACHABLE();
+}
+
+
+void JumpToErrorHandler(uword program_counter,
+                        uword stack_pointer,
+                        uword frame_pointer,
+                        const Error& error) {
+  // The no_gc StackResource is unwound through the tear down of
+  // stack resources below.
+  NoGCScope no_gc;
+  ASSERT(!error.IsNull());
+  RawError* raw_error = error.raw();
+
+  // 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();
+  }
+
+  // Set up the error object as the return value in EAX and continue
+  // from the invocation stub.
+  typedef void (*ErrorHandler)(uword, uword, uword, RawError*);
+  ErrorHandler func = reinterpret_cast<ErrorHandler>(
+      StubCode::JumpToErrorHandlerEntryPoint());
+  func(program_counter, stack_pointer, frame_pointer, raw_error);
+  UNREACHABLE();
+}
+
+
 static void ThrowExceptionHelper(const Instance& incoming_exception,
                                  const Instance& existing_stacktrace) {
   Instance& exception = Instance::Handle(incoming_exception.raw());
   if (exception.IsNull()) {
     GrowableArray<const Object*> arguments;
     exception ^= Exceptions::Create(Exceptions::kNullPointer, arguments);
   }
   uword handler_pc = 0;
   uword handler_sp = 0;
   uword handler_fp = 0;
@@ skipping 15 matching lines @@
     }
   } else {
     stacktrace ^= existing_stacktrace.raw();
   }
   if (FLAG_print_stack_trace_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.
-    CPU::JumpToExceptionHandler(handler_pc,
-                                handler_sp,
-                                handler_fp,
-                                exception,
-                                stacktrace);
+    JumpToExceptionHandler(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));
-    CPU::JumpToErrorHandler(handler_pc,
-                            handler_sp,
-                            handler_fp,
-                            unhandled_exception);
+    JumpToErrorHandler(handler_pc, handler_sp, handler_fp, unhandled_exception);
   }
   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 141 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);
-    CPU::JumpToErrorHandler(handler_pc, handler_sp, handler_fp, error);
+    JumpToErrorHandler(handler_pc, handler_sp, handler_fp, error);
   }
   UNREACHABLE();
 }
 
 
 void Exceptions::ThrowByType(
     ExceptionType type, const GrowableArray<const Object*>& arguments) {
   const Object& result = Object::Handle(Create(type, arguments));
   if (result.IsError()) {
     // We got an error while constructing the exception object.
@@ skipping 66 matching lines @@
     case kIsolateSpawn:
       library = Library::IsolateLibrary();
       class_name = String::NewSymbol("IsolateSpawnException");
       break;
   }
 
   return DartLibraryCalls::ExceptionCreate(library, class_name, arguments);
 }
 
 }  // namespace dart