Reland of "v8::TryCatch now works correctly with ASAN's UseAfterReturn mode enabled."

src/isolate.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_ISOLATE_H_
 #define V8_ISOLATE_H_
 
 #include "../include/v8-debug.h"
 #include "allocation.h"
 #include "assert-scope.h"
@@ skipping 196 matching lines @@
  public:
   // Does early low-level initialization that does not depend on the
   // isolate being present.
   ThreadLocalTop();
 
   // Initialize the thread data.
   void Initialize();
 
   // Get the top C++ try catch handler or NULL if none are registered.
   //
-  // This method is not guarenteed to return an address that can be
+  // This method is not guaranteed to return an address that can be
   // used for comparison with addresses into the JS stack.  If such an
   // address is needed, use try_catch_handler_address.
-  v8::TryCatch* TryCatchHandler();
+  FIELD_ACCESSOR(v8::TryCatch*, try_catch_handler)
 
   // Get the address of the top C++ try catch handler or NULL if
   // none are registered.
   //
   // This method always returns an address that can be compared to
   // pointers into the JavaScript stack.  When running on actual
   // hardware, try_catch_handler_address and TryCatchHandler return
   // the same pointer.  When running on a simulator with a separate JS
   // stack, try_catch_handler_address returns a JS stack address that
   // corresponds to the place on the JS stack where the C++ handler
   // would have been if the stack were not separate.
-  FIELD_ACCESSOR(Address, try_catch_handler_address)
+  Address try_catch_handler_address() {
+    return reinterpret_cast<Address>(
+        v8::TryCatch::JSStackComparableAddress(try_catch_handler()));
+  }
 
   void Free() {
     ASSERT(!has_pending_message_);
     ASSERT(!external_caught_exception_);
-    ASSERT(try_catch_handler_address_ == NULL);
+    ASSERT(try_catch_handler_ == NULL);
   }
 
   Isolate* isolate_;
   // The context where the current execution method is created and for variable
   // lookups.
   Context* context_;
   ThreadId thread_id_;
   Object* pending_exception_;
   bool has_pending_message_;
   bool rethrowing_message_;
@@ skipping 27 matching lines @@
 
   // Call back function to report unsafe JS accesses.
   v8::FailedAccessCheckCallback failed_access_check_callback_;
 
   // Head of the list of live LookupResults.
   LookupResult* top_lookup_result_;
 
  private:
   void InitializeInternal();
 
-  Address try_catch_handler_address_;
+  v8::TryCatch* try_catch_handler_;
 };
 
 
 #if V8_TARGET_ARCH_ARM && !defined(__arm__) || \
     V8_TARGET_ARCH_ARM64 && !defined(__aarch64__) || \
     V8_TARGET_ARCH_MIPS && !defined(__mips__)
 
 #define ISOLATE_INIT_SIMULATOR_LIST(V)                                         \
   V(bool, simulator_initialized, false)                                        \
   V(HashMap*, simulator_i_cache, NULL)                                         \
@@ skipping 258 matching lines @@
   }
 
   THREAD_LOCAL_TOP_ACCESSOR(bool, external_caught_exception)
 
   void clear_pending_message() {
     thread_local_top_.has_pending_message_ = false;
     thread_local_top_.pending_message_obj_ = heap_.the_hole_value();
     thread_local_top_.pending_message_script_ = heap_.the_hole_value();
   }
   v8::TryCatch* try_catch_handler() {
-    return thread_local_top_.TryCatchHandler();
+    return thread_local_top_.try_catch_handler();
   }
   Address try_catch_handler_address() {
     return thread_local_top_.try_catch_handler_address();
   }
   bool* external_caught_exception_address() {
     return &thread_local_top_.external_caught_exception_;
   }
 
   THREAD_LOCAL_TOP_ACCESSOR(v8::TryCatch*, catcher)
 
@@ skipping 906 matching lines @@
   }
 
   EmbeddedVector<char, 128> filename_;
   FILE* file_;
   int scope_depth_;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_ISOLATE_H_