contrib/compiler-rt/lib/asan/tests/asan_asm_test.cc

   1 //===-- asan_asm_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 //===----------------------------------------------------------------------===//
  13 #include "asan_test_utils.h"
  14
  15 #if defined(__linux__)
  16
  17 #if defined(__x86_64__) || (defined(__i386__) && defined(__SSE2__))
  18
  19 #include <emmintrin.h>
  20
  21 namespace {
  22
  23 template<typename T> void asm_write(T *ptr, T val);
  24 template<typename T> T asm_read(T *ptr);
  25 template<typename T> void asm_rep_movs(T *dst, T *src, size_t n);
  26
  27 } // End of anonymous namespace
  28
  29 #endif // defined(__x86_64__) || (defined(__i386__) && defined(__SSE2__))
  30
  31 #if defined(__x86_64__)
  32
  33 namespace {
  34
  35 #define DECLARE_ASM_WRITE(Type, Size, Mov, Reg)        \
  36 template<> void asm_write<Type>(Type *ptr, Type val) { \
  37   __asm__(                                             \
  38     Mov " %[val], (%[ptr])  \n\t"                      \
  39     :                                                  \
  40     : [ptr] "r" (ptr), [val] Reg (val)                 \
  41     : "memory"                                         \
  42   );                                                   \
  43 }
  44
  45 #define DECLARE_ASM_READ(Type, Size, Mov, Reg)     \
  46 template<> Type asm_read<Type>(Type *ptr) {        \
  47   Type res;                                        \
  48   __asm__(                                         \
  49     Mov " (%[ptr]), %[res]  \n\t"                  \
  50     : [res] Reg (res)                              \
  51     : [ptr] "r" (ptr)                              \
  52     : "memory"                                     \
  53   );                                               \
  54   return res;                                      \
  55 }
  56
  57 #define DECLARE_ASM_REP_MOVS(Type, Movs)                                       \
  58   template <> void asm_rep_movs<Type>(Type * dst, Type * src, size_t size) {   \
  59     __asm__("rep " Movs " \n\t"                                                \
  60             :                                                                  \
  61             : "D"(dst), "S"(src), "c"(size)                                    \
  62             : "rsi", "rdi", "rcx", "memory");                                  \
  63   }
  64
  65 DECLARE_ASM_WRITE(U8, "8", "movq", "r");
  66 DECLARE_ASM_READ(U8, "8", "movq", "=r");
  67 DECLARE_ASM_REP_MOVS(U8, "movsq");
  68
  69 } // End of anonymous namespace
  70
  71 #endif // defined(__x86_64__)
  72
  73 #if defined(__i386__) && defined(__SSE2__)
  74
  75 namespace {
  76
  77 #define DECLARE_ASM_WRITE(Type, Size, Mov, Reg)        \
  78 template<> void asm_write<Type>(Type *ptr, Type val) { \
  79   __asm__(                                             \
  80     Mov " %[val], (%[ptr])  \n\t"                      \
  81     :                                                  \
  82     : [ptr] "r" (ptr), [val] Reg (val)                 \
  83     : "memory"                                         \
  84   );                                                   \
  85 }
  86
  87 #define DECLARE_ASM_READ(Type, Size, Mov, Reg)     \
  88 template<> Type asm_read<Type>(Type *ptr) {        \
  89   Type res;                                        \
  90   __asm__(                                         \
  91     Mov " (%[ptr]), %[res]  \n\t"                  \
  92     : [res] Reg (res)                              \
  93     : [ptr] "r" (ptr)                              \
  94     : "memory"                                     \
  95   );                                               \
  96   return res;                                      \
  97 }
  98
  99 #define DECLARE_ASM_REP_MOVS(Type, Movs)                                       \
 100   template <> void asm_rep_movs<Type>(Type * dst, Type * src, size_t size) {   \
 101     __asm__("rep " Movs " \n\t"                                                \
 102             :                                                                  \
 103             : "D"(dst), "S"(src), "c"(size)                                    \
 104             : "esi", "edi", "ecx", "memory");                                  \
 105   }
 106
 107 } // End of anonymous namespace
 108
 109 #endif  // defined(__i386__) && defined(__SSE2__)
 110
 111 #if defined(__x86_64__) || (defined(__i386__) && defined(__SSE2__))
 112
 113 namespace {
 114
 115 DECLARE_ASM_WRITE(U1, "1", "movb", "r");
 116 DECLARE_ASM_WRITE(U2, "2", "movw", "r");
 117 DECLARE_ASM_WRITE(U4, "4", "movl", "r");
 118 DECLARE_ASM_WRITE(__m128i, "16", "movaps", "x");
 119
 120 DECLARE_ASM_READ(U1, "1", "movb", "=r");
 121 DECLARE_ASM_READ(U2, "2", "movw", "=r");
 122 DECLARE_ASM_READ(U4, "4", "movl", "=r");
 123 DECLARE_ASM_READ(__m128i, "16", "movaps", "=x");
 124
 125 DECLARE_ASM_REP_MOVS(U1, "movsb");
 126 DECLARE_ASM_REP_MOVS(U2, "movsw");
 127 DECLARE_ASM_REP_MOVS(U4, "movsl");
 128
 129 template<typename T> void TestAsmWrite(const char *DeathPattern) {
 130   T *buf = new T;
 131   EXPECT_DEATH(asm_write(&buf[1], static_cast<T>(0)), DeathPattern);
 132   T var = 0x12;
 133   asm_write(&var, static_cast<T>(0x21));
 134   ASSERT_EQ(static_cast<T>(0x21), var);
 135   delete buf;
 136 }
 137
 138 template<> void TestAsmWrite<__m128i>(const char *DeathPattern) {
 139   char *buf = new char[16];
 140   char *p = buf + 16;
 141   if (((uintptr_t) p % 16) != 0)
 142     p = buf + 8;
 143   assert(((uintptr_t) p % 16) == 0);
 144   __m128i val = _mm_set1_epi16(0x1234);
 145   EXPECT_DEATH(asm_write<__m128i>((__m128i*) p, val), DeathPattern);
 146   __m128i var = _mm_set1_epi16(0x4321);
 147   asm_write(&var, val);
 148   ASSERT_EQ(0x1234, _mm_extract_epi16(var, 0));
 149   delete [] buf;
 150 }
 151
 152 template<typename T> void TestAsmRead(const char *DeathPattern) {
 153   T *buf = new T;
 154   EXPECT_DEATH(asm_read(&buf[1]), DeathPattern);
 155   T var = 0x12;
 156   ASSERT_EQ(static_cast<T>(0x12), asm_read(&var));
 157   delete buf;
 158 }
 159
 160 template<> void TestAsmRead<__m128i>(const char *DeathPattern) {
 161   char *buf = new char[16];
 162   char *p = buf + 16;
 163   if (((uintptr_t) p % 16) != 0)
 164     p = buf + 8;
 165   assert(((uintptr_t) p % 16) == 0);
 166   EXPECT_DEATH(asm_read<__m128i>((__m128i*) p), DeathPattern);
 167   __m128i val = _mm_set1_epi16(0x1234);
 168   ASSERT_EQ(0x1234, _mm_extract_epi16(asm_read(&val), 0));
 169   delete [] buf;
 170 }
 171
 172 U4 AsmLoad(U4 *a) {
 173   U4 r;
 174   __asm__("movl (%[a]), %[r]  \n\t" : [r] "=r" (r) : [a] "r" (a) : "memory");
 175   return r;
 176 }
 177
 178 void AsmStore(U4 r, U4 *a) {
 179   __asm__("movl %[r], (%[a])  \n\t" : : [a] "r" (a), [r] "r" (r) : "memory");
 180 }
 181
 182 template <typename T>
 183 void TestAsmRepMovs(const char *DeathPatternRead,
 184                     const char *DeathPatternWrite) {
 185   T src_good[4] = { 0x0, 0x1, 0x2, 0x3 };
 186   T dst_good[4] = {};
 187   asm_rep_movs(dst_good, src_good, 4);
 188   ASSERT_EQ(static_cast<T>(0x0), dst_good[0]);
 189   ASSERT_EQ(static_cast<T>(0x1), dst_good[1]);
 190   ASSERT_EQ(static_cast<T>(0x2), dst_good[2]);
 191   ASSERT_EQ(static_cast<T>(0x3), dst_good[3]);
 192
 193   T dst_bad[3];
 194   EXPECT_DEATH(asm_rep_movs(dst_bad, src_good, 4), DeathPatternWrite);
 195
 196   T src_bad[3] = { 0x0, 0x1, 0x2 };
 197   EXPECT_DEATH(asm_rep_movs(dst_good, src_bad, 4), DeathPatternRead);
 198
 199   T* dp = dst_bad + 4;
 200   T* sp = src_bad + 4;
 201   asm_rep_movs(dp, sp, 0);
 202 }
 203
 204 } // End of anonymous namespace
 205
 206 TEST(AddressSanitizer, asm_load_store) {
 207   U4* buf = new U4[2];
 208   EXPECT_DEATH(AsmLoad(&buf[3]), "READ of size 4");
 209   EXPECT_DEATH(AsmStore(0x1234, &buf[3]), "WRITE of size 4");
 210   delete [] buf;
 211 }
 212
 213 TEST(AddressSanitizer, asm_rw) {
 214   TestAsmWrite<U1>("WRITE of size 1");
 215   TestAsmWrite<U2>("WRITE of size 2");
 216   TestAsmWrite<U4>("WRITE of size 4");
 217 #if defined(__x86_64__)
 218   TestAsmWrite<U8>("WRITE of size 8");
 219 #endif // defined(__x86_64__)
 220   TestAsmWrite<__m128i>("WRITE of size 16");
 221
 222   TestAsmRead<U1>("READ of size 1");
 223   TestAsmRead<U2>("READ of size 2");
 224   TestAsmRead<U4>("READ of size 4");
 225 #if defined(__x86_64__)
 226   TestAsmRead<U8>("READ of size 8");
 227 #endif // defined(__x86_64__)
 228   TestAsmRead<__m128i>("READ of size 16");
 229 }
 230
 231 TEST(AddressSanitizer, asm_flags) {
 232   long magic = 0x1234;
 233   long r = 0x0;
 234
 235 #if defined(__x86_64__) && !defined(__ILP32__)
 236   __asm__("xorq %%rax, %%rax  \n\t"
 237           "movq (%[p]), %%rax \n\t"
 238           "sete %%al          \n\t"
 239           "movzbq %%al, %[r]  \n\t"
 240           : [r] "=r"(r)
 241           : [p] "r"(&magic)
 242           : "rax", "memory");
 243 #else
 244   __asm__("xorl %%eax, %%eax  \n\t"
 245           "movl (%[p]), %%eax \n\t"
 246           "sete %%al          \n\t"
 247           "movzbl %%al, %[r]  \n\t"
 248           : [r] "=r"(r)
 249           : [p] "r"(&magic)
 250           : "eax", "memory");
 251 #endif // defined(__x86_64__) && !defined(__ILP32__)
 252
 253   ASSERT_EQ(0x1, r);
 254 }
 255
 256 TEST(AddressSanitizer, asm_rep_movs) {
 257   TestAsmRepMovs<U1>("READ of size 1", "WRITE of size 1");
 258   TestAsmRepMovs<U2>("READ of size 2", "WRITE of size 2");
 259   TestAsmRepMovs<U4>("READ of size 4", "WRITE of size 4");
 260 #if defined(__x86_64__)
 261   TestAsmRepMovs<U8>("READ of size 8", "WRITE of size 8");
 262 #endif  // defined(__x86_64__)
 263 }
 264
 265 #endif // defined(__x86_64__) || (defined(__i386__) && defined(__SSE2__))
 266
 267 #endif // defined(__linux__)