Compiler batch.

Arraying · Arraying · commit fd8f0701be08 · 2025-11-25T17:05:08.000+01:00
diff --git a/src/hotspot/cpu/aarch64/c1_MacroAssembler_aarch64.cpp b/src/hotspot/cpu/aarch64/c1_MacroAssembler_aarch64.cpp
@@ -101,7 +101,8 @@ void C1_MacroAssembler::try_allocate(Register obj, Register var_size_in_bytes, i
 void C1_MacroAssembler::initialize_header(Register obj, Register klass, Register len, Register t1, Register t2) {
   assert_different_registers(obj, klass, len);
 
-  if (UseCompactObjectHeaders || EnableValhalla) {
+  // EnableValhalla legacy
+  if (UseCompactObjectHeaders || Arguments::enable_preview()) {
     // COH: Markword contains class pointer which is only known at runtime.
     // Valhalla: Could have value class which has a different prototype header to a normal object.
     // In both cases, we need to fetch dynamically.
diff --git a/src/hotspot/cpu/x86/c1_MacroAssembler_x86.cpp b/src/hotspot/cpu/x86/c1_MacroAssembler_x86.cpp
@@ -83,7 +83,8 @@ void C1_MacroAssembler::try_allocate(Register obj, Register var_size_in_bytes, i
 
 void C1_MacroAssembler::initialize_header(Register obj, Register klass, Register len, Register t1, Register t2) {
   assert_different_registers(obj, klass, len, t1, t2);
-  if (UseCompactObjectHeaders || EnableValhalla) {
+  // EnableValhalla legacy
+  if (UseCompactObjectHeaders || Arguments::enable_preview()) {
     // COH: Markword contains class pointer which is only known at runtime.
     // Valhalla: Could have value class which has a different prototype header to a normal object.
     // In both cases, we need to fetch dynamically.
diff --git a/src/hotspot/cpu/x86/gc/g1/g1BarrierSetAssembler_x86.cpp b/src/hotspot/cpu/x86/gc/g1/g1BarrierSetAssembler_x86.cpp
@@ -235,7 +235,8 @@ void G1BarrierSetAssembler::g1_write_barrier_pre(MacroAssembler* masm,
 
   __ bind(runtime);
 
-  if (EnableValhalla && InlineTypePassFieldsAsArgs) {
+  // EnableValhalla legacy
+  if (Arguments::enable_preview() && InlineTypePassFieldsAsArgs) {
     // Barriers might be emitted when converting between (scalarized) calling conventions for inline
     // types. Save all argument registers before calling into the runtime.
     // TODO 8366717: use push_set() (see JDK-8283327 push/pop_call_clobbered_registers & aarch64 )
@@ -279,7 +280,8 @@ void G1BarrierSetAssembler::g1_write_barrier_pre(MacroAssembler* masm,
     __ call_VM_leaf(CAST_FROM_FN_PTR(address, G1BarrierSetRuntime::write_ref_field_pre_entry), pre_val, thread);
   }
 
-  if (EnableValhalla && InlineTypePassFieldsAsArgs) {
+  // EnableValhalla legacy
+  if (Arguments::enable_preview() && InlineTypePassFieldsAsArgs) {
     // Restore registers
     __ movdbl(j_farg0, Address(rsp, 0));
     __ movdbl(j_farg1, Address(rsp, 8));
diff --git a/src/hotspot/share/c1/c1_GraphBuilder.cpp b/src/hotspot/share/c1/c1_GraphBuilder.cpp
@@ -1362,7 +1362,8 @@ void GraphBuilder::if_node(Value x, If::Condition cond, Value y, ValueStack* sta
   bool is_bb = tsux->bci() < stream()->cur_bci() || fsux->bci() < stream()->cur_bci();
 
   bool subst_check = false;
-  if (EnableValhalla && (stream()->cur_bc() == Bytecodes::_if_acmpeq || stream()->cur_bc() == Bytecodes::_if_acmpne)) {
+  // EnableValhalla legacy
+  if (Arguments::enable_preview() && (stream()->cur_bc() == Bytecodes::_if_acmpeq || stream()->cur_bc() == Bytecodes::_if_acmpne)) {
     ValueType* left_vt = x->type();
     ValueType* right_vt = y->type();
     if (left_vt->is_object()) {
@@ -2566,7 +2567,8 @@ void GraphBuilder::monitorenter(Value x, int bci) {
 #endif
   } else {
     // We are compiling a monitorenter bytecode
-    if (EnableValhalla) {
+    // EnableValhalla legacy
+    if (Arguments::enable_preview()) {
       ciType* obj_type = x->declared_type();
       if (obj_type == nullptr || obj_type->as_klass()->can_be_inline_klass()) {
         // If we're (possibly) locking on an inline type, check for markWord::always_locked_pattern
@@ -4301,7 +4303,8 @@ bool GraphBuilder::try_inline_full(ciMethod* callee, bool holder_known, bool ign
 
   // Check if we need a membar at the beginning of the java.lang.Object
   // constructor to satisfy the memory model for strict fields.
-  if (EnableValhalla && method()->intrinsic_id() == vmIntrinsics::_Object_init) {
+  // EnableValhalla legacy
+  if (Arguments::enable_preview() && method()->intrinsic_id() == vmIntrinsics::_Object_init) {
     Value receiver = state()->local_at(0);
     ciType* klass = receiver->exact_type();
     if (klass == nullptr) {
diff --git a/src/hotspot/share/c1/c1_LIRGenerator.cpp b/src/hotspot/share/c1/c1_LIRGenerator.cpp
@@ -3008,7 +3008,8 @@ void LIRGenerator::do_Base(Base* x) {
 
   // Check if we need a membar at the beginning of the java.lang.Object
   // constructor to satisfy the memory model for strict fields.
-  if (EnableValhalla && method()->intrinsic_id() == vmIntrinsics::_Object_init) {
+  // EnableValhalla legacy
+  if (Arguments::enable_preview() && method()->intrinsic_id() == vmIntrinsics::_Object_init) {
     __ membar_storestore();
   }
 
diff --git a/src/hotspot/share/ci/ciInstanceKlass.cpp b/src/hotspot/share/ci/ciInstanceKlass.cpp
@@ -696,7 +696,8 @@ ciInstanceKlass* ciInstanceKlass::implementor() {
 }
 
 bool ciInstanceKlass::can_be_inline_klass(bool is_exact) {
-  if (!EnableValhalla) {
+  // EnableValhalla legacy
+  if (!Arguments::enable_preview()) {
     return false;
   }
   if (!is_loaded() || is_inlinetype()) {
diff --git a/src/hotspot/share/ci/ciKlass.hpp b/src/hotspot/share/ci/ciKlass.hpp
@@ -27,6 +27,7 @@
 
 #include "ci/ciType.hpp"
 #include "oops/klass.hpp"
+#include "runtime/arguments.hpp"
 
 // ciKlass
 //
@@ -111,7 +112,8 @@ class ciKlass : public ciType {
   }
 
   virtual bool can_be_inline_array_klass() {
-    return EnableValhalla && is_java_lang_Object();
+    // EnableValhalla legacy
+    return Arguments::enable_preview() && is_java_lang_Object();
   }
 
   bool is_in_encoding_range() {
diff --git a/src/hotspot/share/gc/shared/memAllocator.cpp b/src/hotspot/share/gc/shared/memAllocator.cpp
@@ -380,7 +380,8 @@ oop MemAllocator::finish(HeapWord* mem) const {
   if (UseCompactObjectHeaders) {
     oopDesc::release_set_mark(mem, _klass->prototype_header());
   } else {
-    if (EnableValhalla) {
+    // EnableValhalla legacy
+    if (Arguments::enable_preview()) {
       oopDesc::set_mark(mem, _klass->prototype_header());
     } else {
       oopDesc::set_mark(mem, markWord::prototype());
diff --git a/src/hotspot/share/gc/z/zObjArrayAllocator.cpp b/src/hotspot/share/gc/z/zObjArrayAllocator.cpp
@@ -67,7 +67,8 @@ oop ZObjArrayAllocator::initialize(HeapWord* mem) const {
   if (UseCompactObjectHeaders) {
     oopDesc::release_set_mark(mem, _klass->prototype_header().set_marked());
   } else {
-    if (EnableValhalla) {
+    // EnableValhalla legacy
+    if (Arguments::enable_preview()) {
       arrayOopDesc::set_mark(mem, _klass->prototype_header().set_marked());
     } else {
       arrayOopDesc::set_mark(mem, markWord::prototype().set_marked());
@@ -161,7 +162,8 @@ oop ZObjArrayAllocator::initialize(HeapWord* mem) const {
   ZThreadLocalData::clear_invisible_root(_thread);
 
   // Signal to the ZIterator that this is no longer an invisible root
-  if (UseCompactObjectHeaders || EnableValhalla) {
+  // EnableValhalla legacy
+  if (UseCompactObjectHeaders || Arguments::enable_preview()) {
     oopDesc::release_set_mark(mem, _klass->prototype_header());
   } else {
     oopDesc::release_set_mark(mem, markWord::prototype());
diff --git a/src/hotspot/share/opto/callnode.cpp b/src/hotspot/share/opto/callnode.cpp
@@ -1123,7 +1123,8 @@ bool CallJavaNode::validate_symbolic_info() const {
     return true; // call into runtime or uncommon trap
   }
   Bytecodes::Code bc = jvms()->method()->java_code_at_bci(jvms()->bci());
-  if (EnableValhalla && (bc == Bytecodes::_if_acmpeq || bc == Bytecodes::_if_acmpne)) {
+  // EnableValhalla legacy
+  if (Arguments::enable_preview() && (bc == Bytecodes::_if_acmpeq || bc == Bytecodes::_if_acmpne)) {
     return true;
   }
   ciMethod* symbolic_info = jvms()->method()->get_method_at_bci(jvms()->bci());
@@ -1940,11 +1941,13 @@ void AllocateNode::compute_MemBar_redundancy(ciMethod* initializer)
 
 Node* AllocateNode::make_ideal_mark(PhaseGVN* phase, Node* control, Node* mem) {
   Node* mark_node = nullptr;
-  if (UseCompactObjectHeaders || EnableValhalla) {
+  // EnableValhalla legacy
+  if (UseCompactObjectHeaders || Arguments::enable_preview()) {
     Node* klass_node = in(AllocateNode::KlassNode);
     Node* proto_adr = phase->transform(new AddPNode(klass_node, klass_node, phase->MakeConX(in_bytes(Klass::prototype_header_offset()))));
     mark_node = LoadNode::make(*phase, control, mem, proto_adr, TypeRawPtr::BOTTOM, TypeX_X, TypeX_X->basic_type(), MemNode::unordered);
-    if (EnableValhalla) {
+    // EnavleValhalla legacy
+    if (Arguments::enable_preview()) {
       mark_node = phase->transform(mark_node);
       // Avoid returning a constant (old node) here because this method is used by LoadNode::Ideal
       mark_node = new OrXNode(mark_node, phase->MakeConX(_larval ? markWord::larval_bit_in_place : 0));
diff --git a/src/hotspot/share/opto/cfgnode.hpp b/src/hotspot/share/opto/cfgnode.hpp
@@ -260,7 +260,8 @@ class PhiNode : public TypeNode {
   }
 
   bool can_be_inline_type() const {
-    return EnableValhalla && _type->isa_instptr() && _type->is_instptr()->can_be_inline_type();
+    // EnableValhalla legacy
+    return Arguments::enable_preview() && _type->isa_instptr() && _type->is_instptr()->can_be_inline_type();
   }
 
   Node* try_push_inline_types_down(PhaseGVN* phase, bool can_reshape);
diff --git a/src/hotspot/share/opto/compile.cpp b/src/hotspot/share/opto/compile.cpp
@@ -5574,7 +5574,8 @@ void Compile::remove_speculative_types(PhaseIterGVN &igvn) {
 Node* Compile::optimize_acmp(PhaseGVN* phase, Node* a, Node* b) {
   const TypeInstPtr* ta = phase->type(a)->isa_instptr();
   const TypeInstPtr* tb = phase->type(b)->isa_instptr();
-  if (!EnableValhalla || ta == nullptr || tb == nullptr ||
+  // EnableValhalla legacy
+  if (!Arguments::enable_preview() || ta == nullptr || tb == nullptr ||
       ta->is_zero_type() || tb->is_zero_type() ||
       !ta->can_be_inline_type() || !tb->can_be_inline_type()) {
     // Use old acmp if one operand is null or not an inline type
diff --git a/src/hotspot/share/opto/graphKit.cpp b/src/hotspot/share/opto/graphKit.cpp
@@ -1921,7 +1921,8 @@ Node* GraphKit::load_array_element(Node* ary, Node* idx, const TypeAryPtr* aryty
 // Arguments (pre-popped from the stack) are taken from the JVMS.
 void GraphKit::set_arguments_for_java_call(CallJavaNode* call, bool is_late_inline) {
   PreserveReexecuteState preexecs(this);
-  if (EnableValhalla) {
+  // EnableValhalla legacy
+  if (Arguments::enable_preview()) {
     // Make sure the call is "re-executed", if buffering of inline type arguments triggers deoptimization.
     // At this point, the call hasn't been executed yet, so we will only ever execute the call once.
     jvms()->set_should_reexecute(true);
@@ -3742,7 +3743,8 @@ Node* GraphKit::gen_checkcast(Node* obj, Node* superklass, Node* *failure_contro
 
   bool not_inline = !toop->can_be_inline_type();
   bool not_flat_in_array = !UseArrayFlattening || not_inline || (toop->is_inlinetypeptr() && !toop->inline_klass()->maybe_flat_in_array());
-  if (EnableValhalla && (not_inline || not_flat_in_array)) {
+  // EnableValhalla legacy
+  if (Arguments::enable_preview() && (not_inline || not_flat_in_array)) {
     // Check if obj has been loaded from an array
     obj = obj->isa_DecodeN() ? obj->in(1) : obj;
     Node* array = nullptr;
diff --git a/src/hotspot/share/opto/memnode.cpp b/src/hotspot/share/opto/memnode.cpp
@@ -2421,7 +2421,8 @@ const Type* LoadNode::Value(PhaseGVN* phase) const {
   if (!UseCompactObjectHeaders) {
     Node* alloc = is_new_object_mark_load();
     if (alloc != nullptr) {
-      if (EnableValhalla) {
+      // EnableValhalla legacy
+      if (Arguments::enable_preview()) {
         // The mark word may contain property bits (inline, flat, null-free)
         Node* klass_node = alloc->in(AllocateNode::KlassNode);
         const TypeKlassPtr* tkls = phase->type(klass_node)->isa_klassptr();
diff --git a/src/hotspot/share/opto/parse1.cpp b/src/hotspot/share/opto/parse1.cpp
@@ -1285,7 +1285,8 @@ void Parse::do_method_entry() {
 
   // Check if we need a membar at the beginning of the java.lang.Object
   // constructor to satisfy the memory model for strict fields.
-  if (EnableValhalla && method()->intrinsic_id() == vmIntrinsics::_Object_init) {
+  // EnableValhalla legacy
+  if (Arguments::enable_preview() && method()->intrinsic_id() == vmIntrinsics::_Object_init) {
     Node* receiver_obj = local(0);
     const TypeInstPtr* receiver_type = _gvn.type(receiver_obj)->isa_instptr();
     // If there's no exact type, check if the declared type has no implementors and add a dependency
diff --git a/src/hotspot/share/opto/parse2.cpp b/src/hotspot/share/opto/parse2.cpp
@@ -2103,7 +2103,8 @@ void Parse::do_acmp(BoolTest::mask btest, Node* left, Node* right) {
     record_profile_for_speculation(right, right_type, right_ptr);
   }
 
-  if (!EnableValhalla) {
+  // EnableValhalla legacy
+  if (!Arguments::enable_preview()) {
     Node* cmp = CmpP(left, right);
     cmp = optimize_cmp_with_klass(cmp);
     do_if(btest, cmp);
diff --git a/src/hotspot/share/opto/subnode.cpp b/src/hotspot/share/opto/subnode.cpp
@@ -945,7 +945,8 @@ bool CmpLNode::is_double_null_check(PhaseGVN* phase, Node*& a, Node*& b) const {
       in(1)->in(1)->Opcode() == Op_CastP2X &&
       in(1)->in(2)->Opcode() == Op_CastP2X &&
       in(2)->bottom_type()->is_zero_type()) {
-    assert(EnableValhalla, "unexpected double null check");
+    // EnableValhalla legacy
+    assert(Arguments::enable_preview(), "unexpected double null check");
     a = in(1)->in(1)->in(1);
     b = in(1)->in(2)->in(1);
     return true;

Original file line number	Diff line number	Diff line change
`@@ -3008,7 +3008,8 @@ void LIRGenerator::do_Base(Base* x) {`
`3008`	`3008`
`3009`	`3009`	`// Check if we need a membar at the beginning of the java.lang.Object`
`3010`	`3010`	`// constructor to satisfy the memory model for strict fields.`
`3011`		`- if (EnableValhalla && method()->intrinsic_id() == vmIntrinsics::_Object_init) {`
	`3011`	`+ // EnableValhalla legacy`
	`3012`	`+ if (Arguments::enable_preview() && method()->intrinsic_id() == vmIntrinsics::_Object_init) {`
`3012`	`3013`	`__ membar_storestore();`
`3013`	`3014`	`}`
`3014`	`3015`
Original file line number	Diff line number	Diff line change
`@@ -696,7 +696,8 @@ ciInstanceKlass* ciInstanceKlass::implementor() {`
`696`	`696`	`}`
`697`	`697`
`698`	`698`	`bool ciInstanceKlass::can_be_inline_klass(bool is_exact) {`
`699`		`- if (!EnableValhalla) {`
	`699`	`+ // EnableValhalla legacy`
	`700`	`+ if (!Arguments::enable_preview()) {`
`700`	`701`	`return false;`
`701`	`702`	`}`
`702`	`703`	`if (!is_loaded() \|\| is_inlinetype()) {`
Original file line number	Diff line number	Diff line change
`@@ -27,6 +27,7 @@`
`27`	`27`
`28`	`28`	`#include "ci/ciType.hpp"`
`29`	`29`	`#include "oops/klass.hpp"`
	`30`	`+#include "runtime/arguments.hpp"`
`30`	`31`
`31`	`32`	`// ciKlass`
`32`	`33`	`//`
`@@ -111,7 +112,8 @@ class ciKlass : public ciType {`
`111`	`112`	`}`
`112`	`113`
`113`	`114`	`virtual bool can_be_inline_array_klass() {`
`114`		`- return EnableValhalla && is_java_lang_Object();`
	`115`	`+ // EnableValhalla legacy`
	`116`	`+ return Arguments::enable_preview() && is_java_lang_Object();`
`115`	`117`	`}`
`116`	`118`
`117`	`119`	`bool is_in_encoding_range() {`