Vendor import of compiler-rt trunk r300422:vendor/compiler-rt/compiler-rt-trunk-r300422

https://llvm.org/svn/llvm-project/compiler-rt/trunk@300422

1 files changed, 36 insertions, 22 deletions

diff --git a/test/scudo/quarantine.cpp b/test/scudo/quarantine.cpp
index 4ce0197acdec..39ce1bd91d31 100644
--- a/test/scudo/quarantine.cpp
+++ b/test/scudo/quarantine.cpp
@@ -1,43 +1,57 @@
 // RUN: %clang_scudo %s -o %t
-// RUN: SCUDO_OPTIONS=QuarantineSizeMb=1 %run %t 2>&1
+// RUN: SCUDO_OPTIONS="QuarantineSizeMb=0:ThreadLocalQuarantineSizeKb=0" %run %t zeroquarantine 2>&1
+// RUN: SCUDO_OPTIONS=QuarantineSizeMb=1                                 %run %t smallquarantine 2>&1
 
 // Tests that the quarantine prevents a chunk from being reused right away.
 // Also tests that a chunk will eventually become available again for
 // allocation when the recycling criteria has been met.
 
+#include <assert.h>
 #include <malloc.h>
 #include <stdlib.h>
 #include <string.h>
 
+#include <sanitizer/allocator_interface.h>
+
 int main(int argc, char **argv)
 {
   void *p, *old_p;
-  size_t size = 1U << 16;
+  size_t allocated_bytes, size = 1U << 16;
 
-  // The delayed freelist will prevent a chunk from being available right away
-  p = malloc(size);
-  if (!p)
-    return 1;
-  old_p = p;
-  free(p);
-  p = malloc(size);
-  if (!p)
-    return 1;
-  if (old_p == p)
-    return 1;
-  free(p);
+  assert(argc == 2);
 
-  // Eventually the chunk should become available again
-  bool found = false;
-  for (int i = 0; i < 0x100 && found == false; i++) {
+  if (!strcmp(argv[1], "zeroquarantine")) {
+    // Verifies that a chunk is deallocated right away when the local and
+    // global quarantine sizes are 0.
+    allocated_bytes = __sanitizer_get_current_allocated_bytes();
+    p = malloc(size);
+    assert(p);
+    assert(__sanitizer_get_current_allocated_bytes() > allocated_bytes);
+    free(p);
+    assert(__sanitizer_get_current_allocated_bytes() == allocated_bytes);
+  }
+  if (!strcmp(argv[1], "smallquarantine")) {
+    // The delayed freelist will prevent a chunk from being available right
+    // away.
     p = malloc(size);
-    if (!p)
-      return 1;
-    found = (p == old_p);
+    assert(p);
+    old_p = p;
     free(p);
+    p = malloc(size);
+    assert(p);
+    assert(old_p != p);
+    free(p);
+
+    // Eventually the chunk should become available again.
+    bool found = false;
+    for (int i = 0; i < 0x100 && found == false; i++) {
+      p = malloc(size);
+      assert(p);
+      found = (p == old_p);
+      free(p);
+    }
+    assert(found == true);
   }
-  if (found == false)
-    return 1;
 
   return 0;
 }