8349162: [lworld] VM Flags controlling flattening need an update

src/hotspot/cpu/aarch64/interp_masm_aarch64.cpp

@@ -248,7 +248,7 @@ void InterpreterMacroAssembler::read_flat_field(Register entry,
   allocate_instance(field_klass, obj, alloc_temp, rscratch2, false, alloc_failed);
 
   // Have an oop instance buffer, copy into it
-  data_for_oop(obj, dst_temp, field_klass);  // danger, uses rscratch1
+  payload_address(obj, dst_temp, field_klass);  // danger, uses rscratch1
   pop(alloc_temp);             // restore holder
   lea(src, Address(alloc_temp, field_offset));
   // call_VM_leaf, clobbers a few regs, save restore new obj

src/hotspot/cpu/aarch64/macroAssembler_aarch64.cpp

@@ -5653,15 +5653,15 @@ void MacroAssembler::flat_field_copy(DecoratorSet decorators, Register src, Regi
   bs->flat_field_copy(this, decorators, src, dst, inline_layout_info);
 }
 
-void MacroAssembler::first_field_offset(Register inline_klass, Register offset) {
+void MacroAssembler::payload_offset(Register inline_klass, Register offset) {
   ldr(offset, Address(inline_klass, InstanceKlass::adr_inlineklass_fixed_block_offset()));
-  ldrw(offset, Address(offset, InlineKlass::first_field_offset_offset()));
+  ldrw(offset, Address(offset, InlineKlass::payload_offset_offset()));
 }
 
-void MacroAssembler::data_for_oop(Register oop, Register data, Register inline_klass) {
-  // ((address) (void*) o) + vk->first_field_offset();
+void MacroAssembler::payload_address(Register oop, Register data, Register inline_klass) {
+  // ((address) (void*) o) + vk->payload_offset();
   Register offset = (data == oop) ? rscratch1 : data;
-  first_field_offset(inline_klass, offset);
+  payload_offset(inline_klass, offset);
   if (data == oop) {
     add(data, data, offset);
   } else {

src/hotspot/cpu/aarch64/macroAssembler_aarch64.hpp

@@ -942,8 +942,8 @@ class MacroAssembler: public Assembler {
   void flat_field_copy(DecoratorSet decorators, Register src, Register dst, Register inline_layout_info);
 
   // inline type data payload offsets...
-  void first_field_offset(Register inline_klass, Register offset);
-  void data_for_oop(Register oop, Register data, Register inline_klass);
+  void payload_offset(Register inline_klass, Register offset);
+  void payload_address(Register oop, Register data, Register inline_klass);
   // get data payload ptr a flat value array at index, kills rcx and index
   void data_for_value_array_index(Register array, Register array_klass,
                                   Register index, Register data);

src/hotspot/cpu/aarch64/templateTable_aarch64.cpp

@@ -819,7 +819,7 @@ void TemplateTable::aaload()
   // r1: index
   index_check(r0, r1); // leaves index in r1, kills rscratch1
   __ profile_array_type<ArrayLoadData>(r2, r0, r4);
-  if (UseFlatArray) {
+  if (UseArrayFlattening) {
     Label is_flat_array, done;
 
     __ test_flat_array_oop(r0, r8 /*temp*/, is_flat_array);
@@ -1146,7 +1146,7 @@ void TemplateTable::aastore() {
   // Move array class to r5
   __ load_klass(r5, r3);
 
-  if (UseFlatArray) {
+  if (UseArrayFlattening) {
     __ ldrw(r6, Address(r5, Klass::layout_helper_offset()));
     __ test_flat_array_layout(r6, is_flat_array);
   }
@@ -1182,7 +1182,7 @@ void TemplateTable::aastore() {
   if (EnableValhalla) {
     Label is_null_into_value_array_npe, store_null;
 
-    if (UseFlatArray) {
+    if (UseArrayFlattening) {
       __ test_flat_array_oop(r3, r8, is_flat_array);
     }
 
@@ -1200,7 +1200,7 @@ void TemplateTable::aastore() {
   do_oop_store(_masm, element_address, noreg, IS_ARRAY);
   __ b(done);
 
-  if (UseFlatArray) {
+  if (UseArrayFlattening) {
      Label is_type_ok;
     __ bind(is_flat_array); // Store non-null value to flat
 
@@ -3100,7 +3100,7 @@ void TemplateTable::putfield_or_static(int byte_no, bool is_static, RewriteContr
         __ inline_layout_info(r2, index, r6);
         pop_and_check_object(obj);
         __ load_klass(inline_klass, r0);
-        __ data_for_oop(r0, r0, inline_klass);
+        __ payload_address(r0, r0, inline_klass);
         __ add(obj, obj, off);
         // because we use InlineLayoutInfo, we need special value access code specialized for fields (arrays will need a different API)
         __ flat_field_copy(IN_HEAP, r0, obj, r6);
@@ -3344,7 +3344,7 @@ void TemplateTable::fast_storefield(TosState state)
       __ ldr(r4, Address(r4, in_bytes(ResolvedFieldEntry::field_holder_offset())));
       __ inline_layout_info(r4, r3, r5);
       __ load_klass(r4, r0);
-      __ data_for_oop(r0, r0, r4);
+      __ payload_address(r0, r0, r4);
       __ lea(rscratch1, field);
       __ flat_field_copy(IN_HEAP, r0, rscratch1, r5);
       __ b(done);

src/hotspot/cpu/x86/interp_masm_x86.cpp

@@ -1283,7 +1283,7 @@ void InterpreterMacroAssembler::read_flat_field(Register entry, Register tmp1, R
   movptr(r8, Address(entry, in_bytes(ResolvedFieldEntry::field_holder_offset())));
   inline_layout_info(r8, r9, r8); // holder, index, info => InlineLayoutInfo into r8
 
-  data_for_oop(obj, dst_temp, field_klass);
+  payload_addr(obj, dst_temp, field_klass);
   pop(alloc_temp);             // restore object being read from
   load_sized_value(tmp2, Address(entry, in_bytes(ResolvedFieldEntry::field_offset_offset())), sizeof(int), true /*is_signed*/);
   lea(tmp2, Address(alloc_temp, tmp2));

src/hotspot/cpu/x86/macroAssembler_x86.cpp

@@ -6414,15 +6414,15 @@ void MacroAssembler::flat_field_copy(DecoratorSet decorators, Register src, Regi
   bs->flat_field_copy(this, decorators, src, dst, inline_layout_info);
 }
 
-void MacroAssembler::first_field_offset(Register inline_klass, Register offset) {
+void MacroAssembler::payload_offset(Register inline_klass, Register offset) {
   movptr(offset, Address(inline_klass, InstanceKlass::adr_inlineklass_fixed_block_offset()));
-  movl(offset, Address(offset, InlineKlass::first_field_offset_offset()));
+  movl(offset, Address(offset, InlineKlass::payload_offset_offset()));
 }
 
-void MacroAssembler::data_for_oop(Register oop, Register data, Register inline_klass) {
-  // ((address) (void*) o) + vk->first_field_offset();
+void MacroAssembler::payload_addr(Register oop, Register data, Register inline_klass) {
+  // ((address) (void*) o) + vk->payload_offset();
   Register offset = (data == oop) ? rscratch1 : data;
-  first_field_offset(inline_klass, offset);
+  payload_offset(inline_klass, offset);
   if (data == oop) {
     addptr(data, offset);
   } else {

src/hotspot/cpu/x86/macroAssembler_x86.hpp

@@ -429,8 +429,8 @@ class MacroAssembler: public Assembler {
   void flat_field_copy(DecoratorSet decorators, Register src, Register dst, Register inline_layout_info);
 
   // inline type data payload offsets...
-  void first_field_offset(Register inline_klass, Register offset);
-  void data_for_oop(Register oop, Register data, Register inline_klass);
+  void payload_offset(Register inline_klass, Register offset);
+  void payload_addr(Register oop, Register data, Register inline_klass);
   // get data payload ptr a flat value array at index, kills rcx and index
   void data_for_value_array_index(Register array, Register array_klass,
                                   Register index, Register data);

src/hotspot/cpu/x86/templateTable_x86.cpp

@@ -837,7 +837,7 @@ void TemplateTable::aaload() {
 
   index_check(array, index); // kills rbx
   __ profile_array_type<ArrayLoadData>(rbx, array, rcx);
-  if (UseFlatArray) {
+  if (UseArrayFlattening) {
     Label is_flat_array, done;
     __ test_flat_array_oop(array, rbx, is_flat_array);
     do_oop_load(_masm,
@@ -1166,7 +1166,7 @@ void TemplateTable::aastore() {
 
   // Move array class to rdi
   __ load_klass(rdi, rdx, rscratch1);
-  if (UseFlatArray) {
+  if (UseArrayFlattening) {
     __ movl(rbx, Address(rdi, Klass::layout_helper_offset()));
     __ test_flat_array_layout(rbx, is_flat_array);
   }
@@ -1203,7 +1203,7 @@ void TemplateTable::aastore() {
 
       // Move array class to rdi
     __ load_klass(rdi, rdx, rscratch1);
-    if (UseFlatArray) {
+    if (UseArrayFlattening) {
       __ movl(rbx, Address(rdi, Klass::layout_helper_offset()));
       __ test_flat_array_layout(rbx, is_flat_array);
     }
@@ -1221,7 +1221,7 @@ void TemplateTable::aastore() {
   do_oop_store(_masm, element_address, noreg, IS_ARRAY);
   __ jmp(done);
 
-  if (UseFlatArray) {
+  if (UseArrayFlattening) {
     Label is_type_ok;
     __ bind(is_flat_array); // Store non-null value to flat
 
@@ -3533,7 +3533,7 @@ void TemplateTable::putfield_or_static_helper(int byte_no, bool is_static, Rewri
             __ movptr(r9, Address(rcx, in_bytes(ResolvedFieldEntry::field_holder_offset())));
             pop_and_check_object(obj);  // obj = rcx
             __ load_klass(r8, rax, rscratch1);
-            __ data_for_oop(rax, rax, r8);
+            __ payload_addr(rax, rax, r8);
             __ addptr(obj, off);
             __ inline_layout_info(r9, rdx, rbx);
             // because we use InlineLayoutInfo, we need special value access code specialized for fields (arrays will need a different API)
@@ -3788,7 +3788,7 @@ void TemplateTable::fast_storefield_helper(Address field, Register rax, Register
         __ movptr(r8, Address(r8, in_bytes(ResolvedFieldEntry::field_holder_offset())));
         __ inline_layout_info(r8, r9, r8);
         __ load_klass(rdx, rax, rscratch1);
-        __ data_for_oop(rax, rax, rdx);
+        __ payload_addr(rax, rax, rdx);
         __ lea(rcx, field);
         __ flat_field_copy(IN_HEAP, rax, rcx, r8);
         __ jmp(done);

src/hotspot/share/c1/c1_GraphBuilder.cpp

@@ -1818,14 +1818,14 @@ Value GraphBuilder::make_constant(ciConstant field_value, ciField* field) {
 void GraphBuilder::copy_inline_content(ciInlineKlass* vk, Value src, int src_off, Value dest, int dest_off, ValueStack* state_before, ciField* enclosing_field) {
   for (int i = 0; i < vk->nof_declared_nonstatic_fields(); i++) {
     ciField* field = vk->declared_nonstatic_field_at(i);
-    int offset = field->offset_in_bytes() - vk->first_field_offset();
+    int offset = field->offset_in_bytes() - vk->payload_offset();
     if (field->is_flat()) {
       bool needs_atomic_access = !field->is_null_free() || field->is_volatile();
       assert(!needs_atomic_access, "Atomic access in non-atomic container");
       copy_inline_content(field->type()->as_inline_klass(), src, src_off + offset, dest, dest_off + offset, state_before, enclosing_field);
       if (!field->is_null_free()) {
         // Nullable, copy the null marker using Unsafe because null markers are no real fields
-        int null_marker_offset = field->null_marker_offset() - vk->first_field_offset();
+        int null_marker_offset = field->null_marker_offset() - vk->payload_offset();
         Value offset = append(new Constant(new LongConstant(src_off + null_marker_offset)));
         Value nm = append(new UnsafeGet(T_BOOLEAN, src, offset, false));
         offset = append(new Constant(new LongConstant(dest_off + null_marker_offset)));
@@ -1977,13 +1977,13 @@ void GraphBuilder::access_field(Bytecodes::Code code) {
           if (has_pending_field_access()) {
             assert(!needs_patching, "Can't patch delayed field access");
             obj = pending_field_access()->obj();
-            offset += pending_field_access()->offset() - field->holder()->as_inline_klass()->first_field_offset();
+            offset += pending_field_access()->offset() - field->holder()->as_inline_klass()->payload_offset();
             field = pending_field_access()->holder()->get_field_by_offset(offset, false);
             assert(field != nullptr, "field not found");
             set_pending_field_access(nullptr);
           } else if (has_pending_load_indexed()) {
             assert(!needs_patching, "Can't patch delayed field access");
-            pending_load_indexed()->update(field, offset - field->holder()->as_inline_klass()->first_field_offset());
+            pending_load_indexed()->update(field, offset - field->holder()->as_inline_klass()->payload_offset());
             LoadIndexed* li = pending_load_indexed()->load_instr();
             li->set_type(type);
             push(type, append(li));
@@ -2042,9 +2042,9 @@ void GraphBuilder::access_field(Bytecodes::Code code) {
             }
             if (can_delay_access) {
               if (has_pending_load_indexed()) {
-                pending_load_indexed()->update(field, offset - field->holder()->as_inline_klass()->first_field_offset());
+                pending_load_indexed()->update(field, offset - field->holder()->as_inline_klass()->payload_offset());
               } else if (has_pending_field_access()) {
-                pending_field_access()->inc_offset(offset - field->holder()->as_inline_klass()->first_field_offset());
+                pending_field_access()->inc_offset(offset - field->holder()->as_inline_klass()->payload_offset());
               } else {
                 null_check(obj);
                 DelayedFieldAccess* dfa = new DelayedFieldAccess(obj, field->holder(), field->offset_in_bytes(), state_before);
@@ -2063,7 +2063,7 @@ void GraphBuilder::access_field(Bytecodes::Code code) {
                 }
               } else if (has_pending_load_indexed()) {
                 assert(!needs_patching, "Can't patch delayed field access");
-                pending_load_indexed()->update(field, offset - field->holder()->as_inline_klass()->first_field_offset());
+                pending_load_indexed()->update(field, offset - field->holder()->as_inline_klass()->payload_offset());
                 NewInstance* vt = new NewInstance(inline_klass, pending_load_indexed()->state_before(), false, true);
                 _memory->new_instance(vt);
                 pending_load_indexed()->load_instr()->set_vt(vt);
@@ -2080,11 +2080,11 @@ void GraphBuilder::access_field(Bytecodes::Code code) {
                 apush(append_split(new_instance));
                 if (has_pending_field_access()) {
                   copy_inline_content(inline_klass, pending_field_access()->obj(),
-                                      pending_field_access()->offset() + field->offset_in_bytes() - field->holder()->as_inline_klass()->first_field_offset(),
-                                      new_instance, inline_klass->first_field_offset(), state_before);
+                                      pending_field_access()->offset() + field->offset_in_bytes() - field->holder()->as_inline_klass()->payload_offset(),
+                                      new_instance, inline_klass->payload_offset(), state_before);
                   set_pending_field_access(nullptr);
                 } else {
-                  copy_inline_content(inline_klass, obj, field->offset_in_bytes(), new_instance, inline_klass->first_field_offset(), state_before);
+                  copy_inline_content(inline_klass, obj, field->offset_in_bytes(), new_instance, inline_klass->payload_offset(), state_before);
                 }
                 need_membar = true;
               }
@@ -2136,7 +2136,7 @@ void GraphBuilder::access_field(Bytecodes::Code code) {
           append(new StoreField(obj, offset, field, val, false, state_before, needs_patching));
         } else {
           assert(field->is_null_free(), "must be null-free");
-          copy_inline_content(inline_klass, val, inline_klass->first_field_offset(), obj, offset, state_before, field);
+          copy_inline_content(inline_klass, val, inline_klass->payload_offset(), obj, offset, state_before, field);
         }
       }
       break;

src/hotspot/share/c1/c1_Instruction.cpp

@@ -127,15 +127,15 @@ ciKlass* Instruction::as_loaded_klass_or_null() const {
 }
 
 bool Instruction::is_loaded_flat_array() const {
-  if (UseFlatArray) {
+  if (UseArrayFlattening) {
     ciType* type = declared_type();
     return type != nullptr && type->is_flat_array_klass();
   }
   return false;
 }
 
 bool Instruction::maybe_flat_array() {
-  if (UseFlatArray) {
+  if (UseArrayFlattening) {
     ciType* type = declared_type();
     if (type != nullptr) {
       if (type->is_obj_array_klass()) {

src/hotspot/share/c1/c1_LIRGenerator.cpp

@@ -1765,7 +1765,7 @@ void LIRGenerator::do_StoreField(StoreField* x) {
       }
       // Load payload (if not empty) and set null marker (if not null-free)
       if (!vk->is_empty()) {
-        access_load_at(decorators, bt, value, LIR_OprFact::intConst(vk->first_field_offset()), payload);
+        access_load_at(decorators, bt, value, LIR_OprFact::intConst(vk->payload_offset()), payload);
       }
       if (!field->is_null_free()) {
         __ logical_or(payload, null_marker_mask(bt, field), payload);
@@ -1884,7 +1884,7 @@ void LIRGenerator::access_flat_array(bool is_load, LIRItem& array, LIRItem& inde
     ciField* inner_field = elem_klass->nonstatic_field_at(i);
     assert(!inner_field->is_flat(), "flat fields must have been expanded");
     int obj_offset = inner_field->offset_in_bytes();
-    int elm_offset = obj_offset - elem_klass->first_field_offset() + sub_offset; // object header is not stored in array.
+    int elm_offset = obj_offset - elem_klass->payload_offset() + sub_offset; // object header is not stored in array.
     BasicType field_type = inner_field->type()->basic_type();
 
     // Types which are smaller than int are still passed in an int register.
@@ -2226,7 +2226,7 @@ void LIRGenerator::do_LoadField(LoadField* x) {
     access_load_at(decorators, bt, object, LIR_OprFact::intConst(field->offset_in_bytes()), payload,
                    // Make sure to emit an implicit null check
                    info ? new CodeEmitInfo(info) : nullptr, info);
-    access_store_at(decorators, bt, dest, LIR_OprFact::intConst(vk->first_field_offset()), payload);
+    access_store_at(decorators, bt, dest, LIR_OprFact::intConst(vk->payload_offset()), payload);
 
     if (field->is_null_free()) {
       set_result(x, buffer->operand());

src/hotspot/share/c1/c1_Runtime1.cpp

@@ -446,7 +446,7 @@ JRT_ENTRY(void, Runtime1::new_null_free_array(JavaThread* current, Klass* array_
   elem_klass->initialize(CHECK);
   arrayOop obj= nullptr;
   //  Limitation here, only non-atomic layouts are supported
-  if (UseFlatArray && vk->has_non_atomic_layout()) {
+  if (UseArrayFlattening && vk->has_non_atomic_layout()) {
     obj = oopFactory::new_flatArray(elem_klass, length, LayoutKind::NON_ATOMIC_FLAT, CHECK);
   } else {
     obj = oopFactory::new_null_free_objArray(elem_klass, length, CHECK);

src/hotspot/share/cds/filemap.hpp

@@ -181,13 +181,12 @@ class FileMapRegion: private CDSFileMapRegion {
 
 #define CDS_MUST_MATCH_FLAGS_DO(f) \
   f(EnableValhalla) \
-  f(FlatArrayElementMaxOops) \
-  f(FlatArrayElementMaxSize) \
-  f(InlineFieldMaxFlatSize) \
+  f(UseArrayFlattening) \
+  f(UseFieldFlattening) \
   f(InlineTypePassFieldsAsArgs) \
   f(InlineTypeReturnedAsFields) \
-  f(AtomicFieldFlattening) \
-  f(NullableFieldFlattening)
+  f(UseAtomicValueFlattening) \
+  f(UseNullableValueFlattening)
 
 class CDSMustMatchFlags {
 private:

src/hotspot/share/ci/ciInlineKlass.cpp

@@ -49,8 +49,8 @@ int ciInlineKlass::compute_nonstatic_fields() {
 }
 
 // Offset of the first field in the inline type
-int ciInlineKlass::first_field_offset() const {
-  GUARDED_VM_ENTRY(return to_InlineKlass()->first_field_offset();)
+int ciInlineKlass::payload_offset() const {
+  GUARDED_VM_ENTRY(return to_InlineKlass()->payload_offset();)
 }
 
 // Returns the index of the field with the given offset. If the field at 'offset'

src/hotspot/share/ci/ciInlineKlass.hpp

@@ -74,7 +74,7 @@ class ciInlineKlass : public ciInstanceKlass {
   }
 
   // Inline type fields
-  int first_field_offset() const;
+  int payload_offset() const;
   int field_index_by_offset(int offset);
 
   bool flat_in_array() const;

src/hotspot/share/ci/ciInstanceKlass.cpp

@@ -561,7 +561,7 @@ GrowableArray<ciField*>* ciInstanceKlass::compute_nonstatic_fields_impl(Growable
       for (int i = 0; i < vk->nof_nonstatic_fields(); ++i) {
         ciField* flat_field = vk->nonstatic_field_at(i);
         // Adjust offset to account for missing oop header
-        int offset = field_offset + (flat_field->offset_in_bytes() - vk->first_field_offset());
+        int offset = field_offset + (flat_field->offset_in_bytes() - vk->payload_offset());
         // A flat field can be treated as final if the non-flat
         // field is declared final or the holder klass is an inline type itself.
         bool is_final = fd.is_final() || is_inlinetype();
@@ -815,7 +815,7 @@ void StaticFieldPrinter::do_field_helper(fieldDescriptor* fd, oop mirror, bool i
         InlineKlass* vk = InlineKlass::cast(k);
         oop obj;
         if (is_flat) {
-          int field_offset = fd->offset() - vk->first_field_offset();
+          int field_offset = fd->offset() - vk->payload_offset();
           obj = cast_to_oop(cast_from_oop<address>(mirror) + field_offset);
         } else {
           obj = mirror->obj_field_acquire(fd->offset());