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