# HG changeset patch
# User rkennke
# Date 1557341130 -7200
#      Wed May 08 20:45:30 2019 +0200
# Node ID 08fd06bc692690fe12e8c896925ecd15121ddc45
# Parent  704f605efe4c8e43acbd93cd19ad0f5a4e706e4a
[backport] 8223567: Rename ShenandoahBrooksPointer to ShenandoahForwarding
Reviewed-by: shade

diff --git a/src/cpu/aarch64/vm/shenandoahBarrierSetAssembler_aarch64.cpp b/src/cpu/aarch64/vm/shenandoahBarrierSetAssembler_aarch64.cpp
--- a/src/cpu/aarch64/vm/shenandoahBarrierSetAssembler_aarch64.cpp
+++ b/src/cpu/aarch64/vm/shenandoahBarrierSetAssembler_aarch64.cpp
@@ -28,7 +28,7 @@
 #include "shenandoahBarrierSetAssembler_aarch64.hpp"
 #include "gc_implementation/shenandoah/shenandoahBarrierSet.hpp"
 #include "gc_implementation/shenandoah/shenandoahBarrierSetC1.hpp"
-#include "gc_implementation/shenandoah/shenandoahBrooksPointer.hpp"
+#include "gc_implementation/shenandoah/shenandoahForwarding.hpp"
 #include "gc_implementation/shenandoah/shenandoahHeap.hpp"
 #include "gc_implementation/shenandoah/shenandoahRuntime.hpp"
 #include "runtime/stubCodeGenerator.hpp"
@@ -50,7 +50,7 @@
 
 void ShenandoahBarrierSetAssembler::resolve_forward_pointer_not_null(MacroAssembler* masm, Register dst) {
   assert(ShenandoahCASBarrier || ShenandoahLoadRefBarrier, "should be enabled");
-  __ ldr(dst, Address(dst, ShenandoahBrooksPointer::byte_offset()));
+  __ ldr(dst, Address(dst, ShenandoahForwarding::byte_offset()));
 }
 
 void ShenandoahBarrierSetAssembler::load_reference_barrier_not_null(MacroAssembler* masm, Register dst) {
@@ -189,7 +189,7 @@
 #define __ masm->
 
 void ShenandoahHeap::compile_prepare_oop(MacroAssembler* masm, Register obj) {
-  __ add(obj, obj, ShenandoahBrooksPointer::byte_size());
+  __ add(obj, obj, ShenandoahForwarding::byte_size());
   __ str(obj, Address(obj, -1 * HeapWordSize));
 }
 
diff --git a/src/cpu/x86/vm/shenandoahBarrierSetAssembler_x86.cpp b/src/cpu/x86/vm/shenandoahBarrierSetAssembler_x86.cpp
--- a/src/cpu/x86/vm/shenandoahBarrierSetAssembler_x86.cpp
+++ b/src/cpu/x86/vm/shenandoahBarrierSetAssembler_x86.cpp
@@ -28,7 +28,7 @@
 #include "shenandoahBarrierSetAssembler_x86.hpp"
 #include "gc_implementation/shenandoah/shenandoahBarrierSet.hpp"
 #include "gc_implementation/shenandoah/shenandoahBarrierSetC1.hpp"
-#include "gc_implementation/shenandoah/shenandoahBrooksPointer.hpp"
+#include "gc_implementation/shenandoah/shenandoahForwarding.hpp"
 #include "gc_implementation/shenandoah/shenandoahHeap.hpp"
 #include "gc_implementation/shenandoah/shenandoahHeapRegion.hpp"
 #include "gc_implementation/shenandoah/shenandoahRuntime.hpp"
@@ -51,7 +51,7 @@
 
 void ShenandoahBarrierSetAssembler::resolve_forward_pointer_not_null(MacroAssembler* masm, Register dst) {
   assert(ShenandoahCASBarrier || ShenandoahLoadRefBarrier, "should be enabled");
-  __ movptr(dst, Address(dst, ShenandoahBrooksPointer::byte_offset()));
+  __ movptr(dst, Address(dst, ShenandoahForwarding::byte_offset()));
 }
 
 void ShenandoahBarrierSetAssembler::load_reference_barrier_not_null(MacroAssembler* masm, Register dst) {
@@ -265,11 +265,11 @@
 
 void ShenandoahHeap::compile_prepare_oop(MacroAssembler* masm, Register obj) {
 #ifdef _LP64
-  __ incrementq(obj, ShenandoahBrooksPointer::byte_size());
+  __ incrementq(obj, ShenandoahForwarding::byte_size());
 #else
-  __ incrementl(obj, ShenandoahBrooksPointer::byte_size());
+  __ incrementl(obj, ShenandoahForwarding::byte_size());
 #endif
-  __ movptr(Address(obj, ShenandoahBrooksPointer::byte_offset()), obj);
+  __ movptr(Address(obj, ShenandoahForwarding::byte_offset()), obj);
 }
 
 #undef __
diff --git a/src/cpu/x86/vm/x86_64.ad b/src/cpu/x86/vm/x86_64.ad
--- a/src/cpu/x86/vm/x86_64.ad
+++ b/src/cpu/x86/vm/x86_64.ad
@@ -528,7 +528,6 @@
 
 source_hpp %{
 #if INCLUDE_ALL_GCS
-#include "gc_implementation/shenandoah/shenandoahBrooksPointer.hpp"
 #include "shenandoahBarrierSetAssembler_x86.hpp"
 #endif
 %}
diff --git a/src/share/vm/asm/assembler.cpp b/src/share/vm/asm/assembler.cpp
--- a/src/share/vm/asm/assembler.cpp
+++ b/src/share/vm/asm/assembler.cpp
@@ -26,7 +26,7 @@
 #include "asm/macroAssembler.hpp"
 #include "asm/macroAssembler.inline.hpp"
 #include "asm/codeBuffer.hpp"
-#include "gc_implementation/shenandoah/shenandoahBrooksPointer.hpp"
+#include "gc_implementation/shenandoah/shenandoahForwarding.hpp"
 #include "runtime/atomic.hpp"
 #include "runtime/atomic.inline.hpp"
 #include "runtime/icache.hpp"
@@ -318,7 +318,7 @@
     uintptr_t base = (uintptr_t)Universe::narrow_oop_base();
     int adj = 0;
     if (UseShenandoahGC) {
-      adj = ShenandoahBrooksPointer::byte_offset();
+      adj = ShenandoahForwarding::byte_offset();
       assert(adj < 0, "no need for positive adjustments");
     }
     if ((uintptr_t)((offset - adj) & address_bits) >= base) {
@@ -328,7 +328,7 @@
   }
 #endif
 
-  if (UseShenandoahGC && ((offset & address_bits) == (ShenandoahBrooksPointer::byte_offset() & address_bits))) {
+  if (UseShenandoahGC && ((offset & address_bits) == (ShenandoahForwarding::byte_offset() & address_bits))) {
     return false;
   }
 
diff --git a/src/share/vm/c1/c1_LIRGenerator.cpp b/src/share/vm/c1/c1_LIRGenerator.cpp
--- a/src/share/vm/c1/c1_LIRGenerator.cpp
+++ b/src/share/vm/c1/c1_LIRGenerator.cpp
@@ -33,7 +33,6 @@
 #include "ci/ciArrayKlass.hpp"
 #include "ci/ciInstance.hpp"
 #include "ci/ciObjArray.hpp"
-#include "gc_implementation/shenandoah/shenandoahBrooksPointer.hpp"
 #include "gc_implementation/shenandoah/shenandoahBarrierSetC1.hpp"
 #include "gc_implementation/shenandoah/shenandoahHeap.hpp"
 #include "runtime/sharedRuntime.hpp"
diff --git a/src/share/vm/ci/ciInstanceKlass.cpp b/src/share/vm/ci/ciInstanceKlass.cpp
--- a/src/share/vm/ci/ciInstanceKlass.cpp
+++ b/src/share/vm/ci/ciInstanceKlass.cpp
@@ -28,7 +28,7 @@
 #include "ci/ciInstanceKlass.hpp"
 #include "ci/ciUtilities.hpp"
 #include "classfile/systemDictionary.hpp"
-#include "gc_implementation/shenandoah/shenandoahBrooksPointer.hpp"
+#include "gc_implementation/shenandoah/shenandoahForwarding.hpp"
 #include "memory/allocation.hpp"
 #include "memory/allocation.inline.hpp"
 #include "oops/oop.inline.hpp"
@@ -179,7 +179,7 @@
 //
 ciInstanceKlass* ciInstanceKlass::get_canonical_holder(int offset) {
   #ifdef ASSERT
-  if (!((offset >= 0 && offset < layout_helper()) || (UseShenandoahGC && offset == ShenandoahBrooksPointer::byte_offset()))) {
+  if (!((offset >= 0 && offset < layout_helper()) || (UseShenandoahGC && offset == ShenandoahForwarding::byte_offset()))) {
     tty->print("*** get_canonical_holder(%d) on ", offset);
     this->print();
     tty->print_cr(" ***");
diff --git a/src/share/vm/gc_implementation/shenandoah/shenandoahAsserts.cpp b/src/share/vm/gc_implementation/shenandoah/shenandoahAsserts.cpp
--- a/src/share/vm/gc_implementation/shenandoah/shenandoahAsserts.cpp
+++ b/src/share/vm/gc_implementation/shenandoah/shenandoahAsserts.cpp
@@ -24,7 +24,7 @@
 #include "precompiled.hpp"
 
 #include "gc_implementation/shenandoah/shenandoahAsserts.hpp"
-#include "gc_implementation/shenandoah/shenandoahBrooksPointer.hpp"
+#include "gc_implementation/shenandoah/shenandoahForwarding.hpp"
 #include "gc_implementation/shenandoah/shenandoahHeap.inline.hpp"
 #include "gc_implementation/shenandoah/shenandoahMarkingContext.inline.hpp"
 #include "gc_implementation/shenandoah/shenandoahUtils.hpp"
@@ -131,7 +131,7 @@
   msg.append("\n");
 
   if (level >= _safe_oop) {
-    oop fwd = (oop) ShenandoahBrooksPointer::get_raw_unchecked(obj);
+    oop fwd = (oop) ShenandoahForwarding::get_forwardee_raw_unchecked(obj);
     msg.append("Forwardee:\n");
     if (obj != fwd) {
       if (level >= _safe_oop_fwd) {
@@ -146,8 +146,8 @@
   }
 
   if (level >= _safe_oop_fwd) {
-    oop fwd = (oop) ShenandoahBrooksPointer::get_raw_unchecked(obj);
-    oop fwd2 = (oop) ShenandoahBrooksPointer::get_raw_unchecked(fwd);
+    oop fwd = (oop) ShenandoahForwarding::get_forwardee_raw_unchecked(obj);
+    oop fwd2 = (oop) ShenandoahForwarding::get_forwardee_raw_unchecked(fwd);
     if (fwd != fwd2) {
       msg.append("Second forwardee:\n");
       print_obj_safe(msg, fwd2);
@@ -192,7 +192,7 @@
                   file,line);
   }
 
-  oop fwd = oop(ShenandoahBrooksPointer::get_raw_unchecked(obj));
+  oop fwd = oop(ShenandoahForwarding::get_forwardee_raw_unchecked(obj));
 
   if (obj != fwd) {
     // When Full GC moves the objects, we cannot trust fwdptrs. If we got here, it means something
@@ -225,7 +225,7 @@
     }
 
     // Step 4. Check for multiple forwardings
-    oop fwd2 = oop(ShenandoahBrooksPointer::get_raw_unchecked(fwd));
+    oop fwd2 = oop(ShenandoahForwarding::get_forwardee_raw_unchecked(fwd));
     if (fwd != fwd2) {
       print_failure(_safe_all, obj, interior_loc, NULL, "Shenandoah assert_correct failed",
                     "Multiple forwardings",
@@ -245,7 +245,7 @@
                   file, line);
   }
 
-  size_t alloc_size = obj->size() + ShenandoahBrooksPointer::word_size();
+  size_t alloc_size = obj->size() + ShenandoahForwarding::word_size();
   if (alloc_size > ShenandoahHeapRegion::humongous_threshold_words()) {
     size_t idx = r->region_number();
     size_t num_regions = ShenandoahHeapRegion::required_regions(alloc_size * HeapWordSize);
@@ -267,7 +267,7 @@
 
 void ShenandoahAsserts::assert_forwarded(void* interior_loc, oop obj, const char* file, int line) {
   assert_correct(interior_loc, obj, file, line);
-  oop fwd = oop(ShenandoahBrooksPointer::get_raw_unchecked(obj));
+  oop fwd = oop(ShenandoahForwarding::get_forwardee_raw_unchecked(obj));
 
   if (obj == fwd) {
     print_failure(_safe_all, obj, interior_loc, NULL, "Shenandoah assert_forwarded failed",
@@ -278,7 +278,7 @@
 
 void ShenandoahAsserts::assert_not_forwarded(void* interior_loc, oop obj, const char* file, int line) {
   assert_correct(interior_loc, obj, file, line);
-  oop fwd = oop(ShenandoahBrooksPointer::get_raw_unchecked(obj));
+  oop fwd = oop(ShenandoahForwarding::get_forwardee_raw_unchecked(obj));
 
   if (obj != fwd) {
     print_failure(_safe_all, obj, interior_loc, NULL, "Shenandoah assert_not_forwarded failed",
diff --git a/src/share/vm/gc_implementation/shenandoah/shenandoahBarrierSet.cpp b/src/share/vm/gc_implementation/shenandoah/shenandoahBarrierSet.cpp
--- a/src/share/vm/gc_implementation/shenandoah/shenandoahBarrierSet.cpp
+++ b/src/share/vm/gc_implementation/shenandoah/shenandoahBarrierSet.cpp
@@ -26,6 +26,7 @@
 #include "gc_implementation/shenandoah/shenandoahAsserts.hpp"
 #include "gc_implementation/shenandoah/shenandoahBarrierSet.hpp"
 #include "gc_implementation/shenandoah/shenandoahCollectorPolicy.hpp"
+#include "gc_implementation/shenandoah/shenandoahForwarding.hpp"
 #include "gc_implementation/shenandoah/shenandoahHeap.inline.hpp"
 #include "gc_implementation/shenandoah/shenandoahHeuristics.hpp"
 #include "runtime/interfaceSupport.hpp"
@@ -294,7 +295,7 @@
       ShenandoahHeapRegion* r = _heap->heap_region_containing(obj);
       assert(r->is_cset(), "sanity");
 
-      HeapWord* cur = (HeapWord*)obj + obj->size() + ShenandoahBrooksPointer::word_size();
+      HeapWord* cur = (HeapWord*)obj + obj->size() + ShenandoahForwarding::word_size();
 
       size_t count = 0;
       while ((cur < r->top()) && ctx->is_marked(oop(cur)) && (count++ < max)) {
@@ -302,7 +303,7 @@
         if (cur_oop == resolve_forwarded_not_null(cur_oop)) {
           _heap->evacuate_object(cur_oop, thread);
         }
-        cur = cur + cur_oop->size() + ShenandoahBrooksPointer::word_size();
+        cur = cur + cur_oop->size() + ShenandoahForwarding::word_size();
       }
     }
 
diff --git a/src/share/vm/gc_implementation/shenandoah/shenandoahBarrierSet.inline.hpp b/src/share/vm/gc_implementation/shenandoah/shenandoahBarrierSet.inline.hpp
--- a/src/share/vm/gc_implementation/shenandoah/shenandoahBarrierSet.inline.hpp
+++ b/src/share/vm/gc_implementation/shenandoah/shenandoahBarrierSet.inline.hpp
@@ -25,6 +25,7 @@
 #define SHARE_VM_GC_SHENANDOAH_SHENANDOAHBARRIERSET_INLINE_HPP
 
 #include "gc_implementation/shenandoah/shenandoahBarrierSet.hpp"
+#include "gc_implementation/shenandoah/shenandoahForwarding.inline.hpp"
 #include "gc_implementation/shenandoah/shenandoahHeap.inline.hpp"
 
 bool ShenandoahBarrierSet::need_update_refs_barrier() {
@@ -33,7 +34,7 @@
 }
 
 inline oop ShenandoahBarrierSet::resolve_forwarded_not_null(oop p) {
-  return ShenandoahBrooksPointer::forwardee(p);
+  return ShenandoahForwarding::get_forwardee(p);
 }
 
 inline oop ShenandoahBarrierSet::resolve_forwarded(oop p) {
diff --git a/src/share/vm/gc_implementation/shenandoah/shenandoahBarrierSetC1.cpp b/src/share/vm/gc_implementation/shenandoah/shenandoahBarrierSetC1.cpp
--- a/src/share/vm/gc_implementation/shenandoah/shenandoahBarrierSetC1.cpp
+++ b/src/share/vm/gc_implementation/shenandoah/shenandoahBarrierSetC1.cpp
@@ -25,7 +25,7 @@
 #include "c1/c1_LIRGenerator.hpp"
 #include "c1/c1_IR.hpp"
 #include "gc_implementation/g1/satbQueue.hpp"
-#include "gc_implementation/shenandoah/shenandoahBrooksPointer.hpp"
+#include "gc_implementation/shenandoah/shenandoahForwarding.hpp"
 #include "gc_implementation/shenandoah/shenandoahHeap.hpp"
 #include "gc_implementation/shenandoah/shenandoahHeapRegion.hpp"
 #include "gc_implementation/shenandoah/shenandoahBarrierSetC1.hpp"
diff --git a/src/share/vm/gc_implementation/shenandoah/shenandoahConcurrentMark.cpp b/src/share/vm/gc_implementation/shenandoah/shenandoahConcurrentMark.cpp
--- a/src/share/vm/gc_implementation/shenandoah/shenandoahConcurrentMark.cpp
+++ b/src/share/vm/gc_implementation/shenandoah/shenandoahConcurrentMark.cpp
@@ -28,7 +28,6 @@
 #include "code/codeCache.hpp"
 
 #include "gc_implementation/shared/parallelCleaning.hpp"
-#include "gc_implementation/shenandoah/shenandoahBrooksPointer.hpp"
 #include "gc_implementation/shenandoah/shenandoahBarrierSet.inline.hpp"
 #include "gc_implementation/shenandoah/shenandoahClosures.inline.hpp"
 #include "gc_implementation/shenandoah/shenandoahConcurrentMark.inline.hpp"
diff --git a/src/share/vm/gc_implementation/shenandoah/shenandoahConcurrentMark.inline.hpp b/src/share/vm/gc_implementation/shenandoah/shenandoahConcurrentMark.inline.hpp
--- a/src/share/vm/gc_implementation/shenandoah/shenandoahConcurrentMark.inline.hpp
+++ b/src/share/vm/gc_implementation/shenandoah/shenandoahConcurrentMark.inline.hpp
@@ -24,8 +24,8 @@
 #ifndef SHARE_VM_GC_SHENANDOAH_SHENANDOAHCONCURRENTMARK_INLINE_HPP
 #define SHARE_VM_GC_SHENANDOAH_SHENANDOAHCONCURRENTMARK_INLINE_HPP
 
-#include "gc_implementation/shenandoah/shenandoahBrooksPointer.hpp"
 #include "gc_implementation/shenandoah/shenandoahAsserts.hpp"
+#include "gc_implementation/shenandoah/shenandoahForwarding.hpp"
 #include "gc_implementation/shenandoah/shenandoahBarrierSet.inline.hpp"
 #include "gc_implementation/shenandoah/shenandoahConcurrentMark.hpp"
 #include "gc_implementation/shenandoah/shenandoahMarkingContext.inline.hpp"
@@ -71,7 +71,7 @@
 inline void ShenandoahConcurrentMark::count_liveness(jushort* live_data, oop obj) {
   size_t region_idx = _heap->heap_region_index_containing(obj);
   ShenandoahHeapRegion* region = _heap->get_region(region_idx);
-  size_t size = obj->size() + ShenandoahBrooksPointer::word_size();
+  size_t size = obj->size() + ShenandoahForwarding::word_size();
 
   if (!region->is_humongous_start()) {
     assert(!region->is_humongous(), "Cannot have continuations here");
diff --git a/src/share/vm/gc_implementation/shenandoah/shenandoahBrooksPointer.hpp b/src/share/vm/gc_implementation/shenandoah/shenandoahForwarding.hpp
rename from src/share/vm/gc_implementation/shenandoah/shenandoahBrooksPointer.hpp
rename to src/share/vm/gc_implementation/shenandoah/shenandoahForwarding.hpp
--- a/src/share/vm/gc_implementation/shenandoah/shenandoahBrooksPointer.hpp
+++ b/src/share/vm/gc_implementation/shenandoah/shenandoahForwarding.hpp
@@ -21,13 +21,13 @@
  *
  */
 
-#ifndef SHARE_VM_GC_SHENANDOAH_SHENANDOAHBROOKSPOINTER_HPP
-#define SHARE_VM_GC_SHENANDOAH_SHENANDOAHBROOKSPOINTER_HPP
+#ifndef SHARE_GC_SHENANDOAH_SHENANDOAHFORWARDING_HPP
+#define SHARE_GC_SHENANDOAH_SHENANDOAHFORWARDING_HPP
 
 #include "oops/oop.hpp"
 #include "utilities/globalDefinitions.hpp"
 
-class ShenandoahBrooksPointer {
+class ShenandoahForwarding {
   /*
    * Notes:
    *
@@ -70,13 +70,13 @@
     guarantee (MinObjAlignmentInBytes > 0, "sanity, byte_size is correct");
   }
 
-  /* Initializes Brooks pointer (to self).
+  /* Initializes forwarding pointer (to self).
    */
   static inline void initialize(oop obj);
 
   /* Gets forwardee from the given object.
    */
-  static inline oop forwardee(oop obj);
+  static inline oop get_forwardee(oop obj);
 
   /* Tries to atomically update forwardee in $holder object to $update.
    * Assumes $holder points at itself.
@@ -88,19 +88,19 @@
   /* Sets raw value for forwardee slot.
    * THIS IS DANGEROUS: USERS HAVE TO INITIALIZE/SET FORWARDEE BACK AFTER THEY ARE DONE.
    */
-  static inline void set_raw(oop obj, HeapWord* update);
+  static inline void set_forwardee_raw(oop obj, HeapWord* update);
 
   /* Returns the raw value from forwardee slot.
    */
-  static inline HeapWord* get_raw(oop obj);
+  static inline HeapWord* get_forwardee_raw(oop obj);
 
   /* Returns the raw value from forwardee slot without any checks.
    * Used for quick verification.
    */
-  static inline HeapWord* get_raw_unchecked(oop obj);
+  static inline HeapWord* get_forwardee_raw_unchecked(oop obj);
 
 private:
-  static inline HeapWord** brooks_ptr_addr(oop obj);
+  static inline HeapWord** forward_ptr_addr(oop obj);
 };
 
-#endif // SHARE_VM_GC_SHENANDOAH_SHENANDOAHBROOKSPOINTER_HPP
+#endif // SHARE_GC_SHENANDOAH_SHENANDOAHFORWARDING_HPP
diff --git a/src/share/vm/gc_implementation/shenandoah/shenandoahBrooksPointer.inline.hpp b/src/share/vm/gc_implementation/shenandoah/shenandoahForwarding.inline.hpp
rename from src/share/vm/gc_implementation/shenandoah/shenandoahBrooksPointer.inline.hpp
rename to src/share/vm/gc_implementation/shenandoah/shenandoahForwarding.inline.hpp
--- a/src/share/vm/gc_implementation/shenandoah/shenandoahBrooksPointer.inline.hpp
+++ b/src/share/vm/gc_implementation/shenandoah/shenandoahForwarding.inline.hpp
@@ -21,48 +21,48 @@
  *
  */
 
-#ifndef SHARE_VM_GC_SHENANDOAH_SHENANDOAHBROOKSPOINTER_INLINE_HPP
-#define SHARE_VM_GC_SHENANDOAH_SHENANDOAHBROOKSPOINTER_INLINE_HPP
+#ifndef SHARE_GC_SHENANDOAH_SHENANDOAHFORWARDING_INLINE_HPP
+#define SHARE_GC_SHENANDOAH_SHENANDOAHFORWARDING_INLINE_HPP
 
-#include "gc_implementation/shenandoah/shenandoahBrooksPointer.hpp"
 #include "gc_implementation/shenandoah/shenandoahAsserts.hpp"
+#include "gc_implementation/shenandoah/shenandoahForwarding.hpp"
 #include "gc_implementation/shenandoah/shenandoahHeap.hpp"
 #include "gc_implementation/shenandoah/shenandoahHeapRegion.hpp"
 #include "gc_implementation/shenandoah/shenandoahLogging.hpp"
 #include "runtime/atomic.hpp"
 
-inline HeapWord** ShenandoahBrooksPointer::brooks_ptr_addr(oop obj) {
+inline HeapWord** ShenandoahForwarding::forward_ptr_addr(oop obj) {
   return (HeapWord**)((HeapWord*) obj + word_offset());
 }
 
-inline void ShenandoahBrooksPointer::initialize(oop obj) {
+inline void ShenandoahForwarding::initialize(oop obj) {
   shenandoah_assert_in_heap(NULL, obj);
-  *brooks_ptr_addr(obj) = (HeapWord*) obj;
+  *forward_ptr_addr(obj) = (HeapWord*) obj;
 }
 
-inline void ShenandoahBrooksPointer::set_raw(oop obj, HeapWord* update) {
+inline void ShenandoahForwarding::set_forwardee_raw(oop obj, HeapWord* update) {
   shenandoah_assert_in_heap(NULL, obj);
-  *brooks_ptr_addr(obj) = update;
+  *forward_ptr_addr(obj) = update;
 }
 
-inline HeapWord* ShenandoahBrooksPointer::get_raw(oop obj) {
+inline HeapWord* ShenandoahForwarding::get_forwardee_raw(oop obj) {
   shenandoah_assert_in_heap(NULL, obj);
-  return *brooks_ptr_addr(obj);
+  return *forward_ptr_addr(obj);
 }
 
-inline HeapWord* ShenandoahBrooksPointer::get_raw_unchecked(oop obj) {
-  return *brooks_ptr_addr(obj);
+inline HeapWord* ShenandoahForwarding::get_forwardee_raw_unchecked(oop obj) {
+  return *forward_ptr_addr(obj);
 }
 
-inline oop ShenandoahBrooksPointer::forwardee(oop obj) {
+inline oop ShenandoahForwarding::get_forwardee(oop obj) {
   shenandoah_assert_correct(NULL, obj);
-  return oop(*brooks_ptr_addr(obj));
+  return oop(*forward_ptr_addr(obj));
 }
 
-inline oop ShenandoahBrooksPointer::try_update_forwardee(oop obj, oop update) {
-  oop result = (oop) Atomic::cmpxchg_ptr(update, brooks_ptr_addr(obj), obj);
+inline oop ShenandoahForwarding::try_update_forwardee(oop obj, oop update) {
+  oop result = (oop) Atomic::cmpxchg_ptr(update, forward_ptr_addr(obj), obj);
   shenandoah_assert_correct_except(NULL, obj, result != obj);
   return result;
 }
 
-#endif // SHARE_VM_GC_SHENANDOAH_SHENANDOAHBROOKSPOINTER_INLINE_HPP
+#endif // SHARE_GC_SHENANDOAH_SHENANDOAHFORWARDING_INLINE_HPP
diff --git a/src/share/vm/gc_implementation/shenandoah/shenandoahHeap.cpp b/src/share/vm/gc_implementation/shenandoah/shenandoahHeap.cpp
--- a/src/share/vm/gc_implementation/shenandoah/shenandoahHeap.cpp
+++ b/src/share/vm/gc_implementation/shenandoah/shenandoahHeap.cpp
@@ -28,9 +28,9 @@
 #include "gc_implementation/shenandoah/shenandoahGCTraceTime.hpp"
 #include "gc_implementation/shared/parallelCleaning.hpp"
 
-#include "gc_implementation/shenandoah/shenandoahBrooksPointer.hpp"
 #include "gc_implementation/shenandoah/shenandoahAllocTracker.hpp"
 #include "gc_implementation/shenandoah/shenandoahBarrierSet.hpp"
+#include "gc_implementation/shenandoah/shenandoahForwarding.hpp"
 #include "gc_implementation/shenandoah/shenandoahClosures.inline.hpp"
 #include "gc_implementation/shenandoah/shenandoahCollectionSet.hpp"
 #include "gc_implementation/shenandoah/shenandoahCollectorPolicy.hpp"
@@ -127,7 +127,7 @@
 jint ShenandoahHeap::initialize() {
   CollectedHeap::pre_initialize();
 
-  ShenandoahBrooksPointer::initial_checks();
+  ShenandoahForwarding::initial_checks();
 
   initialize_heuristics();
 
@@ -825,11 +825,11 @@
 
 HeapWord*  ShenandoahHeap::mem_allocate(size_t size,
                                         bool*  gc_overhead_limit_was_exceeded) {
-  ShenandoahAllocRequest req = ShenandoahAllocRequest::for_shared(size + ShenandoahBrooksPointer::word_size());
+  ShenandoahAllocRequest req = ShenandoahAllocRequest::for_shared(size + ShenandoahForwarding::word_size());
   HeapWord* filler = allocate_memory(req);
-  HeapWord* result = filler + ShenandoahBrooksPointer::word_size();
+  HeapWord* result = filler + ShenandoahForwarding::word_size();
   if (filler != NULL) {
-    ShenandoahBrooksPointer::initialize(oop(result));
+    ShenandoahForwarding::initialize(oop(result));
 
     assert(! in_collection_set(result), "never allocate in targetted region");
     return result;
@@ -925,8 +925,8 @@
 void ShenandoahHeap::trash_humongous_region_at(ShenandoahHeapRegion* start) {
   assert(start->is_humongous_start(), "reclaim regions starting with the first one");
 
-  oop humongous_obj = oop(start->bottom() + ShenandoahBrooksPointer::word_size());
-  size_t size = humongous_obj->size() + ShenandoahBrooksPointer::word_size();
+  oop humongous_obj = oop(start->bottom() + ShenandoahForwarding::word_size());
+  size_t size = humongous_obj->size() + ShenandoahForwarding::word_size();
   size_t required_regions = ShenandoahHeapRegion::required_regions(size * HeapWordSize);
   size_t index = start->region_number() + required_regions - 1;
 
@@ -1749,14 +1749,14 @@
 }
 
 HeapWord* ShenandoahHeap::tlab_post_allocation_setup(HeapWord* obj) {
-  // Initialize Brooks pointer for the next object
-  HeapWord* result = obj + ShenandoahBrooksPointer::word_size();
-  ShenandoahBrooksPointer::initialize(oop(result));
+  // Initialize forwarding pointer for the next object
+  HeapWord* result = obj + ShenandoahForwarding::word_size();
+  ShenandoahForwarding::initialize(oop(result));
   return result;
 }
 
 uint ShenandoahHeap::oop_extra_words() {
-  return ShenandoahBrooksPointer::word_size();
+  return ShenandoahForwarding::word_size();
 }
 
 void ShenandoahHeap::ref_processing_init() {
diff --git a/src/share/vm/gc_implementation/shenandoah/shenandoahHeap.inline.hpp b/src/share/vm/gc_implementation/shenandoah/shenandoahHeap.inline.hpp
--- a/src/share/vm/gc_implementation/shenandoah/shenandoahHeap.inline.hpp
+++ b/src/share/vm/gc_implementation/shenandoah/shenandoahHeap.inline.hpp
@@ -26,11 +26,11 @@
 
 #include "gc_implementation/shared/markBitMap.inline.hpp"
 #include "memory/threadLocalAllocBuffer.inline.hpp"
-#include "gc_implementation/shenandoah/shenandoahBrooksPointer.inline.hpp"
 #include "gc_implementation/shenandoah/shenandoahAsserts.hpp"
 #include "gc_implementation/shenandoah/shenandoahBarrierSet.inline.hpp"
 #include "gc_implementation/shenandoah/shenandoahCollectionSet.hpp"
 #include "gc_implementation/shenandoah/shenandoahCollectionSet.inline.hpp"
+#include "gc_implementation/shenandoah/shenandoahForwarding.inline.hpp"
 #include "gc_implementation/shenandoah/shenandoahControlThread.hpp"
 #include "gc_implementation/shenandoah/shenandoahMarkingContext.inline.hpp"
 #include "gc_implementation/shenandoah/shenandoahHeap.hpp"
@@ -182,7 +182,7 @@
   assert(thread->is_evac_allowed(), "must be enclosed in in oom-evac scope");
 
   size_t size_no_fwdptr = (size_t) p->size();
-  size_t size_with_fwdptr = size_no_fwdptr + ShenandoahBrooksPointer::word_size();
+  size_t size_with_fwdptr = size_no_fwdptr + ShenandoahForwarding::word_size();
 
   assert(!heap_region_containing(p)->is_humongous(), "never evacuate humongous objects");
 
@@ -216,14 +216,14 @@
   }
 
   // Copy the object and initialize its forwarding ptr:
-  HeapWord* copy = filler + ShenandoahBrooksPointer::word_size();
+  HeapWord* copy = filler + ShenandoahForwarding::word_size();
   oop copy_val = oop(copy);
 
   Copy::aligned_disjoint_words((HeapWord*) p, copy, size_no_fwdptr);
-  ShenandoahBrooksPointer::initialize(oop(copy));
+  ShenandoahForwarding::initialize(oop(copy));
 
   // Try to install the new forwarding pointer.
-  oop result = ShenandoahBrooksPointer::try_update_forwardee(p, copy_val);
+  oop result = ShenandoahForwarding::try_update_forwardee(p, copy_val);
 
   if (result == p) {
     // Successfully evacuated. Our copy is now the public one!
@@ -308,7 +308,7 @@
 
 template<class T>
 inline void ShenandoahHeap::marked_object_iterate(ShenandoahHeapRegion* region, T* cl, HeapWord* limit) {
-  assert(ShenandoahBrooksPointer::word_offset() < 0, "skip_delta calculation below assumes the forwarding ptr is before obj");
+  assert(ShenandoahForwarding::word_offset() < 0, "skip_delta calculation below assumes the forwarding ptr is before obj");
 
   ShenandoahMarkingContext* const ctx = complete_marking_context();
   assert(ctx->is_complete(), "sanity");
@@ -316,10 +316,10 @@
   MarkBitMap* mark_bit_map = ctx->mark_bit_map();
   HeapWord* tams = ctx->top_at_mark_start(region);
 
-  size_t skip_bitmap_delta = ShenandoahBrooksPointer::word_size() + 1;
-  size_t skip_objsize_delta = ShenandoahBrooksPointer::word_size() /* + actual obj.size() below */;
-  HeapWord* start = region->bottom() + ShenandoahBrooksPointer::word_size();
-  HeapWord* end = MIN2(tams + ShenandoahBrooksPointer::word_size(), region->end());
+  size_t skip_bitmap_delta = ShenandoahForwarding::word_size() + 1;
+  size_t skip_objsize_delta = ShenandoahForwarding::word_size() /* + actual obj.size() below */;
+  HeapWord* start = region->bottom() + ShenandoahForwarding::word_size();
+  HeapWord* end = MIN2(tams + ShenandoahForwarding::word_size(), region->end());
 
   // Step 1. Scan below the TAMS based on bitmap data.
   HeapWord* limit_bitmap = MIN2(limit, tams);
@@ -349,7 +349,7 @@
     do {
       avail = 0;
       for (int c = 0; (c < dist) && (cb < limit_bitmap); c++) {
-        Prefetch::read(cb, ShenandoahBrooksPointer::byte_offset());
+        Prefetch::read(cb, ShenandoahForwarding::byte_offset());
         slots[avail++] = cb;
         cb += skip_bitmap_delta;
         if (cb < limit_bitmap) {
@@ -386,7 +386,7 @@
   // Step 2. Accurate size-based traversal, happens past the TAMS.
   // This restarts the scan at TAMS, which makes sure we traverse all objects,
   // regardless of what happened at Step 1.
-  HeapWord* cs = tams + ShenandoahBrooksPointer::word_size();
+  HeapWord* cs = tams + ShenandoahForwarding::word_size();
   while (cs < limit) {
     assert (cs > tams,  err_msg("only objects past TAMS here: "   PTR_FORMAT " (" PTR_FORMAT ")", p2i(cs), p2i(tams)));
     assert (cs < limit, err_msg("only objects below limit here: " PTR_FORMAT " (" PTR_FORMAT ")", p2i(cs), p2i(limit)));
diff --git a/src/share/vm/gc_implementation/shenandoah/shenandoahHeapRegion.cpp b/src/share/vm/gc_implementation/shenandoah/shenandoahHeapRegion.cpp
--- a/src/share/vm/gc_implementation/shenandoah/shenandoahHeapRegion.cpp
+++ b/src/share/vm/gc_implementation/shenandoah/shenandoahHeapRegion.cpp
@@ -24,7 +24,7 @@
 #include "precompiled.hpp"
 
 #include "memory/allocation.hpp"
-#include "gc_implementation/shenandoah/shenandoahBrooksPointer.hpp"
+#include "gc_implementation/shenandoah/shenandoahForwarding.hpp"
 #include "gc_implementation/shenandoah/shenandoahHeap.inline.hpp"
 #include "gc_implementation/shenandoah/shenandoahHeapRegion.hpp"
 #include "gc_implementation/shenandoah/shenandoahMarkingContext.inline.hpp"
@@ -457,11 +457,11 @@
   if (p >= top()) {
     return top();
   } else {
-    HeapWord* last = bottom() + ShenandoahBrooksPointer::word_size();
+    HeapWord* last = bottom() + ShenandoahForwarding::word_size();
     HeapWord* cur = last;
     while (cur <= p) {
       last = cur;
-      cur += oop(cur)->size() + ShenandoahBrooksPointer::word_size();
+      cur += oop(cur)->size() + ShenandoahForwarding::word_size();
     }
     shenandoah_assert_correct(NULL, oop(last));
     return last;
diff --git a/src/share/vm/gc_implementation/shenandoah/shenandoahHeuristics.cpp b/src/share/vm/gc_implementation/shenandoah/shenandoahHeuristics.cpp
--- a/src/share/vm/gc_implementation/shenandoah/shenandoahHeuristics.cpp
+++ b/src/share/vm/gc_implementation/shenandoah/shenandoahHeuristics.cpp
@@ -24,7 +24,7 @@
 #include "precompiled.hpp"
 
 #include "gc_interface/gcCause.hpp"
-#include "gc_implementation/shenandoah/shenandoahBrooksPointer.hpp"
+#include "gc_implementation/shenandoah/shenandoahForwarding.hpp"
 #include "gc_implementation/shenandoah/shenandoahCollectorPolicy.hpp"
 #include "gc_implementation/shenandoah/shenandoahHeap.inline.hpp"
 #include "gc_implementation/shenandoah/shenandoahHeapRegion.hpp"
@@ -155,7 +155,7 @@
       // Reclaim humongous regions here, and count them as the immediate garbage
 #ifdef ASSERT
       bool reg_live = region->has_live();
-      bool bm_live = ctx->is_marked(oop(region->bottom() + ShenandoahBrooksPointer::word_size()));
+      bool bm_live = ctx->is_marked(oop(region->bottom() + ShenandoahForwarding::word_size()));
       assert(reg_live == bm_live,
              err_msg("Humongous liveness and marks should agree. Region live: %s; Bitmap live: %s; Region Live Words: " SIZE_FORMAT,
                      BOOL_TO_STR(reg_live), BOOL_TO_STR(bm_live), region->get_live_data_words()));
diff --git a/src/share/vm/gc_implementation/shenandoah/shenandoahMarkCompact.cpp b/src/share/vm/gc_implementation/shenandoah/shenandoahMarkCompact.cpp
--- a/src/share/vm/gc_implementation/shenandoah/shenandoahMarkCompact.cpp
+++ b/src/share/vm/gc_implementation/shenandoah/shenandoahMarkCompact.cpp
@@ -26,7 +26,7 @@
 #include "code/codeCache.hpp"
 #include "gc_implementation/shenandoah/shenandoahGCTraceTime.hpp"
 #include "gc_implementation/shared/gcTimer.hpp"
-#include "gc_implementation/shenandoah/shenandoahBrooksPointer.hpp"
+#include "gc_implementation/shenandoah/shenandoahForwarding.hpp"
 #include "gc_implementation/shenandoah/shenandoahCollectorPolicy.hpp"
 #include "gc_implementation/shenandoah/shenandoahConcurrentMark.inline.hpp"
 #include "gc_implementation/shenandoah/shenandoahCollectionSet.hpp"
@@ -269,7 +269,7 @@
     assert(_heap->complete_marking_context()->is_marked(p), "must be marked");
     assert(!_heap->complete_marking_context()->allocated_after_mark_start((HeapWord*) p), "must be truly marked");
 
-    size_t obj_size = p->size() + ShenandoahBrooksPointer::word_size();
+    size_t obj_size = p->size() + ShenandoahForwarding::word_size();
     if (_compact_point + obj_size > _to_region->end()) {
       finish_region();
 
@@ -292,7 +292,7 @@
     // Object fits into current region, record new location:
     assert(_compact_point + obj_size <= _to_region->end(), "must fit");
     shenandoah_assert_not_forwarded(NULL, p);
-    ShenandoahBrooksPointer::set_raw(p, _compact_point + ShenandoahBrooksPointer::word_size());
+    ShenandoahForwarding::set_forwardee_raw(p, _compact_point + ShenandoahForwarding::word_size());
     _compact_point += obj_size;
   }
 };
@@ -389,15 +389,15 @@
 
     if (r->is_humongous_start() && r->is_move_allowed()) {
       // From-region candidate: movable humongous region
-      oop old_obj = oop(r->bottom() + ShenandoahBrooksPointer::word_size());
-      size_t words_size = old_obj->size() + ShenandoahBrooksPointer::word_size();
+      oop old_obj = oop(r->bottom() + ShenandoahForwarding::word_size());
+      size_t words_size = old_obj->size() + ShenandoahForwarding::word_size();
       size_t num_regions = ShenandoahHeapRegion::required_regions(words_size * HeapWordSize);
 
       size_t start = to_end - num_regions;
 
       if (start >= to_begin && start != r->region_number()) {
         // Fits into current window, and the move is non-trivial. Record the move then, and continue scan.
-        ShenandoahBrooksPointer::set_raw(old_obj, heap->get_region(start)->bottom() + ShenandoahBrooksPointer::word_size());
+        ShenandoahForwarding::set_forwardee_raw(old_obj, heap->get_region(start)->bottom() + ShenandoahForwarding::word_size());
         to_end = start;
         continue;
       }
@@ -445,7 +445,7 @@
 
   void heap_region_do(ShenandoahHeapRegion* r) {
     if (r->is_humongous_start()) {
-      oop humongous_obj = oop(r->bottom() + ShenandoahBrooksPointer::word_size());
+      oop humongous_obj = oop(r->bottom() + ShenandoahForwarding::word_size());
       if (!_ctx->is_marked(humongous_obj)) {
         assert(!r->has_live(),
                err_msg("Region " SIZE_FORMAT " is not marked, should not have live", r->region_number()));
@@ -507,7 +507,7 @@
     if (! oopDesc::is_null(o)) {
       oop obj = oopDesc::decode_heap_oop_not_null(o);
       assert(_ctx->is_marked(obj), "must be marked");
-      oop forw = oop(ShenandoahBrooksPointer::get_raw(obj));
+      oop forw = oop(ShenandoahForwarding::get_forwardee_raw(obj));
       oopDesc::encode_store_heap_oop(p, forw);
     }
   }
@@ -609,13 +609,13 @@
   void do_object(oop p) {
     assert(_heap->complete_marking_context()->is_marked(p), "must be marked");
     size_t size = (size_t)p->size();
-    HeapWord* compact_to = ShenandoahBrooksPointer::get_raw(p);
+    HeapWord* compact_to = ShenandoahForwarding::get_forwardee_raw(p);
     HeapWord* compact_from = (HeapWord*) p;
     if (compact_from != compact_to) {
       Copy::aligned_conjoint_words(compact_from, compact_to, size);
     }
     oop new_obj = oop(compact_to);
-    ShenandoahBrooksPointer::initialize(new_obj);
+    ShenandoahForwarding::initialize(new_obj);
   }
 };
 
@@ -709,13 +709,13 @@
   for (size_t c = heap->num_regions() - 1; c > 0; c--) {
     ShenandoahHeapRegion* r = heap->get_region(c);
     if (r->is_humongous_start()) {
-      oop old_obj = oop(r->bottom() + ShenandoahBrooksPointer::word_size());
-      size_t words_size = old_obj->size() + ShenandoahBrooksPointer::word_size();
+      oop old_obj = oop(r->bottom() + ShenandoahForwarding::word_size());
+      size_t words_size = old_obj->size() + ShenandoahForwarding::word_size();
       size_t num_regions = ShenandoahHeapRegion::required_regions(words_size * HeapWordSize);
 
       size_t old_start = r->region_number();
       size_t old_end   = old_start + num_regions - 1;
-      size_t new_start = heap->heap_region_index_containing(ShenandoahBrooksPointer::get_raw(old_obj));
+      size_t new_start = heap->heap_region_index_containing(ShenandoahForwarding::get_forwardee_raw(old_obj));
       size_t new_end   = new_start + num_regions - 1;
 
       if (old_start == new_start) {
@@ -729,8 +729,8 @@
                                    heap->get_region(new_start)->bottom(),
                                    ShenandoahHeapRegion::region_size_words()*num_regions);
 
-      oop new_obj = oop(heap->get_region(new_start)->bottom() + ShenandoahBrooksPointer::word_size());
-      ShenandoahBrooksPointer::initialize(new_obj);
+      oop new_obj = oop(heap->get_region(new_start)->bottom() + ShenandoahForwarding::word_size());
+      ShenandoahForwarding::initialize(new_obj);
 
       {
         for (size_t c = old_start; c <= old_end; c++) {
diff --git a/src/share/vm/gc_implementation/shenandoah/shenandoahStringDedup.cpp b/src/share/vm/gc_implementation/shenandoah/shenandoahStringDedup.cpp
--- a/src/share/vm/gc_implementation/shenandoah/shenandoahStringDedup.cpp
+++ b/src/share/vm/gc_implementation/shenandoah/shenandoahStringDedup.cpp
@@ -24,7 +24,6 @@
 #include "precompiled.hpp"
 
 #include "classfile/altHashing.hpp"
-#include "gc_implementation/shenandoah/shenandoahBrooksPointer.hpp"
 #include "gc_implementation/shenandoah/shenandoahCollectionSet.inline.hpp"
 #include "gc_implementation/shenandoah/shenandoahHeap.inline.hpp"
 #include "gc_implementation/shenandoah/shenandoahMarkingContext.inline.hpp"
diff --git a/src/share/vm/gc_implementation/shenandoah/shenandoahSupport.cpp b/src/share/vm/gc_implementation/shenandoah/shenandoahSupport.cpp
--- a/src/share/vm/gc_implementation/shenandoah/shenandoahSupport.cpp
+++ b/src/share/vm/gc_implementation/shenandoah/shenandoahSupport.cpp
@@ -25,7 +25,7 @@
 
 #include "gc_implementation/shenandoah/shenandoahSupport.hpp"
 #include "gc_implementation/shenandoah/shenandoahBarrierSetC2.hpp"
-#include "gc_implementation/shenandoah/shenandoahBrooksPointer.hpp"
+#include "gc_implementation/shenandoah/shenandoahForwarding.hpp"
 #include "gc_implementation/shenandoah/shenandoahHeap.hpp"
 #include "gc_implementation/shenandoah/shenandoahHeapRegion.hpp"
 #include "gc_implementation/shenandoah/shenandoahRuntime.hpp"
@@ -1432,7 +1432,7 @@
       IfNode* iff = unc_ctrl->in(0)->as_If();
       phase->igvn().replace_input_of(iff, 1, phase->igvn().intcon(1));
     }
-    Node* addr = new (phase->C) AddPNode(new_val, uncasted_val, phase->igvn().MakeConX(ShenandoahBrooksPointer::byte_offset()));
+    Node* addr = new (phase->C) AddPNode(new_val, uncasted_val, phase->igvn().MakeConX(ShenandoahForwarding::byte_offset()));
     phase->register_new_node(addr, ctrl);
     assert(val->bottom_type()->isa_oopptr(), "what else?");
     const TypePtr* obj_type =  val->bottom_type()->is_oopptr();
diff --git a/src/share/vm/gc_implementation/shenandoah/shenandoahSupport.hpp b/src/share/vm/gc_implementation/shenandoah/shenandoahSupport.hpp
--- a/src/share/vm/gc_implementation/shenandoah/shenandoahSupport.hpp
+++ b/src/share/vm/gc_implementation/shenandoah/shenandoahSupport.hpp
@@ -24,7 +24,7 @@
 #ifndef SHARE_GC_SHENANDOAH_C2_SHENANDOAHSUPPORT_HPP
 #define SHARE_GC_SHENANDOAH_C2_SHENANDOAHSUPPORT_HPP
 
-#include "gc_implementation/shenandoah/shenandoahBrooksPointer.hpp"
+#include "gc_implementation/shenandoah/shenandoahForwarding.hpp"
 #include "memory/allocation.hpp"
 #include "opto/addnode.hpp"
 #include "opto/graphKit.hpp"
diff --git a/src/share/vm/gc_implementation/shenandoah/shenandoahVerifier.cpp b/src/share/vm/gc_implementation/shenandoah/shenandoahVerifier.cpp
--- a/src/share/vm/gc_implementation/shenandoah/shenandoahVerifier.cpp
+++ b/src/share/vm/gc_implementation/shenandoah/shenandoahVerifier.cpp
@@ -23,8 +23,8 @@
 
 #include "precompiled.hpp"
 
-#include "gc_implementation/shenandoah/shenandoahBrooksPointer.hpp"
 #include "gc_implementation/shenandoah/shenandoahAsserts.hpp"
+#include "gc_implementation/shenandoah/shenandoahForwarding.hpp"
 #include "gc_implementation/shenandoah/shenandoahHeap.hpp"
 #include "gc_implementation/shenandoah/shenandoahHeap.inline.hpp"
 #include "gc_implementation/shenandoah/shenandoahRootProcessor.hpp"
@@ -136,7 +136,7 @@
           // skip
           break;
         case ShenandoahVerifier::_verify_liveness_complete:
-          Atomic::add(obj->size() + ShenandoahBrooksPointer::word_size(), &_ld[obj_reg->region_number()]);
+          Atomic::add(obj->size() + ShenandoahForwarding::word_size(), &_ld[obj_reg->region_number()]);
           // fallthrough for fast failure for un-live regions:
         case ShenandoahVerifier::_verify_liveness_conservative:
           verify(ShenandoahAsserts::_safe_oop, obj, obj_reg->has_live(),
@@ -147,7 +147,7 @@
       }
     }
 
-    oop fwd = (oop) ShenandoahBrooksPointer::get_raw_unchecked(obj);
+    oop fwd = (oop) ShenandoahForwarding::get_forwardee_raw_unchecked(obj);
 
     ShenandoahHeapRegion* fwd_reg = NULL;
 
@@ -180,7 +180,7 @@
       verify(ShenandoahAsserts::_safe_oop, obj, (fwd_addr + fwd->size()) <= fwd_reg->top(),
              "Forwardee end should be within the region");
 
-      oop fwd2 = (oop) ShenandoahBrooksPointer::get_raw_unchecked(fwd);
+      oop fwd2 = (oop) ShenandoahForwarding::get_forwardee_raw_unchecked(fwd);
       verify(ShenandoahAsserts::_safe_oop, obj, fwd == fwd2,
              "Double forwarding");
     } else {
@@ -504,7 +504,7 @@
 
   virtual void work_humongous(ShenandoahHeapRegion *r, ShenandoahVerifierStack& stack, ShenandoahVerifyOopClosure& cl) {
     jlong processed = 0;
-    HeapWord* obj = r->bottom() + ShenandoahBrooksPointer::word_size();
+    HeapWord* obj = r->bottom() + ShenandoahForwarding::word_size();
     if (_heap->complete_marking_context()->is_marked((oop)obj)) {
       verify_and_follow(obj, stack, cl, &processed);
     }
@@ -518,12 +518,12 @@
 
     // Bitmaps, before TAMS
     if (tams > r->bottom()) {
-      HeapWord* start = r->bottom() + ShenandoahBrooksPointer::word_size();
+      HeapWord* start = r->bottom() + ShenandoahForwarding::word_size();
       HeapWord* addr = mark_bit_map->getNextMarkedWordAddress(start, tams);
 
       while (addr < tams) {
         verify_and_follow(addr, stack, cl, &processed);
-        addr += ShenandoahBrooksPointer::word_size();
+        addr += ShenandoahForwarding::word_size();
         if (addr < tams) {
           addr = mark_bit_map->getNextMarkedWordAddress(addr, tams);
         }
@@ -533,11 +533,11 @@
     // Size-based, after TAMS
     {
       HeapWord* limit = r->top();
-      HeapWord* addr = tams + ShenandoahBrooksPointer::word_size();
+      HeapWord* addr = tams + ShenandoahForwarding::word_size();
 
       while (addr < limit) {
         verify_and_follow(addr, stack, cl, &processed);
-        addr += oop(addr)->size() + ShenandoahBrooksPointer::word_size();
+        addr += oop(addr)->size() + ShenandoahForwarding::word_size();
       }
     }
 
diff --git a/src/share/vm/opto/compile.cpp b/src/share/vm/opto/compile.cpp
--- a/src/share/vm/opto/compile.cpp
+++ b/src/share/vm/opto/compile.cpp
@@ -84,7 +84,7 @@
 #endif
 
 #if INCLUDE_ALL_GCS
-#include "gc_implementation/shenandoah/shenandoahBrooksPointer.hpp"
+#include "gc_implementation/shenandoah/shenandoahForwarding.hpp"
 #include "gc_implementation/shenandoah/shenandoahSupport.hpp"
 #endif
 
diff --git a/src/share/vm/opto/graphKit.cpp b/src/share/vm/opto/graphKit.cpp
--- a/src/share/vm/opto/graphKit.cpp
+++ b/src/share/vm/opto/graphKit.cpp
@@ -27,7 +27,6 @@
 #include "gc_implementation/g1/g1SATBCardTableModRefBS.hpp"
 #include "gc_implementation/g1/heapRegion.hpp"
 #include "gc_interface/collectedHeap.hpp"
-#include "gc_implementation/shenandoah/shenandoahBrooksPointer.hpp"
 #include "gc_implementation/shenandoah/shenandoahHeap.hpp"
 #include "memory/barrierSet.hpp"
 #include "memory/cardTableModRefBS.hpp"
diff --git a/src/share/vm/opto/macro.cpp b/src/share/vm/opto/macro.cpp
--- a/src/share/vm/opto/macro.cpp
+++ b/src/share/vm/opto/macro.cpp
@@ -43,7 +43,7 @@
 #include "runtime/sharedRuntime.hpp"
 #if INCLUDE_ALL_GCS
 #include "gc_implementation/shenandoah/shenandoahBarrierSetC2.hpp"
-#include "gc_implementation/shenandoah/shenandoahBrooksPointer.hpp"
+#include "gc_implementation/shenandoah/shenandoahForwarding.hpp"
 #include "gc_implementation/shenandoah/shenandoahSupport.hpp"
 #endif
 
@@ -1308,8 +1308,8 @@
 
     Node* init_size_in_bytes = size_in_bytes;
     if (UseShenandoahGC) {
-      // Allocate several words more for the Shenandoah brooks pointer.
-      size_in_bytes = new (C) AddXNode(size_in_bytes, _igvn.MakeConX(ShenandoahBrooksPointer::byte_size()));
+      // Allocate several words more for the Shenandoah forwarding pointer.
+      size_in_bytes = new (C) AddXNode(size_in_bytes, _igvn.MakeConX(ShenandoahForwarding::byte_size()));
       transform_later(size_in_bytes);
     }
 
@@ -1404,8 +1404,8 @@
     }
 
     if (UseShenandoahGC) {
-      // Bump up object for Shenandoah brooks pointer.
-      fast_oop = new (C) AddPNode(top(), fast_oop, _igvn.MakeConX(ShenandoahBrooksPointer::byte_size()));
+      // Bump up object for Shenandoah forwarding pointer.
+      fast_oop = new (C) AddPNode(top(), fast_oop, _igvn.MakeConX(ShenandoahForwarding::byte_size()));
       transform_later(fast_oop);
     }
 
@@ -1693,8 +1693,8 @@
   }
 
   if (UseShenandoahGC) {
-    // Initialize Shenandoah brooks pointer to point to the object itself.
-    rawmem = make_store(control, rawmem, object, ShenandoahBrooksPointer::byte_offset(), object, T_OBJECT);
+    // Initialize Shenandoah forwarding pointer to point to the object itself.
+    rawmem = make_store(control, rawmem, object, ShenandoahForwarding::byte_offset(), object, T_OBJECT);
   }
 
   // Clear the object body, if necessary.
diff --git a/src/share/vm/opto/memnode.cpp b/src/share/vm/opto/memnode.cpp
--- a/src/share/vm/opto/memnode.cpp
+++ b/src/share/vm/opto/memnode.cpp
@@ -40,7 +40,7 @@
 #include "opto/regmask.hpp"
 #if INCLUDE_ALL_GCS
 #include "gc_implementation/shenandoah/shenandoahBarrierSetC2.hpp"
-#include "gc_implementation/shenandoah/shenandoahBrooksPointer.hpp"
+#include "gc_implementation/shenandoah/shenandoahForwarding.hpp"
 #include "gc_implementation/shenandoah/shenandoahSupport.hpp"
 #endif
 
@@ -1525,7 +1525,7 @@
     // as to alignment, which will therefore produce the smallest
     // possible base offset.
     const int min_base_off = arrayOopDesc::base_offset_in_bytes(T_BYTE);
-    const bool off_beyond_header = (off != ShenandoahBrooksPointer::byte_offset() || !UseShenandoahGC) && ((uint)off >= (uint)min_base_off);
+    const bool off_beyond_header = (off != ShenandoahForwarding::byte_offset() || !UseShenandoahGC) && ((uint)off >= (uint)min_base_off);
 
     // Try to constant-fold a stable array element.
     if (FoldStableValues && ary->is_stable()) {
diff --git a/src/share/vm/opto/type.cpp b/src/share/vm/opto/type.cpp
--- a/src/share/vm/opto/type.cpp
+++ b/src/share/vm/opto/type.cpp
@@ -28,7 +28,7 @@
 #include "classfile/symbolTable.hpp"
 #include "classfile/systemDictionary.hpp"
 #include "compiler/compileLog.hpp"
-#include "gc_implementation/shenandoah/shenandoahBrooksPointer.hpp"
+#include "gc_implementation/shenandoah/shenandoahForwarding.hpp"
 #include "libadt/dict.hpp"
 #include "memory/gcLocker.hpp"
 #include "memory/oopFactory.hpp"
@@ -2502,7 +2502,7 @@
   if (_offset != 0) {
     if (_offset == oopDesc::klass_offset_in_bytes()) {
       _is_ptr_to_narrowklass = UseCompressedClassPointers;
-    } else if (UseShenandoahGC && _offset == ShenandoahBrooksPointer::byte_offset()) {
+    } else if (UseShenandoahGC && _offset == ShenandoahForwarding::byte_offset()) {
       // Shenandoah doesn't support compressed forwarding pointers
     } else if (klass() == NULL) {
       // Array with unknown body type