Merge branch 'upstream-master'

Author: Datadog Syncup Service

src/hotspot/os/windows/os_windows.cpp

@@ -1947,7 +1947,10 @@ void os::win32::print_windows_version(outputStream* st) {
       // - 2016 GA 10/2016 build: 14393
       // - 2019 GA 11/2018 build: 17763
       // - 2022 GA 08/2021 build: 20348
-      if (build_number > 20347) {
+      // - 2025 Preview build   : 26040
+      if (build_number > 26039) {
+        st->print("Server 2025");
+      } else if (build_number > 20347) {
         st->print("Server 2022");
       } else if (build_number > 17762) {
         st->print("Server 2019");

src/hotspot/share/cds/archiveHeapWriter.cpp

@@ -248,11 +248,16 @@ void ArchiveHeapWriter::copy_roots_to_buffer(GrowableArrayCHeap<oop, mtClassShar
   _heap_root_segments = segments;
 }
 
+// The goal is to sort the objects in increasing order of:
+// - objects that have only oop pointers
+// - objects that have both native and oop pointers
+// - objects that have only native pointers
+// - objects that have no pointers
 static int oop_sorting_rank(oop o) {
   bool has_oop_ptr, has_native_ptr;
   HeapShared::get_pointer_info(o, has_oop_ptr, has_native_ptr);
 
-  if (!has_oop_ptr) {
+  if (has_oop_ptr) {
     if (!has_native_ptr) {
       return 0;
     } else {
@@ -267,11 +272,6 @@ static int oop_sorting_rank(oop o) {
   }
 }
 
-// The goal is to sort the objects in increasing order of:
-// - objects that have no pointers
-// - objects that have only native pointers
-// - objects that have both native and oop pointers
-// - objects that have only oop pointers
 int ArchiveHeapWriter::compare_objs_by_oop_fields(HeapObjOrder* a, HeapObjOrder* b) {
   int rank_a = a->_rank;
   int rank_b = b->_rank;

src/hotspot/share/cds/filemap.cpp

@@ -1581,39 +1581,38 @@ static size_t write_bitmap(const CHeapBitMap* map, char* output, size_t offset)
   return offset + size_in_bytes;
 }
 
-// The start of the archived heap has many primitive arrays (String
-// bodies) that are not marked by the oop/ptr maps. So we must have
-// lots of leading zeros.
-size_t FileMapInfo::remove_bitmap_leading_zeros(CHeapBitMap* map) {
-  size_t old_zeros = map->find_first_set_bit(0);
+// The sorting code groups the objects with non-null oop/ptrs together.
+// Relevant bitmaps then have lots of leading and trailing zeros, which
+// we do not have to store.
+size_t FileMapInfo::remove_bitmap_zeros(CHeapBitMap* map) {
+  BitMap::idx_t first_set = map->find_first_set_bit(0);
+  BitMap::idx_t last_set  = map->find_last_set_bit(0);
   size_t old_size = map->size();
 
   // Slice and resize bitmap
-  map->truncate(old_zeros, map->size());
+  map->truncate(first_set, last_set + 1);
 
-  DEBUG_ONLY(
-    size_t new_zeros = map->find_first_set_bit(0);
-    assert(new_zeros == 0, "Should have removed leading zeros");
-  )
+  assert(map->at(0), "First bit should be set");
+  assert(map->at(map->size() - 1), "Last bit should be set");
   assert(map->size() <= old_size, "sanity");
-  return old_zeros;
+
+  return first_set;
 }
 
 char* FileMapInfo::write_bitmap_region(CHeapBitMap* rw_ptrmap, CHeapBitMap* ro_ptrmap, ArchiveHeapInfo* heap_info,
                                        size_t &size_in_bytes) {
-  size_t removed_rw_zeros = remove_bitmap_leading_zeros(rw_ptrmap);
-  size_t removed_ro_zeros = remove_bitmap_leading_zeros(ro_ptrmap);
-  header()->set_rw_ptrmap_start_pos(removed_rw_zeros);
-  header()->set_ro_ptrmap_start_pos(removed_ro_zeros);
+  size_t removed_rw_leading_zeros = remove_bitmap_zeros(rw_ptrmap);
+  size_t removed_ro_leading_zeros = remove_bitmap_zeros(ro_ptrmap);
+  header()->set_rw_ptrmap_start_pos(removed_rw_leading_zeros);
+  header()->set_ro_ptrmap_start_pos(removed_ro_leading_zeros);
   size_in_bytes = rw_ptrmap->size_in_bytes() + ro_ptrmap->size_in_bytes();
 
   if (heap_info->is_used()) {
-    // Remove leading zeros
-    size_t removed_oop_zeros = remove_bitmap_leading_zeros(heap_info->oopmap());
-    size_t removed_ptr_zeros = remove_bitmap_leading_zeros(heap_info->ptrmap());
-
-    header()->set_heap_oopmap_start_pos(removed_oop_zeros);
-    header()->set_heap_ptrmap_start_pos(removed_ptr_zeros);
+    // Remove leading and trailing zeros
+    size_t removed_oop_leading_zeros = remove_bitmap_zeros(heap_info->oopmap());
+    size_t removed_ptr_leading_zeros = remove_bitmap_zeros(heap_info->ptrmap());
+    header()->set_heap_oopmap_start_pos(removed_oop_leading_zeros);
+    header()->set_heap_ptrmap_start_pos(removed_ptr_leading_zeros);
 
     size_in_bytes += heap_info->oopmap()->size_in_bytes();
     size_in_bytes += heap_info->ptrmap()->size_in_bytes();

src/hotspot/share/cds/filemap.hpp

@@ -445,7 +445,7 @@ class FileMapInfo : public CHeapObj<mtInternal> {
   void  write_header();
   void  write_region(int region, char* base, size_t size,
                      bool read_only, bool allow_exec);
-  size_t remove_bitmap_leading_zeros(CHeapBitMap* map);
+  size_t remove_bitmap_zeros(CHeapBitMap* map);
   char* write_bitmap_region(CHeapBitMap* rw_ptrmap, CHeapBitMap* ro_ptrmap, ArchiveHeapInfo* heap_info,
                             size_t &size_in_bytes);
   size_t write_heap_region(ArchiveHeapInfo* heap_info);

src/hotspot/share/gc/g1/g1ParScanThreadState.hpp

@@ -87,8 +87,6 @@ class G1ParScanThreadState : public CHeapObj<mtGC> {
   // Indicates whether in the last generation (old) there is no more space
   // available for allocation.
   bool _old_gen_is_full;
-  // Size (in elements) of a partial objArray task chunk.
-  size_t _partial_objarray_chunk_size;
   PartialArrayStateAllocator* _partial_array_state_allocator;
   PartialArrayTaskStepper _partial_array_stepper;
   StringDedup::Requests _string_dedup_requests;

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

@@ -1135,6 +1135,26 @@ void OopStorage::BasicParState::report_num_dead() const {
 
 const char* OopStorage::name() const { return _name; }
 
+bool OopStorage::print_containing(const oop* addr, outputStream* st) {
+  if (addr != nullptr) {
+    Block* block = find_block_or_null(addr);
+    if (block != nullptr && block->print_containing(addr, st)) {
+      st->print(" in oop storage \"%s\"", name());
+      return true;
+    }
+  }
+  return false;
+}
+
+bool OopStorage::Block::print_containing(const oop* addr, outputStream* st) {
+  if (contains(addr)) {
+    st->print(PTR_FORMAT " is a pointer %u/%zu into block %zu",
+              p2i(addr), get_index(addr), ARRAY_SIZE(_data), _active_index);
+    return true;
+  }
+  return false;
+}
+
 #ifndef PRODUCT
 
 void OopStorage::print_on(outputStream* st) const {

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

@@ -213,6 +213,7 @@ class OopStorage : public CHeapObjBase {
   // Debugging and logging support.
   const char* name() const;
   void print_on(outputStream* st) const PRODUCT_RETURN;
+  bool print_containing(const oop* addr, outputStream* st);
 
   // Provides access to storage internals, for unit testing.
   // Declare, but not define, the public class OopStorage::TestAccess.

src/hotspot/share/gc/shared/oopStorage.inline.hpp

@@ -196,6 +196,8 @@ class OopStorage::Block /* No base class, to avoid messing up alignment. */ {
 
   template<typename F> bool iterate(F f);
   template<typename F> bool iterate(F f) const;
+
+  bool print_containing(const oop* addr, outputStream* st);
 }; // class Block
 
 inline OopStorage::Block* OopStorage::AllocationList::head() {

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

@@ -82,6 +82,23 @@ template OopStorage* OopStorageSet::get_storage(StrongId);
 template OopStorage* OopStorageSet::get_storage(WeakId);
 template OopStorage* OopStorageSet::get_storage(Id);
 
+bool OopStorageSet::print_containing(const void* addr, outputStream* st) {
+  if (addr != nullptr) {
+    const void* aligned_addr = align_down(addr, alignof(oop));
+    for (OopStorage* storage : Range<Id>()) {
+      if (storage->print_containing((oop*) aligned_addr, st)) {
+        if (aligned_addr != addr) {
+          st->print_cr(" (unaligned)");
+        } else {
+          st->cr();
+        }
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
 #ifdef ASSERT
 
 void OopStorageSet::verify_initialized(uint index) {

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

@@ -26,6 +26,7 @@
 #define SHARE_GC_SHARED_OOPSTORAGESET_HPP
 
 #include "nmt/memTag.hpp"
+#include "oops/oop.hpp"
 #include "utilities/debug.hpp"
 #include "utilities/enumIterator.hpp"
 #include "utilities/globalDefinitions.hpp"
@@ -89,6 +90,8 @@ class OopStorageSet : public AllStatic {
   template <typename Closure>
   static void strong_oops_do(Closure* cl);
 
+  // Debugging: print location info, if in storage.
+  static bool print_containing(const void* addr, outputStream* st);
 };
 
 ENUMERATOR_VALUE_RANGE(OopStorageSet::StrongId,