Merge to tag jdk-28+21

doc/hotspot-style.html

@@ -268,8 +268,8 @@ <h4 id="conventions-for-lock-free-code">Conventions for Lock-free
 synchronization context, such as a held mutex or at a safepoint. In such
 cases the variable should be declared <code>volatile</code> and it
 should NOT be accessed as a normal C++ lvalue. Rather, access should be
-performed via functions from <code>Atomic</code>, such as
-<code>Atomic::load</code>, <code>Atomic::store</code>, etc.</p>
+performed via functions from <code>AtomicAccess</code>, such as
+<code>AtomicAccess::load</code>, <code>AtomicAccess::store</code>, etc.</p>
 <p>This special formulation makes it more clear to maintainers that the
 variable is accessed concurrently in a lock-free manner.</p>
 <h3 id="source-files">Source Files</h3>

doc/hotspot-style.md

@@ -140,8 +140,8 @@ change should be done with a "setter" accessor matched to the simple
 Sometimes variables are accessed concurrently without appropriate synchronization
 context, such as a held mutex or at a safepoint. In such cases the variable should
 be declared `volatile` and it should NOT be accessed as a normal C++ lvalue. Rather,
-access should be performed via functions from `Atomic`, such as `Atomic::load`,
-`Atomic::store`, etc.
+access should be performed via functions from `AtomicAccess`, such as `AtomicAccess::load`,
+`AtomicAccess::store`, etc.
 
 This special formulation makes it more clear to maintainers that the variable is
 accessed concurrently in a lock-free manner.

make/jdk/src/classes/build/tools/blockedcertsconverter/BlockedCertsConverter.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013, 2021, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 2026, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -28,18 +28,17 @@
 import java.io.IOException;
 import java.math.BigInteger;
 import java.security.MessageDigest;
-import java.security.PublicKey;
 import java.security.cert.Certificate;
 import java.security.cert.CertificateFactory;
 import java.security.cert.X509Certificate;
-import java.security.interfaces.ECPublicKey;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
 import java.util.Set;
 import java.util.TreeSet;
 
+import sun.security.util.CurveDB;
 import sun.security.util.DerInputStream;
 import sun.security.util.DerOutputStream;
 import sun.security.util.DerValue;
@@ -140,11 +139,8 @@ private static List<byte[]> altEncodings(X509Certificate c)
         List<DerValue> algIds = Arrays.asList(seq[1], altAlgId(seq[1]));
 
         List<DerValue> sigs;
-        PublicKey p = c.getPublicKey();
-        if (p instanceof ECPublicKey) {
-            ECPublicKey ep = (ECPublicKey) p;
-            BigInteger mod = ep.getParams().getOrder();
-            sigs = Arrays.asList(seq[2], altSig(mod, seq[2]));
+        if (c.getSigAlgName().contains("ECDSA")) {
+            sigs = Arrays.asList(seq[2], altSig(seq[2]));
         } else {
             sigs = Arrays.asList(seq[2]);
         }
@@ -163,14 +159,27 @@ private static List<byte[]> altEncodings(X509Certificate c)
         return result;
     }
 
-    private static DerValue altSig(BigInteger mod, DerValue sig)
+    private static DerValue altSig(DerValue sig)
             throws IOException {
         byte[] sigBits = sig.getBitString();
+        int sigLength = sigBits.length;
         DerInputStream in =
-            new DerInputStream(sigBits, 0, sigBits.length, false);
+            new DerInputStream(sigBits, 0, sigLength, false);
         DerValue[] values = in.getSequence(2);
         BigInteger r = values[0].getBigInteger();
         BigInteger s = values[1].getBigInteger();
+        BigInteger mod;
+        // The following checks cover more than 99.99999% of signature lengths
+        // for the three NIST-P curves. Fail if the length lies outside.
+        if (sigLength >= 100 && sigLength <= 104) {
+            mod = CurveDB.P_384.getOrder();
+        } else if (sigLength >= 68 && sigLength <= 72) {
+            mod = CurveDB.P_256.getOrder();
+        } else if (sigLength >= 135 && sigLength <= 139) {
+            mod = CurveDB.P_521.getOrder();
+        } else {
+            throw new RuntimeException("Unrecognized signature length: " + sigLength);
+        }
         BigInteger s2 = s.negate().mod(mod);
         DerOutputStream out = new DerOutputStream();
         out.putInteger(r);

make/modules/java.sql.rowset/Java.gmk

@@ -29,6 +29,7 @@ DISABLED_WARNINGS_java += dangling-doc-comments
 
 DOCLINT += -Xdoclint:all/protected \
     '-Xdoclint/package:java.*,javax.*'
+COPY += .xsd
 CLEAN_FILES += $(wildcard \
     $(TOPDIR)/src/java.sql.rowset/share/classes/com/sun/rowset/*.properties \
     $(TOPDIR)/src/java.sql.rowset/share/classes/javax/sql/rowset/*.properties)

make/modules/jdk.jpackage/Lib.gmk

@@ -55,8 +55,8 @@ $(eval $(call SetupJdkExecutable, BUILD_JPACKAGEAPPLAUNCHER, \
     EXTRA_SRC := common, \
     INCLUDE_FILES := $(JPACKAGEAPPLAUNCHER_INCLUDE_FILES), \
     OPTIMIZATION := SIZE, \
+    DISABLED_WARNINGS_clang_ExecCommand.c := format-nonliteral, \
     DISABLED_WARNINGS_clang_JvmLauncherLib.c := format-nonliteral, \
-    DISABLED_WARNINGS_clang_LinuxPackage.c := format-nonliteral, \
     DISABLED_WARNINGS_clang_Log.cpp := unused-const-variable, \
     CFLAGS_FILTER_OUT := -MD, \
     CXXFLAGS_FILTER_OUT := -MD, \
@@ -93,6 +93,7 @@ ifeq ($(call isTargetOs, linux), true)
       LINK_TYPE := C++, \
       OPTIMIZATION := SIZE, \
       DISABLED_WARNINGS_gcc_Log.cpp := unused-const-variable, \
+      DISABLED_WARNINGS_clang_ExecCommand.c := format-nonliteral, \
       DISABLED_WARNINGS_clang_JvmLauncherLib.c := format-nonliteral, \
       DISABLED_WARNINGS_clang_tstrings.cpp := format-nonliteral, \
       LD_SET_ORIGIN := false, \

src/hotspot/cpu/aarch64/c1_LIRAssembler_aarch64.cpp

@@ -2379,13 +2379,14 @@ void LIR_Assembler::store_parameter(jobject o,  int offset_from_rsp_in_words) {
 }
 
 void LIR_Assembler::arraycopy_valuetype_check(Register obj, Register tmp, CodeStub* slow_path, bool is_dest, bool null_check) {
+  assert(Arguments::is_valhalla_enabled(), "Value types must be enabled");
   if (null_check) {
     __ cbz(obj, *slow_path->entry());
   }
   if (is_dest) {
     __ test_null_free_array_oop(obj, tmp, *slow_path->entry());
-    __ test_flat_array_oop(obj, tmp, *slow_path->entry());
-  } else {
+  }
+  if (UseArrayFlattening) {
     __ test_flat_array_oop(obj, tmp, *slow_path->entry());
   }
 }
@@ -2467,11 +2468,13 @@ void LIR_Assembler::emit_arraycopy(LIR_OpArrayCopy* op) {
   }
 
   // Handle value type arrays
-  if (flags & LIR_OpArrayCopy::src_valuetype_check) {
-    arraycopy_valuetype_check(src, tmp, stub, false, (flags & LIR_OpArrayCopy::src_null_check));
-  }
-  if (flags & LIR_OpArrayCopy::dst_valuetype_check) {
-    arraycopy_valuetype_check(dst, tmp, stub, true, (flags & LIR_OpArrayCopy::dst_null_check));
+  if (Arguments::is_valhalla_enabled()) {
+    if (flags & LIR_OpArrayCopy::src_valuetype_check) {
+      arraycopy_valuetype_check(src, tmp, stub, false, (flags & LIR_OpArrayCopy::src_null_check));
+    }
+    if (flags & LIR_OpArrayCopy::dst_valuetype_check) {
+      arraycopy_valuetype_check(dst, tmp, stub, true, (flags & LIR_OpArrayCopy::dst_null_check));
+    }
   }
 
   assert(default_type != nullptr && default_type->is_array_klass() && default_type->is_loaded(), "must be true at this point");
@@ -2989,6 +2992,7 @@ void LIR_Assembler::emit_profile_type(LIR_OpProfileType* op) {
 }
 
 void LIR_Assembler::emit_profile_value_type(LIR_OpProfileValueType* op) {
+  assert(Arguments::is_valhalla_enabled(), "Should not be called without value types enabled");
   Register obj = op->obj()->as_register();
   Register tmp = op->tmp()->as_pointer_register();
   bool not_null = op->not_null();

src/hotspot/cpu/aarch64/codeBuffer_aarch64.cpp

@@ -35,9 +35,6 @@ void CodeBuffer::share_trampoline_for(address dest, int caller_offset) {
 
   bool created;
   Offsets* offsets = _shared_trampoline_requests->put_if_absent(dest, &created);
-  if (created) {
-    _shared_trampoline_requests->maybe_grow();
-  }
   offsets->push(caller_offset);
   _finalize_stubs = true;
 }

src/hotspot/cpu/aarch64/gc/shenandoah/shenandoahBarrierSetAssembler_aarch64.cpp

@@ -549,7 +549,7 @@ void ShenandoahBarrierSetAssembler::keepalive_barrier_c1_stub(LIR_Assembler* ce,
   Register obj = stub->obj()->as_register();
 
   if (stub->do_load()) {
-    ce->mem2reg(stub->addr(), stub->obj(), T_OBJECT, lir_patch_none, nullptr, /* wide = */ false);
+    ce->mem2reg(stub->addr(), stub->obj(), T_OBJECT, lir_patch_none, stub->info(), /* wide = */ false);
   }
   __ cbz(obj, *stub->continuation());
   ce->store_parameter(obj, 0);

src/hotspot/cpu/aarch64/interp_masm_aarch64.cpp

@@ -44,6 +44,7 @@
 #include "prims/jvmtiThreadState.hpp"
 #include "runtime/basicLock.hpp"
 #include "runtime/frame.inline.hpp"
+#include "runtime/globals.hpp"
 #include "runtime/javaThread.hpp"
 #include "runtime/safepointMechanism.hpp"
 #include "runtime/sharedRuntime.hpp"
@@ -211,10 +212,12 @@ void InterpreterMacroAssembler::get_method_counters(Register method,
 }
 
 void InterpreterMacroAssembler::read_flat_field(Register entry, Register obj) {
+  assert(UseFieldFlattening, "Should be used only if field flattening is enabled");
   call_VM(obj, CAST_FROM_FN_PTR(address, InterpreterRuntime::read_flat_field), obj, entry);
 }
 
 void InterpreterMacroAssembler::write_flat_field(Register entry, Register tmp1, Register tmp2, Register obj) {
+  assert(UseFieldFlattening, "Should be used only if field flattening is enabled");
   assert_different_registers(entry, tmp1, tmp2, obj);
   Label slow_path, done;
 
@@ -1202,19 +1205,23 @@ template <class ArrayData> void InterpreterMacroAssembler::profile_array_type(Re
     mov(tmp, array);
     profile_obj_type(tmp, Address(mdp, in_bytes(ArrayData::array_offset())));
 
-    Label not_flat;
-    test_non_flat_array_oop(array, tmp, not_flat);
+    if (Arguments::is_valhalla_enabled()) {
+      if (UseArrayFlattening) {
+        Label not_flat;
+        test_non_flat_array_oop(array, tmp, not_flat);
 
-    set_mdp_flag_at(mdp, ArrayData::flat_array_byte_constant());
+        set_mdp_flag_at(mdp, ArrayData::flat_array_byte_constant());
 
-    bind(not_flat);
+        bind(not_flat);
+      }
 
-    Label not_null_free;
-    test_non_null_free_array_oop(array, tmp, not_null_free);
+      Label not_null_free;
+      test_non_null_free_array_oop(array, tmp, not_null_free);
 
-    set_mdp_flag_at(mdp, ArrayData::null_free_array_byte_constant());
+      set_mdp_flag_at(mdp, ArrayData::null_free_array_byte_constant());
 
-    bind(not_null_free);
+      bind(not_null_free);
+    }
 
     bind(profile_continue);
   }
@@ -1278,6 +1285,7 @@ void InterpreterMacroAssembler::profile_acmp(Register mdp,
                                              Register left,
                                              Register right,
                                              Register tmp) {
+  assert(Arguments::is_valhalla_enabled(), "Profiling acmp makes sense only for value types");
   if (ProfileInterpreter) {
     Label profile_continue;
 

src/hotspot/cpu/aarch64/macroAssembler_aarch64.cpp

@@ -2404,6 +2404,7 @@ void MacroAssembler::null_check(Register reg, int offset) {
 }
 
 void MacroAssembler::test_markword_is_value_type(Register markword, Label& is_value_type) {
+  assert(Arguments::is_valhalla_enabled(), "should not be used without value types enabled");
   assert_different_registers(markword, rscratch2);
   mov(rscratch2, markWord::value_type_pattern_mask);
   andr(markword, markword, rscratch2);
@@ -2413,6 +2414,7 @@ void MacroAssembler::test_markword_is_value_type(Register markword, Label& is_va
 }
 
 void MacroAssembler::test_oop_is_not_value_type(Register object, Register tmp, Label& not_value_type, bool can_be_null) {
+  assert(Arguments::is_valhalla_enabled(), "should not be used without value types enabled");
   assert_different_registers(tmp, rscratch1);
   if (can_be_null) {
     cbz(object, not_value_type);
@@ -2426,16 +2428,19 @@ void MacroAssembler::test_oop_is_not_value_type(Register object, Register tmp, L
 }
 
 void MacroAssembler::test_field_is_null_free_value_type(Register flags, Register temp_reg, Label& is_null_free_value_type) {
+  assert(Arguments::is_valhalla_enabled(), "should not be used without value types enabled");
   assert(temp_reg == noreg, "not needed"); // keep signature uniform with x86
   tbnz(flags, ResolvedFieldEntry::is_null_free_value_type_shift, is_null_free_value_type);
 }
 
 void MacroAssembler::test_field_is_not_null_free_value_type(Register flags, Register temp_reg, Label& not_null_free_value_type) {
+  assert(Arguments::is_valhalla_enabled(), "should not be used without value types enabled");
   assert(temp_reg == noreg, "not needed"); // keep signature uniform with x86
   tbz(flags, ResolvedFieldEntry::is_null_free_value_type_shift, not_null_free_value_type);
 }
 
 void MacroAssembler::test_field_is_flat(Register flags, Register temp_reg, Label& is_flat) {
+  assert(UseFieldFlattening, "should not be used without field flattening enabled");
   assert(temp_reg == noreg, "not needed"); // keep signature uniform with x86
   tbnz(flags, ResolvedFieldEntry::is_flat_shift, is_flat);
 }
@@ -2452,23 +2457,28 @@ void MacroAssembler::test_oop_prototype_bit(Register oop, Register temp_reg, int
 }
 
 void MacroAssembler::test_flat_array_oop(Register oop, Register temp_reg, Label& is_flat_array) {
+  assert(UseArrayFlattening, "should not be used without array flattening enabled");
   test_oop_prototype_bit(oop, temp_reg, markWord::flat_array_bit_in_place, true, is_flat_array);
 }
 
 void MacroAssembler::test_non_flat_array_oop(Register oop, Register temp_reg,
                                                   Label&is_non_flat_array) {
+  assert(UseArrayFlattening, "should not be used without array flattening enabled");
   test_oop_prototype_bit(oop, temp_reg, markWord::flat_array_bit_in_place, false, is_non_flat_array);
 }
 
 void MacroAssembler::test_null_free_array_oop(Register oop, Register temp_reg, Label& is_null_free_array) {
+  assert(Arguments::is_valhalla_enabled(), "should not be used without value types enabled");
   test_oop_prototype_bit(oop, temp_reg, markWord::null_free_array_bit_in_place, true, is_null_free_array);
 }
 
 void MacroAssembler::test_non_null_free_array_oop(Register oop, Register temp_reg, Label&is_non_null_free_array) {
+  assert(Arguments::is_valhalla_enabled(), "should not be used without value types enabled");
   test_oop_prototype_bit(oop, temp_reg, markWord::null_free_array_bit_in_place, false, is_non_null_free_array);
 }
 
 void MacroAssembler::test_flat_array_layout(Register lh, Label& is_flat_array) {
+  assert(UseArrayFlattening, "should not be used without array flattening enabled");
   tst(lh, Klass::_lh_array_tag_flat_value_bit_inplace);
   br(Assembler::NE, is_flat_array);
 }
@@ -5695,11 +5705,13 @@ void MacroAssembler::access_store_at(BasicType type, DecoratorSet decorators,
 }
 
 void MacroAssembler::payload_offset(Register value_klass, Register offset) {
+  assert(Arguments::is_valhalla_enabled(), "Must be");
   ldr(offset, Address(value_klass, ValueKlass::adr_members_offset()));
   ldrw(offset, Address(offset, ValueKlass::payload_offset_offset()));
 }
 
 void MacroAssembler::payload_address(Register oop, Register data, Register value_klass) {
+  assert(Arguments::is_valhalla_enabled(), "Must be");
   // ((address) (void*) o) + vk->payload_offset();
   Register offset = (data == oop) ? rscratch1 : data;
   payload_offset(value_klass, offset);
@@ -5887,7 +5899,11 @@ void MacroAssembler::adrp(Register reg1, const Address &dest, uint64_t &byte_off
   code_section()->relocate(inst_mark(), dest.rspec());
   // 8143067: Ensure that the adrp can reach the dest from anywhere within
   // the code cache so that if it is relocated we know it will still reach
-  if (offset_high >= -(1<<20) && offset_low < (1<<20)) {
+  // For AOT code force far distance for external_word relocation.
+  const bool force_far = AOTCodeCache::is_on_for_dump() &&
+                         (dest.rspec().type() == relocInfo::external_word_type) &&
+                         !CodeCache::contains(dest.target());
+  if (!force_far && offset_high >= -(1<<20) && offset_low < (1<<20)) {
     _adrp(reg1, dest.target());
   } else {
     uint64_t target = (uint64_t)dest.target();
@@ -7152,6 +7168,7 @@ int MacroAssembler::store_value_type_fields_to_buf(ciValueKlass* vk, bool from_i
 
 // Move a value between registers/stack slots and update the reg_state
 bool MacroAssembler::move_helper(VMReg from, VMReg to, BasicType bt, RegState reg_state[]) {
+  assert(ValueTypePassFieldsAsArgs, "Must be");
   assert(from->is_valid() && to->is_valid(), "source and destination must be valid");
   if (reg_state[to->value()] == reg_written) {
     return true; // Already written
@@ -7214,6 +7231,7 @@ bool MacroAssembler::move_helper(VMReg from, VMReg to, BasicType bt, RegState re
 // Calculate the extra stack space required for packing or unpacking value
 // args and adjust the stack pointer
 int MacroAssembler::extend_stack_for_value_args(int args_on_stack) {
+  assert(ValueTypePassFieldsAsArgs, "Must be");
   int sp_inc = args_on_stack * VMRegImpl::stack_slot_size;
   sp_inc = align_up(sp_inc, StackAlignmentInBytes);
   assert(sp_inc > 0, "sanity");
@@ -7245,6 +7263,7 @@ int MacroAssembler::extend_stack_for_value_args(int args_on_stack) {
 bool MacroAssembler::unpack_value_helper(const GrowableArray<SigEntry>* sig, int& sig_index,
                                          VMReg from, int& from_index, VMRegPair* to, int to_count, int& to_index,
                                          RegState reg_state[]) {
+  assert(ValueTypePassFieldsAsArgs, "Must be");
   assert(sig->at(sig_index)._bt == T_VOID, "should be at end delimiter");
   assert(from->is_valid(), "source must be valid");
   bool progress = false;
@@ -7391,6 +7410,7 @@ bool MacroAssembler::unpack_value_helper(const GrowableArray<SigEntry>* sig, int
 bool MacroAssembler::pack_value_helper(const GrowableArray<SigEntry>* sig, int& sig_index, int vtarg_index,
                                        VMRegPair* from, int from_count, int& from_index, VMReg to,
                                        RegState reg_state[], Register val_array) {
+  assert(ValueTypePassFieldsAsArgs, "Must be");
   assert(sig->at(sig_index)._bt == T_METADATA, "should be at delimiter");
   assert(to->is_valid(), "destination must be valid");
 

src/hotspot/cpu/aarch64/matcher_aarch64.hpp

@@ -130,11 +130,6 @@
     return true;
   }
 
-  // Does target support predicated operation emulation.
-  static bool supports_vector_predicate_op_emulation(int vopc, int vlen, BasicType bt) {
-    return false;
-  }
-
   // Does the CPU supports vector variable rotate instructions?
   static constexpr bool supports_vector_variable_rotates(void) {
     return false;

src/hotspot/cpu/aarch64/stubGenerator_aarch64.cpp

@@ -2621,10 +2621,12 @@ class StubGenerator: public StubCodeGenerator {
     __ eor(rscratch2, rscratch2, scratch_src_klass);
     __ cbnz(rscratch2, L_failed);
 
-    if (Arguments::is_valhalla_enabled()) {
+    if (UseArrayFlattening) {
       // Check for flat value type array -> return -1
       __ test_flat_array_oop(src, rscratch2, L_failed);
+    }
 
+    if (Arguments::is_valhalla_enabled()) {
       // Check for null-free (non-flat) value type array -> handle as object array
       __ test_null_free_array_oop(src, rscratch2, L_objArray);
     }