8308097: Generational ZGC: Update constructor syntax

Reviewed-by: eosterlund, aboldtch

Author: stefank

src/hotspot/cpu/aarch64/gc/z/zBarrierSetAssembler_aarch64.cpp

@@ -601,8 +601,8 @@ class ZAdjustAddress {
   }
 
 public:
-  ZAdjustAddress(MacroAssembler* masm, Address addr) :
-      _masm(masm),
+  ZAdjustAddress(MacroAssembler* masm, Address addr)
+    : _masm(masm),
       _addr(addr),
       _pre_adjustment(addr.getMode() == Address::pre ? addr.offset() : 0),
       _post_adjustment(addr.getMode() == Address::post ? addr.offset() : 0) {
@@ -1132,8 +1132,8 @@ class ZSaveLiveRegisters {
     }
   }
 
-  ZSaveLiveRegisters(MacroAssembler* masm, ZBarrierStubC2* stub) :
-      _masm(masm),
+  ZSaveLiveRegisters(MacroAssembler* masm, ZBarrierStubC2* stub)
+    : _masm(masm),
       _gp_regs(),
       _fp_regs(),
       _p_regs() {
@@ -1169,8 +1169,8 @@ class ZSetupArguments {
   const Address         _ref_addr;
 
 public:
-  ZSetupArguments(MacroAssembler* masm, ZLoadBarrierStubC2* stub) :
-      _masm(masm),
+  ZSetupArguments(MacroAssembler* masm, ZLoadBarrierStubC2* stub)
+    : _masm(masm),
       _ref(stub->ref()),
       _ref_addr(stub->ref_addr()) {
 

src/hotspot/cpu/ppc/gc/z/zBarrierSetAssembler_ppc.cpp

@@ -860,7 +860,7 @@ class ZSaveLiveRegisters {
 
  public:
   ZSaveLiveRegisters(MacroAssembler *masm, ZBarrierStubC2 *stub)
-      : _masm(masm), _reg_mask(stub->live()), _result_reg(stub->result()) {
+    : _masm(masm), _reg_mask(stub->live()), _result_reg(stub->result()) {
 
     const int register_save_size = iterate_over_register_mask(ACTION_COUNT_ONLY) * BytesPerWord;
     _frame_size = align_up(register_save_size, frame::alignment_in_bytes)
@@ -972,8 +972,8 @@ class ZSetupArguments {
   const Address         _ref_addr;
 
  public:
-  ZSetupArguments(MacroAssembler* masm, ZLoadBarrierStubC2* stub) :
-      _masm(masm),
+  ZSetupArguments(MacroAssembler* masm, ZLoadBarrierStubC2* stub)
+    : _masm(masm),
       _ref(stub->ref()),
       _ref_addr(stub->ref_addr()) {
 

src/hotspot/cpu/riscv/gc/z/zBarrierSetAssembler_riscv.cpp

@@ -420,8 +420,7 @@ void ZBarrierSetAssembler::arraycopy_prologue(MacroAssembler* masm,
                                               Register src,
                                               Register dst,
                                               Register count,
-                                              RegSet saved_regs) {
-}
+                                              RegSet saved_regs) {}
 
 static void copy_load_barrier(MacroAssembler* masm,
                               Register ref,
@@ -695,8 +694,8 @@ class ZSaveLiveRegisters {
     }
   }
 
-  ZSaveLiveRegisters(MacroAssembler* masm, ZBarrierStubC2* stub) :
-      _masm(masm),
+  ZSaveLiveRegisters(MacroAssembler* masm, ZBarrierStubC2* stub)
+    : _masm(masm),
       _gp_regs(),
       _fp_regs(),
       _vp_regs() {
@@ -724,8 +723,8 @@ class ZSetupArguments {
   const Address         _ref_addr;
 
 public:
-  ZSetupArguments(MacroAssembler* masm, ZLoadBarrierStubC2* stub) :
-      _masm(masm),
+  ZSetupArguments(MacroAssembler* masm, ZLoadBarrierStubC2* stub)
+    : _masm(masm),
       _ref(stub->ref()),
       _ref_addr(stub->ref_addr()) {
 

src/hotspot/cpu/x86/gc/z/zBarrierSetAssembler_x86.cpp

@@ -59,8 +59,7 @@
 ZBarrierSetAssembler::ZBarrierSetAssembler()
   : _load_bad_relocations(),
     _store_bad_relocations(),
-    _store_good_relocations() {
-}
+    _store_good_relocations() {}
 
 enum class ZXMMSpillMode {
   none,
@@ -1354,8 +1353,8 @@ class ZSaveLiveRegisters {
   }
 
 public:
-  ZSaveLiveRegisters(MacroAssembler* masm, ZBarrierStubC2* stub) :
-      _masm(masm),
+  ZSaveLiveRegisters(MacroAssembler* masm, ZBarrierStubC2* stub)
+    : _masm(masm),
       _gp_registers(),
       _opmask_registers(),
       _xmm_registers(),
@@ -1446,8 +1445,8 @@ class ZSetupArguments {
   const Address         _ref_addr;
 
 public:
-  ZSetupArguments(MacroAssembler* masm, ZLoadBarrierStubC2* stub) :
-      _masm(masm),
+  ZSetupArguments(MacroAssembler* masm, ZLoadBarrierStubC2* stub)
+    : _masm(masm),
       _ref(stub->ref()),
       _ref_addr(stub->ref_addr()) {
 

src/hotspot/os/bsd/gc/z/zPhysicalMemoryBacking_bsd.cpp

@@ -74,8 +74,8 @@ static ZErrno mremap(uintptr_t from_addr, uintptr_t to_addr, size_t size) {
   return (res == KERN_SUCCESS) ? ZErrno(0) : ZErrno(EINVAL);
 }
 
-ZPhysicalMemoryBacking::ZPhysicalMemoryBacking(size_t max_capacity) :
-    _base(0),
+ZPhysicalMemoryBacking::ZPhysicalMemoryBacking(size_t max_capacity)
+  : _base(0),
     _initialized(false) {
 
   // Reserve address space for backing memory

src/hotspot/os/linux/gc/z/zPhysicalMemoryBacking_linux.cpp

@@ -118,8 +118,8 @@ static const char* z_preferred_hugetlbfs_mountpoints[] = {
 static int z_fallocate_hugetlbfs_attempts = 3;
 static bool z_fallocate_supported = true;
 
-ZPhysicalMemoryBacking::ZPhysicalMemoryBacking(size_t max_capacity) :
-    _fd(-1),
+ZPhysicalMemoryBacking::ZPhysicalMemoryBacking(size_t max_capacity)
+  : _fd(-1),
     _filesystem(0),
     _block_size(0),
     _available(0),

src/hotspot/os/windows/gc/z/zPhysicalMemoryBacking_windows.cpp

@@ -69,8 +69,8 @@ class ZPhysicalMemoryBackingSmallPages : public ZPhysicalMemoryBackingImpl {
   }
 
 public:
-  ZPhysicalMemoryBackingSmallPages(size_t max_capacity) :
-      ZPhysicalMemoryBackingImpl(),
+  ZPhysicalMemoryBackingSmallPages(size_t max_capacity)
+    : ZPhysicalMemoryBackingImpl(),
       _handles(max_capacity) {}
 
   size_t commit(zoffset offset, size_t size) {
@@ -146,8 +146,8 @@ class ZPhysicalMemoryBackingLargePages : public ZPhysicalMemoryBackingImpl {
   }
 
 public:
-  ZPhysicalMemoryBackingLargePages(size_t max_capacity) :
-      ZPhysicalMemoryBackingImpl(),
+  ZPhysicalMemoryBackingLargePages(size_t max_capacity)
+    : ZPhysicalMemoryBackingImpl(),
       _page_array(alloc_page_array(max_capacity)) {}
 
   size_t commit(zoffset offset, size_t size) {
@@ -212,8 +212,8 @@ static ZPhysicalMemoryBackingImpl* select_impl(size_t max_capacity) {
   return new ZPhysicalMemoryBackingSmallPages(max_capacity);
 }
 
-ZPhysicalMemoryBacking::ZPhysicalMemoryBacking(size_t max_capacity) :
-    _impl(select_impl(max_capacity)) {}
+ZPhysicalMemoryBacking::ZPhysicalMemoryBacking(size_t max_capacity)
+  : _impl(select_impl(max_capacity)) {}
 
 bool ZPhysicalMemoryBacking::is_initialized() const {
   return true;

src/hotspot/share/gc/z/c1/zBarrierSetC1.cpp

@@ -34,8 +34,8 @@
 #include "gc/z/zThreadLocalData.hpp"
 #include "utilities/macros.hpp"
 
-ZLoadBarrierStubC1::ZLoadBarrierStubC1(LIRAccess& access, LIR_Opr ref, address runtime_stub) :
-    _decorators(access.decorators()),
+ZLoadBarrierStubC1::ZLoadBarrierStubC1(LIRAccess& access, LIR_Opr ref, address runtime_stub)
+  : _decorators(access.decorators()),
     _ref_addr(access.resolved_addr()),
     _ref(ref),
     _tmp(LIR_OprFact::illegalOpr),
@@ -100,8 +100,8 @@ ZStoreBarrierStubC1::ZStoreBarrierStubC1(LIRAccess& access,
                                          LIR_Opr new_zpointer,
                                          LIR_Opr tmp,
                                          bool is_atomic,
-                                         address runtime_stub) :
-    _ref_addr(access.resolved_addr()),
+                                         address runtime_stub)
+  : _ref_addr(access.resolved_addr()),
     _new_zaddress(new_zaddress),
     _new_zpointer(new_zpointer),
     _tmp(tmp),
@@ -156,8 +156,8 @@ class LIR_OpZUncolor : public LIR_Op {
   LIR_Opr _opr;
 
 public:
-  LIR_OpZUncolor(LIR_Opr opr) :
-      LIR_Op(),
+  LIR_OpZUncolor(LIR_Opr opr)
+    : LIR_Op(),
       _opr(opr) {}
 
   virtual void visit(LIR_OpVisitState* state) {
@@ -188,8 +188,8 @@ class LIR_OpZLoadBarrier : public LIR_Op {
   const bool                _on_non_strong;
 
 public:
-  LIR_OpZLoadBarrier(LIR_Opr opr, ZLoadBarrierStubC1* stub, bool on_non_strong) :
-      LIR_Op(),
+  LIR_OpZLoadBarrier(LIR_Opr opr, ZLoadBarrierStubC1* stub, bool on_non_strong)
+    : LIR_Op(),
       _opr(opr),
       _stub(stub),
       _on_non_strong(on_non_strong) {
@@ -223,8 +223,8 @@ static bool barrier_needed(LIRAccess& access) {
   return ZBarrierSet::barrier_needed(access.decorators(), access.type());
 }
 
-ZBarrierSetC1::ZBarrierSetC1() :
-    _load_barrier_on_oop_field_preloaded_runtime_stub(nullptr),
+ZBarrierSetC1::ZBarrierSetC1()
+  : _load_barrier_on_oop_field_preloaded_runtime_stub(nullptr),
     _load_barrier_on_weak_oop_field_preloaded_runtime_stub(nullptr),
     _store_barrier_on_oop_field_with_healing(nullptr),
     _store_barrier_on_oop_field_without_healing(nullptr) {}
@@ -255,8 +255,8 @@ class LIR_OpZColor : public LIR_Op {
   LIR_Opr _opr;
 
 public:
-  LIR_OpZColor(LIR_Opr opr) :
-      LIR_Op(lir_none, opr, nullptr /* info */),
+  LIR_OpZColor(LIR_Opr opr)
+    : LIR_Op(lir_none, opr, nullptr /* info */),
       _opr(opr) {}
 
   virtual void visit(LIR_OpVisitState* state) {
@@ -294,8 +294,8 @@ class LIR_OpZStoreBarrier : public LIR_Op {
                       LIR_Opr new_zaddress,
                       LIR_Opr new_zpointer,
                       CodeStub* stub,
-                      CodeEmitInfo* info) :
-      LIR_Op(lir_none, new_zpointer, nullptr /* info */),
+                      CodeEmitInfo* info)
+    : LIR_Op(lir_none, new_zpointer, nullptr /* info */),
       _addr(addr),
       _new_zaddress(new_zaddress),
       _new_zpointer(new_zpointer),
@@ -498,8 +498,8 @@ class ZLoadBarrierRuntimeStubCodeGenClosure : public StubAssemblerCodeGenClosure
   const DecoratorSet _decorators;
 
 public:
-  ZLoadBarrierRuntimeStubCodeGenClosure(DecoratorSet decorators) :
-      _decorators(decorators) {}
+  ZLoadBarrierRuntimeStubCodeGenClosure(DecoratorSet decorators)
+    : _decorators(decorators) {}
 
   virtual OopMapSet* generate_code(StubAssembler* sasm) {
     ZBarrierSet::assembler()->generate_c1_load_barrier_runtime_stub(sasm, _decorators);
@@ -518,8 +518,8 @@ class ZStoreBarrierRuntimeStubCodeGenClosure : public StubAssemblerCodeGenClosur
   const bool _self_healing;
 
 public:
-  ZStoreBarrierRuntimeStubCodeGenClosure(bool self_healing) :
-      _self_healing(self_healing) {}
+  ZStoreBarrierRuntimeStubCodeGenClosure(bool self_healing)
+    : _self_healing(self_healing) {}
 
   virtual OopMapSet* generate_code(StubAssembler* sasm) {
     ZBarrierSet::assembler()->generate_c1_store_barrier_runtime_stub(sasm, _self_healing);

src/hotspot/share/gc/z/c2/zBarrierSetC2.cpp

@@ -66,8 +66,8 @@ class ZArenaHashtable : public ResourceObj {
     size_t _current_index;
 
   public:
-    Iterator(ZArenaHashtable* table) :
-        _table(table),
+    Iterator(ZArenaHashtable* table)
+      : _table(table),
         _current_entry(table->_table[0]),
         _current_index(0) {
       if (_current_entry == nullptr) {
@@ -89,8 +89,8 @@ class ZArenaHashtable : public ResourceObj {
     }
   };
 
-  ZArenaHashtable(Arena* arena) :
-      _arena(arena),
+  ZArenaHashtable(Arena* arena)
+    : _arena(arena),
       _table() {
     Copy::zero_to_bytes(&_table, sizeof(_table));
   }
@@ -127,8 +127,8 @@ class ZBarrierSetC2State : public ArenaObj {
   int                             _stubs_start_offset;
 
 public:
-  ZBarrierSetC2State(Arena* arena) :
-      _stubs(new (arena) GrowableArray<ZBarrierStubC2*>(arena, 8,  0, nullptr)),
+  ZBarrierSetC2State(Arena* arena)
+    : _stubs(new (arena) GrowableArray<ZBarrierStubC2*>(arena, 8,  0, nullptr)),
       _live(arena),
       _trampoline_stubs_count(0),
       _stubs_start_offset(0) {}
@@ -200,8 +200,8 @@ int ZBarrierStubC2::stubs_start_offset() {
   return barrier_set_state()->stubs_start_offset();
 }
 
-ZBarrierStubC2::ZBarrierStubC2(const MachNode* node) :
-    _node(node),
+ZBarrierStubC2::ZBarrierStubC2(const MachNode* node)
+  : _node(node),
     _entry(),
     _continuation() {}
 
@@ -232,8 +232,8 @@ ZLoadBarrierStubC2* ZLoadBarrierStubC2::create(const MachNode* node, Address ref
   return stub;
 }
 
-ZLoadBarrierStubC2::ZLoadBarrierStubC2(const MachNode* node, Address ref_addr, Register ref) :
-    ZBarrierStubC2(node),
+ZLoadBarrierStubC2::ZLoadBarrierStubC2(const MachNode* node, Address ref_addr, Register ref)
+  : ZBarrierStubC2(node),
     _ref_addr(ref_addr),
     _ref(ref) {
   assert_different_registers(ref, ref_addr.base());
@@ -281,14 +281,13 @@ ZStoreBarrierStubC2* ZStoreBarrierStubC2::create(const MachNode* node, Address r
   return stub;
 }
 
-ZStoreBarrierStubC2::ZStoreBarrierStubC2(const MachNode* node, Address ref_addr, Register new_zaddress, Register new_zpointer, bool is_native, bool is_atomic) :
-    ZBarrierStubC2(node),
+ZStoreBarrierStubC2::ZStoreBarrierStubC2(const MachNode* node, Address ref_addr, Register new_zaddress, Register new_zpointer, bool is_native, bool is_atomic)
+  : ZBarrierStubC2(node),
     _ref_addr(ref_addr),
     _new_zaddress(new_zaddress),
     _new_zpointer(new_zpointer),
     _is_native(is_native),
-    _is_atomic(is_atomic) {
-}
+    _is_atomic(is_atomic) {}
 
 Address ZStoreBarrierStubC2::ref_addr() const {
   return _ref_addr;

src/hotspot/share/gc/z/vmStructs_z.cpp

@@ -25,8 +25,8 @@
 #include "gc/z/vmStructs_z.hpp"
 #include "gc/z/zAddress.hpp"
 
-ZGlobalsForVMStructs::ZGlobalsForVMStructs() :
-    _ZAddressOffsetMask(&ZAddressOffsetMask),
+ZGlobalsForVMStructs::ZGlobalsForVMStructs()
+  : _ZAddressOffsetMask(&ZAddressOffsetMask),
     _ZPointerLoadGoodMask(&ZPointerLoadGoodMask),
     _ZPointerLoadBadMask(&ZPointerLoadBadMask),
     _ZPointerLoadShift(const_cast<size_t*>(&ZPointerLoadShift)),
@@ -35,8 +35,7 @@ ZGlobalsForVMStructs::ZGlobalsForVMStructs() :
     _ZPointerStoreGoodMask(&ZPointerStoreGoodMask),
     _ZPointerStoreBadMask(&ZPointerStoreBadMask),
     _ZObjectAlignmentSmallShift(&ZObjectAlignmentSmallShift),
-    _ZObjectAlignmentSmall(&ZObjectAlignmentSmall) {
-}
+    _ZObjectAlignmentSmall(&ZObjectAlignmentSmall) {}
 
 ZGlobalsForVMStructs ZGlobalsForVMStructs::_instance;
 ZGlobalsForVMStructs* ZGlobalsForVMStructs::_instance_p = &ZGlobalsForVMStructs::_instance;

src/hotspot/share/gc/z/zAllocationFlags.hpp

@@ -54,8 +54,8 @@ class ZAllocationFlags {
   uint8_t _flags;
 
 public:
-  ZAllocationFlags() :
-      _flags(0) {}
+  ZAllocationFlags()
+    : _flags(0) {}
 
   void set_non_blocking() {
     _flags |= field_non_blocking::encode(true);