Revert Dart_PropagateError until I can track down the problems in

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/cpu.h"
 #include "vm/dart_entry.h"
 #include "vm/flags.h"
 #include "vm/object.h"
@@ skipping 28 matching lines @@
     ASSERT(frame != NULL);
   }
   ASSERT(frame->IsEntryFrame());
   *handler_pc = frame->pc();
   *handler_sp = frame->sp();
   *handler_fp = frame->fp();
   return false;
 }
 
 
-static void FindErrorHandler(uword* handler_pc,
-                             uword* handler_sp,
-                             uword* handler_fp) {
-  // TODO(turnidge): Is there a faster way to get the next entry frame?
-  StackFrameIterator frames(StackFrameIterator::kDontValidateFrames);
-  StackFrame* frame = frames.NextFrame();
-  ASSERT(frame != NULL);
-  while (!frame->IsEntryFrame()) {
-    frame = frames.NextFrame();
-    ASSERT(frame != NULL);
-  }
-  ASSERT(frame->IsEntryFrame());
-  *handler_pc = frame->pc();
-  *handler_sp = frame->sp();
-  *handler_fp = frame->fp();
-}
-
-
 static void ThrowExceptionHelper(const Instance& exception,
                                  const Instance& existing_stacktrace) {
   uword handler_pc = 0;
   uword handler_sp = 0;
   uword handler_fp = 0;
   GrowableArray<uword> stack_frame_pcs;
   bool handler_exists = FindExceptionHandler(&handler_pc,
                                              &handler_sp,
                                              &handler_fp,
                                              &stack_frame_pcs);
@@ skipping 25 matching lines @@
   } 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);
+    CPU::JumpToUnhandledExceptionHandler(handler_pc,
+                                         handler_sp,
+                                         handler_fp,
+                                         unhandled_exception);
   }
   UNREACHABLE();
 }
 
 
 void Exceptions::Throw(const Instance& exception) {
   ThrowExceptionHelper(exception, Instance::Handle());
 }
 
 
 void Exceptions::ReThrow(const Instance& exception,
                          const Instance& stacktrace) {
   ASSERT(!exception.IsNull());
   ThrowExceptionHelper(exception, stacktrace);
 }
 
 
-void Exceptions::PropagateError(const Object& obj) {
-  ASSERT(Isolate::Current()->top_exit_frame_info() != 0);
-  Error& error = Error::Handle();
-  error ^= obj.raw();
-  if (error.IsUnhandledException()) {
-    // If the error object represents an unhandled exception, then
-    // rethrow the exception in the normal fashion.
-    UnhandledException& uhe = UnhandledException::Handle();
-    uhe ^= error.raw();
-    const Instance& exc = Instance::Handle(uhe.exception());
-    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);
-  }
-  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.
-    // Propagate the error instead of throwing the exception.
-    Error& error = Error::Handle();
-    error ^= result.raw();
-    PropagateError(error);
-  } else {
-    ASSERT(result.IsInstance());
-    Instance& exception = Instance::Handle();
-    exception ^= result.raw();
-    Throw(exception);
-  }
+  const Instance& exception = Instance::Handle(Create(type, arguments));
+  Throw(exception);
 }
 
 
-RawObject* Exceptions::Create(
+RawInstance* Exceptions::Create(
     ExceptionType type, const GrowableArray<const Object*>& arguments) {
   String& class_name = String::Handle();
   switch (type) {
     case kIndexOutOfRange:
       class_name = String::NewSymbol("IndexOutOfRangeException");
       break;
     case kIllegalArgument:
       class_name = String::NewSymbol("IllegalArgumentException");
       break;
     case kNoSuchMethod:
@@ skipping 25 matching lines @@
       break;
     case kIllegalJSRegExp:
       class_name = String::NewSymbol("IllegalJSRegExpException");
       break;
   }
 
   return DartLibraryCalls::ExceptionCreate(class_name, arguments);
 }
 
 }  // namespace dart