compiler-rt/lib/asan/tests/asan_fake_stack_test.cpp

   1 //===-- asan_fake_stack_test.cpp ------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file is a part of AddressSanitizer, an address sanity checker.
  10 //
  11 // Tests for FakeStack.
  12 // This test file should be compiled w/o asan instrumentation.
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "asan_fake_stack.h"
  16 #include "asan_test_utils.h"
  17 #include "sanitizer_common/sanitizer_common.h"
  18
  19 #include <assert.h>
  20 #include <stdlib.h>
  21 #include <stdio.h>
  22
  23 #include <map>
  24
  25 namespace __asan {
  26
  27 TEST(FakeStack, FlagsSize) {
  28   EXPECT_EQ(FakeStack::SizeRequiredForFlags(10), 1U << 5);
  29   EXPECT_EQ(FakeStack::SizeRequiredForFlags(11), 1U << 6);
  30   EXPECT_EQ(FakeStack::SizeRequiredForFlags(20), 1U << 15);
  31 }
  32
  33 TEST(FakeStack, RequiredSize) {
  34   // for (int i = 15; i < 20; i++) {
  35   //  uptr alloc_size = FakeStack::RequiredSize(i);
  36   //  printf("%zdK ==> %zd\n", 1 << (i - 10), alloc_size);
  37   // }
  38   EXPECT_EQ(FakeStack::RequiredSize(15), 365568U);
  39   EXPECT_EQ(FakeStack::RequiredSize(16), 727040U);
  40   EXPECT_EQ(FakeStack::RequiredSize(17), 1449984U);
  41   EXPECT_EQ(FakeStack::RequiredSize(18), 2895872U);
  42   EXPECT_EQ(FakeStack::RequiredSize(19), 5787648U);
  43 }
  44
  45 TEST(FakeStack, FlagsOffset) {
  46   for (uptr stack_size_log = 15; stack_size_log <= 20; stack_size_log++) {
  47     uptr stack_size = 1UL << stack_size_log;
  48     uptr offset = 0;
  49     for (uptr class_id = 0; class_id < FakeStack::kNumberOfSizeClasses;
  50          class_id++) {
  51       uptr frame_size = FakeStack::BytesInSizeClass(class_id);
  52       uptr num_flags = stack_size / frame_size;
  53       EXPECT_EQ(offset, FakeStack::FlagsOffset(stack_size_log, class_id));
  54       // printf("%zd: %zd => %zd %zd\n", stack_size_log, class_id, offset,
  55       //        FakeStack::FlagsOffset(stack_size_log, class_id));
  56       offset += num_flags;
  57     }
  58   }
  59 }
  60
  61 #if !defined(_WIN32)  // FIXME: Fails due to OOM on Windows.
  62 TEST(FakeStack, CreateDestroy) {
  63   for (int i = 0; i < 1000; i++) {
  64     for (uptr stack_size_log = 20; stack_size_log <= 22; stack_size_log++) {
  65       FakeStack *fake_stack = FakeStack::Create(stack_size_log);
  66       fake_stack->Destroy(0);
  67     }
  68   }
  69 }
  70 #endif
  71
  72 TEST(FakeStack, ModuloNumberOfFrames) {
  73   EXPECT_EQ(FakeStack::ModuloNumberOfFrames(15, 0, 0), 0U);
  74   EXPECT_EQ(FakeStack::ModuloNumberOfFrames(15, 0, (1<<15)), 0U);
  75   EXPECT_EQ(FakeStack::ModuloNumberOfFrames(15, 0, (1<<10)), 0U);
  76   EXPECT_EQ(FakeStack::ModuloNumberOfFrames(15, 0, (1<<9)), 0U);
  77   EXPECT_EQ(FakeStack::ModuloNumberOfFrames(15, 0, (1<<8)), 1U<<8);
  78   EXPECT_EQ(FakeStack::ModuloNumberOfFrames(15, 0, (1<<15) + 1), 1U);
  79
  80   EXPECT_EQ(FakeStack::ModuloNumberOfFrames(15, 1, 0), 0U);
  81   EXPECT_EQ(FakeStack::ModuloNumberOfFrames(15, 1, 1<<9), 0U);
  82   EXPECT_EQ(FakeStack::ModuloNumberOfFrames(15, 1, 1<<8), 0U);
  83   EXPECT_EQ(FakeStack::ModuloNumberOfFrames(15, 1, 1<<7), 1U<<7);
  84
  85   EXPECT_EQ(FakeStack::ModuloNumberOfFrames(15, 5, 0), 0U);
  86   EXPECT_EQ(FakeStack::ModuloNumberOfFrames(15, 5, 1), 1U);
  87   EXPECT_EQ(FakeStack::ModuloNumberOfFrames(15, 5, 15), 15U);
  88   EXPECT_EQ(FakeStack::ModuloNumberOfFrames(15, 5, 16), 0U);
  89   EXPECT_EQ(FakeStack::ModuloNumberOfFrames(15, 5, 17), 1U);
  90 }
  91
  92 TEST(FakeStack, GetFrame) {
  93   const uptr stack_size_log = 20;
  94   const uptr stack_size = 1 << stack_size_log;
  95   FakeStack *fs = FakeStack::Create(stack_size_log);
  96   u8 *base = fs->GetFrame(stack_size_log, 0, 0);
  97   EXPECT_EQ(base, reinterpret_cast<u8 *>(fs) +
  98                       fs->SizeRequiredForFlags(stack_size_log) + 4096);
  99   EXPECT_EQ(base + 0*stack_size + 64 * 7, fs->GetFrame(stack_size_log, 0, 7U));
 100   EXPECT_EQ(base + 1*stack_size + 128 * 3, fs->GetFrame(stack_size_log, 1, 3U));
 101   EXPECT_EQ(base + 2*stack_size + 256 * 5, fs->GetFrame(stack_size_log, 2, 5U));
 102   fs->Destroy(0);
 103 }
 104
 105 TEST(FakeStack, Allocate) {
 106   const uptr stack_size_log = 19;
 107   FakeStack *fs = FakeStack::Create(stack_size_log);
 108   std::map<FakeFrame *, uptr> s;
 109   for (int iter = 0; iter < 2; iter++) {
 110     s.clear();
 111     for (uptr cid = 0; cid < FakeStack::kNumberOfSizeClasses; cid++) {
 112       uptr n = FakeStack::NumberOfFrames(stack_size_log, cid);
 113       uptr bytes_in_class = FakeStack::BytesInSizeClass(cid);
 114       for (uptr j = 0; j < n; j++) {
 115         FakeFrame *ff = fs->Allocate(stack_size_log, cid, 0);
 116         uptr x = reinterpret_cast<uptr>(ff);
 117         EXPECT_TRUE(s.insert(std::make_pair(ff, cid)).second);
 118         EXPECT_EQ(x, fs->AddrIsInFakeStack(x));
 119         EXPECT_EQ(x, fs->AddrIsInFakeStack(x + 1));
 120         EXPECT_EQ(x, fs->AddrIsInFakeStack(x + bytes_in_class - 1));
 121         EXPECT_NE(x, fs->AddrIsInFakeStack(x + bytes_in_class));
 122       }
 123       // We are out of fake stack, so Allocate should return 0.
 124       EXPECT_EQ(0UL, fs->Allocate(stack_size_log, cid, 0));
 125     }
 126     for (std::map<FakeFrame *, uptr>::iterator it = s.begin(); it != s.end();
 127          ++it) {
 128       fs->Deallocate(reinterpret_cast<uptr>(it->first), it->second);
 129     }
 130   }
 131   fs->Destroy(0);
 132 }
 133
 134 static void RecursiveFunction(FakeStack *fs, int depth) {
 135   uptr class_id = depth / 3;
 136   FakeFrame *ff = fs->Allocate(fs->stack_size_log(), class_id, 0);
 137   if (depth) {
 138     RecursiveFunction(fs, depth - 1);
 139     RecursiveFunction(fs, depth - 1);
 140   }
 141   fs->Deallocate(reinterpret_cast<uptr>(ff), class_id);
 142 }
 143
 144 TEST(FakeStack, RecursiveStressTest) {
 145   const uptr stack_size_log = 16;
 146   FakeStack *fs = FakeStack::Create(stack_size_log);
 147   RecursiveFunction(fs, 22);  // with 26 runs for 2-3 seconds.
 148   fs->Destroy(0);
 149 }
 150
 151 }  // namespace __asan