[sanitizer][test] Don't hard-code page size in CompactRingBuffer.int64

[tangyouling]

Summary

The munmap syscall expects a page size aligned address, but the
CompactRingBuffer.int64 case expects a hard coded page size of 4KiB.
This breaks on e.g. LoongArch which defaults to a 16KiB page size:

$ ./build/runtimes/runtimes-bins/compiler-rt/lib/sanitizer_common/tests/Sanitizer-loongarch64-Test --gtest_filter=CompactRingBuffer.int64
Note: Google Test filter = CompactRingBuffer.int64
[==========] Running 1 test from 1 test suite.
[----------] Global test environment set-up.
[----------] 1 test from CompactRingBuffer
[ RUN      ] CompactRingBuffer.int64
==1395551==ERROR: SanitizerTool failed to deallocate 0xfffffffffffff000 (-4096) bytes at address 0x7ffff2a30000
SanitizerTool: CHECK failed: sanitizer_posix.cpp:63 "(("unable to unmap" && 0)) != (0)" (0x0, 0x0) (tid=1395551)

[xen0n]

LGTM but let's wait for the code owners.

Also I've reworded the patch summary (again) so it's not overly verbose and unnecessarily mentioning LoongArch (it's appropriate to refer to some test output, but the change itself isn't related to LoongArch at all).

Please also pay attention to the patch summary diff (you can do so by clicking the "Show Details" link alongside the edit action in the timeline) so you don't make the same/similar grammatical mistakes over and over again. I'm seriously thinking about composing a checklist of common Chinglish mistakes these days for lightening my proofreading workload...

[tangyouling]

In D137404#3907710, @xen0n wrote:

Please also pay attention to the patch summary diff (you can do so by clicking the "Show Details" link alongside the edit action in the timeline) so you don't make the same/similar grammatical mistakes over and over again. I'm seriously thinking about composing a checklist of common Chinglish mistakes these days for lightening my proofreading workload...

I'm sorry for the heavy proofreading workload caused by my grammatical mistakes, thanks again!

[XiaodongLoong]

FYI:
https://reviews.llvm.org/D117635

[eugenis]

As explained in D117635, kPageSizeBits is part of the compiler contract and must be a compile-time constant.

compiler-rt/lib/sanitizer_common/sanitizer_ring_buffer.h

 // A ring buffer with externally provided storage that encodes its state in 8
 // bytes. Has significant constraints on size and alignment of storage.
 // See a comment in hwasan/hwasan_thread_list.h for the motivation behind this.
 #if SANITIZER_WORDSIZE == 64
 template <class T>
 class CompactRingBuffer {
   // Top byte of long_ stores the buffer size in pages.
   // Lower bytes store the address of the next buffer element.
-  static constexpr int kPageSizeBits = 12;
   static constexpr int kSizeShift = 56;
   static constexpr int kSizeBits = 64 - kSizeShift;
   static constexpr uptr kNextMask = (1ULL << kSizeShift) - 1;
 
-  uptr GetStorageSize() const { return (long_ >> kSizeShift) << kPageSizeBits; }
+  uptr GetStorageSize() const {
+    unsigned kPageSizeBits = Log2(GetPageSizeCached());
+    return (long_ >> kSizeShift) << kPageSizeBits;
+  }
 
   static uptr SignExtend(uptr x) { return ((sptr)x) << kSizeBits >> kSizeBits; }
 
   void Init(void *storage, uptr size) {
+    unsigned kPageSizeBits = Log2(GetPageSizeCached());
     CHECK_EQ(sizeof(CompactRingBuffer<T>), sizeof(void *));
     CHECK(IsPowerOfTwo(size));
     CHECK_GE(size, 1 << kPageSizeBits);
     CHECK_LE(size, 128 << kPageSizeBits);
-    CHECK_EQ(size % 4096, 0);
+    CHECK_EQ(size % GetPageSizeCached(), 0);
     CHECK_EQ(size % sizeof(T), 0);
     uptr st = (uptr)storage;
     CHECK_EQ(st % (size * 2), 0);
     CHECK_EQ(st, SignExtend(st & kNextMask));
     long_ = (st & kNextMask) | ((size >> kPageSizeBits) << kSizeShift);
   }
 
   void SetNext(const T *next) {

compiler-rt/lib/sanitizer_common/tests/sanitizer_ring_buffer_test.cpp

CompactRingBuffer<T> *AllocCompactRingBuffer(size_t count) {
   void *p = MmapAlignedOrDieOnFatalError(sz, sz * 2, "CompactRingBuffer");
   return new CompactRingBuffer<T>(p, sz);
 }
 
 TEST(CompactRingBuffer, int64) {
   const size_t page_sizes[] = {1, 2, 4, 128};
 
   for (size_t pages : page_sizes) {
-    size_t count = 4096 * pages / sizeof(int64_t);
+    size_t count = GetPageSizeCached() * pages / sizeof(int64_t);
     auto R = AllocCompactRingBuffer<int64_t>(count);
     int64_t top = count * 3 + 13;
     for (int64_t i = 0; i < top; ++i) R->push(i);
     for (int64_t i = 0; i < (int64_t)count; ++i)
       EXPECT_EQ(top - i - 1, (*R)[i]);
   }
 }
 #endif
 }  // namespace __sanitizer