[sanitizer_common][test] Disable CombinedAllocator32Compact etc. on Solaris/sparcv9

[ro]

Summary

As reported in PR 48202, two allocator tests FAIL on Solaris/sparcv9, presumably because Solaris uses the full 64-bit address space and the allocator cannot deal with that:

SanitizerCommon-Unit :: ./Sanitizer-sparcv9-Test/SanitizerCommon.CombinedAllocator32Compact
SanitizerCommon-Unit :: ./Sanitizer-sparcv9-Test/SanitizerCommon.SizeClassAllocator32Iteration

This patch disables the tests.

Tested on sparcv9-sun-solaris2.11.

[vitalybuka]

Have you tried to change kAddressSpaceSize above?

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

948

Better approach is to use:

#if defined(_MSC_VER) && defined(_DLL)
#define MAYBE_StrDupOOBTest DISABLED_StrDupOOBTest
#else
#define MAYBE_StrDupOOBTest StrDupOOBTest
#endif

TEST(AddressSanitizer, MAYBE_StrDupOOBTest) {

this way the test at least compiles on the platform.

But it's going to make the file inconsistent.
So you like you can update the file with MAYBE_ in a separate patch.
But feel free to keep as-is.

[ro]

In D91622#2400952, @vitalybuka wrote:

Have you tried to change kAddressSpaceSize above?

Not yet: TBH I was quite confused by how target-specific configuration was sprinkled over both the allocator implementation (where I'd expect it) and the allocator test (where I wouldn't) and how the two interact.

I now gave it a try:

• set SANITIZER_MMAP_RANGE_SIZE for Solaris/sparcv9 to FIRST_32_SECOND_64(1ULL << 32, 0xFFFFFFFFFFFFFFFF)
• keep SANITIZER_SIGN_EXTENDED_ADDRESSES as 0 for Solaris/sparcv9 (IIUC this is only needed/correct on Linux/sparc64 which only uses a low part of the 64-bit address space albeit with the VA hole in the middle just like Solaris)
• set kAddressSpaceSize, keeping the rest as in the default case:

+#elif SANITIZER_SOLARIS && defined(__sparcv9)
+static const uptr kAllocatorSpace = 0x700000000000ULL;
+static const uptr kAllocatorSize  = 0x010000000000ULL;  // 1T.
+static const u64 kAddressSpaceSize = 0xFFFFFFFFFFFFFFFF;
+typedef DefaultSizeClassMap SizeClassMap;

While this allowed Sanitizer-sparcv9-test to compile, both affected tests still FAIL, though in a different way:

  [ RUN      ] SanitizerCommon.SizeClassAllocator32Compact
==15161==Sanitizer CHECK failed: /vol/llvm/src/llvm-project/local/compiler-rt/lib/sanitizer_common/sanitizer_allocator_bytemap.h:69 ((idx)) < ((kSize1 * kSize2)) (1099511627568, 1099511623680)

[ RUN      ] SanitizerCommon.SizeClassAllocator32Iteration
==15162==Sanitizer CHECK failed: /vol/llvm/src/llvm-project/local/compiler-rt/lib/sanitizer_common/sanitizer_allocator_bytemap.h:69 ((idx)) < ((kSize1 * kSize2)) (1099511627644, 1099511623680)

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

948

While I like this approach (I'm effectively doing the same with ASan on SPARC: keep it compiling in compiler-rt for the benefit of gcc where it works, despite being unusable with clang due to a compiler bug/limitation).

However, that's a considerable change and I'm running out of time for LLVM work (GCC just entered stage3 for the GCC 11 release and I'll soon will have to switch attention there), so I'd like to keep my patch as is at least for the moment.

[vitalybuka]

LGTM with some FIXME explaining that it needs investigation in future

[ro]

• Switch disablement to SKIP_ON_* form.
• Add FIXME comment.

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

 #include <stdlib.h>
 #include <algorithm>
 #include <vector>
 #include <random>
 #include <set>
 
 using namespace __sanitizer;
 
+#if SANITIZER_SOLARIS && defined(__sparcv9)
+// FIXME: These tests probably fail because Solaris/sparcv9 uses the full
+// 64-bit address space.  Needs more investigation
+#define SKIP_ON_SOLARIS_SPARCV9(x) DISABLED_##x
+#else
+#define SKIP_ON_SOLARIS_SPARCV9(x) x
+#endif
+
 // Too slow for debug build
 #if !SANITIZER_DEBUG
 
 #if SANITIZER_CAN_USE_ALLOCATOR64
 #if SANITIZER_WINDOWS
 // On Windows 64-bit there is no easy way to find a large enough fixed address
 // space that is always available. Thus, a dynamically allocated address space
 // is used instead (i.e. ~(uptr)0).

 }
 #endif
 
 TEST(SanitizerCommon, CombinedAllocator64VeryCompact) {
   TestCombinedAllocator<Allocator64VeryCompact>();
 }
 #endif
 
-TEST(SanitizerCommon, CombinedAllocator32Compact) {
+TEST(SanitizerCommon, SKIP_ON_SOLARIS_SPARCV9(CombinedAllocator32Compact)) {
   TestCombinedAllocator<Allocator32Compact>();
 }
 
 template <class Allocator>
 void TestSizeClassAllocatorLocalCache() {
   using AllocatorCache = typename Allocator::AllocatorCache;
   AllocatorCache cache;
   Allocator *a = new Allocator();
TEST(SanitizerCommon, SizeClassAllocator64Iteration) {
   TestSizeClassAllocatorIteration<Allocator64>();
 }
 TEST(SanitizerCommon, SizeClassAllocator64DynamicIteration) {
   TestSizeClassAllocatorIteration<Allocator64Dynamic>();
 }
 #endif
 #endif
 
-TEST(SanitizerCommon, SizeClassAllocator32Iteration) {
+TEST(SanitizerCommon, SKIP_ON_SOLARIS_SPARCV9(SizeClassAllocator32Iteration)) {
   TestSizeClassAllocatorIteration<Allocator32Compact>();
 }
 
 TEST(SanitizerCommon, LargeMmapAllocatorIteration) {
   LargeMmapAllocator<NoOpMapUnmapCallback> a;
   a.Init();
   AllocatorStats stats;
   stats.Init();