Properly process try/finally blocks.

src/top.h

 // 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 231 matching lines @@
     ASSERT(has_scheduled_exception());
     return thread_local_.scheduled_exception_;
   }
   static bool has_scheduled_exception() {
     return !thread_local_.scheduled_exception_->IsTheHole();
   }
   static void clear_scheduled_exception() {
     thread_local_.scheduled_exception_ = Heap::the_hole_value();
   }
 
-  static void setup_external_caught() {
-    thread_local_.external_caught_exception_ =
-        has_pending_exception() &&
-        (thread_local_.catcher_ != NULL) &&
-        (try_catch_handler() == thread_local_.catcher_);
-  }
+  static bool IsExternallyCaught();
 
   static void SetCaptureStackTraceForUncaughtExceptions(
       bool capture,
       int frame_limit,
       StackTrace::StackTraceOptions options);
 
   // Tells whether the current context has experienced an out of memory
   // exception.
   static bool is_out_of_memory();
 
+  static bool is_catchable_by_javascript(MaybeObject* exception) {
+    return

[Mads Ager (chromium), 2011/02/16 09:17:49]

Why the extra line? I would probably do:

return ((exception != Failure::...) &&
        (exception != Heap::...));

[antonm, 2011/02/16 11:40:44]

I find it more aesthetically pleasing to have this parallel structures, but
let's do it your way.

On 2011/02/16 09:17:49, Mads Ager wrote:

+        (exception != Failure::OutOfMemoryException()) &&
+        (exception != Heap::termination_exception());
+  }
+
   // JS execution stack (see frames.h).
   static Address c_entry_fp(ThreadLocalTop* thread) {
     return thread->c_entry_fp_;
   }
   static Address handler(ThreadLocalTop* thread) { return thread->handler_; }
 
   static inline Address* c_entry_fp_address() {
     return &thread_local_.c_entry_fp_;
   }
   static inline Address* handler_address() { return &thread_local_.handler_; }
@@ skipping 112 matching lines @@
   static void ReportPendingMessages();
   static Failure* ThrowIllegalOperation();
 
   // Promote a scheduled exception to pending. Asserts has_scheduled_exception.
   static Failure* PromoteScheduledException();
   static void DoThrow(MaybeObject* exception,
                       MessageLocation* location,
                       const char* message);
   // Checks if exception should be reported and finds out if it's
   // caught externally.
-  static bool ShouldReportException(bool* is_caught_externally,
+  static bool ShouldReportException(bool* can_be_caught_externally,
                                     bool catchable_by_javascript);
 
   // Attempts to compute the current source location, storing the
   // result in the target out parameter.
   static void ComputeLocation(MessageLocation* target);
 
   // Override command line flag.
   static void TraceException(bool flag);
 
   // Out of resource exception helpers.
@@ skipping 188 matching lines @@
   static void Unlock() { Top::break_access_->Unlock(); }
 
   static bool TryLock() {
     return Top::break_access_->TryLock();
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_TOP_H_