[msan] Don't hardcode 4kiB page size in msan_test.cc.

[• koriakin]

Summary

This breaks the valloc test on PowerPC, which has 64kiB pages. Since
getting page size portably is nontrivial, and there's already a function
for that in __sanitizer, just use it. Unfortunately, sanitizer_common.h
conflicts with the interface headers inclucded by msan_test.cc (and a few
of its own macros), so we have to declare it manually.

[eugenis]

LGTM

[eugenis]

Unfortunately, this fails if this code is built as a shared library.
__sanitizer::* symbols are not exported by MSan.
It looks like sysconf(_SC_PAGESIZE) should work on all supported platforms. I'll make the change.

[eugenis]

fixed in r266910

compiler-rt/trunk/lib/msan/tests/msan_test.cc

 #else
 # define FILE_TO_READ "/proc/self/stat"
 # define DIR_TO_READ "/proc/self"
 # define SUBFILE_TO_READ "stat"
 # define SYMLINK_TO_READ "/proc/self/exe"
 # define SUPERUSER_GROUP "root"
 #endif
 
-const size_t kPageSize = 4096;
+// We cannot include sanitizer_common.h (it conflicts with public interface
+// headers), so just pull this function directly.
+
+namespace __sanitizer {
+uintptr_t GetPageSizeCached();
+}
+using __sanitizer::GetPageSizeCached;
+
 const size_t kMaxPathLength = 4096;
 
 typedef unsigned char      U1;
 typedef unsigned short     U2;  // NOLINT
 typedef unsigned int       U4;
 typedef unsigned long long U8;  // NOLINT
 typedef   signed char      S1;
 typedef   signed short     S2;  // NOLINT
TEST(MemorySanitizer, posix_memalign) {
   EXPECT_EQ(0U, (uintptr_t)p % 4096);
   free(p);
 }
 
 // There's no memalign() on FreeBSD.
 #if !defined(__FreeBSD__)
 TEST(MemorySanitizer, memalign) {
   void *p = memalign(4096, 13);
-  EXPECT_EQ(0U, (uintptr_t)p % kPageSize);
+  EXPECT_EQ(0U, (uintptr_t)p % 4096);
   free(p);
 }
 #endif
 
 TEST(MemorySanitizer, valloc) {
   void *a = valloc(100);
-  EXPECT_EQ(0U, (uintptr_t)a % kPageSize);
+  uintptr_t PageSize = GetPageSizeCached();
+  EXPECT_EQ(0U, (uintptr_t)a % PageSize);
   free(a);
 }
 
 // There's no pvalloc() on FreeBSD.
 #if !defined(__FreeBSD__)
 TEST(MemorySanitizer, pvalloc) {
-  void *p = pvalloc(kPageSize + 100);
-  EXPECT_EQ(0U, (uintptr_t)p % kPageSize);
-  EXPECT_EQ(2 * kPageSize, __sanitizer_get_allocated_size(p));
+  uintptr_t PageSize = GetPageSizeCached();
+  void *p = pvalloc(PageSize + 100);
+  EXPECT_EQ(0U, (uintptr_t)p % PageSize);
+  EXPECT_EQ(2 * PageSize, __sanitizer_get_allocated_size(p));
   free(p);
 
   p = pvalloc(0);  // pvalloc(0) should allocate at least one page.
-  EXPECT_EQ(0U, (uintptr_t)p % kPageSize);
-  EXPECT_EQ(kPageSize, __sanitizer_get_allocated_size(p));
+  EXPECT_EQ(0U, (uintptr_t)p % PageSize);
+  EXPECT_EQ(PageSize, __sanitizer_get_allocated_size(p));
   free(p);
 }
 #endif
 
 TEST(MemorySanitizer, inet_pton) {
   const char *s = "1:0:0:0:0:0:0:8";
   unsigned char buf[sizeof(struct in6_addr)];
   int res = inet_pton(AF_INET6, s, buf);