@@ -2260,14 +2260,6 @@ struct JSEntryStub {
   MemoryRange code;
 };
 
-struct UnwindState {
-  MemoryRange code_range;
-  MemoryRange embedded_code_range;
-  JSEntryStub js_entry_stub;
-  JSEntryStub js_construct_entry_stub;
-  JSEntryStub js_run_microtasks_entry_stub;
-};
-
 struct JSEntryStubs {
   JSEntryStub js_entry_stub;
   JSEntryStub js_construct_entry_stub;
@@ -9325,13 +9317,6 @@ class V8_EXPORT Isolate {
    */
   void GetCodeRange(void** start, size_t* length_in_bytes);
 
-  /**
-   * Returns the UnwindState necessary for use with the Unwinder API.
-   */
-  // TODO(petermarshall): Remove this API.
-  V8_DEPRECATED("Use entry_stubs + code_pages version.")
-  UnwindState GetUnwindState();
-
   /**
    * Returns the JSEntryStubs necessary for use with the Unwinder API.
    */
@@ -10689,12 +10674,14 @@ class V8_EXPORT Unwinder {
    *
    * The unwinder also needs the virtual memory range of all possible V8 code
    * objects. There are two ranges required - the heap code range and the range
-   * for code embedded in the binary. The V8 API provides all required inputs
-   * via an UnwindState object through the Isolate::GetUnwindState() API. These
-   * values will not change after Isolate initialization, so the same
-   * |unwind_state| can be used for multiple calls.
+   * for code embedded in the binary.
+   *
+   * Available on x64, ARM64 and ARM32.
    *
-   * \param unwind_state Input state for the Isolate that the stack comes from.
+   * \param code_pages A list of all of the ranges in which V8 has allocated
+   * executable code. The caller should obtain this list by calling
+   * Isolate::CopyCodePages() during the same interrupt/thread suspension that
+   * captures the stack.
    * \param register_state The current registers. This is an in-out param that
    * will be overwritten with the register values after unwinding, on success.
    * \param stack_base The resulting stack pointer and frame pointer values are
@@ -10705,41 +10692,20 @@ class V8_EXPORT Unwinder {
    *
    * \return True on success.
    */
-  // TODO(petermarshall): Remove this API
-  V8_DEPRECATED("Use entry_stubs + code_pages version.")
-  static bool TryUnwindV8Frames(const UnwindState& unwind_state,
-                                RegisterState* register_state,
-                                const void* stack_base);
-
-  /**
-   * The same as above, but is available on x64, ARM64 and ARM32.
-   *
-   * \param code_pages A list of all of the ranges in which V8 has allocated
-   * executable code. The caller should obtain this list by calling
-   * Isolate::CopyCodePages() during the same interrupt/thread suspension that
-   * captures the stack.
-   */
   static bool TryUnwindV8Frames(const JSEntryStubs& entry_stubs,
                                 size_t code_pages_length,
                                 const MemoryRange* code_pages,
                                 RegisterState* register_state,
                                 const void* stack_base);
 
   /**
-   * Whether the PC is within the V8 code range represented by code_range or
-   * embedded_code_range in |unwind_state|.
+   * Whether the PC is within the V8 code range represented by code_pages.
    *
    * If this returns false, then calling UnwindV8Frames() with the same PC
    * and unwind_state will always fail. If it returns true, then unwinding may
    * (but not necessarily) be successful.
-   */
-  // TODO(petermarshall): Remove this API
-  V8_DEPRECATED("Use code_pages version.")
-  static bool PCIsInV8(const UnwindState& unwind_state, void* pc);
-
-  /**
-   * The same as above, but is available on x64, ARM64 and ARM32. See the
-   * comment on TryUnwindV8Frames.
+   *
+   * Available on x64, ARM64 and ARM32
    */
   static bool PCIsInV8(size_t code_pages_length, const MemoryRange* code_pages,
                        void* pc);
 
@@ -8933,33 +8933,6 @@ void Isolate::GetCodeRange(void** start, size_t* length_in_bytes) {
   *length_in_bytes = code_range.size();
 }
 
-UnwindState Isolate::GetUnwindState() {
-  UnwindState unwind_state;
-  void* code_range_start;
-  GetCodeRange(&code_range_start, &unwind_state.code_range.length_in_bytes);
-  unwind_state.code_range.start = code_range_start;
-
-  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
-  unwind_state.embedded_code_range.start =
-      reinterpret_cast<const void*>(isolate->embedded_blob_code());
-  unwind_state.embedded_code_range.length_in_bytes =
-      isolate->embedded_blob_code_size();
-
-  std::array<std::pair<i::Builtins::Name, JSEntryStub*>, 3> entry_stubs = {
-      {{i::Builtins::kJSEntry, &unwind_state.js_entry_stub},
-       {i::Builtins::kJSConstructEntry, &unwind_state.js_construct_entry_stub},
-       {i::Builtins::kJSRunMicrotasksEntry,
-        &unwind_state.js_run_microtasks_entry_stub}}};
-  for (auto& pair : entry_stubs) {
-    i::Code js_entry = isolate->heap()->builtin(pair.first);
-    pair.second->code.start =
-        reinterpret_cast<const void*>(js_entry.InstructionStart());
-    pair.second->code.length_in_bytes = js_entry.InstructionSize();
-  }
-
-  return unwind_state;
-}
-
 JSEntryStubs Isolate::GetJSEntryStubs() {
   JSEntryStubs entry_stubs;
 
 
@@ -46,21 +46,6 @@ bool PCIsInCodePages(size_t code_pages_length, const MemoryRange* code_pages,
   return it->start <= pc && pc < CalculateEnd(it->start, it->length_in_bytes);
 }
 
-bool IsInJSEntryRange(const UnwindState& unwind_state, void* pc) {
-  return PCIsInCodeRange(unwind_state.js_entry_stub.code, pc) ||
-         PCIsInCodeRange(unwind_state.js_construct_entry_stub.code, pc) ||
-         PCIsInCodeRange(unwind_state.js_run_microtasks_entry_stub.code, pc);
-}
-
-bool IsInUnsafeJSEntryRange(const UnwindState& unwind_state, void* pc) {
-  return IsInJSEntryRange(unwind_state, pc);
-
-  // TODO(petermarshall): We can be more precise by checking whether we are
-  // in JSEntry but after frame setup and before frame teardown, in which case
-  // we are safe to unwind the stack. For now, we bail out if the PC is anywhere
-  // within JSEntry.
-}
-
 bool IsInJSEntryRange(const JSEntryStubs& entry_stubs, void* pc) {
   return PCIsInCodeRange(entry_stubs.js_entry_stub.code, pc) ||
          PCIsInCodeRange(entry_stubs.js_construct_entry_stub.code, pc) ||
@@ -80,19 +65,6 @@ i::Address Load(i::Address address) {
   return *reinterpret_cast<i::Address*>(address);
 }
 
-void* GetReturnAddressFromFP(void* fp, void* pc,
-                             const v8::UnwindState& unwind_state) {
-  int caller_pc_offset = i::CommonFrameConstants::kCallerPCOffset;
-#ifdef V8_TARGET_ARCH_ARM64
-  if (IsInJSEntryRange(unwind_state, pc)) {
-    caller_pc_offset = i::EntryFrameConstants::kDirectCallerPCOffset;
-  }
-#endif
-  i::Address ret_addr =
-      Load(reinterpret_cast<i::Address>(fp) + caller_pc_offset);
-  return reinterpret_cast<void*>(i::PointerAuthentication::StripPAC(ret_addr));
-}
-
 void* GetReturnAddressFromFP(void* fp, void* pc,
                              const JSEntryStubs& entry_stubs) {
   int caller_pc_offset = i::CommonFrameConstants::kCallerPCOffset;
@@ -106,18 +78,6 @@ void* GetReturnAddressFromFP(void* fp, void* pc,
   return reinterpret_cast<void*>(i::PointerAuthentication::StripPAC(ret_addr));
 }
 
-void* GetCallerFPFromFP(void* fp, void* pc,
-                        const v8::UnwindState& unwind_state) {
-  int caller_fp_offset = i::CommonFrameConstants::kCallerFPOffset;
-#ifdef V8_TARGET_ARCH_ARM64
-  if (IsInJSEntryRange(unwind_state, pc)) {
-    caller_fp_offset = i::EntryFrameConstants::kDirectCallerFPOffset;
-  }
-#endif
-  return reinterpret_cast<void*>(
-      Load(reinterpret_cast<i::Address>(fp) + caller_fp_offset));
-}
-
 void* GetCallerFPFromFP(void* fp, void* pc, const JSEntryStubs& entry_stubs) {
   int caller_fp_offset = i::CommonFrameConstants::kCallerFPOffset;
 #ifdef V8_TARGET_ARCH_ARM64
@@ -129,18 +89,6 @@ void* GetCallerFPFromFP(void* fp, void* pc, const JSEntryStubs& entry_stubs) {
       Load(reinterpret_cast<i::Address>(fp) + caller_fp_offset));
 }
 
-void* GetCallerSPFromFP(void* fp, void* pc,
-                        const v8::UnwindState& unwind_state) {
-  int caller_sp_offset = i::CommonFrameConstants::kCallerSPOffset;
-#ifdef V8_TARGET_ARCH_ARM64
-  if (IsInJSEntryRange(unwind_state, pc)) {
-    caller_sp_offset = i::EntryFrameConstants::kDirectCallerSPOffset;
-  }
-#endif
-  return reinterpret_cast<void*>(reinterpret_cast<i::Address>(fp) +
-                                 caller_sp_offset);
-}
-
 void* GetCallerSPFromFP(void* fp, void* pc, const JSEntryStubs& entry_stubs) {
   int caller_sp_offset = i::CommonFrameConstants::kCallerSPOffset;
 #ifdef V8_TARGET_ARCH_ARM64
@@ -159,46 +107,6 @@ bool AddressIsInStack(const void* address, const void* stack_base,
 
 }  // namespace
 
-bool Unwinder::TryUnwindV8Frames(const UnwindState& unwind_state,
-                                 RegisterState* register_state,
-                                 const void* stack_base) {
-  const void* stack_top = register_state->sp;
-
-  void* pc = register_state->pc;
-  if (PCIsInV8(unwind_state, pc) && !IsInUnsafeJSEntryRange(unwind_state, pc)) {
-    void* current_fp = register_state->fp;
-    if (!AddressIsInStack(current_fp, stack_base, stack_top)) return false;
-
-    // Peek at the return address that the caller pushed. If it's in V8, then we
-    // assume the caller frame is a JS frame and continue to unwind.
-    void* next_pc = GetReturnAddressFromFP(current_fp, pc, unwind_state);
-    while (PCIsInV8(unwind_state, next_pc)) {
-      current_fp = GetCallerFPFromFP(current_fp, pc, unwind_state);
-      if (!AddressIsInStack(current_fp, stack_base, stack_top)) return false;
-      pc = next_pc;
-      next_pc = GetReturnAddressFromFP(current_fp, pc, unwind_state);
-    }
-
-    void* final_sp = GetCallerSPFromFP(current_fp, pc, unwind_state);
-    if (!AddressIsInStack(final_sp, stack_base, stack_top)) return false;
-    register_state->sp = final_sp;
-
-    // We don't check that the final FP value is within the stack bounds because
-    // this is just the rbp value that JSEntryStub pushed. On platforms like
-    // Win64 this is not used as a dedicated FP register, and could contain
-    // anything.
-    void* final_fp = GetCallerFPFromFP(current_fp, pc, unwind_state);
-    register_state->fp = final_fp;
-
-    register_state->pc = next_pc;
-
-    // Link register no longer valid after unwinding.
-    register_state->lr = nullptr;
-    return true;
-  }
-  return false;
-}
-
 bool Unwinder::TryUnwindV8Frames(const JSEntryStubs& entry_stubs,
                                  size_t code_pages_length,
                                  const MemoryRange* code_pages,
@@ -242,11 +150,6 @@ bool Unwinder::TryUnwindV8Frames(const JSEntryStubs& entry_stubs,
   return false;
 }
 
-bool Unwinder::PCIsInV8(const UnwindState& unwind_state, void* pc) {
-  return pc && (PCIsInCodeRange(unwind_state.code_range, pc) ||
-                PCIsInCodeRange(unwind_state.embedded_code_range, pc));
-}
-
 bool Unwinder::PCIsInV8(size_t code_pages_length, const MemoryRange* code_pages,
                         void* pc) {
   return pc && PCIsInCodePages(code_pages_length, code_pages, pc);
 
@@ -267,7 +267,6 @@ v8_source_set("cctest_sources") {
     "test-unboxed-doubles.cc",
     "test-unscopables-hidden-prototype.cc",
     "test-unwinder-code-pages.cc",
-    "test-unwinder.cc",
     "test-usecounters.cc",
     "test-utils.cc",
     "test-version.cc",
 
@@ -26692,42 +26692,6 @@ TEST(BigIntAPI) {
   }
 }
 
-TEST(TestGetUnwindState) {
-  LocalContext env;
-  v8::Isolate* isolate = env->GetIsolate();
-  i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
-
-// Ignore deprecation warnings so that we can keep the tests for now.
-// TODO(petermarshall): Remove this once the deprecated API is gone.
-#if __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdeprecated"
-#endif
-  v8::UnwindState unwind_state = isolate->GetUnwindState();
-#if __clang__
-#pragma clang diagnostic pop
-#endif
-  v8::MemoryRange builtins_range = unwind_state.embedded_code_range;
-
-  // Check that each off-heap builtin is within the builtins code range.
-  for (int id = 0; id < i::Builtins::builtin_count; id++) {
-    if (!i::Builtins::IsIsolateIndependent(id)) continue;
-    i::Code builtin = i_isolate->builtins()->builtin(id);
-    i::Address start = builtin.InstructionStart();
-    i::Address end = start + builtin.InstructionSize();
-
-    i::Address builtins_start =
-        reinterpret_cast<i::Address>(builtins_range.start);
-    CHECK(start >= builtins_start &&
-          end < builtins_start + builtins_range.length_in_bytes);
-  }
-
-  v8::JSEntryStub js_entry_stub = unwind_state.js_entry_stub;
-
-  CHECK_EQ(i_isolate->heap()->builtin(i::Builtins::kJSEntry).InstructionStart(),
-           reinterpret_cast<i::Address>(js_entry_stub.code.start));
-}
-
 TEST(GetJSEntryStubs) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();