Removing one more TLS from ON_BAILOUT

src/api.cc

 // Copyright 2010 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 51 matching lines @@
   i::VMState __state__((isolate), i::EXTERNAL)
 #else
 #define ENTER_V8(isolate) ((void) 0)
 #define LEAVE_V8(isolate) ((void) 0)
 #endif
 
 namespace v8 {
 
 #define ON_BAILOUT(isolate, location, code)                        \
   if (IsDeadCheck(isolate, location) ||                            \
-            v8::V8::IsExecutionTerminating()) {                    \
+            IsExecutionTerminatingCheck(isolate)) {                \
     code;                                                          \
     UNREACHABLE();                                                 \
   }
 
 
 #define EXCEPTION_PREAMBLE(isolate)                                         \
   (isolate)->handle_scope_implementer()->IncrementCallDepth();              \
   ASSERT(!(isolate)->external_caught_exception());                          \
   bool has_pending_exception = false
 
@@ skipping 165 matching lines @@
  * can arrange to return if the VM is dead.  This is needed to ensure that no VM
  * heap allocations are attempted on a dead VM.  EnsureInitialized has the
  * advantage over ON_BAILOUT that it actually initializes the VM if this has not
  * yet been done.
  */
 static inline bool IsDeadCheck(i::Isolate* isolate, const char* location) {
   return !isolate->IsInitialized()
       && i::V8::IsDead() ? ReportV8Dead(location) : false;
 }
 
+static inline bool IsExecutionTerminatingCheck(i::Isolate* isolate) {
+  if (!isolate->IsInitialized()) return false;
+  if (isolate->has_scheduled_exception()) {
+    return isolate->scheduled_exception() ==
+        isolate->heap()->termination_exception();
+  }
+  return false;
+}
 
 static inline bool EmptyCheck(const char* location, v8::Handle<v8::Data> obj) {
   return obj.IsEmpty() ? ReportEmptyHandle(location) : false;
 }
 
 
 static inline bool EmptyCheck(const char* location, const v8::Data* obj) {
   return (obj == 0) ? ReportEmptyHandle(location) : false;
 }
 
@@ skipping 4354 matching lines @@
   if (isolate != NULL) {
     reinterpret_cast<i::Isolate*>(isolate)->stack_guard()->TerminateExecution();
   } else {
     i::Isolate::GetDefaultIsolateStackGuard()->TerminateExecution();
   }
 }
 
 
 bool V8::IsExecutionTerminating() {
   i::Isolate* isolate = i::Isolate::Current();
-  if (!isolate->IsInitialized()) return false;
-  if (isolate->has_scheduled_exception()) {
-    return isolate->scheduled_exception() ==
-        HEAP->termination_exception();
-  }
-  return false;
+  return IsExecutionTerminatingCheck(isolate);
 }
 
 
 Isolate* Isolate::GetCurrent() {
   i::Isolate* isolate = i::Isolate::UncheckedCurrent();
   return reinterpret_cast<Isolate*>(isolate);
 }
 
 
 Isolate* Isolate::New() {
@@ skipping 1074 matching lines @@
 
 
 char* HandleScopeImplementer::Iterate(ObjectVisitor* v, char* storage) {
   HandleScopeImplementer* thread_local =
       reinterpret_cast<HandleScopeImplementer*>(storage);
   thread_local->IterateThis(v);
   return storage + ArchiveSpacePerThread();
 }
 
 } }  // namespace v8::internal