diff --git a/src/hotspot/share/oops/instanceStackChunkKlass.hpp b/src/hotspot/share/oops/instanceStackChunkKlass.hpp
index 62d52180d94..711188a81b0 100644
--- a/src/hotspot/share/oops/instanceStackChunkKlass.hpp
+++ b/src/hotspot/share/oops/instanceStackChunkKlass.hpp
@@ -39,7 +39,7 @@ typedef VMRegImpl* VMReg;
 template <bool mixed = true> class StackChunkFrameStream;
 
 
-// An InstanceStackChunkKlass is a specialization of the InstanceKlass. 
+// An InstanceStackChunkKlass is a specialization of the InstanceKlass.
 // It has a header containing metadata, and a blob containing a stack segment
 // (some integral number of stack frames)
 //
@@ -56,7 +56,7 @@ class InstanceStackChunkKlass: public InstanceKlass {
   friend class InstanceKlass;
   friend class stackChunkOopDesc;
   friend class Continuations;
-  template <bool mixed> friend class StackChunkFrameStream; 
+  template <bool mixed> friend class StackChunkFrameStream;
   friend class FixChunkIterateStackClosure;
   friend class MarkMethodsStackClosure;
   template <bool concurrent_gc, typename OopClosureType> friend class OopOopIterateStackClosure;
@@ -104,7 +104,7 @@ class InstanceStackChunkKlass: public InstanceKlass {
   void oop_print_on(oop obj, outputStream* st) override;
   static bool verify(oop obj, size_t* out_size = NULL, int* out_oops = NULL, int* out_frames = NULL, int* out_interpreted_frames = NULL);
 #endif
-  
+
   // Stack offset is an offset into the Heap
   static HeapWord* start_of_stack(oop obj) { return (HeapWord*)(cast_from_oop<intptr_t>(obj) + offset_of_stack()); }
   static inline HeapWord* start_of_bitmap(oop obj);
@@ -119,7 +119,7 @@ class InstanceStackChunkKlass: public InstanceKlass {
 
   template<bool mixed = true>
   static int count_frames(stackChunkOop chunk);
-  
+
   // Oop fields (and metadata) iterators
   //
   // The InstanceClassLoaderKlass iterators also visit the CLD pointer (or mirror of anonymous klasses.)
@@ -155,7 +155,7 @@ class InstanceStackChunkKlass: public InstanceKlass {
 
   template<bool disjoint> size_t copy(oop obj, HeapWord* to, size_t word_size);
   template<bool disjoint> size_t copy_compact(oop obj, HeapWord* to);
-  
+
   template <typename T, class OopClosureType>
   inline void oop_oop_iterate_header(stackChunkOop chunk, OopClosureType* closure);
 
@@ -164,7 +164,7 @@ class InstanceStackChunkKlass: public InstanceKlass {
 
   template <bool concurrent_gc, class OopClosureType>
   inline void oop_oop_iterate_stack_bounded(stackChunkOop chunk, OopClosureType* closure, MemRegion mr);
-  
+
   template <class OopClosureType>
   inline void oop_oop_iterate_stack_helper(stackChunkOop chunk, OopClosureType* closure, intptr_t* start, intptr_t* end);
 
@@ -184,7 +184,7 @@ class InstanceStackChunkKlass: public InstanceKlass {
 
   static inline void relativize(intptr_t* const fp, intptr_t* const hfp, int offset);
   static inline void derelativize(intptr_t* const fp, int offset);
-  
+
   typedef void (*MemcpyFnT)(void* src, void* dst, size_t count);
   static void resolve_memcpy_functions();
   static MemcpyFnT memcpy_fn_from_stack_to_chunk;
@@ -243,7 +243,7 @@ class StackChunkFrameStream : public StackObj {
   template <typename RegisterMapT> inline void next(RegisterMapT* map);
 
   template <typename RegisterMapT> inline void update_reg_map(RegisterMapT* map);
-  
+
   void handle_deopted() const;
 
   inline int to_offset(stackChunkOop chunk) const { assert (!is_done(), ""); return _sp - chunk->start_address(); }
diff --git a/src/hotspot/share/oops/instanceStackChunkKlass.inline.hpp b/src/hotspot/share/oops/instanceStackChunkKlass.inline.hpp
index 112af6411ad..cddc6dc96e4 100644
--- a/src/hotspot/share/oops/instanceStackChunkKlass.inline.hpp
+++ b/src/hotspot/share/oops/instanceStackChunkKlass.inline.hpp
@@ -92,9 +92,9 @@ inline void stackChunkOopDesc::set_mark_cycle(uint64_t value) { jdk_internal_mis
 inline void stackChunkOopDesc::set_cont(oop value) { jdk_internal_misc_StackChunk::set_cont(this, value); }
 template<typename P> inline void stackChunkOopDesc::set_cont_raw(oop value)   { jdk_internal_misc_StackChunk::set_cont_raw<P>(this, value); }
 inline oop stackChunkOopDesc::cont() const  { return UseCompressedOops ? cont<narrowOop>() : cont<oop>(); /* jdk_internal_misc_StackChunk::cont(as_oop()); */ }
-template<typename P> inline oop stackChunkOopDesc::cont() const { 
+template<typename P> inline oop stackChunkOopDesc::cont() const {
   // this is a special field used to detect GC processing status (see should_fix) and so we don't want to invoke a barrier directly on it
-  oop obj = jdk_internal_misc_StackChunk::cont_raw<P>(as_oop()); 
+  oop obj = jdk_internal_misc_StackChunk::cont_raw<P>(as_oop());
   obj = (oop)NativeAccess<>::oop_load(&obj);
   return obj;
 }
@@ -107,7 +107,7 @@ inline intptr_t* stackChunkOopDesc::bottom_address() const { return start_addres
 inline intptr_t* stackChunkOopDesc::sp_address()  const { return start_address() + sp(); }
 
 inline int stackChunkOopDesc::to_offset(intptr_t* p) const {
-  assert(is_in_chunk(p) || (p >= start_address() && (p - start_address()) <= stack_size() + InstanceStackChunkKlass::metadata_words()), 
+  assert(is_in_chunk(p) || (p >= start_address() && (p - start_address()) <= stack_size() + InstanceStackChunkKlass::metadata_words()),
     "p: " INTPTR_FORMAT " start: " INTPTR_FORMAT " end: " INTPTR_FORMAT, p2i(p), p2i(start_address()), p2i(bottom_address()));
   return p - start_address();
 }
@@ -150,7 +150,7 @@ inline void stackChunkOopDesc::set_flag(uint8_t flag, bool value) {
 inline void stackChunkOopDesc::clear_flags() {
   set_flags(0);
 }
-inline bool stackChunkOopDesc::requires_barriers() const { 
+inline bool stackChunkOopDesc::requires_barriers() const {
   return Universe::heap()->requires_barriers(as_oop());
 }
 
@@ -308,7 +308,7 @@ inline void stackChunkOopDesc::copy_from_stack_to_chunk(intptr_t* from, intptr_t
   log_develop_trace(jvmcont)("Chunk bounds: " INTPTR_FORMAT "(%d) - " INTPTR_FORMAT "(%d) (%d words, %d bytes)",
     p2i(start_address()), to_offset(start_address()), p2i(end_address()), to_offset(end_address() - 1) + 1, stack_size(), stack_size() << LogBytesPerWord);
   log_develop_trace(jvmcont)("Copying from v: " INTPTR_FORMAT " - " INTPTR_FORMAT " (%d words, %d bytes)", p2i(from), p2i(from + size), size, size << LogBytesPerWord);
-  log_develop_trace(jvmcont)("Copying to h: " INTPTR_FORMAT "(%ld,%ld) - " INTPTR_FORMAT "(%ld,%ld) (%d words, %d bytes)", 
+  log_develop_trace(jvmcont)("Copying to h: " INTPTR_FORMAT "(%ld,%ld) - " INTPTR_FORMAT "(%ld,%ld) (%d words, %d bytes)",
     p2i(to), to - start_address(), relative_base() - to, p2i(to + size), to + size - start_address(), relative_base() - (to + size), size, size << LogBytesPerWord);
 
   assert (to >= start_address(), "to: " INTPTR_FORMAT " start: " INTPTR_FORMAT, p2i(to), p2i(start_address()));
@@ -319,7 +319,7 @@ inline void stackChunkOopDesc::copy_from_stack_to_chunk(intptr_t* from, intptr_t
 
 template <bool dword_aligned>
 inline void stackChunkOopDesc::copy_from_chunk_to_stack(intptr_t* from, intptr_t* to, int size) {
-  log_develop_trace(jvmcont)("Copying from h: " INTPTR_FORMAT "(%ld,%ld) - " INTPTR_FORMAT "(%ld,%ld) (%d words, %d bytes)", 
+  log_develop_trace(jvmcont)("Copying from h: " INTPTR_FORMAT "(%ld,%ld) - " INTPTR_FORMAT "(%ld,%ld) (%d words, %d bytes)",
     p2i(from), from - start_address(), relative_base() - from, p2i(from + size), from + size - start_address(), relative_base() - (from + size), size, size << LogBytesPerWord);
   log_develop_trace(jvmcont)("Copying to v: " INTPTR_FORMAT " - " INTPTR_FORMAT " (%d words, %d bytes)", p2i(to), p2i(to + size), size, size << LogBytesPerWord);
 
@@ -389,7 +389,7 @@ inline void stackChunkOopDesc::iterate_stack(StackChunkFrameClosureType* closure
 
     RegisterMap full_map((JavaThread*)nullptr, true, false, true);
     full_map.set_include_argument_oops(false);
-    
+
     f.next(&full_map);
 
     // log_develop_trace(jvmcont)("stackChunkOopDesc::iterate_stack this: " INTPTR_FORMAT " safepoint yield caller frame: %d", p2i(this), f.index());
@@ -445,7 +445,7 @@ StackChunkFrameStream<mixed>::StackChunkFrameStream(stackChunkOop chunk, bool gc
     // }
   }
   DEBUG_ONLY(else _unextended_sp = nullptr;)
-  
+
   if (is_stub()) {
     get_oopmap(pc(), 0);
     DEBUG_ONLY(_has_stub = true);
@@ -458,7 +458,7 @@ StackChunkFrameStream<mixed>::StackChunkFrameStream(stackChunkOop chunk, const f
   assert (mixed || !chunk->has_mixed_frames(), "");
 
   DEBUG_ONLY(_index = 0;)
-  
+
   _end = chunk->bottom_address();
 
   assert (chunk->is_in_chunk(f.sp()), "");
@@ -494,13 +494,13 @@ inline bool StackChunkFrameStream<mixed>::is_compiled() const {
 }
 
 template <bool mixed>
-inline bool StackChunkFrameStream<mixed>::is_interpreted() const { 
-  return mixed ? (!is_done() && Interpreter::contains(pc())) : false; 
+inline bool StackChunkFrameStream<mixed>::is_interpreted() const {
+  return mixed ? (!is_done() && Interpreter::contains(pc())) : false;
 }
 
 template <bool mixed>
 inline int StackChunkFrameStream<mixed>::frame_size() const {
-  return is_interpreted() ? interpreter_frame_size() 
+  return is_interpreted() ? interpreter_frame_size()
                           : cb()->frame_size() + stack_argsize();
 }
 
@@ -565,18 +565,18 @@ inline void StackChunkFrameStream<mixed>::get_cb() {
     return;
   }
 
-  assert (pc() != nullptr && dbg_is_safe(pc(), -1), 
-  "index: %d sp: " INTPTR_FORMAT " sp offset: %d end offset: %d size: %d chunk sp: %d", 
+  assert (pc() != nullptr && dbg_is_safe(pc(), -1),
+  "index: %d sp: " INTPTR_FORMAT " sp offset: %d end offset: %d size: %d chunk sp: %d",
   _index, p2i(sp()), _chunk->to_offset(sp()), _chunk->to_offset(_chunk->bottom_address()), _chunk->stack_size(), _chunk->sp());
 
   _cb = CodeCache::find_blob_fast(pc());
 
   // if (_cb == nullptr) { tty->print_cr("OOPS"); os::print_location(tty, (intptr_t)pc()); }
-  assert (_cb != nullptr, 
-    "index: %d sp: " INTPTR_FORMAT " sp offset: %d end offset: %d size: %d chunk sp: %d gc_flag: %d", 
+  assert (_cb != nullptr,
+    "index: %d sp: " INTPTR_FORMAT " sp offset: %d end offset: %d size: %d chunk sp: %d gc_flag: %d",
     _index, p2i(sp()), _chunk->to_offset(sp()), _chunk->to_offset(_chunk->bottom_address()), _chunk->stack_size(), _chunk->sp(), _chunk->is_gc_mode());
-  assert (is_interpreted() || ((is_stub() || is_compiled()) && _cb->frame_size() > 0), 
-    "index: %d sp: " INTPTR_FORMAT " sp offset: %d end offset: %d size: %d chunk sp: %d is_stub: %d is_compiled: %d frame_size: %d mixed: %d", 
+  assert (is_interpreted() || ((is_stub() || is_compiled()) && _cb->frame_size() > 0),
+    "index: %d sp: " INTPTR_FORMAT " sp offset: %d end offset: %d size: %d chunk sp: %d is_stub: %d is_compiled: %d frame_size: %d mixed: %d",
     _index, p2i(sp()), _chunk->to_offset(sp()), _chunk->to_offset(_chunk->bottom_address()), _chunk->stack_size(), _chunk->sp(), is_stub(), is_compiled(), _cb->frame_size(), mixed);
 }
 
@@ -584,7 +584,7 @@ template <bool mixed>
 inline void StackChunkFrameStream<mixed>::get_oopmap() const {
   if (is_interpreted()) return;
   assert (is_compiled(), "");
-  get_oopmap(pc(), CodeCache::find_oopmap_slot_fast(pc())); 
+  get_oopmap(pc(), CodeCache::find_oopmap_slot_fast(pc()));
 }
 
 template <bool mixed>
@@ -724,12 +724,12 @@ template<bool mixed>
 template <class DerivedOopClosureType, class RegisterMapT>
 inline void StackChunkFrameStream<mixed>::iterate_derived_pointers(DerivedOopClosureType* closure, const RegisterMapT* map) const {
   if (is_interpreted()) return;
-  
+
   for (OopMapStream oms(oopmap()); !oms.is_done(); oms.next()) {
     OopMapValue omv = oms.current();
     if (omv.type() != OopMapValue::derived_oop_value)
       continue;
-    
+
     intptr_t* derived_loc = (intptr_t*)reg_to_loc(omv.reg(), map);
     intptr_t* base_loc    = (intptr_t*)reg_to_loc(omv.content_reg(), map); // see OopMapDo<OopMapFnT, DerivedOopFnT, ValueFilterT>::walk_derived_pointers1
     assert (is_in_frame(base_loc), "");
@@ -737,7 +737,7 @@ inline void StackChunkFrameStream<mixed>::iterate_derived_pointers(DerivedOopClo
     assert (derived_loc != base_loc, "Base and derived in same location");
     assert (is_in_oops(base_loc, map), "not found: " INTPTR_FORMAT, p2i(base_loc));
     assert (!is_in_oops(derived_loc, map), "found: " INTPTR_FORMAT, p2i(derived_loc));
-    
+
     Devirtualizer::do_derived_oop(closure, (oop*)base_loc, (derived_pointer*)derived_loc);
   }
   OrderAccess::storestore(); // to preserve that we set the offset *before* fixing the base oop
diff --git a/src/hotspot/share/runtime/continuation.cpp b/src/hotspot/share/runtime/continuation.cpp
index ef6ab5848de..71e531339a4 100644
--- a/src/hotspot/share/runtime/continuation.cpp
+++ b/src/hotspot/share/runtime/continuation.cpp
@@ -55,7 +55,7 @@
 #include "oops/weakHandle.inline.hpp"
 #include "prims/jvmtiDeferredUpdates.hpp"
 #include "prims/jvmtiThreadState.hpp"
-#include "runtime/continuation.inline.hpp"
+#include "runtime/continuation.hpp"
 #include "runtime/deoptimization.hpp"
 #include "runtime/frame.hpp"
 #include "runtime/frame.inline.hpp"
@@ -590,7 +590,7 @@ class ContMirror {
   template <bool aligned = true>
   void copy_to_chunk(intptr_t* from, intptr_t* to, int size);
 
-  address last_pc() { return last_nonempty_chunk()->pc(); } 
+  address last_pc() { return last_nonempty_chunk()->pc(); }
 
   stackChunkOop find_chunk_by_address(void* p) const;
 
@@ -732,7 +732,7 @@ ALWAYSINLINE void ContMirror::read_minimal() {
   // if (log_develop_is_enabled(Trace, jvmcont)) {
   //   log_develop_trace(jvmcont)("Reading continuation object: " INTPTR_FORMAT, p2i((oopDesc*)_cont));
   //   log_develop_trace(jvmcont)("\ttail: " INTPTR_FORMAT, p2i((oopDesc*)_tail));
-  //   if (_tail != nullptr) _tail->print_on(tty);  
+  //   if (_tail != nullptr) _tail->print_on(tty);
   // }
 }
 
@@ -939,7 +939,7 @@ class Freeze {
   inline bool should_flush_stack_processing() {
     StackWatermark* sw;
     uintptr_t watermark;
-    return ((sw = StackWatermarkSet::get(_thread, StackWatermarkKind::gc)) != nullptr 
+    return ((sw = StackWatermarkSet::get(_thread, StackWatermarkKind::gc)) != nullptr
       && (watermark = sw->watermark()) != 0
       && watermark <= ((uintptr_t)_cont.entrySP() + ContinuationEntry::size()));
   }
@@ -955,7 +955,7 @@ class Freeze {
     _cont.copy_to_chunk<aligned>(from, to, size);
   #ifdef ASSERT
     stackChunkOop chunk = _cont.tail();
-    assert (_last_write == to + size, "Missed a spot: _last_write: " INTPTR_FORMAT " to+size: " INTPTR_FORMAT " stack_size: %d _last_write offset: %ld to+size: %ld", 
+    assert (_last_write == to + size, "Missed a spot: _last_write: " INTPTR_FORMAT " to+size: " INTPTR_FORMAT " stack_size: %d _last_write offset: %ld to+size: %ld",
       p2i(_last_write), p2i(to + size), chunk->stack_size(), _last_write - chunk->start_address(), to + size - chunk->start_address());
     _last_write = to;
     // tty->print_cr(">>> copy_to_chunk _last_write: %p", _last_write);
@@ -1090,7 +1090,7 @@ class Freeze {
         chunk->set_max_size(size);
         chunk->set_argsize(argsize);
       }
-      
+
       // chunk->reset_counters(chunk);
     } else {
       assert (_thread->thread_state() == _thread_in_vm, "");
@@ -1107,7 +1107,7 @@ class Freeze {
       log_develop_trace(jvmcont)("add max_size: %d -- %d", size + ContinuationHelper::frame_metadata, size + ContinuationHelper::frame_metadata);
       chunk->set_max_size(size);
       chunk->set_argsize(argsize);
-      
+
       sp = size + ContinuationHelper::frame_metadata;
       DEBUG_ONLY(orig_chunk_sp = chunk->start_address() + sp;)
 
@@ -1125,7 +1125,7 @@ class Freeze {
 
     if (should_flush_stack_processing())
       flush_stack_processing();
-      
+
     NoSafepointVerifier nsv;
     assert (chunk->is_stackChunk(), "");
     assert (!chunk->requires_barriers(), "");
@@ -1213,7 +1213,7 @@ class Freeze {
     HandleMark hm(Thread::current());
 
     frame f = freeze_start_frame();
-    
+
     _top_address = f.sp();
     frame caller;
     freeze_result res = freeze(f, caller, 0, false, true);
@@ -1225,7 +1225,7 @@ class Freeze {
 
     return res;
   }
-  
+
   frame freeze_start_frame() {
     frame f = _thread->last_frame();
     if (LIKELY(!_preempt)) {
@@ -1371,7 +1371,7 @@ class Freeze {
 
     _size -= overlap;
     assert (_size >= 0, "");
-    
+
     assert (chunk == nullptr || chunk->is_empty() || unextended_sp == chunk->to_offset(StackChunkFrameStream<true>(chunk).unextended_sp()), "");
     assert (chunk != nullptr || unextended_sp < _size, "");
 
@@ -1431,7 +1431,7 @@ class Freeze {
     if (log_develop_is_enabled(Trace, jvmcont)) chunk->print_on(tty);
 
     caller = StackChunkFrameStream<true>(chunk).to_frame();
-    
+
     DEBUG_ONLY(_last_write = caller.unextended_sp() + (empty_chunk ? argsize : overlap);)
     // tty->print_cr(">>> finalize_freeze chunk->sp_address(): %p empty_chunk: %d argsize: %d overlap: %d _last_write: %p _last_write - _size: %p", chunk->sp_address(), empty_chunk, argsize, overlap, _last_write, _last_write - _size); // caller.print_on<true>(tty);
     assert(chunk->is_in_chunk(_last_write - _size), "_last_write - _size: " INTPTR_FORMAT " start: " INTPTR_FORMAT, p2i(_last_write - _size), p2i(chunk->start_address()));
@@ -1470,7 +1470,7 @@ class Freeze {
       // in fast mode, partial copy does not copy _is_interpreted for the caller
       assert (Interpreter::contains(FKind::interpreted ? FKind::return_pc(hf) : Frame::real_pc(caller)) == caller.is_interpreted_frame(),
         "FKind: %s contains: %d is_interpreted: %d", FKind::name, Interpreter::contains(FKind::interpreted ? FKind::return_pc(hf) : Frame::real_pc(caller)), caller.is_interpreted_frame());
-      
+
       patch_pd<FKind, false>(hf, caller);
     }
     if (FKind::interpreted) {
@@ -1496,7 +1496,7 @@ class Freeze {
       intptr_t* real_unextended_sp = (intptr_t*)f.at<false>(frame::interpreter_frame_last_sp_offset);
       if (real_unextended_sp != nullptr) f.set_unextended_sp(real_unextended_sp); // can be null at a safepoint
     }
-    
+
     intptr_t* const vsp = Interpreted::frame_top(f, callee_argsize, callee_interpreted);
     const int argsize = Interpreted::stack_argsize(f);
     const int fsize = Interpreted::frame_bottom<false>(f) - vsp;
@@ -1519,7 +1519,7 @@ class Freeze {
 
     log_develop_trace(jvmcont)("recurse_freeze_interpreted_frame %s _size: %d fsize: %d argsize: %d callee_interpreted: %d callee_argsize: %d :: " INTPTR_FORMAT " - " INTPTR_FORMAT,
       frame_method->name_and_sig_as_C_string(), _size, fsize, argsize, callee_interpreted, callee_argsize, p2i(vsp), p2i(vsp+fsize));
-    
+
     freeze_result result = recurse_freeze_java_frame<Interpreted>(f, caller, fsize, argsize);
     if (UNLIKELY(result > freeze_ok_bottom)) return result;
     bool bottom = result == freeze_ok_bottom;
@@ -1870,7 +1870,7 @@ int freeze0(JavaThread* current, intptr_t* const sp, bool preempt) {
   assert (!fast || current->held_monitor_count() == 0, "");
 
   Freeze<ConfigT> fr(current, cont, preempt);
-  
+
   if (UNLIKELY(preempt)) {
     assert (current->thread_state() == _thread_in_vm, "");
     freeze_result res = fr.freeze_slow();
@@ -1885,7 +1885,7 @@ int freeze0(JavaThread* current, intptr_t* const sp, bool preempt) {
   #if CONT_JFR
     cont.post_jfr_event(&event, current);
   #endif
-  
+
     // if (UNLIKELY(preempt)) cont.set_preempted(true);
     return freeze_epilog(current, cont);
   }
@@ -2160,7 +2160,7 @@ class Thaw {
   }
 
   inline bool can_thaw_fast(stackChunkOop chunk) {
-    return    !_barriers 
+    return    !_barriers
            &&  _thread->cont_fastpath_thread_state()
            && !chunk->has_mixed_frames();
   }
@@ -2177,7 +2177,7 @@ class Thaw {
 
     stackChunkOop chunk = _cont.tail();
     assert (chunk != nullptr && !chunk->is_empty(), ""); // guaranteed by prepare_thaw
-    
+
     _barriers = (chunk->should_fix<typename ConfigT::OopT, ConfigT::_concurrent_gc>() || chunk->requires_barriers());
     if (LIKELY(can_thaw_fast(chunk))) {
       // if (kind != thaw_return_barrier) tty->print_cr("THAW FAST");
@@ -2232,11 +2232,11 @@ class Thaw {
       chunk->set_max_size(0);
       log_develop_trace(jvmcont)("set max_size: 0");
       // chunk->set_pc(nullptr);
-      
+
     } else { // thaw a single frame
       partial = true;
       DEBUG_ONLY(_mode = 2;)
-      
+
       StackChunkFrameStream<false> f(chunk);
       assert (hsp == f.sp() && hsp == f.unextended_sp(), "");
       size = f.cb()->frame_size();
@@ -2367,7 +2367,7 @@ class Thaw {
 
     frame hf = _stream.to_frame();
     log_develop_trace(jvmcont)("top_hframe before (thaw):"); if (log_develop_is_enabled(Trace, jvmcont)) hf.print_on<true>(tty);
-    
+
     frame f;
     thaw(hf, f, num_frames, true);
     intptr_t* sp = f.sp();
@@ -2398,7 +2398,7 @@ class Thaw {
 
     return sp;
   }
-  
+
   void thaw(const frame& hf, frame& caller, int num_frames, bool top) {
     log_develop_debug(jvmcont)("thaw num_frames: %d", num_frames);
     assert(!_cont.is_empty(), "no more frames");
@@ -2449,7 +2449,7 @@ class Thaw {
   template<typename FKind>
   void finalize_thaw(frame& entry, int argsize) {
     stackChunkOop chunk = _cont.tail();
-    
+
     OrderAccess::storestore();
     if (!_stream.is_done()) {
       assert (_stream.sp() >= chunk->sp_address(), "");
@@ -2461,7 +2461,7 @@ class Thaw {
       chunk->set_sp(chunk->stack_size());
     }
     assert(_stream.is_done() == chunk->is_empty(), "_stream.is_done(): %d chunk->is_empty(): %d", _stream.is_done(), chunk->is_empty());
-    
+
     int delta = _stream.unextended_sp() - _top_unextended_sp;
     log_develop_trace(jvmcont)("sub max_size: %d -- %d (unextended_sp: " INTPTR_FORMAT " orig unextended_sp: " INTPTR_FORMAT ")", delta, chunk->max_size() - delta, p2i(_stream.unextended_sp()), p2i(_top_unextended_sp));
     chunk->set_max_size(chunk->max_size() - delta);
@@ -2469,7 +2469,7 @@ class Thaw {
     assert (!_stream.is_done() || chunk->parent() != nullptr || argsize == 0, "");
     _cont.set_argsize(FKind::interpreted ? 0 : argsize);
     log_develop_trace(jvmcont)("setting entry argsize: %d (bottom interpreted: %d)", _cont.argsize(), FKind::interpreted);
-  
+
     entry = new_entry_frame();
 
     assert (entry.sp() == _cont.entrySP(), "entry.sp: %p entrySP: %p", entry.sp(), _cont.entrySP());
@@ -2516,7 +2516,7 @@ class Thaw {
 
   NOINLINE void recurse_thaw_interpreted_frame(const frame& hf, frame& caller, int num_frames) {
     assert (hf.is_interpreted_frame(), "");
-    
+
     const bool bottom = recurse_thaw_java_frame<Interpreted>(caller, num_frames);
 
     DEBUG_ONLY(before_thaw_java_frame(hf, caller, bottom, num_frames);)
@@ -2649,7 +2649,7 @@ class Thaw {
       }
       assert (!_stream.is_done(), "");
     }
-    
+
     recurse_thaw_compiled_frame(_stream.to_frame(), caller, num_frames);
 
     DEBUG_ONLY(before_thaw_java_frame(hf, caller, false, num_frames);)
@@ -3074,7 +3074,7 @@ frame Continuation::continuation_parent_frame(RegisterMap* map) {
   assert (map->in_cont(), "");
   ContMirror cont(map);
   assert (map->thread() != nullptr || !cont.is_mounted(), "map->thread() == nullptr: %d cont.is_mounted(): %d", map->thread() == nullptr, cont.is_mounted());
-  
+
   log_develop_trace(jvmcont)("continuation_parent_frame");
   if (map->update_map()) {
     ContinuationHelper::update_register_map_for_entry_frame(cont, map);
@@ -3093,7 +3093,7 @@ frame Continuation::continuation_parent_frame(RegisterMap* map) {
   }
 
   map->set_stack_chunk(nullptr);
- 
+
   frame sender(cont.entrySP(), cont.entryFP(), cont.entryPC());
 
   // tty->print_cr("continuation_parent_frame");
@@ -3568,7 +3568,7 @@ bool ContinuationEntry::assert_entry_frame_laid_out(JavaThread* thread) {
     assert (Continuation::is_continuation_enterSpecial(f), "");
     sp = interpreted_bottom ? f.sp() : cont->bottom_sender_sp();
   }
-  
+
   assert (sp != nullptr && sp <= cont->entry_sp(), "sp: " INTPTR_FORMAT " entry_sp: " INTPTR_FORMAT " bottom_sender_sp: " INTPTR_FORMAT, p2i(sp), p2i(cont->entry_sp()), p2i(cont->bottom_sender_sp()));
   address pc = *(address*)(sp - SENDER_SP_RET_ADDRESS_OFFSET);
 
@@ -3580,7 +3580,7 @@ bool ContinuationEntry::assert_entry_frame_laid_out(JavaThread* thread) {
       if (cb == nullptr) tty->print_cr("NULL"); else cb->print_on(tty);
       os::print_location(tty, (intptr_t)pc);
      }
-  
+
     assert (cb != nullptr, "");
     assert (cb->is_compiled(), "");
     assert (cb->as_compiled_method()->method()->is_continuation_enter_intrinsic(), "");
@@ -3588,7 +3588,7 @@ bool ContinuationEntry::assert_entry_frame_laid_out(JavaThread* thread) {
 
   // intptr_t* fp = *(intptr_t**)(sp - frame::sender_sp_offset);
   // assert (cont->entry_fp() == fp, "entry_fp: " INTPTR_FORMAT " actual: " INTPTR_FORMAT, p2i(cont->entry_sp()), p2i(fp));
-  
+
   return true;
 }
 #endif
diff --git a/src/hotspot/share/runtime/continuation.inline.hpp b/src/hotspot/share/runtime/continuation.inline.hpp
deleted file mode 100644
index f64d39c03b8..00000000000
--- a/src/hotspot/share/runtime/continuation.inline.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- *
- */
-
-#ifndef SHARE_VM_RUNTIME_CONTINUATION_INLINE_HPP
-#define SHARE_VM_RUNTIME_CONTINUATION_INLINE_HPP
-
-// #include "code/vmreg.inline.hpp"
-// #include "compiler/oopMap.hpp"
-// #include "logging/log.hpp"
-#include "runtime/continuation.hpp"
-
-#endif // SHARE_VM_RUNTIME_CONTINUATION_INLINE_HPP