From 11b2436500d5018a7c8a17a48a49a7f84d8f4df9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C3=ABl=20Zasso?= <targos@protonmail.com>
Date: Fri, 11 Nov 2022 08:20:17 +0100
Subject: [PATCH] deps: V8: cherry-pick 031b98b25cba
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Original commit message:

    [runtime] Clear array join stack when throwing uncatchable

    ... exception.

    Array#join depends array_join_stack to avoid infinite loop
    and ensures symmetric pushes/pops through catch blocks to
    correctly maintain the elements in the join stack.
    However, the stack does not pop the elements and leaves in
    an invalid state when throwing the uncatchable termination
    exception. And the invalid join stack state will affect
    subsequent Array#join calls. Because all the terminate
    exception will be handled by Isolate::UnwindAndFindHandler,
    we could clear the array join stack when unwinding the terminate
    exception.

    Bug: v8:13259
    Change-Id: I23823e823c5fe0b089528c5cf654864cea78ebeb
    Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/3878451
    Reviewed-by: Jakob Linke <jgruber@chromium.org>
    Commit-Queue: 王澳 <wangao.james@bytedance.com>
    Cr-Commit-Position: refs/heads/main@{#83465}

Refs: https://github.com/v8/v8/commit/031b98b25cbaaa4c62d8544f5f667d33ea4076c4
Closes: https://github.com/nodejs/node/issues/44417
PR-URL: https://github.com/nodejs/node/pull/45375
Fixes: https://github.com/nodejs/node/issues/44417
Reviewed-By: Jiawen Geng <technicalcute@gmail.com>
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Kohei Ueno <kohei.ueno119@gmail.com>
---
 deps/v8/src/execution/isolate.cc              |    9 +
 ...ode-side-effecting-array-join-expected.txt |   48 +
 ...ate-repl-mode-side-effecting-array-join.js |   32 +
 .../execution/thread-termination-unittest.cc  | 1069 +++++++++++++++++
 4 files changed, 1158 insertions(+)
 create mode 100644 deps/v8/test/inspector/runtime/evaluate-repl-mode-side-effecting-array-join-expected.txt
 create mode 100644 deps/v8/test/inspector/runtime/evaluate-repl-mode-side-effecting-array-join.js
 create mode 100644 deps/v8/test/unittests/execution/thread-termination-unittest.cc

diff --git a/deps/v8/src/execution/isolate.cc b/deps/v8/src/execution/isolate.cc
index 62d9f4abc33fed..e5dba75764f6a9 100644
--- a/deps/v8/src/execution/isolate.cc
+++ b/deps/v8/src/execution/isolate.cc
@@ -1909,6 +1909,15 @@ Object Isolate::UnwindAndFindHandler() {
   // Special handling of termination exceptions, uncatchable by JavaScript and
   // Wasm code, we unwind the handlers until the top ENTRY handler is found.
   bool catchable_by_js = is_catchable_by_javascript(exception);
+  if (!catchable_by_js && !context().is_null()) {
+    // Because the array join stack will not pop the elements when throwing the
+    // uncatchable terminate exception, we need to clear the array join stack to
+    // avoid leaving the stack in an invalid state.
+    // See also CycleProtectedArrayJoin.
+    raw_native_context().set_array_join_stack(
+        ReadOnlyRoots(this).undefined_value());
+  }
+
   int visited_frames = 0;
 
   // Compute handler and stack unwinding information by performing a full walk
diff --git a/deps/v8/test/inspector/runtime/evaluate-repl-mode-side-effecting-array-join-expected.txt b/deps/v8/test/inspector/runtime/evaluate-repl-mode-side-effecting-array-join-expected.txt
new file mode 100644
index 00000000000000..19ad7f863eeba9
--- /dev/null
+++ b/deps/v8/test/inspector/runtime/evaluate-repl-mode-side-effecting-array-join-expected.txt
@@ -0,0 +1,48 @@
+Tests that Runtime.evaluate with REPL mode correctly handles Array.prototype.join.
+{
+    id : <messageId>
+    result : {
+        result : {
+            className : Array
+            description : Array(1)
+            objectId : <objectId>
+            subtype : array
+            type : object
+        }
+    }
+}
+{
+    id : <messageId>
+    result : {
+        exceptionDetails : {
+            columnNumber : -1
+            exception : {
+                className : EvalError
+                description : EvalError: Possible side-effect in debug-evaluate
+                objectId : <objectId>
+                subtype : error
+                type : object
+            }
+            exceptionId : <exceptionId>
+            lineNumber : -1
+            scriptId : <scriptId>
+            text : Uncaught
+        }
+        result : {
+            className : EvalError
+            description : EvalError: Possible side-effect in debug-evaluate
+            objectId : <objectId>
+            subtype : error
+            type : object
+        }
+    }
+}
+{
+    id : <messageId>
+    result : {
+        result : {
+            type : string
+            value : /a/
+        }
+    }
+}
diff --git a/deps/v8/test/inspector/runtime/evaluate-repl-mode-side-effecting-array-join.js b/deps/v8/test/inspector/runtime/evaluate-repl-mode-side-effecting-array-join.js
new file mode 100644
index 00000000000000..05259ff24f4d95
--- /dev/null
+++ b/deps/v8/test/inspector/runtime/evaluate-repl-mode-side-effecting-array-join.js
@@ -0,0 +1,32 @@
+// Copyright 2022 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.
+
+let {Protocol} = InspectorTest.start(
+  'Tests that Runtime.evaluate with REPL mode correctly handles \
+Array.prototype.join.');
+
+Protocol.Runtime.enable();
+(async function () {
+  await evaluateReplWithSideEffects('a=[/a/]')
+  await evaluateRepl('a.toString()');
+  await evaluateReplWithSideEffects('a.toString()');
+
+  InspectorTest.completeTest();
+})();
+
+async function evaluateRepl(expression) {
+  InspectorTest.logMessage(await Protocol.Runtime.evaluate({
+    expression: expression,
+    replMode: true,
+    throwOnSideEffect: true
+  }));
+}
+
+async function evaluateReplWithSideEffects(expression) {
+  InspectorTest.logMessage(await Protocol.Runtime.evaluate({
+    expression: expression,
+    replMode: true,
+    throwOnSideEffect: false
+  }));
+}
diff --git a/deps/v8/test/unittests/execution/thread-termination-unittest.cc b/deps/v8/test/unittests/execution/thread-termination-unittest.cc
new file mode 100644
index 00000000000000..f9634b4a53d7e3
--- /dev/null
+++ b/deps/v8/test/unittests/execution/thread-termination-unittest.cc
@@ -0,0 +1,1069 @@
+// Copyright 2009 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
+//       with the distribution.
+//     * Neither the name of Google Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived
+//       from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "include/v8-function.h"
+#include "include/v8-locker.h"
+#include "src/api/api-inl.h"
+#include "src/base/platform/platform.h"
+#include "src/execution/isolate.h"
+#include "src/init/v8.h"
+#include "src/objects/objects-inl.h"
+#include "test/unittests/test-utils.h"
+#include "testing/gmock-support.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace v8 {
+
+base::Semaphore* semaphore = nullptr;
+
+class TerminatorThread : public base::Thread {
+ public:
+  explicit TerminatorThread(i::Isolate* isolate)
+      : Thread(Options("TerminatorThread")),
+        isolate_(reinterpret_cast<Isolate*>(isolate)) {}
+  void Run() override {
+    semaphore->Wait();
+    CHECK(!isolate_->IsExecutionTerminating());
+    isolate_->TerminateExecution();
+  }
+
+ private:
+  Isolate* isolate_;
+};
+
+void Signal(const FunctionCallbackInfo<Value>& args) { semaphore->Signal(); }
+
+MaybeLocal<Value> CompileRun(Local<Context> context, Local<String> source) {
+  Local<Script> script = Script::Compile(context, source).ToLocalChecked();
+  return script->Run(context);
+}
+
+MaybeLocal<Value> CompileRun(Local<Context> context, const char* source) {
+  return CompileRun(
+      context,
+      String::NewFromUtf8(context->GetIsolate(), source).ToLocalChecked());
+}
+
+void DoLoop(const FunctionCallbackInfo<Value>& args) {
+  TryCatch try_catch(args.GetIsolate());
+  CHECK(!args.GetIsolate()->IsExecutionTerminating());
+  MaybeLocal<Value> result = CompileRun(args.GetIsolate()->GetCurrentContext(),
+                                        "function f() {"
+                                        "  var term = true;"
+                                        "  try {"
+                                        "    while(true) {"
+                                        "      if (term) terminate();"
+                                        "      term = false;"
+                                        "    }"
+                                        "    fail();"
+                                        "  } catch(e) {"
+                                        "    fail();"
+                                        "  }"
+                                        "}"
+                                        "f()");
+  CHECK(result.IsEmpty());
+  CHECK(try_catch.HasCaught());
+  CHECK(try_catch.Exception()->IsNull());
+  CHECK(try_catch.Message().IsEmpty());
+  CHECK(!try_catch.CanContinue());
+  CHECK(args.GetIsolate()->IsExecutionTerminating());
+}
+
+void Fail(const FunctionCallbackInfo<Value>& args) { UNREACHABLE(); }
+
+void Loop(const FunctionCallbackInfo<Value>& args) {
+  CHECK(!args.GetIsolate()->IsExecutionTerminating());
+  MaybeLocal<Value> result =
+      CompileRun(args.GetIsolate()->GetCurrentContext(),
+                 "try { doloop(); fail(); } catch(e) { fail(); }");
+  CHECK(result.IsEmpty());
+  CHECK(args.GetIsolate()->IsExecutionTerminating());
+}
+
+void TerminateCurrentThread(const FunctionCallbackInfo<Value>& args) {
+  CHECK(!args.GetIsolate()->IsExecutionTerminating());
+  args.GetIsolate()->TerminateExecution();
+}
+
+class ThreadTerminationTest : public TestWithIsolate {
+ public:
+  void TestTerminatingFromOtherThread(const char* source) {
+    semaphore = new base::Semaphore(0);
+    TerminatorThread thread(i_isolate());
+    CHECK(thread.Start());
+
+    HandleScope scope(isolate());
+    Local<ObjectTemplate> global =
+        CreateGlobalTemplate(isolate(), Signal, DoLoop);
+    Local<Context> context = Context::New(isolate(), nullptr, global);
+    Context::Scope context_scope(context);
+    CHECK(!isolate()->IsExecutionTerminating());
+    MaybeLocal<Value> result = TryRunJS(source);
+    CHECK(result.IsEmpty());
+    thread.Join();
+    delete semaphore;
+    semaphore = nullptr;
+  }
+
+  void TestTerminatingFromCurrentThread(const char* source) {
+    HandleScope scope(isolate());
+    Local<ObjectTemplate> global =
+        CreateGlobalTemplate(isolate(), TerminateCurrentThread, DoLoop);
+    Local<Context> context = Context::New(isolate(), nullptr, global);
+    Context::Scope context_scope(context);
+    CHECK(!isolate()->IsExecutionTerminating());
+    MaybeLocal<Value> result = TryRunJS(source);
+    CHECK(result.IsEmpty());
+  }
+
+  Local<ObjectTemplate> CreateGlobalTemplate(Isolate* isolate,
+                                             FunctionCallback terminate,
+                                             FunctionCallback doloop) {
+    Local<ObjectTemplate> global = ObjectTemplate::New(isolate);
+    global->Set(NewString("terminate"),
+                FunctionTemplate::New(isolate, terminate));
+    global->Set(NewString("fail"), FunctionTemplate::New(isolate, Fail));
+    global->Set(NewString("loop"), FunctionTemplate::New(isolate, Loop));
+    global->Set(NewString("doloop"), FunctionTemplate::New(isolate, doloop));
+    return global;
+  }
+};
+
+void DoLoopNoCall(const FunctionCallbackInfo<Value>& args) {
+  TryCatch try_catch(args.GetIsolate());
+  CHECK(!args.GetIsolate()->IsExecutionTerminating());
+  MaybeLocal<Value> result = CompileRun(args.GetIsolate()->GetCurrentContext(),
+                                        "var term = true;"
+                                        "while(true) {"
+                                        "  if (term) terminate();"
+                                        "  term = false;"
+                                        "}");
+  CHECK(result.IsEmpty());
+  CHECK(try_catch.HasCaught());
+  CHECK(try_catch.Exception()->IsNull());
+  CHECK(try_catch.Message().IsEmpty());
+  CHECK(!try_catch.CanContinue());
+  CHECK(args.GetIsolate()->IsExecutionTerminating());
+}
+
+// Test that a single thread of JavaScript execution can terminate
+// itself.
+TEST_F(ThreadTerminationTest, TerminateOnlyV8ThreadFromThreadItself) {
+  HandleScope scope(isolate());
+  Local<ObjectTemplate> global =
+      CreateGlobalTemplate(isolate(), TerminateCurrentThread, DoLoop);
+  Local<Context> context = Context::New(isolate(), nullptr, global);
+  Context::Scope context_scope(context);
+  CHECK(!isolate()->IsExecutionTerminating());
+  // Run a loop that will be infinite if thread termination does not work.
+  MaybeLocal<Value> result =
+      TryRunJS("try { loop(); fail(); } catch(e) { fail(); }");
+  CHECK(result.IsEmpty());
+  // Test that we can run the code again after thread termination.
+  CHECK(!isolate()->IsExecutionTerminating());
+  result = TryRunJS("try { loop(); fail(); } catch(e) { fail(); }");
+  CHECK(result.IsEmpty());
+}
+
+// Test that a single thread of JavaScript execution can terminate
+// itself in a loop that performs no calls.
+TEST_F(ThreadTerminationTest, TerminateOnlyV8ThreadFromThreadItselfNoLoop) {
+  HandleScope scope(isolate());
+  Local<ObjectTemplate> global =
+      CreateGlobalTemplate(isolate(), TerminateCurrentThread, DoLoopNoCall);
+  Local<Context> context = Context::New(isolate(), nullptr, global);
+  Context::Scope context_scope(context);
+  CHECK(!isolate()->IsExecutionTerminating());
+  // Run a loop that will be infinite if thread termination does not work.
+  static const char* source = "try { loop(); fail(); } catch(e) { fail(); }";
+  MaybeLocal<Value> result = TryRunJS(source);
+  CHECK(result.IsEmpty());
+  CHECK(!isolate()->IsExecutionTerminating());
+  // Test that we can run the code again after thread termination.
+  result = TryRunJS(source);
+  CHECK(result.IsEmpty());
+}
+
+// Test that a single thread of JavaScript execution can be terminated
+// from the side by another thread.
+TEST_F(ThreadTerminationTest, TerminateOnlyV8ThreadFromOtherThread) {
+  // Run a loop that will be infinite if thread termination does not work.
+  TestTerminatingFromOtherThread(
+      "try { loop(); fail(); } catch(e) { fail(); }");
+}
+
+// Test that execution can be terminated from within JSON.stringify.
+TEST_F(ThreadTerminationTest, TerminateJsonStringify) {
+  TestTerminatingFromCurrentThread(
+      "var x = [];"
+      "x[2**31]=1;"
+      "terminate();"
+      "JSON.stringify(x);"
+      "fail();");
+}
+
+TEST_F(ThreadTerminationTest, TerminateBigIntMultiplication) {
+  TestTerminatingFromCurrentThread(
+      "terminate();"
+      "var a = 5n ** 555555n;"
+      "var b = 3n ** 3333333n;"
+      "a * b;"
+      "fail();");
+}
+
+TEST_F(ThreadTerminationTest, TerminateOptimizedBigIntMultiplication) {
+  i::FLAG_allow_natives_syntax = true;
+  TestTerminatingFromCurrentThread(
+      "function foo(a, b) { return a * b; }"
+      "%PrepareFunctionForOptimization(foo);"
+      "foo(1n, 2n);"
+      "foo(1n, 2n);"
+      "%OptimizeFunctionOnNextCall(foo);"
+      "foo(1n, 2n);"
+      "var a = 5n ** 555555n;"
+      "var b = 3n ** 3333333n;"
+      "terminate();"
+      "foo(a, b);"
+      "fail();");
+}
+
+TEST_F(ThreadTerminationTest, TerminateBigIntDivision) {
+  TestTerminatingFromCurrentThread(
+      "var a = 2n ** 2222222n;"
+      "var b = 3n ** 333333n;"
+      "terminate();"
+      "a / b;"
+      "fail();");
+}
+
+TEST_F(ThreadTerminationTest, TerminateOptimizedBigIntDivision) {
+  i::FLAG_allow_natives_syntax = true;
+  TestTerminatingFromCurrentThread(
+      "function foo(a, b) { return a / b; }"
+      "%PrepareFunctionForOptimization(foo);"
+      "foo(3n, 2n);"
+      "foo(3n, 2n);"
+      "%OptimizeFunctionOnNextCall(foo);"
+      "foo(3n, 2n);"
+      "var a = 2n ** 2222222n;"
+      "var b = 3n ** 333333n;"
+      "terminate();"
+      "foo(a, b);"
+      "fail();");
+}
+
+TEST_F(ThreadTerminationTest, TerminateBigIntToString) {
+  TestTerminatingFromCurrentThread(
+      "var a = 2n ** 2222222n;"
+      "terminate();"
+      "a.toString();"
+      "fail();");
+}
+
+TEST_F(ThreadTerminationTest, TerminateBigIntFromString) {
+  TestTerminatingFromCurrentThread(
+      "var a = '12344567890'.repeat(100000);\n"
+      "terminate();\n"
+      "BigInt(a);\n"
+      "fail();\n");
+}
+
+void LoopGetProperty(const FunctionCallbackInfo<Value>& args) {
+  TryCatch try_catch(args.GetIsolate());
+  CHECK(!args.GetIsolate()->IsExecutionTerminating());
+  MaybeLocal<Value> result =
+      CompileRun(args.GetIsolate()->GetCurrentContext(),
+                 "function f() {"
+                 "  try {"
+                 "    while(true) {"
+                 "      terminate_or_return_object().x;"
+                 "    }"
+                 "    fail();"
+                 "  } catch(e) {"
+                 "    (function() {})();"  // trigger stack check.
+                 "    fail();"
+                 "  }"
+                 "}"
+                 "f()");
+  CHECK(result.IsEmpty());
+  CHECK(try_catch.HasCaught());
+  CHECK(try_catch.Exception()->IsNull());
+  CHECK(try_catch.Message().IsEmpty());
+  CHECK(!try_catch.CanContinue());
+  CHECK(args.GetIsolate()->IsExecutionTerminating());
+}
+
+int call_count = 0;
+
+void TerminateOrReturnObject(const FunctionCallbackInfo<Value>& args) {
+  if (++call_count == 10) {
+    CHECK(!args.GetIsolate()->IsExecutionTerminating());
+    args.GetIsolate()->TerminateExecution();
+    return;
+  }
+  Local<Object> result = Object::New(args.GetIsolate());
+  Local<Context> context = args.GetIsolate()->GetCurrentContext();
+  Maybe<bool> val = result->Set(
+      context, String::NewFromUtf8(context->GetIsolate(), "x").ToLocalChecked(),
+      Integer::New(args.GetIsolate(), 42));
+  CHECK(val.FromJust());
+  args.GetReturnValue().Set(result);
+}
+
+// Test that we correctly handle termination exceptions if they are
+// triggered by the creation of error objects in connection with ICs.
+TEST_F(ThreadTerminationTest, TerminateLoadICException) {
+  HandleScope scope(isolate());
+  Local<ObjectTemplate> global = ObjectTemplate::New(isolate());
+  global->Set(NewString("terminate_or_return_object"),
+              FunctionTemplate::New(isolate(), TerminateOrReturnObject));
+  global->Set(NewString("fail"), FunctionTemplate::New(isolate(), Fail));
+  global->Set(NewString("loop"),
+              FunctionTemplate::New(isolate(), LoopGetProperty));
+
+  Local<Context> context = Context::New(isolate(), nullptr, global);
+  Context::Scope context_scope(context);
+  CHECK(!isolate()->IsExecutionTerminating());
+  // Run a loop that will be infinite if thread termination does not work.
+  static const char* source = "try { loop(); fail(); } catch(e) { fail(); }";
+  call_count = 0;
+  MaybeLocal<Value> result = CompileRun(isolate()->GetCurrentContext(), source);
+  CHECK(result.IsEmpty());
+  // Test that we can run the code again after thread termination.
+  CHECK(!isolate()->IsExecutionTerminating());
+  call_count = 0;
+  result = CompileRun(isolate()->GetCurrentContext(), source);
+  CHECK(result.IsEmpty());
+}
+
+Persistent<String> reenter_script_1;
+Persistent<String> reenter_script_2;
+
+void ReenterAfterTermination(const FunctionCallbackInfo<Value>& args) {
+  TryCatch try_catch(args.GetIsolate());
+  Isolate* isolate = args.GetIsolate();
+  CHECK(!isolate->IsExecutionTerminating());
+  Local<String> script = Local<String>::New(isolate, reenter_script_1);
+  MaybeLocal<Value> result =
+      CompileRun(Isolate::GetCurrent()->GetCurrentContext(), script);
+  CHECK(result.IsEmpty());
+  CHECK(try_catch.HasCaught());
+  CHECK(try_catch.Exception()->IsNull());
+  CHECK(try_catch.Message().IsEmpty());
+  CHECK(!try_catch.CanContinue());
+  CHECK(try_catch.HasTerminated());
+  CHECK(isolate->IsExecutionTerminating());
+  script = Local<String>::New(isolate, reenter_script_2);
+  MaybeLocal<Script> compiled_script =
+      Script::Compile(isolate->GetCurrentContext(), script);
+  CHECK(compiled_script.IsEmpty());
+}
+
+// Test that reentry into V8 while the termination exception is still pending
+// (has not yet unwound the 0-level JS frame) does not crash.
+TEST_F(ThreadTerminationTest, TerminateAndReenterFromThreadItself) {
+  HandleScope scope(isolate());
+  Local<ObjectTemplate> global = CreateGlobalTemplate(
+      isolate(), TerminateCurrentThread, ReenterAfterTermination);
+  Local<Context> context = Context::New(isolate(), nullptr, global);
+  Context::Scope context_scope(context);
+  CHECK(!isolate()->IsExecutionTerminating());
+  // Create script strings upfront as it won't work when terminating.
+  reenter_script_1.Reset(isolate(), NewString("function f() {"
+                                              "  var term = true;"
+                                              "  try {"
+                                              "    while(true) {"
+                                              "      if (term) terminate();"
+                                              "      term = false;"
+                                              "    }"
+                                              "    fail();"
+                                              "  } catch(e) {"
+                                              "    fail();"
+                                              "  }"
+                                              "}"
+                                              "f()"));
+  reenter_script_2.Reset(isolate(), NewString("function f() { fail(); } f()"));
+  TryRunJS("try { loop(); fail(); } catch(e) { fail(); }");
+  CHECK(!isolate()->IsExecutionTerminating());
+  // Check we can run JS again after termination.
+  CHECK(RunJS("function f() { return true; } f()")->IsTrue());
+  reenter_script_1.Reset();
+  reenter_script_2.Reset();
+}
+
+TEST_F(ThreadTerminationTest,
+       TerminateAndReenterFromThreadItselfWithOuterTryCatch) {
+  HandleScope scope(isolate());
+  Local<ObjectTemplate> global = CreateGlobalTemplate(
+      isolate(), TerminateCurrentThread, ReenterAfterTermination);
+  Local<Context> context = Context::New(isolate(), nullptr, global);
+  Context::Scope context_scope(context);
+  CHECK(!isolate()->IsExecutionTerminating());
+  // Create script strings upfront as it won't work when terminating.
+  reenter_script_1.Reset(isolate(), NewString("function f() {"
+                                              "  var term = true;"
+                                              "  try {"
+                                              "    while(true) {"
+                                              "      if (term) terminate();"
+                                              "      term = false;"
+                                              "    }"
+                                              "    fail();"
+                                              "  } catch(e) {"
+                                              "    fail();"
+                                              "  }"
+                                              "}"
+                                              "f()"));
+  reenter_script_2.Reset(isolate(), NewString("function f() { fail(); } f()"));
+  {
+    TryCatch try_catch(isolate());
+    TryRunJS("try { loop(); fail(); } catch(e) { fail(); }");
+    CHECK(try_catch.HasCaught());
+    CHECK(try_catch.Exception()->IsNull());
+    CHECK(try_catch.Message().IsEmpty());
+    CHECK(!try_catch.CanContinue());
+    CHECK(try_catch.HasTerminated());
+    CHECK(isolate()->IsExecutionTerminating());
+  }
+  CHECK(!isolate()->IsExecutionTerminating());
+  // Check we can run JS again after termination.
+  CHECK(RunJS("function f() { return true; } f()")->IsTrue());
+  reenter_script_1.Reset();
+  reenter_script_2.Reset();
+}
+
+void DoLoopCancelTerminate(const FunctionCallbackInfo<Value>& args) {
+  Isolate* isolate = args.GetIsolate();
+  TryCatch try_catch(isolate);
+  CHECK(!isolate->IsExecutionTerminating());
+  MaybeLocal<Value> result = CompileRun(isolate->GetCurrentContext(),
+                                        "var term = true;"
+                                        "while(true) {"
+                                        "  if (term) terminate();"
+                                        "  term = false;"
+                                        "}"
+                                        "fail();");
+  CHECK(result.IsEmpty());
+  CHECK(try_catch.HasCaught());
+  CHECK(try_catch.Exception()->IsNull());
+  CHECK(try_catch.Message().IsEmpty());
+  CHECK(!try_catch.CanContinue());
+  CHECK(isolate->IsExecutionTerminating());
+  CHECK(try_catch.HasTerminated());
+  isolate->CancelTerminateExecution();
+  CHECK(!isolate->IsExecutionTerminating());
+}
+
+// Test that a single thread of JavaScript execution can terminate
+// itself and then resume execution.
+TEST_F(ThreadTerminationTest, TerminateCancelTerminateFromThreadItself) {
+  HandleScope scope(isolate());
+  Local<ObjectTemplate> global = CreateGlobalTemplate(
+      isolate(), TerminateCurrentThread, DoLoopCancelTerminate);
+  Local<Context> context = Context::New(isolate(), nullptr, global);
+  Context::Scope context_scope(context);
+  CHECK(!isolate()->IsExecutionTerminating());
+  // Check that execution completed with correct return value.
+  Local<Value> result =
+      CompileRun(isolate()->GetCurrentContext(),
+                 "try { doloop(); } catch(e) { fail(); } 'completed';")
+          .ToLocalChecked();
+  CHECK(result->Equals(isolate()->GetCurrentContext(), NewString("completed"))
+            .FromJust());
+}
+
+void MicrotaskShouldNotRun(const FunctionCallbackInfo<Value>& info) {
+  UNREACHABLE();
+}
+
+void MicrotaskLoopForever(const FunctionCallbackInfo<Value>& info) {
+  Isolate* isolate = info.GetIsolate();
+  HandleScope scope(isolate);
+  // Enqueue another should-not-run task to ensure we clean out the queue
+  // when we terminate.
+  isolate->EnqueueMicrotask(
+      Function::New(isolate->GetCurrentContext(), MicrotaskShouldNotRun)
+          .ToLocalChecked());
+  CompileRun(isolate->GetCurrentContext(), "terminate(); while (true) { }");
+  CHECK(isolate->IsExecutionTerminating());
+}
+
+TEST_F(ThreadTerminationTest, TerminateFromOtherThreadWhileMicrotaskRunning) {
+  semaphore = new base::Semaphore(0);
+  TerminatorThread thread(i_isolate());
+  CHECK(thread.Start());
+
+  isolate()->SetMicrotasksPolicy(MicrotasksPolicy::kExplicit);
+  HandleScope scope(isolate());
+  Local<ObjectTemplate> global =
+      CreateGlobalTemplate(isolate(), Signal, DoLoop);
+  Local<Context> context = Context::New(isolate(), nullptr, global);
+  Context::Scope context_scope(context);
+  isolate()->EnqueueMicrotask(
+      Function::New(isolate()->GetCurrentContext(), MicrotaskLoopForever)
+          .ToLocalChecked());
+  // The second task should never be run because we bail out if we're
+  // terminating.
+  isolate()->EnqueueMicrotask(
+      Function::New(isolate()->GetCurrentContext(), MicrotaskShouldNotRun)
+          .ToLocalChecked());
+  isolate()->PerformMicrotaskCheckpoint();
+
+  isolate()->CancelTerminateExecution();
+  // Should not run MicrotaskShouldNotRun.
+  isolate()->PerformMicrotaskCheckpoint();
+
+  thread.Join();
+  delete semaphore;
+  semaphore = nullptr;
+}
+
+static int callback_counter = 0;
+
+static void CounterCallback(Isolate* isolate, void* data) {
+  callback_counter++;
+}
+
+TEST_F(ThreadTerminationTest, PostponeTerminateException) {
+  HandleScope scope(isolate());
+  Local<ObjectTemplate> global =
+      CreateGlobalTemplate(isolate(), TerminateCurrentThread, DoLoop);
+  Local<Context> context = Context::New(isolate(), nullptr, global);
+  Context::Scope context_scope(context);
+
+  TryCatch try_catch(isolate());
+  static const char* terminate_and_loop =
+      "terminate(); for (var i = 0; i < 10000; i++);";
+
+  {  // Postpone terminate execution interrupts.
+    i::PostponeInterruptsScope p1(i_isolate(),
+                                  i::StackGuard::TERMINATE_EXECUTION);
+
+    // API interrupts should still be triggered.
+    isolate()->RequestInterrupt(&CounterCallback, nullptr);
+    CHECK_EQ(0, callback_counter);
+    RunJS(terminate_and_loop);
+    CHECK(!try_catch.HasTerminated());
+    CHECK_EQ(1, callback_counter);
+
+    {  // Postpone API interrupts as well.
+      i::PostponeInterruptsScope p2(i_isolate(), i::StackGuard::API_INTERRUPT);
+
+      // None of the two interrupts should trigger.
+      isolate()->RequestInterrupt(&CounterCallback, nullptr);
+      RunJS(terminate_and_loop);
+      CHECK(!try_catch.HasTerminated());
+      CHECK_EQ(1, callback_counter);
+    }
+
+    // Now the previously requested API interrupt should trigger.
+    RunJS(terminate_and_loop);
+    CHECK(!try_catch.HasTerminated());
+    CHECK_EQ(2, callback_counter);
+  }
+
+  // Now the previously requested terminate execution interrupt should trigger.
+  TryRunJS("for (var i = 0; i < 10000; i++);");
+  CHECK(try_catch.HasTerminated());
+  CHECK_EQ(2, callback_counter);
+}
+
+static void AssertTerminatedCodeRun(Isolate* isolate) {
+  TryCatch try_catch(isolate);
+  CompileRun(isolate->GetCurrentContext(), "for (var i = 0; i < 10000; i++);");
+  CHECK(try_catch.HasTerminated());
+}
+
+static void AssertFinishedCodeRun(Isolate* isolate) {
+  TryCatch try_catch(isolate);
+  CompileRun(isolate->GetCurrentContext(), "for (var i = 0; i < 10000; i++);");
+  CHECK(!try_catch.HasTerminated());
+}
+
+TEST_F(ThreadTerminationTest, SafeForTerminateException) {
+  HandleScope scope(isolate());
+  Local<Context> context = Context::New(isolate());
+  Context::Scope context_scope(context);
+
+  {  // Checks safe for termination scope.
+    i::PostponeInterruptsScope p1(i_isolate(),
+                                  i::StackGuard::TERMINATE_EXECUTION);
+    isolate()->TerminateExecution();
+    AssertFinishedCodeRun(isolate());
+    {
+      i::SafeForInterruptsScope p2(i_isolate(),
+                                   i::StackGuard::TERMINATE_EXECUTION);
+      AssertTerminatedCodeRun(isolate());
+      AssertFinishedCodeRun(isolate());
+      isolate()->TerminateExecution();
+    }
+    AssertFinishedCodeRun(isolate());
+    isolate()->CancelTerminateExecution();
+  }
+
+  isolate()->TerminateExecution();
+  {  // no scope -> postpone
+    i::PostponeInterruptsScope p1(i_isolate(),
+                                  i::StackGuard::TERMINATE_EXECUTION);
+    AssertFinishedCodeRun(isolate());
+    {  // postpone -> postpone
+      i::PostponeInterruptsScope p2(i_isolate(),
+                                    i::StackGuard::TERMINATE_EXECUTION);
+      AssertFinishedCodeRun(isolate());
+
+      {  // postpone -> safe
+        i::SafeForInterruptsScope p3(i_isolate(),
+                                     i::StackGuard::TERMINATE_EXECUTION);
+        AssertTerminatedCodeRun(isolate());
+        isolate()->TerminateExecution();
+
+        {  // safe -> safe
+          i::SafeForInterruptsScope p4(i_isolate(),
+                                       i::StackGuard::TERMINATE_EXECUTION);
+          AssertTerminatedCodeRun(isolate());
+          isolate()->TerminateExecution();
+
+          {  // safe -> postpone
+            i::PostponeInterruptsScope p5(i_isolate(),
+                                          i::StackGuard::TERMINATE_EXECUTION);
+            AssertFinishedCodeRun(isolate());
+          }  // postpone -> safe
+
+          AssertTerminatedCodeRun(isolate());
+          isolate()->TerminateExecution();
+        }  // safe -> safe
+
+        AssertTerminatedCodeRun(isolate());
+        isolate()->TerminateExecution();
+      }  // safe -> postpone
+
+      AssertFinishedCodeRun(isolate());
+    }  // postpone -> postpone
+
+    AssertFinishedCodeRun(isolate());
+  }  // postpone -> no scope
+  AssertTerminatedCodeRun(isolate());
+
+  isolate()->TerminateExecution();
+  {  // no scope -> safe
+    i::SafeForInterruptsScope p1(i_isolate(),
+                                 i::StackGuard::TERMINATE_EXECUTION);
+    AssertTerminatedCodeRun(isolate());
+  }  // safe -> no scope
+  AssertFinishedCodeRun(isolate());
+
+  {  // no scope -> postpone
+    i::PostponeInterruptsScope p1(i_isolate(),
+                                  i::StackGuard::TERMINATE_EXECUTION);
+    isolate()->TerminateExecution();
+    {  // postpone -> safe
+      i::SafeForInterruptsScope p2(i_isolate(),
+                                   i::StackGuard::TERMINATE_EXECUTION);
+      AssertTerminatedCodeRun(isolate());
+    }  // safe -> postpone
+  }    // postpone -> no scope
+  AssertFinishedCodeRun(isolate());
+
+  {  // no scope -> postpone
+    i::PostponeInterruptsScope p1(i_isolate(),
+                                  i::StackGuard::TERMINATE_EXECUTION);
+    {  // postpone -> safe
+      i::SafeForInterruptsScope p2(i_isolate(),
+                                   i::StackGuard::TERMINATE_EXECUTION);
+      {  // safe -> postpone
+        i::PostponeInterruptsScope p3(i_isolate(),
+                                      i::StackGuard::TERMINATE_EXECUTION);
+        isolate()->TerminateExecution();
+      }  // postpone -> safe
+      AssertTerminatedCodeRun(isolate());
+    }  // safe -> postpone
+  }    // postpone -> no scope
+}
+
+void RequestTermianteAndCallAPI(const FunctionCallbackInfo<Value>& args) {
+  args.GetIsolate()->TerminateExecution();
+  AssertFinishedCodeRun(args.GetIsolate());
+}
+
+TEST_F(TestWithPlatform, IsolateSafeForTerminationMode) {
+  Isolate::CreateParams create_params;
+  create_params.only_terminate_in_safe_scope = true;
+  create_params.array_buffer_allocator =
+      v8::ArrayBuffer::Allocator::NewDefaultAllocator();
+  Isolate* isolate = Isolate::New(create_params);
+  i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
+  {
+    Isolate::Scope isolate_scope(isolate);
+    HandleScope handle_scope(isolate);
+    Local<ObjectTemplate> global = ObjectTemplate::New(isolate);
+    global->Set(
+        String::NewFromUtf8(isolate, "terminateAndCallAPI").ToLocalChecked(),
+        FunctionTemplate::New(isolate, RequestTermianteAndCallAPI));
+    Local<Context> context = Context::New(isolate, nullptr, global);
+    Context::Scope context_scope(context);
+
+    // Should postpone termination without safe scope.
+    isolate->TerminateExecution();
+    AssertFinishedCodeRun(isolate);
+    {
+      Isolate::SafeForTerminationScope safe_scope(isolate);
+      AssertTerminatedCodeRun(isolate);
+    }
+    AssertFinishedCodeRun(isolate);
+
+    {
+      isolate->TerminateExecution();
+      AssertFinishedCodeRun(isolate);
+      i::PostponeInterruptsScope p1(i_isolate,
+                                    i::StackGuard::TERMINATE_EXECUTION);
+      {
+        // SafeForTermination overrides postpone.
+        Isolate::SafeForTerminationScope safe_scope(isolate);
+        AssertTerminatedCodeRun(isolate);
+      }
+      AssertFinishedCodeRun(isolate);
+    }
+
+    {
+      Isolate::SafeForTerminationScope safe_scope(isolate);
+      // Request terminate and call API recursively.
+      CompileRun(context, "terminateAndCallAPI()");
+      AssertTerminatedCodeRun(isolate);
+    }
+
+    {
+      i::PostponeInterruptsScope p1(i_isolate,
+                                    i::StackGuard::TERMINATE_EXECUTION);
+      // Request terminate and call API recursively.
+      CompileRun(context, "terminateAndCallAPI()");
+      AssertFinishedCodeRun(isolate);
+    }
+    AssertFinishedCodeRun(isolate);
+    {
+      Isolate::SafeForTerminationScope safe_scope(isolate);
+      AssertTerminatedCodeRun(isolate);
+    }
+  }
+  isolate->Dispose();
+  delete create_params.array_buffer_allocator;
+}
+
+TEST_F(ThreadTerminationTest, ErrorObjectAfterTermination) {
+  HandleScope scope(isolate());
+  Local<Context> context = Context::New(isolate());
+  Context::Scope context_scope(context);
+  isolate()->TerminateExecution();
+  Local<Value> error = Exception::Error(NewString("error"));
+  CHECK(error->IsNativeError());
+}
+
+void InnerTryCallTerminate(const FunctionCallbackInfo<Value>& args) {
+  CHECK(!args.GetIsolate()->IsExecutionTerminating());
+  Isolate* isolate = args.GetIsolate();
+  Local<Object> global = isolate->GetCurrentContext()->Global();
+  Local<Function> loop = Local<Function>::Cast(
+      global
+          ->Get(isolate->GetCurrentContext(),
+                String::NewFromUtf8(isolate, "loop").ToLocalChecked())
+          .ToLocalChecked());
+  i::MaybeHandle<i::Object> exception;
+  i::MaybeHandle<i::Object> result = i::Execution::TryCall(
+      reinterpret_cast<i::Isolate*>(isolate), Utils::OpenHandle((*loop)),
+      Utils::OpenHandle((*global)), 0, nullptr,
+      i::Execution::MessageHandling::kReport, &exception);
+  CHECK(result.is_null());
+  CHECK(exception.is_null());
+  // TryCall reschedules the termination exception.
+  CHECK(args.GetIsolate()->IsExecutionTerminating());
+}
+
+TEST_F(ThreadTerminationTest, TerminationInInnerTryCall) {
+  HandleScope scope(isolate());
+  Local<ObjectTemplate> global_template =
+      CreateGlobalTemplate(isolate(), TerminateCurrentThread, DoLoopNoCall);
+  global_template->Set(NewString("inner_try_call_terminate"),
+                       FunctionTemplate::New(isolate(), InnerTryCallTerminate));
+  Local<Context> context = Context::New(isolate(), nullptr, global_template);
+  Context::Scope context_scope(context);
+  {
+    TryCatch try_catch(isolate());
+    TryRunJS("inner_try_call_terminate()");
+    CHECK(try_catch.HasTerminated());
+    // Any further exectutions in this TryCatch scope would fail.
+    CHECK(isolate()->IsExecutionTerminating());
+  }
+  // Leaving the TryCatch cleared the termination exception.
+  Maybe<int32_t> result =
+      RunJS("2 + 2")->Int32Value(isolate()->GetCurrentContext());
+  CHECK_EQ(4, result.FromJust());
+  CHECK(!isolate()->IsExecutionTerminating());
+}
+
+TEST_F(ThreadTerminationTest, TerminateAndTryCall) {
+  i::FLAG_allow_natives_syntax = true;
+  HandleScope scope(isolate());
+  Local<ObjectTemplate> global = CreateGlobalTemplate(
+      isolate(), TerminateCurrentThread, DoLoopCancelTerminate);
+  Local<Context> context = Context::New(isolate(), nullptr, global);
+  Context::Scope context_scope(context);
+  CHECK(!isolate()->IsExecutionTerminating());
+  {
+    TryCatch try_catch(isolate());
+    CHECK(!isolate()->IsExecutionTerminating());
+    // Terminate execution has been triggered inside TryCall, but re-requested
+    // to trigger later.
+    CHECK(TryRunJS("terminate(); reference_error();").IsEmpty());
+    CHECK(try_catch.HasCaught());
+    CHECK(!isolate()->IsExecutionTerminating());
+    Local<Value> value =
+        context->Global()
+            ->Get(isolate()->GetCurrentContext(), NewString("terminate"))
+            .ToLocalChecked();
+    CHECK(value->IsFunction());
+    // Any further executions in this TryCatch scope fail.
+    CHECK(!isolate()->IsExecutionTerminating());
+    CHECK(TryRunJS("1 + 1").IsEmpty());
+    CHECK(isolate()->IsExecutionTerminating());
+  }
+  // Leaving the TryCatch cleared the termination exception.
+  Maybe<int32_t> result =
+      RunJS("2 + 2")->Int32Value(isolate()->GetCurrentContext());
+  CHECK_EQ(4, result.FromJust());
+  CHECK(!isolate()->IsExecutionTerminating());
+}
+
+class ConsoleImpl : public debug::ConsoleDelegate {
+ private:
+  void Log(const debug::ConsoleCallArguments& args,
+           const debug::ConsoleContext&) override {
+    CompileRun(Isolate::GetCurrent()->GetCurrentContext(), "1 + 1");
+  }
+};
+
+TEST_F(ThreadTerminationTest, TerminateConsole) {
+  i::FLAG_allow_natives_syntax = true;
+  ConsoleImpl console;
+  debug::SetConsoleDelegate(isolate(), &console);
+  HandleScope scope(isolate());
+  Local<ObjectTemplate> global = CreateGlobalTemplate(
+      isolate(), TerminateCurrentThread, DoLoopCancelTerminate);
+  Local<Context> context = Context::New(isolate(), nullptr, global);
+  Context::Scope context_scope(context);
+  {
+    // setup console global.
+    HandleScope scope(isolate());
+    Local<String> name = String::NewFromUtf8Literal(
+        isolate(), "console", NewStringType::kInternalized);
+    Local<Value> console =
+        context->GetExtrasBindingObject()->Get(context, name).ToLocalChecked();
+    context->Global()->Set(context, name, console).FromJust();
+  }
+
+  CHECK(!isolate()->IsExecutionTerminating());
+  TryCatch try_catch(isolate());
+  CHECK(!isolate()->IsExecutionTerminating());
+  CHECK(TryRunJS("terminate(); console.log(); fail();").IsEmpty());
+  CHECK(try_catch.HasCaught());
+  CHECK(isolate()->IsExecutionTerminating());
+}
+
+TEST_F(ThreadTerminationTest, TerminationClearArrayJoinStack) {
+  internal::v8_flags.allow_natives_syntax = true;
+  HandleScope scope(isolate());
+  Local<ObjectTemplate> global_template =
+      CreateGlobalTemplate(isolate(), TerminateCurrentThread, DoLoopNoCall);
+  {
+    Local<Context> context = Context::New(isolate(), nullptr, global_template);
+    Context::Scope context_scope(context);
+    {
+      TryCatch try_catch(isolate());
+      TryRunJS(
+          "var error = false;"
+          "var a = [{toString(){if(error)loop()}}];"
+          "function Join(){ return a.join();}; "
+          "%PrepareFunctionForOptimization(Join);"
+          "Join();"
+          "%OptimizeFunctionOnNextCall(Join);"
+          "error = true;"
+          "Join();");
+      CHECK(try_catch.HasTerminated());
+      CHECK(isolate()->IsExecutionTerminating());
+    }
+    EXPECT_THAT(RunJS("a[0] = 1; Join();"), testing::IsString("1"));
+  }
+  {
+    Local<Context> context = Context::New(isolate(), nullptr, global_template);
+    Context::Scope context_scope(context);
+    {
+      TryCatch try_catch(isolate());
+      TryRunJS(
+          "var a = [{toString(){loop()}}];"
+          "function Join(){ return a.join();}; "
+          "Join();");
+      CHECK(try_catch.HasTerminated());
+      CHECK(isolate()->IsExecutionTerminating());
+    }
+    EXPECT_THAT(RunJS("a[0] = 1; Join();"), testing::IsString("1"));
+  }
+  {
+    ConsoleImpl console;
+    debug::SetConsoleDelegate(isolate(), &console);
+    HandleScope scope(isolate());
+    Local<Context> context = Context::New(isolate(), nullptr, global_template);
+    Context::Scope context_scope(context);
+    {
+      // setup console global.
+      HandleScope scope(isolate());
+      Local<String> name = String::NewFromUtf8Literal(
+          isolate(), "console", NewStringType::kInternalized);
+      Local<Value> console = context->GetExtrasBindingObject()
+                                 ->Get(context, name)
+                                 .ToLocalChecked();
+      context->Global()->Set(context, name, console).FromJust();
+    }
+    CHECK(!isolate()->IsExecutionTerminating());
+    {
+      TryCatch try_catch(isolate());
+      CHECK(!isolate()->IsExecutionTerminating());
+      CHECK(TryRunJS("var a = [{toString(){terminate();console.log();fail()}}];"
+                     "function Join() {return a.join();}"
+                     "Join();")
+                .IsEmpty());
+      CHECK(try_catch.HasCaught());
+      CHECK(isolate()->IsExecutionTerminating());
+    }
+    EXPECT_THAT(RunJS("a[0] = 1; Join();"), testing::IsString("1"));
+  }
+}
+
+class TerminatorSleeperThread : public base::Thread {
+ public:
+  explicit TerminatorSleeperThread(Isolate* isolate, int sleep_ms)
+      : Thread(Options("TerminatorSlepperThread")),
+        isolate_(isolate),
+        sleep_ms_(sleep_ms) {}
+  void Run() override {
+    base::OS::Sleep(base::TimeDelta::FromMilliseconds(sleep_ms_));
+    CHECK(!isolate_->IsExecutionTerminating());
+    isolate_->TerminateExecution();
+  }
+
+ private:
+  Isolate* isolate_;
+  int sleep_ms_;
+};
+
+TEST_F(ThreadTerminationTest, TerminateRegExp) {
+  i::FLAG_allow_natives_syntax = true;
+  // We want to be stuck regexp execution, so no fallback to linear-time
+  // engine.
+  // TODO(mbid,v8:10765): Find a way to test interrupt support of the
+  // experimental engine.
+  i::FLAG_enable_experimental_regexp_engine_on_excessive_backtracks = false;
+
+  HandleScope scope(isolate());
+  Local<ObjectTemplate> global = CreateGlobalTemplate(
+      isolate(), TerminateCurrentThread, DoLoopCancelTerminate);
+  Local<Context> context = Context::New(isolate(), nullptr, global);
+  Context::Scope context_scope(context);
+  CHECK(!isolate()->IsExecutionTerminating());
+  TryCatch try_catch(isolate());
+  CHECK(!isolate()->IsExecutionTerminating());
+  CHECK(!RunJS("var re = /(x+)+y$/; re.test('x');").IsEmpty());
+  TerminatorSleeperThread terminator(isolate(), 100);
+  CHECK(terminator.Start());
+  CHECK(TryRunJS("re.test('xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'); fail();")
+            .IsEmpty());
+  CHECK(try_catch.HasCaught());
+  CHECK(isolate()->IsExecutionTerminating());
+}
+
+TEST_F(ThreadTerminationTest, TerminateInMicrotask) {
+  Locker locker(isolate());
+  isolate()->SetMicrotasksPolicy(MicrotasksPolicy::kExplicit);
+  HandleScope scope(isolate());
+  Local<ObjectTemplate> global = CreateGlobalTemplate(
+      isolate(), TerminateCurrentThread, DoLoopCancelTerminate);
+  Local<Context> context1 = Context::New(isolate(), nullptr, global);
+  Local<Context> context2 = Context::New(isolate(), nullptr, global);
+  {
+    TryCatch try_catch(isolate());
+    {
+      Context::Scope context_scope(context1);
+      CHECK(!isolate()->IsExecutionTerminating());
+      CHECK(!RunJS("Promise.resolve().then(function() {"
+                   "terminate(); loop(); fail();})")
+                 .IsEmpty());
+      CHECK(!try_catch.HasCaught());
+    }
+    {
+      Context::Scope context_scope(context2);
+      CHECK(context2 == isolate()->GetCurrentContext());
+      CHECK(context2 == isolate()->GetEnteredOrMicrotaskContext());
+      CHECK(!isolate()->IsExecutionTerminating());
+      isolate()->PerformMicrotaskCheckpoint();
+      CHECK(context2 == isolate()->GetCurrentContext());
+      CHECK(context2 == isolate()->GetEnteredOrMicrotaskContext());
+      CHECK(try_catch.HasCaught());
+      CHECK(try_catch.HasTerminated());
+      // Any further exectutions in this TryCatch scope would fail.
+      CHECK(isolate()->IsExecutionTerminating());
+      CHECK(!i_isolate()->stack_guard()->CheckTerminateExecution());
+    }
+  }
+  CHECK(!i_isolate()->stack_guard()->CheckTerminateExecution());
+  CHECK(!isolate()->IsExecutionTerminating());
+}
+
+void TerminationMicrotask(void* data) {
+  Isolate::GetCurrent()->TerminateExecution();
+  CompileRun(Isolate::GetCurrent()->GetCurrentContext(), "");
+}
+
+void UnreachableMicrotask(void* data) { UNREACHABLE(); }
+
+TEST_F(ThreadTerminationTest, TerminateInApiMicrotask) {
+  Locker locker(isolate());
+  isolate()->SetMicrotasksPolicy(MicrotasksPolicy::kExplicit);
+  HandleScope scope(isolate());
+  Local<ObjectTemplate> global = CreateGlobalTemplate(
+      isolate(), TerminateCurrentThread, DoLoopCancelTerminate);
+  Local<Context> context = Context::New(isolate(), nullptr, global);
+  {
+    TryCatch try_catch(isolate());
+    Context::Scope context_scope(context);
+    CHECK(!isolate()->IsExecutionTerminating());
+    isolate()->EnqueueMicrotask(TerminationMicrotask);
+    isolate()->EnqueueMicrotask(UnreachableMicrotask);
+    isolate()->PerformMicrotaskCheckpoint();
+    CHECK(try_catch.HasCaught());
+    CHECK(try_catch.HasTerminated());
+    CHECK(isolate()->IsExecutionTerminating());
+  }
+  CHECK(!isolate()->IsExecutionTerminating());
+}
+
+}  // namespace v8