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