Roll back main changes on zero_words_reg_reg and generate_zero_blocks

Signed-off-by: Patrick Zhang <patrick@os.amperecomputing.com>

Author: cnqpzhang

src/hotspot/cpu/aarch64/macroAssembler_aarch64.cpp

@@ -6199,22 +6199,21 @@ const int MacroAssembler::zero_words_block_size = 8;
 // ptr, cnt, rscratch1, and rscratch2 are clobbered.
 address MacroAssembler::zero_words(Register ptr, Register cnt)
 {
-  BLOCK_COMMENT("zero_words {");
   assert(is_power_of_2(zero_words_block_size), "adjust this");
+
+  BLOCK_COMMENT("zero_words {");
   assert(ptr == r10 && cnt == r11, "mismatch in register usage");
 
   subs(rscratch1, cnt, zero_words_block_size);
   Label around;
   br(LO, around);
-
-  if (UseBlockZeroing) {
-    // Try to zero blocks using DC ZVA if allowed.
+  {
     RuntimeAddress zero_blocks = RuntimeAddress(StubRoutines::aarch64::zero_blocks());
     assert(zero_blocks.target() != nullptr, "zero_blocks stub has not been generated");
-    // Ensure that this is a C2 compilation.
-    // The C1 compiler allocates space solely for trampoline stubs generated
-    // by Call LIR operations, and in any case, it is preferable
-    // for a C1 compilation task to complete as quickly as possible.
+    // Make sure this is a C2 compilation. C1 allocates space only for
+    // trampoline stubs generated by Call LIR ops, and in any case it
+    // makes sense for a C1 compilation task to proceed as quickly as
+    // possible.
     CompileTask* task;
     if (StubRoutines::aarch64::complete()
         && Thread::current()->is_Compiler_thread()
@@ -6229,26 +6228,11 @@ address MacroAssembler::zero_words(Register ptr, Register cnt)
       far_call(zero_blocks);
     }
   }
-
-  // Process words with length exceeding the predefined block size threshold.
-  // The loop body will be unrolled based on the number of STP instructions calculated below.
-  const int unroll = zero_words_block_size / 2;
-  Label done, loop;
-  subs(cnt, cnt, unroll * 2);
-  br(Assembler::LT, done);
-  bind(loop);
-  for (int i = 0; i < unroll; i++)
-    stp(zr, zr, post(ptr, 16));
-  subs(cnt, cnt, unroll * 2);
-  br(Assembler::GE, loop);
-  bind(done);
-  add(cnt, cnt, unroll * 2);
-
   bind(around);
 
   // A few words remain to complete.
-  // If called, the zero_blocks routine has already performed the necessary
-  // adjustments to registers r10 and r11, ensuring they are correctly set
+  // The zero_blocks routine has already performed the necessary
+  // adjustments to r10 and r11, ensuring they are correctly set
   // for subsequent processing.
   for (int i = zero_words_block_size >> 1; i > 1; i >>= 1) {
     Label l;
@@ -6288,6 +6272,8 @@ address MacroAssembler::zero_words(Register base, uint64_t cnt)
       BLOCK_COMMENT(buf);
     }
 #endif
+    // Use 16 words as the block size which is 128 bytes on 64-bit systems.
+    // A complete loop body will be 8 STPs unrolled there.
     const int block_size = 16;
     if (cnt >= block_size) {
       uint64_t loops = cnt/block_size;

src/hotspot/cpu/aarch64/stubGenerator_aarch64.cpp

@@ -642,9 +642,9 @@ class StubGenerator: public StubCodeGenerator {
     return start;
   }
 
-  // The inner part of zero_words(). This is the bulk operation,
-  // zeroing words in blocks, using DC ZVA.
-  // The caller is responsible for zeroing the last few words.
+  // The inner part of zero_words().  This is the bulk operation,
+  // zeroing words in blocks, possibly using DC ZVA to do it.  The
+  // caller is responsible for zeroing the last few words.
   //
   // Inputs:
   // r10: the HeapWord-aligned base address of an array to zero.
@@ -653,8 +653,10 @@ class StubGenerator: public StubCodeGenerator {
   // Returns r10 and r11, adjusted for the caller to clear.
   // r10: the base address of the tail of words left to clear.
   // r11: the number of words in the tail.
-  //      r11 < MAX2(zva_length * 2, (int)BlockZeroingLowLimit)
+  //      r11 < MacroAssembler::zero_words_block_size.
+
   address generate_zero_blocks() {
+    Label done;
     Label base_aligned;
 
     Register base = r10, cnt = r11;
@@ -664,34 +666,51 @@ class StubGenerator: public StubCodeGenerator {
     StubCodeMark mark(this, stub_id);
     address start = __ pc();
 
-    assert (UseBlockZeroing, "only work when UseBlockZeroing is true");
+    if (UseBlockZeroing) {
+      int zva_length = VM_Version::zva_length();
 
-    int zva_length = VM_Version::zva_length();
+      // Ensure ZVA length can be divided by 16. This is required by
+      // the subsequent operations.
+      assert (zva_length % 16 == 0, "Unexpected ZVA Length");
 
-    // Ensure ZVA length can be divided by 16. This is required by
-    // the subsequent operations.
-    assert (zva_length % 16 == 0, "Unexpected ZVA Length");
+      __ tbz(base, 3, base_aligned);
+      __ str(zr, Address(__ post(base, 8)));
+      __ sub(cnt, cnt, 1);
+      __ bind(base_aligned);
 
-    __ tbz(base, 3, base_aligned);
-    __ str(zr, Address(__ post(base, 8)));
-    __ sub(cnt, cnt, 1);
-    __ bind(base_aligned);
+      // Ensure count >= zva_length * 2 so that it still deserves a zva after
+      // alignment.
+      Label small;
+      int low_limit = MAX2(zva_length * 2, (int)BlockZeroingLowLimit);
+      __ subs(rscratch1, cnt, low_limit >> 3);
+      __ br(Assembler::LT, small);
+      __ zero_dcache_blocks(base, cnt);
+      __ bind(small);
+    }
 
-    // Ensure count >= zva_length * 2 so that it still deserves a zva after
-    // alignment.
-    Label small;
-    int low_limit = MAX2(zva_length * 2, (int)BlockZeroingLowLimit);
-    __ subs(rscratch1, cnt, low_limit >> 3);
-    __ br(Assembler::LT, small);
-    __ zero_dcache_blocks(base, cnt);
-    __ bind(small);
+    {
+      // Process words with length exceeding the predefined
+      // block size threshold. The loop body will be unrolled based on
+      // the number of STPs calculated below.
+      const int unroll = MacroAssembler::zero_words_block_size / 2;
+      // Clear the remaining blocks.
+      Label loop;
+      __ subs(cnt, cnt, unroll * 2);
+      __ br(Assembler::LT, done);
+      __ bind(loop);
+      for (int i = 0; i < unroll; i++)
+        __ stp(zr, zr, __ post(base, 16));
+      __ subs(cnt, cnt, unroll * 2);
+      __ br(Assembler::GE, loop);
+      __ bind(done);
+      __ add(cnt, cnt, unroll * 2);
+    }
 
     __ ret(lr);
 
     return start;
   }
 
-
   typedef enum {
     copy_forwards = 1,
     copy_backwards = -1