[NFC][libc] rearrange aarch64 memset code to better match new implementation

[courbet]

libc/src/string/memory_utils/memset_implementations.h

95

This is magical. Maybe at least spell it 64 + 32 ?

103–105

ditto.

[gchatelet]

• address comment

[gchatelet]

libc/src/string/memory_utils/memset_implementations.h

103–105

@avieira how did you come up with 448 here?

[avieira]

libc/src/string/memory_utils/memset_implementations.h

103–105

I believe I found this number through benchmarking a non ZVA version with ZVA to see at what sizes (more or less) ZVA started to beat non ZVA. So 'Magical' is as good a way to describe it as I can come up with now too.

[gchatelet]

I've reverted the patch as it triggered errors in tests
https://lab.llvm.org/buildbot/#/builders/223/builds/5502/steps/7/logs/stdio
https://lab.llvm.org/buildbot/#/builders/138/builds/29082/steps/4/logs/stdio

Looking at it.

libc/src/string/memory_utils/elements_aarch64.h

 
 using _1 = __llvm_libc::scalar::_1;
 using _2 = __llvm_libc::scalar::_2;
 using _3 = __llvm_libc::scalar::_3;
 using _4 = __llvm_libc::scalar::_4;
 using _32 = Chained<_16, _16>;
 using _64 = Chained<_32, _32>;
 
-struct ZVA {
+struct Zva64 {
   static constexpr size_t SIZE = 64;
+
   static void splat_set(char *dst, const unsigned char) {
 #if __SIZEOF_POINTER__ == 4
     asm("dc zva, %w[dst]" : : [dst] "r"(dst) : "memory");
 #else
     asm("dc zva, %[dst]" : : [dst] "r"(dst) : "memory");
 #endif
   }
 };
 
-inline static bool AArch64ZVA(char *dst, size_t count) {
+inline static bool hasZva() {
   uint64_t zva_val;
   asm("mrs %[zva_val], dczid_el0" : [zva_val] "=r"(zva_val));
-  if ((zva_val & 31) != 4)
-    return false;
-  splat_set<Align<_64, Arg::_1>::Then<Loop<ZVA, _64>>>(dst, 0, count);
-  return true;
+  // DC ZVA is permitted if DZP, bit [4] is zero.
+  // BS, bits [3:0] is log2 of the block size in words.
+  // So the next line checks whether the instruction is permitted and block size
+  // is 16 words (i.e. 64 bytes).
+  return (zva_val & 0b11111) == 0b00100;
 }
 
 } // namespace aarch64_memset
 
 namespace aarch64 {
 
 using _1 = __llvm_libc::scalar::_1;
 using _2 = __llvm_libc::scalar::_2;

libc/src/string/memory_utils/memset_implementations.h

if (count <= 3) {
     return;
   }
   if (count <= 8)
     return splat_set<HeadTail<_4>>(dst, value, count);
   if (count <= 16)
     return splat_set<HeadTail<_8>>(dst, value, count);
   if (count <= 32)
     return splat_set<HeadTail<_16>>(dst, value, count);
-  if (count <= 96) {
+  if (count <= (32 + 64)) {
     splat_set<_32>(dst, value);
     if (count <= 64)
       return splat_set<Tail<_32>>(dst, value, count);
     splat_set<Skip<32>::Then<_32>>(dst, value);
     splat_set<Tail<_32>>(dst, value, count);
     return;
   }
-  if (count < 448 || value != 0 || !AArch64ZVA(dst, count))
+  if (count >= 448 && value == 0 && hasZva())
+    return splat_set<Align<_64, Arg::_1>::Then<Loop<Zva64>>>(dst, 0, count);
+  else
     return splat_set<Align<_16, Arg::_1>::Then<Loop<_64>>>(dst, value, count);
 #else
   /////////////////////////////////////////////////////////////////////////////
   // Default
   /////////////////////////////////////////////////////////////////////////////
   using namespace ::__llvm_libc::scalar;
 
   if (count == 0)