8373864: [lworld] Hide and rename InstanceKlassFixedBlock

Reviewed-by: phubner, fparain

Author: stefank

src/hotspot/cpu/aarch64/c1_LIRAssembler_aarch64.cpp

@@ -511,7 +511,7 @@ void LIR_Assembler::return_op(LIR_Opr result, C1SafepointPollStub* code_stub) {
 
       // Load fields from a buffered value with an inline class specific handler
       __ load_klass(rscratch1 /*dst*/, r0 /*src*/);
-      __ ldr(rscratch1, Address(rscratch1, InstanceKlass::adr_inlineklass_fixed_block_offset()));
+      __ ldr(rscratch1, Address(rscratch1, InlineKlass::adr_members_offset()));
       __ ldr(rscratch1, Address(rscratch1, InlineKlass::unpack_handler_offset()));
       // Unpack handler can be null if inline type is not scalarizable in returns
       __ cbz(rscratch1, skip);

src/hotspot/cpu/aarch64/interp_masm_aarch64.cpp

@@ -771,7 +771,7 @@ void InterpreterMacroAssembler::remove_activation(TosState state,
 
     // Load fields from a buffered value with an inline class specific handler
     load_klass(rscratch1 /*dst*/, r0 /*src*/);
-    ldr(rscratch1, Address(rscratch1, InstanceKlass::adr_inlineklass_fixed_block_offset()));
+    ldr(rscratch1, Address(rscratch1, InlineKlass::adr_members_offset()));
     ldr(rscratch1, Address(rscratch1, InlineKlass::unpack_handler_offset()));
     // Unpack handler can be null if inline type is not scalarizable in returns
     cbz(rscratch1, skip);

src/hotspot/cpu/aarch64/macroAssembler_aarch64.cpp

@@ -5543,7 +5543,7 @@ void MacroAssembler::flat_field_copy(DecoratorSet decorators, Register src, Regi
 }
 
 void MacroAssembler::payload_offset(Register inline_klass, Register offset) {
-  ldr(offset, Address(inline_klass, InstanceKlass::adr_inlineklass_fixed_block_offset()));
+  ldr(offset, Address(inline_klass, InlineKlass::adr_members_offset()));
   ldrw(offset, Address(offset, InlineKlass::payload_offset_offset()));
 }
 
@@ -7037,7 +7037,7 @@ int MacroAssembler::store_inline_type_fields_to_buf(ciInlineKlass* vk, bool from
     if (vk != nullptr) {
       far_call(RuntimeAddress(vk->pack_handler())); // no need for call info as this will not safepoint.
     } else {
-      ldr(tmp1, Address(klass, InstanceKlass::adr_inlineklass_fixed_block_offset()));
+      ldr(tmp1, Address(klass, InlineKlass::adr_members_offset()));
       ldr(tmp1, Address(tmp1, InlineKlass::pack_handler_offset()));
       blr(tmp1);
     }

src/hotspot/cpu/aarch64/stubGenerator_aarch64.cpp

@@ -404,7 +404,7 @@ class StubGenerator: public StubCodeGenerator {
       __ tbz(r0, 0, is_long);
       // Load pack handler address
       __ andr(rscratch1, r0, -2);
-      __ ldr(rscratch1, Address(rscratch1, InstanceKlass::adr_inlineklass_fixed_block_offset()));
+      __ ldr(rscratch1, Address(rscratch1, InlineKlass::adr_members_offset()));
       __ ldr(rscratch1, Address(rscratch1, InlineKlass::pack_handler_jobject_offset()));
       __ blr(rscratch1);
       __ b(exit);

src/hotspot/cpu/x86/c1_LIRAssembler_x86.cpp

@@ -508,7 +508,7 @@ void LIR_Assembler::return_op(LIR_Opr result, C1SafepointPollStub* code_stub) {
 
       // Load fields from a buffered value with an inline class specific handler
       __ load_klass(rdi, rax, rscratch1);
-      __ movptr(rdi, Address(rdi, InstanceKlass::adr_inlineklass_fixed_block_offset()));
+      __ movptr(rdi, Address(rdi, InlineKlass::adr_members_offset()));
       __ movptr(rdi, Address(rdi, InlineKlass::unpack_handler_offset()));
       // Unpack handler can be null if inline type is not scalarizable in returns
       __ testptr(rdi, rdi);

src/hotspot/cpu/x86/interp_masm_x86.cpp

@@ -1081,7 +1081,7 @@ void InterpreterMacroAssembler::remove_activation(TosState state,
 #else
     // Load fields from a buffered value with an inline class specific handler
     load_klass(rdi, rax, rscratch1);
-    movptr(rdi, Address(rdi, InstanceKlass::adr_inlineklass_fixed_block_offset()));
+    movptr(rdi, Address(rdi, InlineKlass::adr_members_offset()));
     movptr(rdi, Address(rdi, InlineKlass::unpack_handler_offset()));
     // Unpack handler can be null if inline type is not scalarizable in returns
     testptr(rdi, rdi);

src/hotspot/cpu/x86/macroAssembler_x86.cpp

@@ -5524,7 +5524,7 @@ void MacroAssembler::flat_field_copy(DecoratorSet decorators, Register src, Regi
 }
 
 void MacroAssembler::payload_offset(Register inline_klass, Register offset) {
-  movptr(offset, Address(inline_klass, InstanceKlass::adr_inlineklass_fixed_block_offset()));
+  movptr(offset, Address(inline_klass, InlineKlass::adr_members_offset()));
   movl(offset, Address(offset, InlineKlass::payload_offset_offset()));
 }
 
@@ -5977,7 +5977,7 @@ int MacroAssembler::store_inline_type_fields_to_buf(ciInlineKlass* vk, bool from
     if (vk != nullptr) {
       call(RuntimeAddress(vk->pack_handler())); // no need for call info as this will not safepoint.
     } else {
-      movptr(rbx, Address(klass, InstanceKlass::adr_inlineklass_fixed_block_offset()));
+      movptr(rbx, Address(klass, InlineKlass::adr_members_offset()));
       movptr(rbx, Address(rbx, InlineKlass::pack_handler_offset()));
       call(rbx);
     }

src/hotspot/cpu/x86/stubGenerator_x86_64.cpp

@@ -392,7 +392,7 @@ address StubGenerator::generate_call_stub(address& return_address) {
     __ jcc(Assembler::zero, is_long);
     // Load pack handler address
     __ andptr(rax, -2);
-    __ movptr(rax, Address(rax, InstanceKlass::adr_inlineklass_fixed_block_offset()));
+    __ movptr(rax, Address(rax, InlineKlass::adr_members_offset()));
     __ movptr(rbx, Address(rax, InlineKlass::pack_handler_jobject_offset()));
     // Call pack handler to initialize the buffer
     __ call(rbx);

src/hotspot/share/ci/ciMethod.hpp

@@ -41,6 +41,7 @@ class MethodLiveness;
 class Arena;
 class BCEscapeAnalyzer;
 class InlineTree;
+class SigEntry;
 class xmlStream;
 
 // Whether profiling found an oop to be always, never or sometimes

src/hotspot/share/oops/inlineKlass.cpp

@@ -53,41 +53,45 @@
 #include "utilities/copy.hpp"
 #include "utilities/stringUtils.hpp"
 
+InlineKlass::Members::Members()
+  : _extended_sig(nullptr),
+    _return_regs(nullptr),
+    _pack_handler(nullptr),
+    _pack_handler_jobject(nullptr),
+    _unpack_handler(nullptr),
+    _null_reset_value_offset(0),
+    _payload_offset(-1),
+    _payload_size_in_bytes(-1),
+    _payload_alignment(-1),
+    _non_atomic_size_in_bytes(-1),
+    _non_atomic_alignment(-1),
+    _atomic_size_in_bytes(-1),
+    _nullable_size_in_bytes(-1),
+    _null_marker_offset(-1) {
+}
+
 InlineKlass::InlineKlass() {
   assert(CDSConfig::is_dumping_archive() || UseSharedSpaces, "only for CDS");
 }
 
-  // Constructor
+// Constructor
 InlineKlass::InlineKlass(const ClassFileParser& parser)
     : InstanceKlass(parser, InlineKlass::Kind, markWord::inline_type_prototype()) {
   assert(is_inline_klass(), "sanity");
   assert(prototype_header().is_inline_type(), "sanity");
 
-  // Set up the offset to the InstanceKlassFixedBlock of this klass
-  _adr_inlineklass_fixed_block = new (calculate_fixed_block_address()) InlineKlassFixedBlock;
+  // Set up the offset to the members of this klass
+  _adr_inline_klass_members = calculate_members_address();
 
-  // Addresses used for inline type calling convention
-  set_extended_sig(nullptr);
-  set_return_regs(nullptr);
-  set_pack_handler(nullptr);
-  set_pack_handler_jobject(nullptr);
-  set_unpack_handler(nullptr);
+  // Placement install the members
+  new (_adr_inline_klass_members) Members();
 
+  // Sanity check construction of the members
   assert(pack_handler() == nullptr, "pack handler not null");
-
-  set_null_reset_value_offset(0);
-  set_payload_offset(-1);
-  set_payload_size_in_bytes(-1);
-  set_payload_alignment(-1);
-  set_non_atomic_size_in_bytes(-1);
-  set_non_atomic_alignment(-1);
-  set_atomic_size_in_bytes(-1);
-  set_nullable_size_in_bytes(-1);
-  set_null_marker_offset(-1);
 }
 
-address InlineKlass::calculate_fixed_block_address() const {
-  // The fix block is placed after all other fields inherited from the InstanceKlass
+address InlineKlass::calculate_members_address() const {
+  // The members are placed after all other contents inherited from the InstanceKlass
   return end_of_instance_klass();
 }
 
@@ -429,11 +433,11 @@ void InlineKlass::initialize_calling_convention(TRAPS) {
 
 void InlineKlass::deallocate_contents(ClassLoaderData* loader_data) {
   if (extended_sig() != nullptr) {
-    MetadataFactory::free_array<SigEntry>(loader_data, fixed_block()._extended_sig);
+    MetadataFactory::free_array<SigEntry>(loader_data, members()._extended_sig);
     set_extended_sig(nullptr);
   }
   if (return_regs() != nullptr) {
-    MetadataFactory::free_array<VMRegPair>(loader_data, fixed_block()._return_regs);
+    MetadataFactory::free_array<VMRegPair>(loader_data, members()._return_regs);
     set_return_regs(nullptr);
   }
   cleanup_blobs();
@@ -651,8 +655,8 @@ void InlineKlass::remove_unshareable_info() {
   InstanceKlass::remove_unshareable_info();
 
   // update it to point to the "buffered" copy of this class.
-  _adr_inlineklass_fixed_block = reinterpret_cast<InlineKlassFixedBlock*>(calculate_fixed_block_address());
-  ArchivePtrMarker::mark_pointer((address*)&_adr_inlineklass_fixed_block);
+  _adr_inline_klass_members = calculate_members_address();
+  ArchivePtrMarker::mark_pointer(&_adr_inline_klass_members);
 
   set_extended_sig(nullptr);
   set_return_regs(nullptr);