diff --git a/src/hotspot/share/gc/g1/g1BlockOffsetTable.cpp b/src/hotspot/share/gc/g1/g1BlockOffsetTable.cpp
index c695ad977fe..fd70796251d 100644
--- a/src/hotspot/share/gc/g1/g1BlockOffsetTable.cpp
+++ b/src/hotspot/share/gc/g1/g1BlockOffsetTable.cpp
@@ -24,10 +24,9 @@
 
 #include "gc/g1/g1BlockOffsetTable.inline.hpp"
 #include "gc/g1/g1CollectedHeap.inline.hpp"
-#include "gc/g1/g1HeapRegion.inline.hpp"
+#include "gc/g1/g1RegionToSpaceMapper.hpp"
+#include "gc/shared/memset_with_concurrent_readers.hpp"
 #include "logging/log.hpp"
-#include "oops/oop.inline.hpp"
-#include "runtime/java.hpp"
 #include "runtime/os.hpp"
 
 size_t G1BlockOffsetTable::compute_size(size_t mem_region_words) {
@@ -52,6 +51,12 @@ void G1BlockOffsetTable::set_offset_array(Atomic<uint8_t>* addr, uint8_t offset)
   addr->store_relaxed(offset);
 }
 
+static void check_offset(size_t offset, const char* msg) {
+  assert(offset < CardTable::card_size_in_words(),
+         "%s - offset: %zu, N_words: %u",
+         msg, offset, CardTable::card_size_in_words());
+}
+
 void G1BlockOffsetTable::set_offset_array(Atomic<uint8_t>* addr, HeapWord* high, HeapWord* low) {
   assert(high >= low, "addresses out of order");
   size_t offset = pointer_delta(high, low);
diff --git a/src/hotspot/share/gc/g1/g1BlockOffsetTable.hpp b/src/hotspot/share/gc/g1/g1BlockOffsetTable.hpp
index 89c68ce96d2..21d447549a6 100644
--- a/src/hotspot/share/gc/g1/g1BlockOffsetTable.hpp
+++ b/src/hotspot/share/gc/g1/g1BlockOffsetTable.hpp
@@ -37,19 +37,12 @@
 // for each such subregion indicates how far back one must go to find the
 // start of the chunk that includes the first word of the subregion.
 class G1BlockOffsetTable : public CHeapObj<mtGC> {
-private:
   // The reserved region covered by the table.
   MemRegion _reserved;
 
   // Biased array-start of BOT array for fast BOT entry translation
   Atomic<uint8_t>* _offset_base;
 
-  void check_offset(size_t offset, const char* msg) const {
-    assert(offset < CardTable::card_size_in_words(),
-           "%s - offset: %zu, N_words: %u",
-           msg, offset, CardTable::card_size_in_words());
-  }
-
   // Bounds checking accessors:
   // For performance these have to devolve to array accesses in product builds.
   inline uint8_t offset_array(Atomic<uint8_t>* addr) const;
@@ -85,7 +78,6 @@ private:
   }
 
 public:
-
   // Return the number of slots needed for an offset array
   // that covers mem_region_words words.
   static size_t compute_size(size_t mem_region_words);
@@ -99,22 +91,14 @@ public:
   // in the heap parameter.
   G1BlockOffsetTable(MemRegion heap, G1RegionToSpaceMapper* storage);
 
-  static bool is_crossing_card_boundary(HeapWord* const obj_start,
-                                        HeapWord* const obj_end) {
-    HeapWord* cur_card_boundary = align_up_by_card_size(obj_start);
-    // strictly greater-than
-    return obj_end > cur_card_boundary;
-  }
+  inline static bool is_crossing_card_boundary(HeapWord* const obj_start,
+                                               HeapWord* const obj_end);
 
   // Returns the address of the start of the block reaching into the card containing
   // "addr".
   inline HeapWord* block_start_reaching_into_card(const void* addr) const;
 
-  void update_for_block(HeapWord* blk_start, HeapWord* blk_end) {
-    if (is_crossing_card_boundary(blk_start, blk_end)) {
-      update_for_block_work(blk_start, blk_end);
-    }
-  }
+  inline void update_for_block(HeapWord* blk_start, HeapWord* blk_end);
 };
 
 #endif // SHARE_GC_G1_G1BLOCKOFFSETTABLE_HPP
diff --git a/src/hotspot/share/gc/g1/g1BlockOffsetTable.inline.hpp b/src/hotspot/share/gc/g1/g1BlockOffsetTable.inline.hpp
index 0d809b65526..b707e310781 100644
--- a/src/hotspot/share/gc/g1/g1BlockOffsetTable.inline.hpp
+++ b/src/hotspot/share/gc/g1/g1BlockOffsetTable.inline.hpp
@@ -27,10 +27,7 @@
 
 #include "gc/g1/g1BlockOffsetTable.hpp"
 
-#include "gc/g1/g1HeapRegion.hpp"
 #include "gc/shared/cardTable.hpp"
-#include "gc/shared/memset_with_concurrent_readers.hpp"
-#include "oops/oop.inline.hpp"
 
 inline HeapWord* G1BlockOffsetTable::block_start_reaching_into_card(const void* addr) const {
   assert(_reserved.contains(addr), "invalid address");
@@ -70,4 +67,17 @@ inline HeapWord* G1BlockOffsetTable::addr_for_entry(const Atomic<uint8_t>* const
   return result;
 }
 
+inline bool G1BlockOffsetTable::is_crossing_card_boundary(HeapWord* const obj_start,
+                                                          HeapWord* const obj_end) {
+  HeapWord* cur_card_boundary = align_up_by_card_size(obj_start);
+  // strictly greater-than
+  return obj_end > cur_card_boundary;
+}
+
+inline void G1BlockOffsetTable::update_for_block(HeapWord* blk_start, HeapWord* blk_end) {
+  if (is_crossing_card_boundary(blk_start, blk_end)) {
+    update_for_block_work(blk_start, blk_end);
+  }
+}
+
 #endif // SHARE_GC_G1_G1BLOCKOFFSETTABLE_INLINE_HPP