Add support for forceful termination of JavaScript execution.

src/top.cc

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 80 matching lines @@
 
 void Top::InitializeThreadLocal() {
   thread_local_.c_entry_fp_ = 0;
   thread_local_.handler_ = 0;
 #ifdef ENABLE_LOGGING_AND_PROFILING
   thread_local_.js_entry_sp_ = 0;
 #endif
   thread_local_.stack_is_cooked_ = false;
   thread_local_.try_catch_handler_ = NULL;
   thread_local_.context_ = NULL;
+  thread_local_.thread_id_ = ThreadManager::kInvalidId;
   thread_local_.external_caught_exception_ = false;
   thread_local_.failed_access_check_callback_ = NULL;
   clear_pending_exception();
   clear_pending_message();
   clear_scheduled_exception();
   thread_local_.save_context_ = NULL;
   thread_local_.catcher_ = NULL;
 }
 
 
@@ skipping 480 matching lines @@
   // double fault with another stack overflow exception, we use a
   // precomputed message. This is somewhat problematic in that it
   // doesn't use ReportUncaughtException to determine the location
   // from where the exception occurred. It should probably be
   // reworked.
   DoThrow(*exception, NULL, kStackOverflowMessage);
   return Failure::Exception();
 }
 
 
+Failure* Top::TerminateExecution() {
+  DoThrow(Heap::termination_exception(), NULL, NULL);
+  return Failure::Exception();
+}
+
+
 Failure* Top::Throw(Object* exception, MessageLocation* location) {
   DoThrow(exception, location, NULL);
   return Failure::Exception();
 }
 
 
 Failure* Top::ReThrow(Object* exception, MessageLocation* location) {
   // Set the exception being re-thrown.
   set_pending_exception(exception);
   return Failure::Exception();
@@ skipping 76 matching lines @@
     MessageHandler::MakeMessageObject("uncaught_exception",
                                       location,
                                       HandleVector<Object>(&exception, 1),
                                       stack_trace);
 
   // Report the uncaught exception.
   MessageHandler::ReportMessage(location, message);
 }
 
 
-bool Top::ShouldReportException(bool* is_caught_externally) {
+bool Top::ShouldReturnException(bool* is_caught_externally,
+                                bool catchable_by_javascript) {
   // Find the top-most try-catch handler.
   StackHandler* handler =
       StackHandler::FromAddress(Top::handler(Top::GetCurrentThread()));
   while (handler != NULL && !handler->is_try_catch()) {
     handler = handler->next();
   }
 
   // Get the address of the external handler so we can compare the address to
   // determine which one is closer to the top of the stack.
   v8::TryCatch* try_catch = thread_local_.try_catch_handler_;
 
   // The exception has been externally caught if and only if there is
   // an external handler which is on top of the top-most try-catch
   // handler.
   //
   // See comments in RegisterTryCatchHandler for details.
   *is_caught_externally = try_catch != NULL &&
-      (handler == NULL || handler == try_catch->js_handler_);
+      (handler == NULL || handler == try_catch->js_handler_ ||
+       !catchable_by_javascript);
 
   if (*is_caught_externally) {
     // Only report the exception if the external handler is verbose.
     return thread_local_.try_catch_handler_->is_verbose_;
   } else {
     // Report the exception if it isn't caught by JavaScript code.
     return handler == NULL;
   }
 }
 
 
 void Top::DoThrow(Object* exception,
                   MessageLocation* location,
                   const char* message) {
   ASSERT(!has_pending_exception());
 
   HandleScope scope;
   Handle<Object> exception_handle(exception);
 
   // Determine reporting and whether the exception is caught externally.
   bool is_caught_externally = false;
   bool is_out_of_memory = exception == Failure::OutOfMemoryException();
-  bool should_return_exception = ShouldReportException(&is_caught_externally);
-  bool report_exception = !is_out_of_memory && should_return_exception;
+  bool is_termination_exception = exception == Heap::termination_exception();
+  bool catchable_by_javascript = !is_termination_exception && !is_out_of_memory;
+  bool should_return_exception =
+      ShouldReturnException(&is_caught_externally, catchable_by_javascript);
+  bool report_exception = catchable_by_javascript && should_return_exception;
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
   // Notify debugger of exception.
-  Debugger::OnException(exception_handle, report_exception);
+  if (catchable_by_javascript) {
+    Debugger::OnException(exception_handle, report_exception);
+  }
 #endif
 
   // Generate the message.
   Handle<Object> message_obj;
   MessageLocation potential_computed_location;
   bool try_catch_needs_message =
       is_caught_externally &&
       thread_local_.try_catch_handler_->capture_message_;
   if (report_exception || try_catch_needs_message) {
     if (location == NULL) {
@@ skipping 30 matching lines @@
 }
 
 
 void Top::ReportPendingMessages() {
   ASSERT(has_pending_exception());
   setup_external_caught();
   // If the pending exception is OutOfMemoryException set out_of_memory in
   // the global context.  Note: We have to mark the global context here
   // since the GenerateThrowOutOfMemory stub cannot make a RuntimeCall to
   // set it.
+  bool external_caught = thread_local_.external_caught_exception_;
   HandleScope scope;
   if (thread_local_.pending_exception_ == Failure::OutOfMemoryException()) {
     context()->mark_out_of_memory();
+  } else if (thread_local_.pending_exception_ ==
+             Heap::termination_exception()) {
+    if (external_caught) {
+      thread_local_.try_catch_handler_->can_continue_ = false;
+      thread_local_.try_catch_handler_->exception_ = Heap::null_value();
+    }
   } else {
     Handle<Object> exception(pending_exception());
-    bool external_caught = thread_local_.external_caught_exception_;
     thread_local_.external_caught_exception_ = false;
     if (external_caught) {
+      thread_local_.try_catch_handler_->can_continue_ = true;
       thread_local_.try_catch_handler_->exception_ =
         thread_local_.pending_exception_;
       if (!thread_local_.pending_message_obj_->IsTheHole()) {
         try_catch_handler()->message_ = thread_local_.pending_message_obj_;
       }
     }
     if (thread_local_.has_pending_message_) {
       thread_local_.has_pending_message_ = false;
       if (thread_local_.pending_message_ != NULL) {
         MessageHandler::ReportMessage(thread_local_.pending_message_);
@@ skipping 15 matching lines @@
   }
   clear_pending_message();
 }
 
 
 void Top::TraceException(bool flag) {
   FLAG_trace_exception = flag;
 }
 
 
-bool Top::optional_reschedule_exception(bool is_bottom_call) {
+bool Top::OptionalRescheduleException(bool is_bottom_call,
+                                      bool force_clear_catchable) {
   // Allways reschedule out of memory exceptions.
   if (!is_out_of_memory()) {
-    // Never reschedule the exception if this is the bottom call.
-    bool clear_exception = is_bottom_call;
+    bool is_termination_exception =
+        pending_exception() == Heap::termination_exception();
 
-    // If the exception is externally caught, clear it if there are no
-    // JavaScript frames on the way to the C++ frame that has the
-    // external handler.
-    if (thread_local_.external_caught_exception_) {
+    // Do not reschedule the exception if this is the bottom call or
+    // if we are asked to clear catchable exceptions.  Termination
+    // exceptions are not catchable and are only cleared if this is
+    // the bottom call.
+    bool clear_exception = is_bottom_call ||
+        (force_clear_catchable && !is_termination_exception);
+
+    if (is_termination_exception) {
+      thread_local_.external_caught_exception_ = false;
+      if (is_bottom_call) {
+        clear_pending_exception();
+        return false;
+      }
+    } else if (thread_local_.external_caught_exception_) {
+      // If the exception is externally caught, clear it if there are no
+      // JavaScript frames on the way to the C++ frame that has the
+      // external handler.
       ASSERT(thread_local_.try_catch_handler_ != NULL);
       Address external_handler_address =
           reinterpret_cast<Address>(thread_local_.try_catch_handler_);
       JavaScriptFrameIterator it;
       if (it.done() || (it.frame()->sp() > external_handler_address)) {
         clear_exception = true;
       }
     }
 
     // Clear the exception if needed.
@@ skipping 76 matching lines @@
   Top::break_access_->Lock();
 }
 
 
 ExecutionAccess::~ExecutionAccess() {
   Top::break_access_->Unlock();
 }
 
 
 } }  // namespace v8::internal