lib/sanitizer_common/tests/sanitizer_common_test.cc

   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_allocator_internal.h"
  14 #include "sanitizer_common/sanitizer_common.h"
  15 #include "sanitizer_common/sanitizer_flags.h"
  16 #include "sanitizer_common/sanitizer_libc.h"
  17 #include "sanitizer_common/sanitizer_platform.h"
  18 #include "gtest/gtest.h"
  19
  20 namespace __sanitizer {
  21
  22 static bool IsSorted(const uptr *array, uptr n) {
  23   for (uptr i = 1; i < n; i++) {
  24     if (array[i] < array[i - 1]) return false;
  25   }
  26   return true;
  27 }
  28
  29 TEST(SanitizerCommon, SortTest) {
  30   uptr array[100];
  31   uptr n = 100;
  32   // Already sorted.
  33   for (uptr i = 0; i < n; i++) {
  34     array[i] = i;
  35   }
  36   SortArray(array, n);
  37   EXPECT_TRUE(IsSorted(array, n));
  38   // Reverse order.
  39   for (uptr i = 0; i < n; i++) {
  40     array[i] = n - 1 - i;
  41   }
  42   SortArray(array, n);
  43   EXPECT_TRUE(IsSorted(array, n));
  44   // Mixed order.
  45   for (uptr i = 0; i < n; i++) {
  46     array[i] = (i % 2 == 0) ? i : n - 1 - i;
  47   }
  48   SortArray(array, n);
  49   EXPECT_TRUE(IsSorted(array, n));
  50   // All equal.
  51   for (uptr i = 0; i < n; i++) {
  52     array[i] = 42;
  53   }
  54   SortArray(array, n);
  55   EXPECT_TRUE(IsSorted(array, n));
  56   // All but one sorted.
  57   for (uptr i = 0; i < n - 1; i++) {
  58     array[i] = i;
  59   }
  60   array[n - 1] = 42;
  61   SortArray(array, n);
  62   EXPECT_TRUE(IsSorted(array, n));
  63   // Minimal case - sort three elements.
  64   array[0] = 1;
  65   array[1] = 0;
  66   SortArray(array, 2);
  67   EXPECT_TRUE(IsSorted(array, 2));
  68 }
  69
  70 TEST(SanitizerCommon, MmapAlignedOrDie) {
  71   uptr PageSize = GetPageSizeCached();
  72   for (uptr size = 1; size <= 32; size *= 2) {
  73     for (uptr alignment = 1; alignment <= 32; alignment *= 2) {
  74       for (int iter = 0; iter < 100; iter++) {
  75         uptr res = (uptr)MmapAlignedOrDie(
  76             size * PageSize, alignment * PageSize, "MmapAlignedOrDieTest");
  77         EXPECT_EQ(0U, res % (alignment * PageSize));
  78         internal_memset((void*)res, 1, size * PageSize);
  79         UnmapOrDie((void*)res, size * PageSize);
  80       }
  81     }
  82   }
  83 }
  84
  85 #if SANITIZER_LINUX
  86 TEST(SanitizerCommon, SanitizerSetThreadName) {
  87   const char *names[] = {
  88     "0123456789012",
  89     "01234567890123",
  90     "012345678901234",  // Larger names will be truncated on linux.
  91   };
  92
  93   for (size_t i = 0; i < ARRAY_SIZE(names); i++) {
  94     EXPECT_TRUE(SanitizerSetThreadName(names[i]));
  95     char buff[100];
  96     EXPECT_TRUE(SanitizerGetThreadName(buff, sizeof(buff) - 1));
  97     EXPECT_EQ(0, internal_strcmp(buff, names[i]));
  98   }
  99 }
 100 #endif
 101
 102 TEST(SanitizerCommon, InternalMmapVector) {
 103   InternalMmapVector<uptr> vector(1);
 104   for (uptr i = 0; i < 100; i++) {
 105     EXPECT_EQ(i, vector.size());
 106     vector.push_back(i);
 107   }
 108   for (uptr i = 0; i < 100; i++) {
 109     EXPECT_EQ(i, vector[i]);
 110   }
 111   for (int i = 99; i >= 0; i--) {
 112     EXPECT_EQ((uptr)i, vector.back());
 113     vector.pop_back();
 114     EXPECT_EQ((uptr)i, vector.size());
 115   }
 116   InternalMmapVector<uptr> empty_vector(0);
 117   CHECK_GT(empty_vector.capacity(), 0U);
 118   CHECK_EQ(0U, empty_vector.size());
 119 }
 120
 121 void TestThreadInfo(bool main) {
 122   uptr stk_addr = 0;
 123   uptr stk_size = 0;
 124   uptr tls_addr = 0;
 125   uptr tls_size = 0;
 126   GetThreadStackAndTls(main, &stk_addr, &stk_size, &tls_addr, &tls_size);
 127
 128   int stack_var;
 129   EXPECT_NE(stk_addr, (uptr)0);
 130   EXPECT_NE(stk_size, (uptr)0);
 131   EXPECT_GT((uptr)&stack_var, stk_addr);
 132   EXPECT_LT((uptr)&stack_var, stk_addr + stk_size);
 133
 134 #if SANITIZER_LINUX && defined(__x86_64__)
 135   static __thread int thread_var;
 136   EXPECT_NE(tls_addr, (uptr)0);
 137   EXPECT_NE(tls_size, (uptr)0);
 138   EXPECT_GT((uptr)&thread_var, tls_addr);
 139   EXPECT_LT((uptr)&thread_var, tls_addr + tls_size);
 140
 141   // Ensure that tls and stack do not intersect.
 142   uptr tls_end = tls_addr + tls_size;
 143   EXPECT_TRUE(tls_addr < stk_addr || tls_addr >= stk_addr + stk_size);
 144   EXPECT_TRUE(tls_end  < stk_addr || tls_end  >=  stk_addr + stk_size);
 145   EXPECT_TRUE((tls_addr < stk_addr) == (tls_end  < stk_addr));
 146 #endif
 147 }
 148
 149 static void *WorkerThread(void *arg) {
 150   TestThreadInfo(false);
 151   return 0;
 152 }
 153
 154 TEST(SanitizerCommon, ThreadStackTlsMain) {
 155   InitTlsSize();
 156   TestThreadInfo(true);
 157 }
 158
 159 TEST(SanitizerCommon, ThreadStackTlsWorker) {
 160   InitTlsSize();
 161   pthread_t t;
 162   pthread_create(&t, 0, WorkerThread, 0);
 163   pthread_join(t, 0);
 164 }
 165
 166 bool UptrLess(uptr a, uptr b) {
 167   return a < b;
 168 }
 169
 170 TEST(SanitizerCommon, InternalBinarySearch) {
 171   static const uptr kSize = 5;
 172   uptr arr[kSize];
 173   for (uptr i = 0; i < kSize; i++) arr[i] = i * i;
 174
 175   for (uptr i = 0; i < kSize; i++)
 176     ASSERT_EQ(InternalBinarySearch(arr, 0, kSize, i * i, UptrLess), i);
 177
 178   ASSERT_EQ(InternalBinarySearch(arr, 0, kSize, 7, UptrLess), kSize + 1);
 179 }
 180
 181 #if SANITIZER_LINUX && !SANITIZER_ANDROID
 182 TEST(SanitizerCommon, FindPathToBinary) {
 183   char *true_path = FindPathToBinary("true");
 184   EXPECT_NE((char*)0, internal_strstr(true_path, "/bin/true"));
 185   InternalFree(true_path);
 186   EXPECT_EQ(0, FindPathToBinary("unexisting_binary.ergjeorj"));
 187 }
 188 #endif
 189
 190 TEST(SanitizerCommon, StripPathPrefix) {
 191   EXPECT_EQ(0, StripPathPrefix(0, "prefix"));
 192   EXPECT_STREQ("foo", StripPathPrefix("foo", 0));
 193   EXPECT_STREQ("dir/file.cc",
 194                StripPathPrefix("/usr/lib/dir/file.cc", "/usr/lib/"));
 195   EXPECT_STREQ("/file.cc", StripPathPrefix("/usr/myroot/file.cc", "/myroot"));
 196   EXPECT_STREQ("file.h", StripPathPrefix("/usr/lib/./file.h", "/usr/lib/"));
 197 }
 198
 199 TEST(SanitizerCommon, InternalScopedString) {
 200   InternalScopedString str(10);
 201   EXPECT_EQ(0U, str.length());
 202   EXPECT_STREQ("", str.data());
 203
 204   str.append("foo");
 205   EXPECT_EQ(3U, str.length());
 206   EXPECT_STREQ("foo", str.data());
 207
 208   int x = 1234;
 209   str.append("%d", x);
 210   EXPECT_EQ(7U, str.length());
 211   EXPECT_STREQ("foo1234", str.data());
 212
 213   str.append("%d", x);
 214   EXPECT_EQ(9U, str.length());
 215   EXPECT_STREQ("foo123412", str.data());
 216
 217   str.clear();
 218   EXPECT_EQ(0U, str.length());
 219   EXPECT_STREQ("", str.data());
 220
 221   str.append("0123456789");
 222   EXPECT_EQ(9U, str.length());
 223   EXPECT_STREQ("012345678", str.data());
 224 }
 225
 226 TEST(SanitizerCommon, PrintSourceLocation) {
 227   InternalScopedString str(128);
 228   PrintSourceLocation(&str, "/dir/file.cc", 10, 5);
 229   EXPECT_STREQ("/dir/file.cc:10:5", str.data());
 230
 231   str.clear();
 232   PrintSourceLocation(&str, "/dir/file.cc", 11, 0);
 233   EXPECT_STREQ("/dir/file.cc:11", str.data());
 234
 235   str.clear();
 236   PrintSourceLocation(&str, "/dir/file.cc", 0, 0);
 237   EXPECT_STREQ("/dir/file.cc", str.data());
 238
 239   // Check that we strip file prefix if necessary.
 240   const char *old_strip_path_prefix = common_flags()->strip_path_prefix;
 241   common_flags()->strip_path_prefix = "/dir/";
 242   str.clear();
 243   PrintSourceLocation(&str, "/dir/file.cc", 10, 5);
 244   EXPECT_STREQ("file.cc:10:5", str.data());
 245   common_flags()->strip_path_prefix = old_strip_path_prefix;
 246 }
 247
 248 TEST(SanitizerCommon, PrintModuleAndOffset) {
 249   InternalScopedString str(128);
 250   PrintModuleAndOffset(&str, "/dir/exe", 0x123);
 251   EXPECT_STREQ("(/dir/exe+0x123)", str.data());
 252
 253   // Check that we strip file prefix if necessary.
 254   const char *old_strip_path_prefix = common_flags()->strip_path_prefix;
 255   common_flags()->strip_path_prefix = "/dir/";
 256   str.clear();
 257   PrintModuleAndOffset(&str, "/dir/exe", 0x123);
 258   EXPECT_STREQ("(exe+0x123)", str.data());
 259   common_flags()->strip_path_prefix = old_strip_path_prefix;
 260 }
 261
 262 }  // namespace __sanitizer