sanitizer_common_test.cc revision 24323de08fa8850712d56621bff29dbbbd0285a9 
1//===-- sanitizer_common_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 ThreadSanitizer/AddressSanitizer runtime.
11//
12//===----------------------------------------------------------------------===//
13#include "sanitizer_common/sanitizer_common.h"
14#include "sanitizer_common/sanitizer_libc.h"
15#include "gtest/gtest.h"
16
17namespace __sanitizer {
18
19static bool IsSorted(const uptr *array, uptr n) {
20  for (uptr i = 1; i < n; i++) {
21    if (array[i] < array[i - 1]) return false;
22  }
23  return true;
24}
25
26TEST(SanitizerCommon, SortTest) {
27  uptr array[100];
28  uptr n = 100;
29  // Already sorted.
30  for (uptr i = 0; i < n; i++) {
31    array[i] = i;
32  }
33  SortArray(array, n);
34  EXPECT_TRUE(IsSorted(array, n));
35  // Reverse order.
36  for (uptr i = 0; i < n; i++) {
37    array[i] = n - 1 - i;
38  }
39  SortArray(array, n);
40  EXPECT_TRUE(IsSorted(array, n));
41  // Mixed order.
42  for (uptr i = 0; i < n; i++) {
43    array[i] = (i % 2 == 0) ? i : n - 1 - i;
44  }
45  SortArray(array, n);
46  EXPECT_TRUE(IsSorted(array, n));
47  // All equal.
48  for (uptr i = 0; i < n; i++) {
49    array[i] = 42;
50  }
51  SortArray(array, n);
52  EXPECT_TRUE(IsSorted(array, n));
53  // All but one sorted.
54  for (uptr i = 0; i < n - 1; i++) {
55    array[i] = i;
56  }
57  array[n - 1] = 42;
58  SortArray(array, n);
59  EXPECT_TRUE(IsSorted(array, n));
60  // Minimal case - sort three elements.
61  array[0] = 1;
62  array[1] = 0;
63  SortArray(array, 2);
64  EXPECT_TRUE(IsSorted(array, 2));
65}
66
67TEST(SanitizerCommon, MmapAlignedOrDie) {
68  uptr PageSize = GetPageSizeCached();
69  for (uptr size = 1; size <= 32; size *= 2) {
70    for (uptr alignment = 1; alignment <= 32; alignment *= 2) {
71      for (int iter = 0; iter < 100; iter++) {
72        uptr res = (uptr)MmapAlignedOrDie(
73            size * PageSize, alignment * PageSize, "MmapAlignedOrDieTest");
74        EXPECT_EQ(0U, res % (alignment * PageSize));
75        internal_memset((void*)res, 1, size * PageSize);
76        UnmapOrDie((void*)res, size * PageSize);
77      }
78    }
79  }
80}
81
82#ifdef __linux__
83TEST(SanitizerCommon, SanitizerSetThreadName) {
84  const char *names[] = {
85    "0123456789012",
86    "01234567890123",
87    "012345678901234",  // Larger names will be truncated on linux.
88  };
89
90  for (size_t i = 0; i < ARRAY_SIZE(names); i++) {
91    EXPECT_TRUE(SanitizerSetThreadName(names[i]));
92    char buff[100];
93    EXPECT_TRUE(SanitizerGetThreadName(buff, sizeof(buff) - 1));
94    EXPECT_EQ(0, internal_strcmp(buff, names[i]));
95  }
96}
97#endif
98
99TEST(SanitizerCommon, InternalVector) {
100  InternalVector<uptr> vector(1);
101  for (uptr i = 0; i < 100; i++) {
102    EXPECT_EQ(i, vector.size());
103    vector.push_back(i);
104  }
105  for (uptr i = 0; i < 100; i++) {
106    EXPECT_EQ(i, vector[i]);
107  }
108  for (int i = 99; i >= 0; i--) {
109    EXPECT_EQ((uptr)i, vector.back());
110    vector.pop_back();
111    EXPECT_EQ((uptr)i, vector.size());
112  }
113}
114
115void TestThreadInfo(bool main) {
116  uptr stk_addr = 0;
117  uptr stk_size = 0;
118  uptr tls_addr = 0;
119  uptr tls_size = 0;
120  GetThreadStackAndTls(main, &stk_addr, &stk_size, &tls_addr, &tls_size);
121
122  int stack_var;
123  EXPECT_NE(stk_addr, (uptr)0);
124  EXPECT_NE(stk_size, (uptr)0);
125  EXPECT_GT((uptr)&stack_var, stk_addr);
126  EXPECT_LT((uptr)&stack_var, stk_addr + stk_size);
127
128#if defined(__linux__) && defined(__x86_64__)
129  static __thread int thread_var;
130  EXPECT_NE(tls_addr, (uptr)0);
131  EXPECT_NE(tls_size, (uptr)0);
132  EXPECT_GT((uptr)&thread_var, tls_addr);
133  EXPECT_LT((uptr)&thread_var, tls_addr + tls_size);
134
135  // Ensure that tls and stack do not intersect.
136  uptr tls_end = tls_addr + tls_size;
137  EXPECT_TRUE(tls_addr < stk_addr || tls_addr >= stk_addr + stk_size);
138  EXPECT_TRUE(tls_end  < stk_addr || tls_end  >=  stk_addr + stk_size);
139  EXPECT_TRUE((tls_addr < stk_addr) == (tls_end  < stk_addr));
140#endif
141}
142
143static void *WorkerThread(void *arg) {
144  TestThreadInfo(false);
145  return 0;
146}
147
148TEST(SanitizerCommon, ThreadStackTlsMain) {
149  InitTlsSize();
150  TestThreadInfo(true);
151}
152
153TEST(Platform, ThreadStackTlsWorker) {
154  InitTlsSize();
155  pthread_t t;
156  pthread_create(&t, 0, WorkerThread, 0);
157  pthread_join(t, 0);
158}
159
160}  // namespace __sanitizer
161