PPC64 implementation of Compact Object Headers (JEP 450)

Author: TheRealMDoerr

make/autoconf/jdk-options.m4

@@ -689,7 +689,9 @@ AC_DEFUN([JDKOPT_ENABLE_DISABLE_CDS_ARCHIVE_COH],
           AC_MSG_RESULT([no (CDS default archive generation is disabled)])
           AVAILABLE=false
         elif test "x$OPENJDK_TARGET_CPU" != "xx86_64" &&
-             test "x$OPENJDK_TARGET_CPU" != "xaarch64"; then
+             test "x$OPENJDK_TARGET_CPU" != "xaarch64" &&
+             test "x$OPENJDK_TARGET_CPU" != "xppc64" &&
+             test "x$OPENJDK_TARGET_CPU" != "xppc64le"; then
           AC_MSG_RESULT([no (compact object headers not supported for this platform)])
           AVAILABLE=false
         else

src/hotspot/cpu/ppc/c1_LIRAssembler_ppc.cpp

@@ -1976,16 +1976,7 @@ void LIR_Assembler::emit_arraycopy(LIR_OpArrayCopy* op) {
     // We don't know the array types are compatible.
     if (basic_type != T_OBJECT) {
       // Simple test for basic type arrays.
-      if (UseCompressedClassPointers) {
-        // We don't need decode because we just need to compare.
-        __ lwz(tmp, oopDesc::klass_offset_in_bytes(), src);
-        __ lwz(tmp2, oopDesc::klass_offset_in_bytes(), dst);
-        __ cmpw(CCR0, tmp, tmp2);
-      } else {
-        __ ld(tmp, oopDesc::klass_offset_in_bytes(), src);
-        __ ld(tmp2, oopDesc::klass_offset_in_bytes(), dst);
-        __ cmpd(CCR0, tmp, tmp2);
-      }
+      __ cmp_klasses_from_objects(CCR0, src, dst, tmp, tmp2);
       __ beq(CCR0, cont);
     } else {
       // For object arrays, if src is a sub class of dst then we can
@@ -2108,39 +2099,15 @@ void LIR_Assembler::emit_arraycopy(LIR_OpArrayCopy* op) {
     // but not necessarily exactly of type default_type.
     Label known_ok, halt;
     metadata2reg(default_type->constant_encoding(), tmp);
-    if (UseCompressedClassPointers) {
-      // Tmp holds the default type. It currently comes uncompressed after the
-      // load of a constant, so encode it.
-      __ encode_klass_not_null(tmp);
-      // Load the raw value of the dst klass, since we will be comparing
-      // uncompressed values directly.
-      __ lwz(tmp2, oopDesc::klass_offset_in_bytes(), dst);
-      __ cmpw(CCR0, tmp, tmp2);
-      if (basic_type != T_OBJECT) {
-        __ bne(CCR0, halt);
-        // Load the raw value of the src klass.
-        __ lwz(tmp2, oopDesc::klass_offset_in_bytes(), src);
-        __ cmpw(CCR0, tmp, tmp2);
-        __ beq(CCR0, known_ok);
-      } else {
-        __ beq(CCR0, known_ok);
-        __ cmpw(CCR0, src, dst);
-        __ beq(CCR0, known_ok);
-      }
+    __ cmp_klass(CCR0, dst, tmp, R11_scratch1, R12_scratch2);
+    if (basic_type != T_OBJECT) {
+      __ bne(CCR0, halt);
+      __ cmp_klass(CCR0, src, tmp, R11_scratch1, R12_scratch2);
+      __ beq(CCR0, known_ok);
     } else {
-      __ ld(tmp2, oopDesc::klass_offset_in_bytes(), dst);
-      __ cmpd(CCR0, tmp, tmp2);
-      if (basic_type != T_OBJECT) {
-        __ bne(CCR0, halt);
-        // Load the raw value of the src klass.
-        __ ld(tmp2, oopDesc::klass_offset_in_bytes(), src);
-        __ cmpd(CCR0, tmp, tmp2);
-        __ beq(CCR0, known_ok);
-      } else {
-        __ beq(CCR0, known_ok);
-        __ cmpd(CCR0, src, dst);
-        __ beq(CCR0, known_ok);
-      }
+      __ beq(CCR0, known_ok);
+      __ cmpw(CCR0, src, dst);
+      __ beq(CCR0, known_ok);
     }
     __ bind(halt);
     __ stop("incorrect type information in arraycopy");
@@ -2717,12 +2684,7 @@ void LIR_Assembler::emit_load_klass(LIR_OpLoadKlass* op) {
     }
   }
 
-  if (UseCompressedClassPointers) {
-    __ lwz(result, oopDesc::klass_offset_in_bytes(), obj);
-    __ decode_klass_not_null(result);
-  } else {
-    __ ld(result, oopDesc::klass_offset_in_bytes(), obj);
-  }
+  __ load_klass(result, obj);
 }
 
 void LIR_Assembler::emit_profile_call(LIR_OpProfileCall* op) {

src/hotspot/cpu/ppc/c1_MacroAssembler_ppc.cpp

@@ -197,12 +197,19 @@ void C1_MacroAssembler::try_allocate(
 
 void C1_MacroAssembler::initialize_header(Register obj, Register klass, Register len, Register t1, Register t2) {
   assert_different_registers(obj, klass, len, t1, t2);
-  load_const_optimized(t1, (intx)markWord::prototype().value());
-  std(t1, oopDesc::mark_offset_in_bytes(), obj);
-  store_klass(obj, klass);
+
+  if (UseCompactObjectHeaders) {
+    ld(t1, in_bytes(Klass::prototype_header_offset()), klass);
+    std(t1, oopDesc::mark_offset_in_bytes(), obj);
+  } else {
+    load_const_optimized(t1, (intx)markWord::prototype().value());
+    std(t1, oopDesc::mark_offset_in_bytes(), obj);
+    store_klass(obj, klass);
+  }
+
   if (len->is_valid()) {
     stw(len, arrayOopDesc::length_offset_in_bytes(), obj);
-  } else if (UseCompressedClassPointers) {
+  } else if (UseCompressedClassPointers && !UseCompactObjectHeaders) {
     // Otherwise length is in the class gap.
     store_klass_gap(obj);
   }

src/hotspot/cpu/ppc/c2_MacroAssembler_ppc.cpp

@@ -47,6 +47,15 @@ void C2_MacroAssembler::fast_unlock_lightweight(ConditionRegister flag, Register
   compiler_fast_unlock_lightweight_object(flag, obj, box, tmp1, tmp2, tmp3);
 }
 
+void C2_MacroAssembler::load_narrow_klass_compact_c2(Register dst, Register obj, int disp) {
+  // Note: Don't clobber obj anywhere in that method!
+
+  // The incoming address is pointing into obj-start + klass_offset_in_bytes. We need to extract
+  // obj-start, so that we can load from the object's mark-word instead.
+  ld(dst, disp - oopDesc::klass_offset_in_bytes(), obj);
+  srdi(dst, dst, markWord::klass_shift);
+}
+
 // Intrinsics for CompactStrings
 
 // Compress char[] to byte[] by compressing 16 bytes at once.

src/hotspot/cpu/ppc/c2_MacroAssembler_ppc.hpp

@@ -34,6 +34,8 @@
   void fast_unlock_lightweight(ConditionRegister flag, Register obj, Register box,
                                Register tmp1, Register tmp2, Register tmp3);
 
+  void load_narrow_klass_compact_c2(Register dst, Register obj, int disp);
+
   // Intrinsics for CompactStrings
   // Compress char[] to byte[] by compressing 16 bytes at once.
   void string_compress_16(Register src, Register dst, Register cnt,

src/hotspot/cpu/ppc/macroAssembler_ppc.cpp

@@ -1218,6 +1218,9 @@ int MacroAssembler::ic_check_size() {
     num_ins = 7;
     if (!implicit_null_checks_available) num_ins += 2;
   }
+
+  if (UseCompactObjectHeaders) num_ins++;
+
   return num_ins * BytesPerInstWord;
 }
 
@@ -1245,7 +1248,9 @@ int MacroAssembler::ic_check(int end_alignment) {
     if (use_trap_based_null_check) {
       trap_null_check(receiver);
     }
-    if (UseCompressedClassPointers) {
+    if (UseCompactObjectHeaders) {
+      load_narrow_klass_compact(tmp1, receiver);
+    } else if (UseCompressedClassPointers) {
       lwz(tmp1, oopDesc::klass_offset_in_bytes(), receiver);
     } else {
       ld(tmp1, oopDesc::klass_offset_in_bytes(), receiver);
@@ -3239,6 +3244,7 @@ Register MacroAssembler::encode_klass_not_null(Register dst, Register src) {
 }
 
 void MacroAssembler::store_klass(Register dst_oop, Register klass, Register ck) {
+  assert(!UseCompactObjectHeaders, "not with compact headers");
   if (UseCompressedClassPointers) {
     Register compressedKlass = encode_klass_not_null(ck, klass);
     stw(compressedKlass, oopDesc::klass_offset_in_bytes(), dst_oop);
@@ -3248,12 +3254,13 @@ void MacroAssembler::store_klass(Register dst_oop, Register klass, Register ck)
 }
 
 void MacroAssembler::store_klass_gap(Register dst_oop, Register val) {
+  assert(!UseCompactObjectHeaders, "not with compact headers");
   if (UseCompressedClassPointers) {
     if (val == noreg) {
       val = R0;
       li(val, 0);
     }
-    stw(val, oopDesc::klass_gap_offset_in_bytes(), dst_oop); // klass gap if compressed
+    stw(val, oopDesc::klass_gap_offset_in_bytes(), dst_oop);
   }
 }
 
@@ -3294,15 +3301,60 @@ void MacroAssembler::decode_klass_not_null(Register dst, Register src) {
 }
 
 void MacroAssembler::load_klass(Register dst, Register src) {
-  if (UseCompressedClassPointers) {
+  if (UseCompactObjectHeaders) {
+    load_narrow_klass_compact(dst, src);
+    decode_klass_not_null(dst);
+  } else if (UseCompressedClassPointers) {
     lwz(dst, oopDesc::klass_offset_in_bytes(), src);
-    // Attention: no null check here!
-    decode_klass_not_null(dst, dst);
+    decode_klass_not_null(dst);
   } else {
     ld(dst, oopDesc::klass_offset_in_bytes(), src);
   }
 }
 
+// Loads the obj's Klass* into dst.
+// Preserves all registers (incl src, rscratch1 and rscratch2).
+// Input:
+// src - the oop we want to load the klass from.
+// dst - output nklass.
+void MacroAssembler::load_narrow_klass_compact(Register dst, Register src) {
+  assert(UseCompactObjectHeaders, "expects UseCompactObjectHeaders");
+  ld(dst, oopDesc::mark_offset_in_bytes(), src);
+  srdi(dst, dst, markWord::klass_shift);
+}
+
+void MacroAssembler::cmp_klass(ConditionRegister dst, Register obj, Register klass, Register tmp, Register tmp2) {
+  assert_different_registers(obj, klass, tmp);
+  if (UseCompressedClassPointers) {
+    if (UseCompactObjectHeaders) {
+      load_narrow_klass_compact(tmp, obj);
+    } else {
+      lwz(tmp, oopDesc::klass_offset_in_bytes(), obj);
+    }
+    Register encoded_klass = encode_klass_not_null(tmp2, klass);
+    cmpw(dst, tmp, encoded_klass);
+  } else {
+    ld(tmp, oopDesc::klass_offset_in_bytes(), obj);
+    cmpd(dst, tmp, klass);
+  }
+}
+
+void MacroAssembler::cmp_klasses_from_objects(ConditionRegister dst, Register obj1, Register obj2, Register tmp1, Register tmp2) {
+  if (UseCompactObjectHeaders) {
+    load_narrow_klass_compact(tmp1, obj1);
+    load_narrow_klass_compact(tmp2, obj2);
+    cmpw(dst, tmp1, tmp2);
+  } else if (UseCompressedClassPointers) {
+    lwz(tmp1, oopDesc::klass_offset_in_bytes(), obj1);
+    lwz(tmp2, oopDesc::klass_offset_in_bytes(), obj2);
+    cmpw(dst, tmp1, tmp2);
+  } else {
+    ld(tmp1, oopDesc::klass_offset_in_bytes(), obj1);
+    ld(tmp2, oopDesc::klass_offset_in_bytes(), obj2);
+    cmpd(dst, tmp1, tmp2);
+  }
+}
+
 void MacroAssembler::load_klass_check_null(Register dst, Register src, Label* is_null) {
   null_check(src, oopDesc::klass_offset_in_bytes(), is_null);
   load_klass(dst, src);

src/hotspot/cpu/ppc/macroAssembler_ppc.hpp

@@ -757,6 +757,9 @@ class MacroAssembler: public Assembler {
 
   // Load/Store klass oop from klass field. Compress.
   void load_klass(Register dst, Register src);
+  void load_narrow_klass_compact(Register dst, Register src);
+  void cmp_klass(ConditionRegister dst, Register obj, Register klass, Register tmp, Register tmp2);
+  void cmp_klasses_from_objects(ConditionRegister dst, Register obj1, Register obj2, Register tmp1, Register tmp2);
   void load_klass_check_null(Register dst, Register src, Label* is_null = nullptr);
   void store_klass(Register dst_oop, Register klass, Register tmp = R0);
   void store_klass_gap(Register dst_oop, Register val = noreg); // Will store 0 if val not specified.

src/hotspot/cpu/ppc/ppc.ad

@@ -5500,6 +5500,7 @@ instruct loadP2X(iRegLdst dst, memoryAlg4 mem) %{
 // Load compressed klass pointer.
 instruct loadNKlass(iRegNdst dst, memory mem) %{
   match(Set dst (LoadNKlass mem));
+  predicate(!UseCompactObjectHeaders);
   ins_cost(MEMORY_REF_COST);
 
   format %{ "LWZ     $dst, $mem \t// compressed klass ptr" %}
@@ -5508,6 +5509,20 @@ instruct loadNKlass(iRegNdst dst, memory mem) %{
   ins_pipe(pipe_class_memory);
 %}
 
+instruct loadNKlassCompactHeaders(iRegNdst dst, memory mem) %{
+  match(Set dst (LoadNKlass mem));
+  predicate(UseCompactObjectHeaders);
+  ins_cost(MEMORY_REF_COST);
+
+  format %{ "load_narrow_klass_compact $dst, $mem \t// compressed class ptr" %}
+  size(8);
+  ins_encode %{
+    assert($mem$$index$$Register == R0, "must not have indexed address: %s[%s]", $mem$$base$$Register.name(), $mem$$index$$Register.name());
+    __ load_narrow_klass_compact_c2($dst$$Register, $mem$$base$$Register, $mem$$disp);
+  %}
+  ins_pipe(pipe_class_memory);
+%}
+
 // Load Klass Pointer
 instruct loadKlass(iRegPdst dst, memoryAlg4 mem) %{
   match(Set dst (LoadKlass mem));

src/hotspot/cpu/ppc/templateTable_ppc_64.cpp

@@ -3840,8 +3840,9 @@ void TemplateTable::_new() {
       // Init1: Zero out newly allocated memory.
       // Initialize remaining object fields.
       Register Rbase = Rtags;
-      __ addi(Rinstance_size, Rinstance_size, 7 - (int)sizeof(oopDesc));
-      __ addi(Rbase, RallocatedObject, sizeof(oopDesc));
+      int header_size = oopDesc::header_size() * HeapWordSize;
+      __ addi(Rinstance_size, Rinstance_size, 7 - header_size);
+      __ addi(Rbase, RallocatedObject, header_size);
       __ srdi(Rinstance_size, Rinstance_size, 3);
 
       // Clear out object skipping header. Takes also care of the zero length case.
@@ -3851,12 +3852,15 @@ void TemplateTable::_new() {
     // --------------------------------------------------------------------------
     // Init2: Initialize the header: mark, klass
     // Init mark.
-    __ load_const_optimized(Rscratch, markWord::prototype().value(), R0);
-    __ std(Rscratch, oopDesc::mark_offset_in_bytes(), RallocatedObject);
-
-    // Init klass.
-    __ store_klass_gap(RallocatedObject);
-    __ store_klass(RallocatedObject, RinstanceKlass, Rscratch); // klass (last for cms)
+    if (UseCompactObjectHeaders) {
+      __ ld(Rscratch, in_bytes(Klass::prototype_header_offset()), RinstanceKlass);
+      __ std(Rscratch, oopDesc::mark_offset_in_bytes(), RallocatedObject);
+    } else {
+      __ load_const_optimized(Rscratch, markWord::prototype().value(), R0);
+      __ std(Rscratch, oopDesc::mark_offset_in_bytes(), RallocatedObject);
+      __ store_klass_gap(RallocatedObject);
+      __ store_klass(RallocatedObject, RinstanceKlass, Rscratch);
+    }
 
     // Check and trigger dtrace event.
     if (DTraceAllocProbes) {