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