Fix TryCatch.ReThrow() to not clobber Message.

src/isolate.cc

 // Copyright 2012 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 89 matching lines @@
   external_caught_exception_ = false;
   failed_access_check_callback_ = NULL;
   save_context_ = NULL;
   catcher_ = NULL;
   top_lookup_result_ = NULL;
 
   // These members are re-initialized later after deserialization
   // is complete.
   pending_exception_ = NULL;
   has_pending_message_ = false;
+  restoring_message_ = false;
   pending_message_obj_ = NULL;
   pending_message_script_ = NULL;
   scheduled_exception_ = NULL;
 }
 
 
 void ThreadLocalTop::Initialize() {
   InitializeInternal();
 #ifdef USE_SIMULATOR
 #ifdef V8_TARGET_ARCH_ARM
@@ skipping 353 matching lines @@
   Object* scheduled;
   if (thread->scheduled_exception_->ToObject(&scheduled)) {
     v->VisitPointer(&scheduled);
     thread->scheduled_exception_ = scheduled;
   }
 
   for (v8::TryCatch* block = thread->TryCatchHandler();
        block != NULL;
        block = TRY_CATCH_FROM_ADDRESS(block->next_)) {
     v->VisitPointer(BitCast<Object**>(&(block->exception_)));
-    v->VisitPointer(BitCast<Object**>(&(block->message_)));
+    v->VisitPointer(BitCast<Object**>(&(block->message_obj_)));
+    v->VisitPointer(BitCast<Object**>(&(block->message_script_)));
   }
 
   // Iterate over pointers on native execution stack.
   for (StackFrameIterator it(this, thread); !it.done(); it.Advance()) {
     it.frame()->Iterate(v);
   }
 
   // Iterate pointers in live lookup results.
   thread->top_lookup_result_->Iterate(v);
 }
@@ skipping 655 matching lines @@
   Throw(exception);
   PropagatePendingExceptionToExternalTryCatch();
   if (has_pending_exception()) {
     thread_local_top()->scheduled_exception_ = pending_exception();
     thread_local_top()->external_caught_exception_ = false;
     clear_pending_exception();
   }
 }
 
 
+void Isolate::RestoreMessage(Object* message, Script* script,
+                             int start_pos, int end_pos) {
+  // Flag is checked in DoThrow(), which immediately follows.
+  thread_local_top()->restoring_message_ = true;
+  thread_local_top()->pending_message_obj_ = message;
+  if (script) {
+    thread_local_top()->pending_message_script_ = script;
+  }
+  thread_local_top()->pending_message_start_pos_ = start_pos;
+  thread_local_top()->pending_message_end_pos_ = end_pos;
+}
+
+
 Failure* Isolate::PromoteScheduledException() {
   MaybeObject* thrown = scheduled_exception();
   clear_scheduled_exception();
   // Re-throw the exception to avoid getting repeated error reporting.
   return ReThrow(thrown);
 }
 
 
 void Isolate::PrintCurrentStackTrace(FILE* out) {
   StackTraceFrameIterator it(this);
@@ skipping 97 matching lines @@
 
   HandleScope scope(this);
   Handle<Object> exception_handle(exception, this);
 
   // Determine reporting and whether the exception is caught externally.
   bool catchable_by_javascript = is_catchable_by_javascript(exception);
   bool can_be_caught_externally = false;
   bool should_report_exception =
       ShouldReportException(&can_be_caught_externally, catchable_by_javascript);
   bool report_exception = catchable_by_javascript && should_report_exception;
+  // When determining if a message needs to be generated, make sure to check
+  // restoring_message_.  If an external TryCatch re-threw an exception, it
+  // will have already called RestoreMessage() to put the original message,
+  // script, and location back in place.  In that case, this code must not
+  // clobber the values computed from the original exception.
   bool try_catch_needs_message =
-      can_be_caught_externally && try_catch_handler()->capture_message_;
+      can_be_caught_externally && try_catch_handler()->capture_message_ &&
+      !thread_local_top_.restoring_message_;
   bool bootstrapping = bootstrapper()->IsActive();
 
+  thread_local_top_.restoring_message_ = false;
+
 #ifdef ENABLE_DEBUGGER_SUPPORT
   // Notify debugger of exception.
   if (catchable_by_javascript) {
     debugger_->OnException(exception_handle, report_exception);
   }
 #endif
 
   // Generate the message if required.
   if (report_exception || try_catch_needs_message) {
     MessageLocation potential_computed_location;
@@ skipping 744 matching lines @@
     try_catch_handler()->has_terminated_ = true;
     try_catch_handler()->exception_ = heap()->null_value();
   } else {
     // At this point all non-object (failure) exceptions have
     // been dealt with so this shouldn't fail.
     ASSERT(!pending_exception()->IsFailure());
     try_catch_handler()->can_continue_ = true;
     try_catch_handler()->has_terminated_ = false;
     try_catch_handler()->exception_ = pending_exception();
     if (!thread_local_top_.pending_message_obj_->IsTheHole()) {
-      try_catch_handler()->message_ = thread_local_top_.pending_message_obj_;
+      try_catch_handler()->message_obj_ =
+        thread_local_top_.pending_message_obj_;
+      if (!thread_local_top_.pending_message_script_->IsTheHole()) {
+        try_catch_handler()->message_script_ =
+          thread_local_top_.pending_message_script_;
+      }
+      try_catch_handler()->message_start_pos_ =
+        thread_local_top_.pending_message_start_pos_;
+      try_catch_handler()->message_end_pos_ =
+        thread_local_top_.pending_message_end_pos_;
     }
   }
 }
 
 
 void Isolate::InitializeLoggingAndCounters() {
   if (logger_ == NULL) {
     logger_ = new Logger(this);
   }
   if (counters_ == NULL) {
@@ skipping 436 matching lines @@
 
 #ifdef DEBUG
 #define ISOLATE_FIELD_OFFSET(type, name, ignored)                       \
 const intptr_t Isolate::name##_debug_offset_ = OFFSET_OF(Isolate, name##_);
 ISOLATE_INIT_LIST(ISOLATE_FIELD_OFFSET)
 ISOLATE_INIT_ARRAY_LIST(ISOLATE_FIELD_OFFSET)
 #undef ISOLATE_FIELD_OFFSET
 #endif
 
 } }  // namespace v8::internal