[asan] Enable back some ASan tests disabled on PowerPC.

[alekseyshl]

Summary

D33521 addressed a memory ordering issue in BlockingMutex, which seems
to be the cause of a flakiness of a few ASan tests on PowerPC.

[eugenis]

LGTM, nice.

lib/asan/tests/asan_interface_test.cc

TEST(AddressSanitizerInterface, GetHeapSizeTest) {
   size_t old_heap_size = __sanitizer_get_heap_size();
   for (int i = 0; i < 3; i++) {
     // fprintf(stderr, "allocating %zu bytes:\n", kLargeMallocSize);
     free(Ident(malloc(kLargeMallocSize)));
     EXPECT_EQ(old_heap_size, __sanitizer_get_heap_size());
   }
 }
 
-#ifndef __powerpc64__
-// FIXME: This has not reliably worked on powerpc since r279664.  Re-enable
-// this once the problem is tracked down and fixed.
 static const size_t kManyThreadsMallocSizes[] = {5, 1UL<<10, 1UL<<14, 357};
 static const size_t kManyThreadsIterations = 250;
 static const size_t kManyThreadsNumThreads =
   (SANITIZER_WORDSIZE == 32) ? 40 : 200;
 
 static void *ManyThreadsWithStatsWorker(void *arg) {
   (void)arg;
   for (size_t iter = 0; iter < kManyThreadsIterations; iter++) {
TEST(AddressSanitizerInterface, ManyThreadsWithStatsStressTest) {
   for (i = 0; i < kManyThreadsNumThreads; i++) {
     PTHREAD_JOIN(threads[i], 0);
   }
   after_test = __sanitizer_get_current_allocated_bytes();
   // ASan stats also reflect memory usage of internal ASan RTL structs,
   // so we can't check for equality here.
   EXPECT_LT(after_test, before_test + (1UL<<20));
 }
-#endif
 
 static void DoDoubleFree() {
   int *x = Ident(new int);
   delete Ident(x);
   delete Ident(x);
 }
 
 static void MyDeathCallback() {

lib/asan/tests/asan_noinst_test.cc

for (size_t i = 0; i < vec.size(); i++)
     __asan::asan_free(vec[i], &stack3, __asan::FROM_MALLOC);
 }
 
 
 TEST(AddressSanitizer, NoInstMallocTest) {
   MallocStress(ASAN_LOW_MEMORY ? 300000 : 1000000);
 }
 
-#ifndef __powerpc64__
-// FIXME: This has not reliably worked on powerpc since r279664.  Re-enable
-// this once the problem is tracked down and fixed.
 TEST(AddressSanitizer, ThreadedMallocStressTest) {
   const int kNumThreads = 4;
   const int kNumIterations = (ASAN_LOW_MEMORY) ? 10000 : 100000;
   pthread_t t[kNumThreads];
   for (int i = 0; i < kNumThreads; i++) {
     PTHREAD_CREATE(&t[i], 0, (void* (*)(void *x))MallocStress,
         (void*)kNumIterations);
   }
   for (int i = 0; i < kNumThreads; i++) {
     PTHREAD_JOIN(t[i], 0);
   }
 }
-#endif
 
 static void PrintShadow(const char *tag, uptr ptr, size_t size) {
   fprintf(stderr, "%s shadow: %lx size % 3ld: ", tag, (long)ptr, (long)size);
   uptr prev_shadow = 0;
   for (sptr i = -32; i < (sptr)size + 32; i++) {
     uptr shadow = __asan::MemToShadow(ptr + i);
     if (i == 0 || i == (sptr)size)
       fprintf(stderr, ".");
for (int iter = 0; iter < 1000; iter++) {
     }
     for (size_t i = 0; i < kNumMallocs; i++) {
       __asan::asan_free(p[i], &stack, __asan::FROM_MALLOC);
     }
   }
   return NULL;
 }
 
-#ifndef __powerpc64__
-// FIXME: This has not reliably worked on powerpc since r279664.  Re-enable
-// this once the problem is tracked down and fixed.
-
 TEST(AddressSanitizer, ThreadedOneSizeMallocStressTest) {
   const int kNumThreads = 4;
   pthread_t t[kNumThreads];
   for (int i = 0; i < kNumThreads; i++) {
     PTHREAD_CREATE(&t[i], 0, ThreadedOneSizeMallocStress, 0);
   }
   for (int i = 0; i < kNumThreads; i++) {
     PTHREAD_JOIN(t[i], 0);
   }
 }
-#endif
 
 TEST(AddressSanitizer, ShadowRegionIsPoisonedTest) {
   using __asan::kHighMemEnd;
   // Check that __asan_region_is_poisoned works for shadow regions.
   uptr ptr = kLowShadowBeg + 200;
   EXPECT_EQ(ptr, __asan_region_is_poisoned(ptr, 100));
   ptr = kShadowGapBeg + 200;
   EXPECT_EQ(ptr, __asan_region_is_poisoned(ptr, 100));

test/asan/TestCases/Posix/current_allocated_bytes.cc

 // RUN: %clangxx_asan -O0 %s -pthread -o %t && %run %t
 // RUN: %clangxx_asan -O2 %s -pthread -o %t && %run %t
 // REQUIRES: stable-runtime
-// UNSUPPORTED: powerpc64le
-// FIXME: This test occasionally fails on powerpc64 LE possibly starting with
-// r279664.  Re-enable the test once the problem(s) have been fixed.
 
 #include <assert.h>
 #include <pthread.h>
 #include <sanitizer/allocator_interface.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 const size_t kLargeAlloc = 1UL << 20;