diff --git a/src/hotspot/share/runtime/interfaceSupport.inline.hpp b/src/hotspot/share/runtime/interfaceSupport.inline.hpp
index 403ff1d9ea2..f6f30eaea91 100644
--- a/src/hotspot/share/runtime/interfaceSupport.inline.hpp
+++ b/src/hotspot/share/runtime/interfaceSupport.inline.hpp
@@ -210,12 +210,14 @@ class ThreadBlockInVMPreprocess : public ThreadStateTransition {
   }
   ~ThreadBlockInVMPreprocess() {
     assert(_thread->thread_state() == _thread_blocked, "coming from wrong thread state");
-    // Change back to _thread_in_vm and ensure it is seen by the VM thread.
-    _thread->set_thread_state_fence(_thread_in_vm);
 
     if (SafepointMechanism::should_process(_thread, _allow_suspend)) {
       _pr(_thread);
-      SafepointMechanism::process_if_requested(_thread, _allow_suspend, false /* check_async_exception */);
+      SafepointMechanism::process_if_requested(_thread, _allow_suspend, false /* check_async_exception */, true /*call from tbivm*/);
+    }
+    if (_thread->thread_state() == _thread_blocked) {
+      // Change back to _thread_in_vm and ensure it is seen by the VM thread.
+      _thread->set_thread_state_fence(_thread_in_vm);
     }
   }
 };
diff --git a/src/hotspot/share/runtime/safepoint.cpp b/src/hotspot/share/runtime/safepoint.cpp
index 05f59de4a17..e7b676de799 100644
--- a/src/hotspot/share/runtime/safepoint.cpp
+++ b/src/hotspot/share/runtime/safepoint.cpp
@@ -371,6 +371,7 @@ void SafepointSynchronize::begin() {
 
   // Will spin until all threads are safe.
   int iterations = synchronize_threads(safepoint_limit_time, nof_threads, &initial_running);
+  DEBUG_ONLY(log_info(safepoint)("Safepoint synchronize threads iterations: %i", iterations););
   assert(_waiting_to_block == 0, "No thread should be running");
 
 #ifndef PRODUCT
@@ -565,7 +566,7 @@ void SafepointSynchronize::block(JavaThread *thread) {
      return;
   }
 
-  JavaThreadState state = thread->thread_state();
+  JavaThreadState const state = thread->thread_state();
   thread->frame_anchor()->make_walkable();
 
   uint64_t safepoint_id = SafepointSynchronize::safepoint_counter();
@@ -579,14 +580,18 @@ void SafepointSynchronize::block(JavaThread *thread) {
   // This part we can skip if we notice we miss or are in a future safepoint.
   OrderAccess::storestore();
   // Load in wait barrier should not float up
-  thread->set_thread_state_fence(_thread_blocked);
+  if (state != _thread_blocked) {
+    thread->set_thread_state_fence(_thread_blocked);
+  }
 
   _wait_barrier->wait(static_cast<int>(safepoint_id));
   assert(_state != _synchronized, "Can't be");
 
   // If barrier is disarmed stop store from floating above loads in barrier.
   OrderAccess::loadstore();
-  thread->set_thread_state(state);
+  if (state != _thread_blocked) {
+    thread->set_thread_state(state);
+  }
 
   // Then we reset the safepoint id to inactive.
   thread->safepoint_state()->reset_safepoint_id(); // Release store
diff --git a/src/hotspot/share/runtime/safepointMechanism.cpp b/src/hotspot/share/runtime/safepointMechanism.cpp
index 624583db3d1..e2b9d1ed141 100644
--- a/src/hotspot/share/runtime/safepointMechanism.cpp
+++ b/src/hotspot/share/runtime/safepointMechanism.cpp
@@ -92,7 +92,6 @@ uintptr_t SafepointMechanism::compute_poll_word(bool armed, uintptr_t stack_wate
 
 void SafepointMechanism::update_poll_values(JavaThread* thread) {
   assert(thread == Thread::current(), "Must be");
-  assert(thread->thread_state() != _thread_blocked, "Must not be");
   assert(thread->thread_state() != _thread_in_native, "Must not be");
 
   for (;;) {
@@ -131,16 +130,20 @@ void SafepointMechanism::update_poll_values(JavaThread* thread) {
   }
 }
 
-void SafepointMechanism::process(JavaThread *thread, bool allow_suspend, bool check_async_exception) {
+void SafepointMechanism::process(JavaThread *thread, bool allow_suspend, bool check_async_exception, bool is_from_tbivm) {
   DEBUG_ONLY(intptr_t* sp_before = thread->last_Java_sp();)
   // Read global poll and has_handshake after local poll
   OrderAccess::loadload();
 
   // local poll already checked, if used.
-  bool need_rechecking;
+  bool need_rechecking = false;
   do {
     JavaThreadState state = thread->thread_state();
-    guarantee(state == _thread_in_vm, "Illegal threadstate encountered: %d", state);
+    if (is_from_tbivm && !need_rechecking) {
+      guarantee(state == _thread_blocked, "Illegal threadstate encountered: %d", state);
+    } else {
+      guarantee(state == _thread_in_vm, "Illegal threadstate encountered: %d", state);
+    }
     if (global_poll()) {
       // Any load in ::block() must not pass the global poll load.
       // Otherwise we might load an old safepoint counter (for example).
@@ -148,6 +151,13 @@ void SafepointMechanism::process(JavaThread *thread, bool allow_suspend, bool ch
       SafepointSynchronize::block(thread);
     }
 
+    if (is_from_tbivm && !need_rechecking) {
+      guarantee(thread->thread_state() == _thread_blocked, "Illegal threadstate encountered: %d", state);
+      // Must set state to _thread_in_vm before StackWatermark and handshake processing 
+      thread->set_thread_state_fence(_thread_in_vm);
+    }
+
+    guarantee(thread->thread_state() == _thread_in_vm, "Illegal threadstate encountered: %d", state);
     // The call to on_safepoint fixes the thread's oops and the first few frames.
     //
     // The call has been carefully placed here to cater to a few situations:
diff --git a/src/hotspot/share/runtime/safepointMechanism.hpp b/src/hotspot/share/runtime/safepointMechanism.hpp
index 331f5177e60..804aecf3039 100644
--- a/src/hotspot/share/runtime/safepointMechanism.hpp
+++ b/src/hotspot/share/runtime/safepointMechanism.hpp
@@ -49,7 +49,7 @@ class SafepointMechanism : public AllStatic {
 
   static inline bool global_poll();
 
-  static void process(JavaThread *thread, bool allow_suspend, bool check_async_exception);
+  static void process(JavaThread *thread, bool allow_suspend, bool check_async_exception, bool is_from_tbivm = false);
 
   static void default_initialize();
 
@@ -79,7 +79,7 @@ class SafepointMechanism : public AllStatic {
   static inline bool should_process(JavaThread* thread, bool allow_suspend = true);
 
   // Processes a pending requested operation.
-  static inline void process_if_requested(JavaThread* thread, bool allow_suspend, bool check_async_exception);
+  static inline void process_if_requested(JavaThread* thread, bool allow_suspend, bool check_async_exception, bool is_from_tbivm = false);
   static inline void process_if_requested_with_exit_check(JavaThread* thread, bool check_async_exception);
   // Compute what the poll values should be and install them.
   static void update_poll_values(JavaThread* thread);
diff --git a/src/hotspot/share/runtime/safepointMechanism.inline.hpp b/src/hotspot/share/runtime/safepointMechanism.inline.hpp
index d0fb3a8fa2d..7a20e9735bb 100644
--- a/src/hotspot/share/runtime/safepointMechanism.inline.hpp
+++ b/src/hotspot/share/runtime/safepointMechanism.inline.hpp
@@ -75,12 +75,12 @@ bool SafepointMechanism::should_process(JavaThread* thread, bool allow_suspend)
   return false;
 }
 
-void SafepointMechanism::process_if_requested(JavaThread* thread, bool allow_suspend, bool check_async_exception) {
+void SafepointMechanism::process_if_requested(JavaThread* thread, bool allow_suspend, bool check_async_exception, bool is_from_tbivm) {
   // Check NoSafepointVerifier. This also clears unhandled oops if CheckUnhandledOops is used.
   thread->check_possible_safepoint();
 
   if (local_poll_armed(thread)) {
-    process(thread, allow_suspend, check_async_exception);
+    process(thread, allow_suspend, check_async_exception, is_from_tbivm);
   }
 }