8301070: Replace NULL with nullptr in share/memory/

Reviewed-by: stefank, stuefe

Author: jdksjolen

src/hotspot/share/memory/allocation.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2022, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2023, 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
@@ -40,7 +40,7 @@ char* AllocateHeap(size_t size,
                    const NativeCallStack& stack,
                    AllocFailType alloc_failmode /* = AllocFailStrategy::EXIT_OOM*/) {
   char* p = (char*) os::malloc(size, flags, stack);
-  if (p == NULL && alloc_failmode == AllocFailStrategy::EXIT_OOM) {
+  if (p == nullptr && alloc_failmode == AllocFailStrategy::EXIT_OOM) {
     vm_exit_out_of_memory(size, OOM_MALLOC_ERROR, "AllocateHeap");
   }
   return p;
@@ -57,19 +57,19 @@ char* ReallocateHeap(char *old,
                      MEMFLAGS flag,
                      AllocFailType alloc_failmode) {
   char* p = (char*) os::realloc(old, size, flag, CALLER_PC);
-  if (p == NULL && alloc_failmode == AllocFailStrategy::EXIT_OOM) {
+  if (p == nullptr && alloc_failmode == AllocFailStrategy::EXIT_OOM) {
     vm_exit_out_of_memory(size, OOM_MALLOC_ERROR, "ReallocateHeap");
   }
   return p;
 }
 
-// handles NULL pointers
+// handles null pointers
 void FreeHeap(void* p) {
   os::free(p);
 }
 
-void* MetaspaceObj::_shared_metaspace_base = NULL;
-void* MetaspaceObj::_shared_metaspace_top  = NULL;
+void* MetaspaceObj::_shared_metaspace_base = nullptr;
+void* MetaspaceObj::_shared_metaspace_top  = nullptr;
 
 void* StackObj::operator new(size_t size)     throw() { ShouldNotCallThis(); return 0; }
 void  StackObj::operator delete(void* p)              { ShouldNotCallThis(); }
@@ -132,7 +132,7 @@ void* AnyObj::operator new(size_t size, const std::nothrow_t&  nothrow_constant,
     MEMFLAGS flags) throw() {
   // should only call this with std::nothrow, use other operator new() otherwise
     address res = (address)AllocateHeap(size, flags, CALLER_PC, AllocFailStrategy::RETURN_NULL);
-    DEBUG_ONLY(if (res!= NULL) set_allocation_type(res, C_HEAP);)
+    DEBUG_ONLY(if (res!= nullptr) set_allocation_type(res, C_HEAP);)
   return res;
 }
 

src/hotspot/share/memory/allocation.hpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2022, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2023, 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
@@ -174,7 +174,7 @@ char* ReallocateHeap(char *old,
                      MEMFLAGS flag,
                      AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM);
 
-// handles NULL pointers
+// handles null pointers
 void FreeHeap(void* p);
 
 class CHeapObjBase {
@@ -321,7 +321,7 @@ class MetaspaceObj {
   // into a single contiguous memory block, so we can use these
   // two pointers to quickly determine if something is in the
   // shared metaspace.
-  // When CDS is not enabled, both pointers are set to NULL.
+  // When CDS is not enabled, both pointers are set to null.
   static void* _shared_metaspace_base;  // (inclusive) low address
   static void* _shared_metaspace_top;   // (exclusive) high address
 
@@ -335,7 +335,7 @@ class MetaspaceObj {
 #if INCLUDE_CDS
   static bool is_shared(const MetaspaceObj* p) {
     // If no shared metaspace regions are mapped, _shared_metaspace_{base,top} will
-    // both be NULL and all values of p will be rejected quickly.
+    // both be null and all values of p will be rejected quickly.
     return (((void*)p) < _shared_metaspace_top &&
             ((void*)p) >= _shared_metaspace_base);
   }
@@ -386,7 +386,7 @@ class MetaspaceObj {
     METASPACE_OBJ_TYPES_DO(METASPACE_OBJ_TYPE_NAME_CASE)
     default:
       ShouldNotReachHere();
-      return NULL;
+      return nullptr;
     }
   }
 
@@ -511,7 +511,7 @@ class AnyObj {
   }
   void* operator new(size_t size, const std::nothrow_t& nothrow_constant) throw() {
     address res = (address)resource_allocate_bytes(size, AllocFailStrategy::RETURN_NULL);
-    DEBUG_ONLY(if (res != NULL) set_allocation_type(res, RESOURCE_AREA);)
+    DEBUG_ONLY(if (res != nullptr) set_allocation_type(res, RESOURCE_AREA);)
     return res;
   }
 

src/hotspot/share/memory/allocation.inline.hpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2023, 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
@@ -59,15 +59,15 @@ E* MmapArrayAllocator<E>::allocate_or_null(size_t length, MEMFLAGS flags) {
   size_t size = size_for(length);
 
   char* addr = os::reserve_memory(size, !ExecMem, flags);
-  if (addr == NULL) {
-    return NULL;
+  if (addr == nullptr) {
+    return nullptr;
   }
 
   if (os::commit_memory(addr, size, !ExecMem)) {
     return (E*)addr;
   } else {
     os::release_memory(addr, size);
-    return NULL;
+    return nullptr;
   }
 }
 
@@ -76,7 +76,7 @@ E* MmapArrayAllocator<E>::allocate(size_t length, MEMFLAGS flags) {
   size_t size = size_for(length);
 
   char* addr = os::reserve_memory(size, !ExecMem, flags);
-  if (addr == NULL) {
+  if (addr == nullptr) {
     vm_exit_out_of_memory(size, OOM_MMAP_ERROR, "Allocator (reserve)");
   }
 
@@ -148,13 +148,13 @@ E* ArrayAllocator<E>::reallocate(E* old_addr, size_t old_length, size_t new_leng
 
   E* new_addr = (new_length > 0)
       ? allocate(new_length, flags)
-      : NULL;
+      : nullptr;
 
-  if (new_addr != NULL && old_addr != NULL) {
+  if (new_addr != nullptr && old_addr != nullptr) {
     memcpy(new_addr, old_addr, MIN2(old_length, new_length) * sizeof(E));
   }
 
-  if (old_addr != NULL) {
+  if (old_addr != nullptr) {
     free(old_addr, old_length);
   }
 
@@ -173,7 +173,7 @@ void ArrayAllocator<E>::free_mmap(E* addr, size_t length) {
 
 template <class E>
 void ArrayAllocator<E>::free(E* addr, size_t length) {
-  if (addr != NULL) {
+  if (addr != nullptr) {
     if (should_use_malloc(length)) {
       free_malloc(addr, length);
     } else {

src/hotspot/share/memory/arena.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2021, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2023, 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
@@ -56,9 +56,9 @@ class ChunkPool {
   static ChunkPool _pools[_num_pools];
 
  public:
-  ChunkPool(size_t size) : _first(NULL), _num_chunks(0), _size(size) {}
+  ChunkPool(size_t size) : _first(nullptr), _num_chunks(0), _size(size) {}
 
-  // Allocate a chunk from the pool; returns NULL if pool is empty.
+  // Allocate a chunk from the pool; returns null if pool is empty.
   Chunk* allocate() {
     ThreadCritical tc;
     Chunk* c = _first;
@@ -81,26 +81,26 @@ class ChunkPool {
   // Prune the pool
   void prune() {
     static const int blocksToKeep = 5;
-    Chunk* cur = NULL;
+    Chunk* cur = nullptr;
     Chunk* next;
     // if we have more than n chunks, free all of them
     ThreadCritical tc;
     if (_num_chunks > blocksToKeep) {
       // free chunks at end of queue, for better locality
       cur = _first;
       for (size_t i = 0; i < (blocksToKeep - 1); i++) {
-        assert(cur != NULL, "counter out of sync?");
+        assert(cur != nullptr, "counter out of sync?");
         cur = cur->next();
       }
-      assert(cur != NULL, "counter out of sync?");
+      assert(cur != nullptr, "counter out of sync?");
 
       next = cur->next();
-      cur->set_next(NULL);
+      cur->set_next(nullptr);
       cur = next;
 
       // Free all remaining chunks while in ThreadCritical lock
       // so NMT adjustment is stable.
-      while(cur != NULL) {
+      while(cur != nullptr) {
         next = cur->next();
         os::free(cur);
         _num_chunks--;
@@ -115,14 +115,14 @@ class ChunkPool {
     }
   }
 
-  // Given a (inner payload) size, return the pool responsible for it, or NULL if the size is non-standard
+  // Given a (inner payload) size, return the pool responsible for it, or null if the size is non-standard
   static ChunkPool* get_pool_for_size(size_t size) {
     for (int i = 0; i < _num_pools; i++) {
       if (_pools[i]._size == size) {
         return _pools + i;
       }
     }
-    return NULL;
+    return nullptr;
   }
 
 };
@@ -170,17 +170,17 @@ void* Chunk::operator new (size_t sizeofChunk, AllocFailType alloc_failmode, siz
          SIZE_FORMAT ".", length);
   // Try to reuse a freed chunk from the pool
   ChunkPool* pool = ChunkPool::get_pool_for_size(length);
-  if (pool != NULL) {
+  if (pool != nullptr) {
     Chunk* c = pool->allocate();
-    if (c != NULL) {
+    if (c != nullptr) {
       assert(c->length() == length, "wrong length?");
       return c;
     }
   }
   // Either the pool was empty, or this is a non-standard length. Allocate a new Chunk from C-heap.
   size_t bytes = ARENA_ALIGN(sizeofChunk) + length;
   void* p = os::malloc(bytes, mtChunk, CALLER_PC);
-  if (p == NULL && alloc_failmode == AllocFailStrategy::EXIT_OOM) {
+  if (p == nullptr && alloc_failmode == AllocFailStrategy::EXIT_OOM) {
     vm_exit_out_of_memory(bytes, OOM_MALLOC_ERROR, "Chunk::new");
   }
   // We rely on arena alignment <= malloc alignment.
@@ -192,7 +192,7 @@ void Chunk::operator delete(void* p) {
   // If this is a standard-sized chunk, return it to its pool; otherwise free it.
   Chunk* c = (Chunk*)p;
   ChunkPool* pool = ChunkPool::get_pool_for_size(c->length());
-  if (pool != NULL) {
+  if (pool != nullptr) {
     pool->free(c);
   } else {
     ThreadCritical tc;  // Free chunks under TC lock so that NMT adjustment is stable.
@@ -201,7 +201,7 @@ void Chunk::operator delete(void* p) {
 }
 
 Chunk::Chunk(size_t length) : _len(length) {
-  _next = NULL;         // Chain on the linked list
+  _next = nullptr;         // Chain on the linked list
 }
 
 void Chunk::chop() {
@@ -217,7 +217,7 @@ void Chunk::chop() {
 
 void Chunk::next_chop() {
   _next->chop();
-  _next = NULL;
+  _next = nullptr;
 }
 
 void Chunk::start_chunk_pool_cleaner_task() {
@@ -276,7 +276,7 @@ void Arena::destruct_contents() {
   // reset size before chop to avoid a rare racing condition
   // that can have total arena memory exceed total chunk memory
   set_size_in_bytes(0);
-  if (_first != NULL) {
+  if (_first != nullptr) {
     _first->chop();
   }
   reset();
@@ -312,9 +312,9 @@ void* Arena::grow(size_t x, AllocFailType alloc_failmode) {
   Chunk *k = _chunk;            // Get filled-up chunk address
   _chunk = new (alloc_failmode, len) Chunk(len);
 
-  if (_chunk == NULL) {
+  if (_chunk == nullptr) {
     _chunk = k;                 // restore the previous value of _chunk
-    return NULL;
+    return nullptr;
   }
   if (k) k->set_next(_chunk);   // Append new chunk to end of linked list
   else _first = _chunk;
@@ -332,11 +332,11 @@ void* Arena::grow(size_t x, AllocFailType alloc_failmode) {
 void *Arena::Arealloc(void* old_ptr, size_t old_size, size_t new_size, AllocFailType alloc_failmode) {
   if (new_size == 0) {
     Afree(old_ptr, old_size); // like realloc(3)
-    return NULL;
+    return nullptr;
   }
-  if (old_ptr == NULL) {
+  if (old_ptr == nullptr) {
     assert(old_size == 0, "sanity");
-    return Amalloc(new_size, alloc_failmode); // as with realloc(3), a NULL old ptr is equivalent to malloc(3)
+    return Amalloc(new_size, alloc_failmode); // as with realloc(3), a null old ptr is equivalent to malloc(3)
   }
   char *c_old = (char*)old_ptr; // Handy name
   // Stupid fast special case
@@ -358,8 +358,8 @@ void *Arena::Arealloc(void* old_ptr, size_t old_size, size_t new_size, AllocFail
 
   // Oops, got to relocate guts
   void *new_ptr = Amalloc(new_size, alloc_failmode);
-  if (new_ptr == NULL) {
-    return NULL;
+  if (new_ptr == nullptr) {
+    return nullptr;
   }
   memcpy( new_ptr, c_old, old_size );
   Afree(c_old,old_size);        // Mostly done to keep stats accurate
@@ -369,7 +369,7 @@ void *Arena::Arealloc(void* old_ptr, size_t old_size, size_t new_size, AllocFail
 
 // Determine if pointer belongs to this Arena or not.
 bool Arena::contains( const void *ptr ) const {
-  if (_chunk == NULL) return false;
+  if (_chunk == nullptr) return false;
   if( (void*)_chunk->bottom() <= ptr && ptr < (void*)_hwm )
     return true;                // Check for in this chunk
   for (Chunk *c = _first; c; c = c->next()) {

src/hotspot/share/memory/arena.hpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2021, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2023, 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
@@ -140,8 +140,8 @@ class Arena : public CHeapObjBase {
 
   // Fast delete in area.  Common case is: NOP (except for storage reclaimed)
   bool Afree(void *ptr, size_t size) {
-    if (ptr == NULL) {
-      return true; // as with free(3), freeing NULL is a noop.
+    if (ptr == nullptr) {
+      return true; // as with free(3), freeing null is a noop.
     }
 #ifdef ASSERT
     if (ZapResourceArea) memset(ptr, badResourceValue, size); // zap freed memory
@@ -174,8 +174,8 @@ class Arena : public CHeapObjBase {
 private:
   // Reset this Arena to empty, access will trigger grow if necessary
   void   reset(void) {
-    _first = _chunk = NULL;
-    _hwm = _max = NULL;
+    _first = _chunk = nullptr;
+    _hwm = _max = nullptr;
     set_size_in_bytes(0);
   }
 };