Pull out revision 915 and 916 to get a green builder. I believe the...

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 672 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 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;
-
-
-  // Notify debugger of exception.
-  Debugger::OnException(exception_handle, report_exception);
+  bool report_exception = (exception != Failure::OutOfMemoryException()) &&
+      ShouldReportException(&is_caught_externally);
 
   // 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);
   }
 
-  // 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();
+  // 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);
     }
   }
 
-  if (is_caught_externally) {
-    thread_local_.catcher_ = thread_local_.try_catch_handler_;
+  // 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);
+    }
   }
 
-  // NOTE: Notifying the debugger or generating the message
-  // may have caused new exceptions. For now, we just ignore
-  // that and set the pending exception to the original one.
+  // NOTE: Notifying the debugger or reporting the exception may have caused
+  // new exceptions. 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_;
-      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