Merge branch 'master' into JDK-8378319_obsolete_maxram

Author: jsikstro

src/hotspot/cpu/s390/compiledIC_s390.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2016, 2026, Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2016, 2019 SAP SE. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
@@ -29,17 +29,13 @@
 #include "memory/resourceArea.hpp"
 #include "runtime/mutexLocker.hpp"
 #include "runtime/safepoint.hpp"
-#ifdef COMPILER2
-#include "opto/matcher.hpp"
-#endif
 
 // ----------------------------------------------------------------------------
 
 #undef  __
 #define __ masm->
 
 address CompiledDirectCall::emit_to_interp_stub(MacroAssembler *masm, address mark/* = nullptr*/) {
-#ifdef COMPILER2
   // Stub is fixed up when the corresponding call is converted from calling
   // compiled code to calling interpreted code.
   if (mark == nullptr) {
@@ -55,7 +51,7 @@ address CompiledDirectCall::emit_to_interp_stub(MacroAssembler *masm, address ma
   __ relocate(static_stub_Relocation::spec(mark));
 
   AddressLiteral meta = __ allocate_metadata_address(nullptr);
-  bool success = __ load_const_from_toc(as_Register(Matcher::inline_cache_reg_encode()), meta);
+  bool success = __ load_const_from_toc(Z_inline_cache, meta);
 
   __ set_inst_mark();
   AddressLiteral a((address)-1);
@@ -67,10 +63,6 @@ address CompiledDirectCall::emit_to_interp_stub(MacroAssembler *masm, address ma
   __ z_br(Z_R1);
   __ end_a_stub(); // Update current stubs pointer and restore insts_end.
   return stub;
-#else
-  ShouldNotReachHere();
-  return nullptr;
-#endif
 }
 
 #undef __

src/hotspot/cpu/zero/bytecodeInterpreter_zero.inline.hpp

@@ -26,6 +26,8 @@
 #ifndef CPU_ZERO_BYTECODEINTERPRETER_ZERO_INLINE_HPP
 #define CPU_ZERO_BYTECODEINTERPRETER_ZERO_INLINE_HPP
 
+#include "sanitizers/ub.hpp"
+
 // Inline interpreter functions for zero
 
 inline jfloat BytecodeInterpreter::VMfloatAdd(jfloat op1, jfloat op2) {
@@ -40,6 +42,7 @@ inline jfloat BytecodeInterpreter::VMfloatMul(jfloat op1, jfloat op2) {
   return op1 * op2;
 }
 
+ATTRIBUTE_NO_UBSAN // IEEE-754 division by zero is well-defined
 inline jfloat BytecodeInterpreter::VMfloatDiv(jfloat op1, jfloat op2) {
   return op1 / op2;
 }
@@ -68,7 +71,7 @@ inline void BytecodeInterpreter::VMmemCopy64(uint32_t       to[2],
 }
 
 inline jlong BytecodeInterpreter::VMlongAdd(jlong op1, jlong op2) {
-  return op1 + op2;
+  return java_add(op1, op2);
 }
 
 inline jlong BytecodeInterpreter::VMlongAnd(jlong op1, jlong op2) {
@@ -82,15 +85,15 @@ inline jlong BytecodeInterpreter::VMlongDiv(jlong op1, jlong op2) {
 }
 
 inline jlong BytecodeInterpreter::VMlongMul(jlong op1, jlong op2) {
-  return op1 * op2;
+  return java_multiply(op1, op2);
 }
 
 inline jlong BytecodeInterpreter::VMlongOr(jlong op1, jlong op2) {
   return op1 | op2;
 }
 
 inline jlong BytecodeInterpreter::VMlongSub(jlong op1, jlong op2) {
-  return op1 - op2;
+  return java_subtract(op1, op2);
 }
 
 inline jlong BytecodeInterpreter::VMlongXor(jlong op1, jlong op2) {
@@ -104,19 +107,19 @@ inline jlong BytecodeInterpreter::VMlongRem(jlong op1, jlong op2) {
 }
 
 inline jlong BytecodeInterpreter::VMlongUshr(jlong op1, jint op2) {
-  return ((unsigned long long) op1) >> (op2 & 0x3F);
+  return java_shift_right_unsigned(op1, op2);
 }
 
 inline jlong BytecodeInterpreter::VMlongShr(jlong op1, jint op2) {
-  return op1 >> (op2 & 0x3F);
+  return java_shift_right(op1, op2);
 }
 
 inline jlong BytecodeInterpreter::VMlongShl(jlong op1, jint op2) {
-  return op1 << (op2 & 0x3F);
+  return java_shift_left(op1, op2);
 }
 
 inline jlong BytecodeInterpreter::VMlongNeg(jlong op) {
-  return -op;
+  return java_negate(op);
 }
 
 inline jlong BytecodeInterpreter::VMlongNot(jlong op) {
@@ -183,8 +186,8 @@ inline jdouble BytecodeInterpreter::VMdoubleAdd(jdouble op1, jdouble op2) {
   return op1 + op2;
 }
 
+ATTRIBUTE_NO_UBSAN // IEEE-754 division by zero is well-defined
 inline jdouble BytecodeInterpreter::VMdoubleDiv(jdouble op1, jdouble op2) {
-  // Divide by zero... QQQ
   return op1 / op2;
 }
 
@@ -228,7 +231,7 @@ inline jdouble BytecodeInterpreter::VMfloat2Double(jfloat op) {
 // Integer Arithmetic
 
 inline jint BytecodeInterpreter::VMintAdd(jint op1, jint op2) {
-  return op1 + op2;
+  return java_add(op1, op2);
 }
 
 inline jint BytecodeInterpreter::VMintAnd(jint op1, jint op2) {
@@ -242,11 +245,11 @@ inline jint BytecodeInterpreter::VMintDiv(jint op1, jint op2) {
 }
 
 inline jint BytecodeInterpreter::VMintMul(jint op1, jint op2) {
-  return op1 * op2;
+  return java_multiply(op1, op2);
 }
 
 inline jint BytecodeInterpreter::VMintNeg(jint op) {
-  return -op;
+  return java_negate(op);
 }
 
 inline jint BytecodeInterpreter::VMintOr(jint op1, jint op2) {
@@ -260,19 +263,19 @@ inline jint BytecodeInterpreter::VMintRem(jint op1, jint op2) {
 }
 
 inline jint BytecodeInterpreter::VMintShl(jint op1, jint op2) {
-  return op1 << (op2 & 0x1F);
+  return java_shift_left(op1, op2);
 }
 
 inline jint BytecodeInterpreter::VMintShr(jint op1, jint op2) {
-  return op1 >> (op2 & 0x1F);
+  return java_shift_right(op1, op2);
 }
 
 inline jint BytecodeInterpreter::VMintSub(jint op1, jint op2) {
-  return op1 - op2;
+  return java_subtract(op1, op2);
 }
 
 inline juint BytecodeInterpreter::VMintUshr(jint op1, jint op2) {
-  return ((juint) op1) >> (op2 & 0x1F);
+  return java_shift_right_unsigned(op1, op2);
 }
 
 inline jint BytecodeInterpreter::VMintXor(jint op1, jint op2) {

src/hotspot/cpu/zero/zeroInterpreter_zero.cpp

@@ -368,12 +368,15 @@ int ZeroInterpreter::native_entry(Method* method, intptr_t UNUSED, TRAPS) {
     goto unlock_unwind_and_return;
 
   void **arguments;
-  void *mirror; {
+  // These locals must remain on stack until call completes
+  void *mirror;
+  void *env;
+  {
     arguments =
       (void **) stack->alloc(handler->argument_count() * sizeof(void **));
     void **dst = arguments;
 
-    void *env = thread->jni_environment();
+    env = thread->jni_environment();
     *(dst++) = &env;
 
     if (method->is_static()) {

src/hotspot/os/aix/globals_aix.hpp

@@ -1,6 +1,6 @@
 /*
- * Copyright (c) 2005, 2024, Oracle and/or its affiliates. All rights reserved.
- * Copyright (c) 2012, 2024 SAP SE. All rights reserved.
+ * Copyright (c) 2005, 2026, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2026 SAP SE. 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
@@ -61,10 +61,6 @@
   product(bool, OptimizePollingPageLocation, true, DIAGNOSTIC,                      \
              "Optimize the location of the polling page used for Safepoints")       \
                                                                                     \
-  /* Use 64K pages for virtual memory (shmat). */                                   \
-  product(bool, Use64KPages, true, DIAGNOSTIC,                                      \
-          "Use 64K pages if available.")                                            \
-                                                                                    \
   /* Normally AIX commits memory on touch, but sometimes it is helpful to have */   \
   /* explicit commit behaviour. This flag, if true, causes the VM to touch     */   \
   /* memory on os::commit_memory() (which normally is a noop).                 */   \
@@ -79,7 +75,6 @@
 //
 
 // UseLargePages means nothing, for now, on AIX.
-// Use Use64KPages or Use16MPages instead.
 define_pd_global(size_t, PreTouchParallelChunkSize, 1 * G);
 define_pd_global(bool, UseLargePages, false);
 define_pd_global(bool, UseLargePagesIndividualAllocation, false);

src/hotspot/os/aix/os_aix.cpp

@@ -2142,46 +2142,12 @@ void os::init(void) {
   // 64k          no              --- AIX 5.2 ? ---
   // 64k          yes                                              64k                             new systems and standard java loader (we set datapsize=64k when linking)
 
-  // We explicitly leave no option to change page size, because only upgrading would work,
-  // not downgrading (if stack page size is 64k you cannot pretend its 4k).
-
-  if (g_multipage_support.datapsize == 4*K) {
-    // datapsize = 4K. Data segment, thread stacks are 4K paged.
-    if (g_multipage_support.can_use_64K_pages || g_multipage_support.can_use_64K_mmap_pages) {
-      // .. but we are able to use 64K pages dynamically.
-      // This would be typical for java launchers which are not linked
-      // with datapsize=64K (like, any other launcher but our own).
-      //
-      // In this case it would be smart to allocate the java heap with 64K
-      // to get the performance benefit, and to fake 64k pages for the
-      // data segment (when dealing with thread stacks).
-      //
-      // However, leave a possibility to downgrade to 4K, using
-      // -XX:-Use64KPages.
-      if (Use64KPages) {
-        trcVerbose("64K page mode (faked for data segment)");
-        set_page_size(64*K);
-      } else {
-        trcVerbose("4K page mode (Use64KPages=off)");
-        set_page_size(4*K);
-      }
-    } else {
-      // .. and not able to allocate 64k pages dynamically. Here, just
-      // fall back to 4K paged mode and use mmap for everything.
-      trcVerbose("4K page mode");
-      set_page_size(4*K);
-      FLAG_SET_ERGO(Use64KPages, false);
-    }
-  } else {
-    // datapsize = 64k. Data segment, thread stacks are 64k paged.
-    // This normally means that we can allocate 64k pages dynamically.
-    // (There is one special case where this may be false: EXTSHM=on.
-    // but we decided to not support that mode).
-    assert0(g_multipage_support.can_use_64K_pages || g_multipage_support.can_use_64K_mmap_pages);
-    set_page_size(64*K);
-    trcVerbose("64K page mode");
-    FLAG_SET_ERGO(Use64KPages, true);
-  }
+  // datapsize = 64k. Data segment, thread stacks are 64k paged.
+  // This normally means that we can allocate 64k pages dynamically.
+  // (There is one special case where this may be false: EXTSHM=on.
+  // but we decided to not support that mode).
+  assert0(g_multipage_support.can_use_64K_pages || g_multipage_support.can_use_64K_mmap_pages);
+  set_page_size(64*K);
 
   // For now UseLargePages is just ignored.
   FLAG_SET_ERGO(UseLargePages, false);

src/hotspot/share/cds/aotMetaspace.cpp

@@ -1148,7 +1148,7 @@ void AOTMetaspace::dump_static_archive_impl(StaticArchiveBuilder& builder, TRAPS
     if (CDSConfig::is_dumping_full_module_graph()) {
       ClassLoaderDataShared::ensure_module_entry_tables_exist();
       ClassLoaderDataShared::build_tables(CHECK);
-      HeapShared::reset_archived_object_states(CHECK);
+      HeapShared::prepare_for_archiving(CHECK);
     }
 
     AOTReferenceObjSupport::initialize(CHECK);

src/hotspot/share/cds/heapShared.cpp

@@ -247,6 +247,28 @@ void HeapShared::reset_archived_object_states(TRAPS) {
   reset_states(boot_loader(), CHECK);
 }
 
+void HeapShared::ensure_determinism(TRAPS) {
+  TempNewSymbol class_name = SymbolTable::new_symbol("jdk/internal/util/WeakReferenceKey");
+  TempNewSymbol method_name = SymbolTable::new_symbol("ensureDeterministicAOTCache");
+
+  Klass* weak_ref_key_class = SystemDictionary::resolve_or_fail(class_name, true, CHECK);
+  precond(weak_ref_key_class != nullptr);
+
+  log_debug(aot)("Calling WeakReferenceKey::ensureDeterministicAOTCache(Object.class)");
+  JavaValue result(T_BOOLEAN);
+  JavaCalls::call_static(&result,
+                         weak_ref_key_class,
+                         method_name,
+                         vmSymbols::void_boolean_signature(),
+                         CHECK);
+  assert(result.get_jboolean() == false, "sanity");
+}
+
+void HeapShared::prepare_for_archiving(TRAPS) {
+  reset_archived_object_states(CHECK);
+  ensure_determinism(CHECK);
+}
+
 HeapShared::ArchivedObjectCache* HeapShared::_archived_object_cache = nullptr;
 
 bool HeapShared::is_archived_heap_in_use() {

src/hotspot/share/cds/heapShared.hpp

@@ -382,8 +382,10 @@ class HeapShared: AllStatic {
   static bool walk_one_object(PendingOopStack* stack, int level, KlassSubGraphInfo* subgraph_info,
                               oop orig_obj, oop referrer);
 
- public:
   static void reset_archived_object_states(TRAPS);
+  static void ensure_determinism(TRAPS);
+ public:
+  static void prepare_for_archiving(TRAPS);
   static void create_archived_object_cache() {
     _archived_object_cache =
       new (mtClass)ArchivedObjectCache(INITIAL_TABLE_SIZE, MAX_TABLE_SIZE);

src/hotspot/share/gc/shared/gc_globals.hpp

@@ -202,9 +202,6 @@
           "(Deprecated) Enable parallel reference processing "              \
           "whenever possible")                                              \
                                                                             \
-  product(bool, ParallelRefProcBalancingEnabled, true,                      \
-          "(Deprecated) Enable balancing of reference processing queues")   \
-                                                                            \
   product(size_t, ReferencesPerThread, 1000, EXPERIMENTAL,                  \
                "Ergonomically start one thread for this amount of "         \
                "references for reference processing if "                    \

src/hotspot/share/gc/shared/referenceProcessor.cpp

@@ -586,33 +586,9 @@ void ReferenceProcessor::set_active_mt_degree(uint v) {
   _next_id = 0;
 }
 
-bool ReferenceProcessor::need_balance_queues(DiscoveredList refs_lists[]) {
-  assert(processing_is_mt(), "why balance non-mt processing?");
-  // _num_queues is the processing degree.  Only list entries up to
-  // _num_queues will be processed, so any non-empty lists beyond
-  // that must be redistributed to lists in that range.  Even if not
-  // needed for that, balancing may be desirable to eliminate poor
-  // distribution of references among the lists.
-  if (ParallelRefProcBalancingEnabled) {
-    return true;                // Configuration says do it.
-  } else {
-    // Configuration says don't balance, but if there are non-empty
-    // lists beyond the processing degree, then must ignore the
-    // configuration and balance anyway.
-    for (uint i = _num_queues; i < _max_num_queues; ++i) {
-      if (!refs_lists[i].is_empty()) {
-        return true;            // Must balance despite configuration.
-      }
-    }
-    return false;               // Safe to obey configuration and not balance.
-  }
-}
-
 void ReferenceProcessor::maybe_balance_queues(DiscoveredList refs_lists[]) {
   assert(processing_is_mt(), "Should not call this otherwise");
-  if (need_balance_queues(refs_lists)) {
-    balance_queues(refs_lists);
-  }
+  balance_queues(refs_lists);
 }
 
 // Balances reference queues.