Reporting uncaught errors at the boundary between C++ and JS instead of tryin...

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 48 matching lines @@
   ThreadLocalTop* thread = reinterpret_cast<ThreadLocalTop*>(thread_storage);
   Iterate(v, thread);
   return thread_storage + sizeof(ThreadLocalTop);
 }
 
 
 #define VISIT(field) v->VisitPointer(reinterpret_cast<Object**>(&(field)));
 
 void Top::Iterate(ObjectVisitor* v, ThreadLocalTop* thread) {
   v->VisitPointer(&(thread->pending_exception_));
+  v->VisitPointer(&(thread->pending_message_obj_));
+  v->VisitPointer(bit_cast<Object**, Script**>(&(thread->pending_message_script_)));
   v->VisitPointer(bit_cast<Object**, Context**>(&(thread->context_)));
   v->VisitPointer(&(thread->scheduled_exception_));
 
   for (v8::TryCatch* block = thread->try_catch_handler_;
        block != NULL;
        block = block->next_) {
     v->VisitPointer(bit_cast<Object**, void**>(&(block->exception_)));
     v->VisitPointer(bit_cast<Object**, void**>(&(block->message_)));
   }
 
@@ skipping 13 matching lines @@
 
 void Top::InitializeThreadLocal() {
   thread_local_.c_entry_fp_ = 0;
   thread_local_.handler_ = 0;
   thread_local_.stack_is_cooked_ = false;
   thread_local_.try_catch_handler_ = NULL;
   thread_local_.context_ = NULL;
   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;
 }
 
 
 // Create a dummy thread that will wait forever on a semaphore. The only
 // purpose for this thread is to have some stack area to save essential data
 // into for use by a stacks only core dump (aka minidump).
 class PreallocatedMemoryThread: public Thread {
@@ skipping 617 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::IsUncaughtException(bool* is_caught_externally) {

[Søren Thygesen Gjesse, 2008/12/04 07:53:53]

This function does not only check whether the exception is uncaught as if it is
caught by a C++ TryCatch it also checks whether that handler is verbose. This
should be taken into account with the name change (perhaps adding another
reference parameter) and the comments should also be changed as they still
mention reporting the exception.

[olehougaard, 2008/12/04 08:44:35]

Reverting to the original name.

   StackHandler* handler =
       StackHandler::FromAddress(Top::handler(Top::GetCurrentThread()));
 
   // Determine if we have an external exception handler and 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.
   bool has_external_handler = (thread_local_.try_catch_handler_ != NULL);
   v8::TryCatch* try_catch = thread_local_.try_catch_handler_;
 
   // NOTE: The stack is assumed to grown towards lower addresses. If
@@ skipping 34 matching lines @@
 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 report_exception = (exception != Failure::OutOfMemoryException()) &&
-      ShouldReportException(&is_caught_externally);
+  bool is_out_of_memory = exception == Failure::OutOfMemoryException();
+  bool is_uncaught_exception =  IsUncaughtException(&is_caught_externally);
+  bool report_exception = !is_out_of_memory && is_uncaught_exception;
+
+
+  // Notify debugger of exception.
+  Debugger::OnException(exception_handle, report_exception);
 
   // 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) {
       // If no location was specified we use a computed one instead
       ComputeLocation(&potential_computed_location);
       location = &potential_computed_location;
     }
     Handle<String> stack_trace;
     if (FLAG_trace_exception) stack_trace = StackTrace();
     message_obj = MessageHandler::MakeMessageObject("uncaught_exception",
         location, HandleVector<Object>(&exception_handle, 1), stack_trace);
   }
 
-  // If the exception is caught externally, we store it in the
-  // try/catch handler. The C code can find it later and process it if
-  // necessary.
-  thread_local_.catcher_ = NULL;
-  if (is_caught_externally) {
-    thread_local_.catcher_ = thread_local_.try_catch_handler_;
-    thread_local_.try_catch_handler_->exception_ =
-      reinterpret_cast<void*>(*exception_handle);
-    if (!message_obj.is_null()) {
-      thread_local_.try_catch_handler_->message_ =
-        reinterpret_cast<void*>(*message_obj);
+  // Save the message for reporting if the the exception remains uncaught.
+  thread_local_.pending_message_ = message;
+  if (!message_obj.is_null()) {
+    thread_local_.pending_message_obj_ = *message_obj;
+    if (location != NULL) {
+      thread_local_.pending_message_script_ = *location->script();
+      thread_local_.pending_message_start_pos_ = location->start_pos();
+      thread_local_.pending_message_end_pos_ = location->end_pos();
     }
   }
 
-  // Notify debugger of exception.
-  Debugger::OnException(exception_handle, report_exception);
-
-  if (report_exception) {
-    if (message != NULL) {
-      MessageHandler::ReportMessage(message);
-    } else if (!message_obj.is_null()) {
-      MessageHandler::ReportMessage(location, message_obj);
-    }
+  if (is_caught_externally) {
+    thread_local_.catcher_ = thread_local_.try_catch_handler_;
   }
 
-  // NOTE: Notifying the debugger or reporting the exception may have caused
-  // new exceptions. For now, we just ignore that and set the pending exception
+  // NOTE: Notifying the debugger may have caused new exceptions.

[Søren Thygesen Gjesse, 2008/12/04 07:53:53]

Generating the message without reporting it can also cause a new exception.

[olehougaard, 2008/12/04 08:44:35]

Updated the comment.

+  // For now, we just ignore that and set the pending exception
   // to the original one.
   set_pending_exception(*exception_handle);
 }
 
 
+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.
+  HandleScope scope;
+  if (thread_local_.pending_exception_ == Failure::OutOfMemoryException()) {
+    context()->mark_out_of_memory();
+  } else {
+    Handle<Object> exception(pending_exception());
+    if (thread_local_.external_caught_exception_) {
+      thread_local_.try_catch_handler_->exception_
+        = thread_local_.pending_exception_;

[Mads Ager (chromium), 2008/12/03 15:44:48]

We normally have the '=' on the previous line.

[olehougaard, 2008/12/04 08:44:35]

Fixed.

+      if (!thread_local_.pending_message_obj_->IsTheHole()) {
+        try_catch_handler()->message_ = thread_local_.pending_message_obj_;
+      }
+    } else if (thread_local_.pending_message_ != NULL) {
+      MessageHandler::ReportMessage(thread_local_.pending_message_);
+    } else if (!thread_local_.pending_message_obj_->IsTheHole()) {
+      Handle<Object> message_obj(thread_local_.pending_message_obj_);
+      if (thread_local_.pending_message_script_ != NULL) {
+        Handle<Script> script(thread_local_.pending_message_script_);
+        int start_pos = thread_local_.pending_message_start_pos_;
+        int end_pos = thread_local_.pending_message_end_pos_;
+        MessageLocation location(script, start_pos, end_pos);
+        MessageHandler::ReportMessage(&location, message_obj);
+      } else {
+        MessageHandler::ReportMessage(NULL, message_obj);
+      }
+    }
+    set_pending_exception(*exception);
+  }
+  clear_pending_message();
+}
+
+
 void Top::TraceException(bool flag) {
   FLAG_trace_exception = flag;
 }
 
 
 bool Top::optional_reschedule_exception(bool is_bottom_call) {
   if (!is_out_of_memory() &&
       (thread_local_.external_caught_exception_ || is_bottom_call)) {
     thread_local_.external_caught_exception_ = false;
     clear_pending_exception();
@@ skipping 62 matching lines @@
   Top::break_access_->Lock();
 }
 
 
 ExecutionAccess::~ExecutionAccess() {
   Top::break_access_->Unlock();
 }
 
 
 } }  // namespace v8::internal