[ASan] Kill use_stack_depot runtime flag and stack trace compression routines.

git-svn-id: https://llvm.org/svn/llvm-project/compiler-rt/trunk@193868 91177308-0d34-0410-b5e6-96231b3b80d8

6 files changed, 4 insertions, 280 deletions

diff --git a/lib/asan/asan_allocator2.cc b/lib/asan/asan_allocator2.cc
index d6d7d94d..4b2afb6f 100644
--- a/lib/asan/asan_allocator2.cc
+++ b/lib/asan/asan_allocator2.cc
@@ -241,19 +241,11 @@ static void GetStackTraceFromId(u32 id, StackTrace *stack) {
 }
 
 void AsanChunkView::GetAllocStack(StackTrace *stack) {
-  if (flags()->use_stack_depot)
-    GetStackTraceFromId(chunk_->alloc_context_id, stack);
-  else
-    StackTrace::UncompressStack(stack, chunk_->AllocStackBeg(),
-                                chunk_->AllocStackSize());
+  GetStackTraceFromId(chunk_->alloc_context_id, stack);
 }
 
 void AsanChunkView::GetFreeStack(StackTrace *stack) {
-  if (flags()->use_stack_depot)
-    GetStackTraceFromId(chunk_->free_context_id, stack);
-  else
-    StackTrace::UncompressStack(stack, chunk_->FreeStackBeg(),
-                                chunk_->FreeStackSize());
+  GetStackTraceFromId(chunk_->free_context_id, stack);
 }
 
 struct QuarantineCallback;
@@ -399,12 +391,7 @@ static void *Allocate(uptr size, uptr alignment, StackTrace *stack,
     meta[1] = chunk_beg;
   }
 
-  if (fl.use_stack_depot) {
-    m->alloc_context_id = StackDepotPut(stack->trace, stack->size);
-  } else {
-    m->alloc_context_id = 0;
-    StackTrace::CompressStack(stack, m->AllocStackBeg(), m->AllocStackSize());
-  }
+  m->alloc_context_id = StackDepotPut(stack->trace, stack->size);
 
   uptr size_rounded_down_to_granularity = RoundDownTo(size, SHADOW_GRANULARITY);
   // Unpoison the bulk of the memory region.
@@ -472,12 +459,7 @@ static void QuarantineChunk(AsanChunk *m, void *ptr,
     CHECK_EQ(m->free_tid, kInvalidTid);
   AsanThread *t = GetCurrentThread();
   m->free_tid = t ? t->tid() : 0;
-  if (flags()->use_stack_depot) {
-    m->free_context_id = StackDepotPut(stack->trace, stack->size);
-  } else {
-    m->free_context_id = 0;
-    StackTrace::CompressStack(stack, m->FreeStackBeg(), m->FreeStackSize());
-  }
+  m->free_context_id = StackDepotPut(stack->trace, stack->size);
   // Poison the region.
   PoisonShadow(m->Beg(),
                RoundUpTo(m->UsedSize(), SHADOW_GRANULARITY),
diff --git a/lib/asan/asan_flags.h b/lib/asan/asan_flags.h
index 735628d7..86eb3b6c 100644
--- a/lib/asan/asan_flags.h
+++ b/lib/asan/asan_flags.h
@@ -101,8 +101,6 @@ struct Flags {
   bool poison_partial;
   // Report errors on malloc/delete, new/free, new/delete[], etc.
   bool alloc_dealloc_mismatch;
-  // Use stack depot instead of storing stacks in the redzones.
-  bool use_stack_depot;
   // If true, assume that memcmp(p1, p2, n) always reads n bytes before
   // comparing p1 and p2.
   bool strict_memcmp;
diff --git a/lib/asan/asan_rtl.cc b/lib/asan/asan_rtl.cc
index 93033f97..a202abe4 100644
--- a/lib/asan/asan_rtl.cc
+++ b/lib/asan/asan_rtl.cc
@@ -126,7 +126,6 @@ static void ParseFlagsFromString(Flags *f, const char *str) {
   ParseFlag(str, &f->poison_heap, "poison_heap");
   ParseFlag(str, &f->poison_partial, "poison_partial");
   ParseFlag(str, &f->alloc_dealloc_mismatch, "alloc_dealloc_mismatch");
-  ParseFlag(str, &f->use_stack_depot, "use_stack_depot");
   ParseFlag(str, &f->strict_memcmp, "strict_memcmp");
   ParseFlag(str, &f->strict_init_order, "strict_init_order");
 }
@@ -177,7 +176,6 @@ void InitializeFlags(Flags *f, const char *env) {
   // Turn off alloc/dealloc mismatch checker on Mac and Windows for now.
   // TODO(glider,timurrrr): Fix known issues and enable this back.
   f->alloc_dealloc_mismatch = (SANITIZER_MAC == 0) && (SANITIZER_WINDOWS == 0);
-  f->use_stack_depot = true;
   f->strict_memcmp = true;
   f->strict_init_order = false;
 
@@ -201,12 +199,6 @@ void InitializeFlags(Flags *f, const char *env) {
     cf->detect_leaks = false;
   }
 #endif
-
-  if (cf->detect_leaks && !f->use_stack_depot) {
-    Report("%s: detect_leaks is ignored (requires use_stack_depot).\n",
-           SanitizerToolName);
-    cf->detect_leaks = false;
-  }
 }
 
 // -------------------------- Globals --------------------- {{{1
diff --git a/lib/asan/tests/asan_noinst_test.cc b/lib/asan/tests/asan_noinst_test.cc
index b170314a..4c67d685 100644
--- a/lib/asan/tests/asan_noinst_test.cc
+++ b/lib/asan/tests/asan_noinst_test.cc
@@ -159,144 +159,6 @@ TEST(AddressSanitizer, DISABLED_InternalPrintShadow) {
   }
 }
 
-static uptr pc_array[] = {
-#if SANITIZER_WORDSIZE == 64
-  0x7effbf756068ULL,
-  0x7effbf75e5abULL,
-  0x7effc0625b7cULL,
-  0x7effc05b8997ULL,
-  0x7effbf990577ULL,
-  0x7effbf990c56ULL,
-  0x7effbf992f3cULL,
-  0x7effbf950c22ULL,
-  0x7effc036dba0ULL,
-  0x7effc03638a3ULL,
-  0x7effc035be4aULL,
-  0x7effc0539c45ULL,
-  0x7effc0539a65ULL,
-  0x7effc03db9b3ULL,
-  0x7effc03db100ULL,
-  0x7effc037c7b8ULL,
-  0x7effc037bfffULL,
-  0x7effc038b777ULL,
-  0x7effc038021cULL,
-  0x7effc037c7d1ULL,
-  0x7effc037bfffULL,
-  0x7effc038b777ULL,
-  0x7effc038021cULL,
-  0x7effc037c7d1ULL,
-  0x7effc037bfffULL,
-  0x7effc038b777ULL,
-  0x7effc038021cULL,
-  0x7effc037c7d1ULL,
-  0x7effc037bfffULL,
-  0x7effc0520d26ULL,
-  0x7effc009ddffULL,
-  0x7effbf90bb50ULL,
-  0x7effbdddfa69ULL,
-  0x7effbdde1fe2ULL,
-  0x7effbdde2424ULL,
-  0x7effbdde27b3ULL,
-  0x7effbddee53bULL,
-  0x7effbdde1988ULL,
-  0x7effbdde0904ULL,
-  0x7effc106ce0dULL,
-  0x7effbcc3fa04ULL,
-  0x7effbcc3f6a4ULL,
-  0x7effbcc3e726ULL,
-  0x7effbcc40852ULL,
-  0x7effb681ec4dULL,
-#endif  // SANITIZER_WORDSIZE
-  0xB0B5E768,
-  0x7B682EC1,
-  0x367F9918,
-  0xAE34E13,
-  0xBA0C6C6,
-  0x13250F46,
-  0xA0D6A8AB,
-  0x2B07C1A8,
-  0x6C844F4A,
-  0x2321B53,
-  0x1F3D4F8F,
-  0x3FE2924B,
-  0xB7A2F568,
-  0xBD23950A,
-  0x61020930,
-  0x33E7970C,
-  0x405998A1,
-  0x59F3551D,
-  0x350E3028,
-  0xBC55A28D,
-  0x361F3AED,
-  0xBEAD0F73,
-  0xAEF28479,
-  0x757E971F,
-  0xAEBA450,
-  0x43AD22F5,
-  0x8C2C50C4,
-  0x7AD8A2E1,
-  0x69EE4EE8,
-  0xC08DFF,
-  0x4BA6538,
-  0x3708AB2,
-  0xC24B6475,
-  0x7C8890D7,
-  0x6662495F,
-  0x9B641689,
-  0xD3596B,
-  0xA1049569,
-  0x44CBC16,
-  0x4D39C39F
-};
-
-void CompressStackTraceTest(size_t n_iter) {
-  u32 seed = my_rand();
-  const size_t kNumPcs = ARRAY_SIZE(pc_array);
-  u32 compressed[2 * kNumPcs];
-
-  for (size_t iter = 0; iter < n_iter; iter++) {
-    std::random_shuffle(pc_array, pc_array + kNumPcs);
-    StackTrace stack0, stack1;
-    stack0.CopyFrom(pc_array, kNumPcs);
-    stack0.size = std::max((size_t)1, (size_t)(my_rand_r(&seed) % stack0.size));
-    size_t compress_size =
-      std::max((size_t)2, (size_t)my_rand_r(&seed) % (2 * kNumPcs));
-    size_t n_frames =
-      StackTrace::CompressStack(&stack0, compressed, compress_size);
-    Ident(n_frames);
-    assert(n_frames <= stack0.size);
-    StackTrace::UncompressStack(&stack1, compressed, compress_size);
-    assert(stack1.size == n_frames);
-    for (size_t i = 0; i < stack1.size; i++) {
-      assert(stack0.trace[i] == stack1.trace[i]);
-    }
-  }
-}
-
-TEST(AddressSanitizer, CompressStackTraceTest) {
-  CompressStackTraceTest(10000);
-}
-
-void CompressStackTraceBenchmark(size_t n_iter) {
-  const size_t kNumPcs = ARRAY_SIZE(pc_array);
-  u32 compressed[2 * kNumPcs];
-  std::random_shuffle(pc_array, pc_array + kNumPcs);
-
-  StackTrace stack0;
-  stack0.CopyFrom(pc_array, kNumPcs);
-  stack0.size = kNumPcs;
-  for (size_t iter = 0; iter < n_iter; iter++) {
-    size_t compress_size = kNumPcs;
-    size_t n_frames =
-      StackTrace::CompressStack(&stack0, compressed, compress_size);
-    Ident(n_frames);
-  }
-}
-
-TEST(AddressSanitizer, CompressStackTraceBenchmark) {
-  CompressStackTraceBenchmark(1 << 24);
-}
-
 TEST(AddressSanitizer, QuarantineTest) {
   StackTrace stack;
   stack.trace[0] = 0x890;
diff --git a/lib/sanitizer_common/sanitizer_stacktrace.cc b/lib/sanitizer_common/sanitizer_stacktrace.cc
index d01e26b0..a110774e 100644
--- a/lib/sanitizer_common/sanitizer_stacktrace.cc
+++ b/lib/sanitizer_common/sanitizer_stacktrace.cc
@@ -147,109 +147,4 @@ void StackTrace::PopStackFrames(uptr count) {
   }
 }
 
-// On 32-bits we don't compress stack traces.
-// On 64-bits we compress stack traces: if a given pc differes slightly from
-// the previous one, we record a 31-bit offset instead of the full pc.
-uptr StackTrace::CompressStack(StackTrace *stack, u32 *compressed, uptr size) {
-#if SANITIZER_WORDSIZE == 32
-  // Don't compress, just copy.
-  uptr res = 0;
-  for (uptr i = 0; i < stack->size && i < size; i++) {
-    compressed[i] = stack->trace[i];
-    res++;
-  }
-  if (stack->size < size)
-    compressed[stack->size] = 0;
-#else  // 64 bits, compress.
-  uptr prev_pc = 0;
-  const uptr kMaxOffset = (1ULL << 30) - 1;
-  uptr c_index = 0;
-  uptr res = 0;
-  for (uptr i = 0, n = stack->size; i < n; i++) {
-    uptr pc = stack->trace[i];
-    if (!pc) break;
-    if ((s64)pc < 0) break;
-    // Printf("C pc[%zu] %zx\n", i, pc);
-    if (prev_pc - pc < kMaxOffset || pc - prev_pc < kMaxOffset) {
-      uptr offset = (s64)(pc - prev_pc);
-      offset |= (1U << 31);
-      if (c_index >= size) break;
-      // Printf("C co[%zu] offset %zx\n", i, offset);
-      compressed[c_index++] = offset;
-    } else {
-      uptr hi = pc >> 32;
-      uptr lo = (pc << 32) >> 32;
-      CHECK_EQ((hi & (1 << 31)), 0);
-      if (c_index + 1 >= size) break;
-      // Printf("C co[%zu] hi/lo: %zx %zx\n", c_index, hi, lo);
-      compressed[c_index++] = hi;
-      compressed[c_index++] = lo;
-    }
-    res++;
-    prev_pc = pc;
-  }
-  if (c_index < size)
-    compressed[c_index] = 0;
-  if (c_index + 1 < size)
-    compressed[c_index + 1] = 0;
-#endif  // SANITIZER_WORDSIZE
-
-  // debug-only code
-#if 0
-  StackTrace check_stack;
-  UncompressStack(&check_stack, compressed, size);
-  if (res < check_stack.size) {
-    Printf("res %zu check_stack.size %zu; c_size %zu\n", res,
-           check_stack.size, size);
-  }
-  // |res| may be greater than check_stack.size, because
-  // UncompressStack(CompressStack(stack)) eliminates the 0x0 frames.
-  CHECK(res >= check_stack.size);
-  CHECK_EQ(0, REAL(memcmp)(check_stack.trace, stack->trace,
-                          check_stack.size * sizeof(uptr)));
-#endif
-
-  return res;
-}
-
-void StackTrace::UncompressStack(StackTrace *stack,
-                                 u32 *compressed, uptr size) {
-#if SANITIZER_WORDSIZE == 32
-  // Don't uncompress, just copy.
-  stack->size = 0;
-  for (uptr i = 0; i < size && i < kStackTraceMax; i++) {
-    if (!compressed[i]) break;
-    stack->size++;
-    stack->trace[i] = compressed[i];
-  }
-#else  // 64 bits, uncompress
-  uptr prev_pc = 0;
-  stack->size = 0;
-  for (uptr i = 0; i < size && stack->size < kStackTraceMax; i++) {
-    u32 x = compressed[i];
-    uptr pc = 0;
-    if (x & (1U << 31)) {
-      // Printf("U co[%zu] offset: %x\n", i, x);
-      // this is an offset
-      s32 offset = x;
-      offset = (offset << 1) >> 1;  // remove the 31-byte and sign-extend.
-      pc = prev_pc + offset;
-      CHECK(pc);
-    } else {
-      // CHECK(i + 1 < size);
-      if (i + 1 >= size) break;
-      uptr hi = x;
-      uptr lo = compressed[i+1];
-      // Printf("U co[%zu] hi/lo: %zx %zx\n", i, hi, lo);
-      i++;
-      pc = (hi << 32) | lo;
-      if (!pc) break;
-    }
-    // Printf("U pc[%zu] %zx\n", stack->size, pc);
-    stack->trace[stack->size++] = pc;
-    prev_pc = pc;
-  }
-#endif  // SANITIZER_WORDSIZE
-}
-
 }  // namespace __sanitizer
diff --git a/lib/sanitizer_common/sanitizer_stacktrace.h b/lib/sanitizer_common/sanitizer_stacktrace.h
index 8c55397f..7c6a25cc 100644
--- a/lib/sanitizer_common/sanitizer_stacktrace.h
+++ b/lib/sanitizer_common/sanitizer_stacktrace.h
@@ -56,11 +56,6 @@ struct StackTrace {
 
   static uptr GetCurrentPc();
   static uptr GetPreviousInstructionPc(uptr pc);
-
-  static uptr CompressStack(StackTrace *stack,
-                            u32 *compressed, uptr size);
-  static void UncompressStack(StackTrace *stack,
-                              u32 *compressed, uptr size);
 };
 
 }  // namespace __sanitizer