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
26 } // End of anonymous namespace
27
28 #endif // defined(__x86_64__) || (defined(__i386__) && defined(__SSE2__))
29
30 #if defined(__x86_64__)
31
32 namespace {
33
34 #define DECLARE_ASM_WRITE(Type, Size, Mov, Reg) \
35 template<> void asm_write<Type>(Type *ptr, Type val) { \
36 __asm__( \
37 Mov " %[val], (%[ptr]) \n\t" \
38 : \
39 : [ptr] "r" (ptr), [val] Reg (val) \
40 : "memory" \
41 ); \
42 }
43
44 #define DECLARE_ASM_READ(Type, Size, Mov, Reg) \
45 template<> Type asm_read<Type>(Type *ptr) { \
46 Type res; \
47 __asm__( \
48 Mov " (%[ptr]), %[res] \n\t" \
49 : [res] Reg (res) \
50 : [ptr] "r" (ptr) \
51 : "memory" \
52 ); \
53 return res; \
54 }
55
56 DECLARE_ASM_WRITE(U8, "8", "movq", "r");
57 DECLARE_ASM_READ(U8, "8", "movq", "=r");
58
59 } // End of anonymous namespace
60
61 #endif // defined(__x86_64__)
62
63 #if defined(__i386__) && defined(__SSE2__)
64
65 namespace {
66
67 #define DECLARE_ASM_WRITE(Type, Size, Mov, Reg) \
68 template<> void asm_write<Type>(Type *ptr, Type val) { \
69 __asm__( \
70 Mov " %[val], (%[ptr]) \n\t" \
71 : \
72 : [ptr] "r" (ptr), [val] Reg (val) \
73 : "memory" \
74 ); \
75 }
76
77 #define DECLARE_ASM_READ(Type, Size, Mov, Reg) \
78 template<> Type asm_read<Type>(Type *ptr) { \
79 Type res; \
80 __asm__( \
81 Mov " (%[ptr]), %[res] \n\t" \
82 : [res] Reg (res) \
83 : [ptr] "r" (ptr) \
84 : "memory" \
85 ); \
86 return res; \
87 }
88
89 } // End of anonymous namespace
90
91 #endif // defined(__i386__) && defined(__SSE2__)
92
93 #if defined(__x86_64__) || (defined(__i386__) && defined(__SSE2__))
94
95 namespace {
96
97 DECLARE_ASM_WRITE(U1, "1", "movb", "r");
98 DECLARE_ASM_WRITE(U2, "2", "movw", "r");
99 DECLARE_ASM_WRITE(U4, "4", "movl", "r");
100 DECLARE_ASM_WRITE(__m128i, "16", "movaps", "x");
101
102 DECLARE_ASM_READ(U1, "1", "movb", "=r");
103 DECLARE_ASM_READ(U2, "2", "movw", "=r");
104 DECLARE_ASM_READ(U4, "4", "movl", "=r");
105 DECLARE_ASM_READ(__m128i, "16", "movaps", "=x");
106
TestAsmWrite(const char * DeathPattern)107 template<typename T> void TestAsmWrite(const char *DeathPattern) {
108 T *buf = new T;
109 EXPECT_DEATH(asm_write(&buf[1], static_cast<T>(0)), DeathPattern);
110 T var = 0x12;
111 asm_write(&var, static_cast<T>(0x21));
112 ASSERT_EQ(static_cast<T>(0x21), var);
113 delete buf;
114 }
115
TestAsmWrite(const char * DeathPattern)116 template<> void TestAsmWrite<__m128i>(const char *DeathPattern) {
117 char *buf = new char[16];
118 char *p = buf + 16;
119 if (((uintptr_t) p % 16) != 0)
120 p = buf + 8;
121 assert(((uintptr_t) p % 16) == 0);
122 __m128i val = _mm_set1_epi16(0x1234);
123 EXPECT_DEATH(asm_write<__m128i>((__m128i*) p, val), DeathPattern);
124 __m128i var = _mm_set1_epi16(0x4321);
125 asm_write(&var, val);
126 ASSERT_EQ(0x1234, _mm_extract_epi16(var, 0));
127 delete [] buf;
128 }
129
TestAsmRead(const char * DeathPattern)130 template<typename T> void TestAsmRead(const char *DeathPattern) {
131 T *buf = new T;
132 EXPECT_DEATH(asm_read(&buf[1]), DeathPattern);
133 T var = 0x12;
134 ASSERT_EQ(static_cast<T>(0x12), asm_read(&var));
135 delete buf;
136 }
137
TestAsmRead(const char * DeathPattern)138 template<> void TestAsmRead<__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 EXPECT_DEATH(asm_read<__m128i>((__m128i*) p), DeathPattern);
145 __m128i val = _mm_set1_epi16(0x1234);
146 ASSERT_EQ(0x1234, _mm_extract_epi16(asm_read(&val), 0));
147 delete [] buf;
148 }
149
AsmLoad(U4 * a)150 U4 AsmLoad(U4 *a) {
151 U4 r;
152 __asm__("movl (%[a]), %[r] \n\t" : [r] "=r" (r) : [a] "r" (a) : "memory");
153 return r;
154 }
155
AsmStore(U4 r,U4 * a)156 void AsmStore(U4 r, U4 *a) {
157 __asm__("movl %[r], (%[a]) \n\t" : : [a] "r" (a), [r] "r" (r) : "memory");
158 }
159
160 } // End of anonymous namespace
161
TEST(AddressSanitizer,asm_load_store)162 TEST(AddressSanitizer, asm_load_store) {
163 U4* buf = new U4[2];
164 EXPECT_DEATH(AsmLoad(&buf[3]), "READ of size 4");
165 EXPECT_DEATH(AsmStore(0x1234, &buf[3]), "WRITE of size 4");
166 delete [] buf;
167 }
168
TEST(AddressSanitizer,asm_rw)169 TEST(AddressSanitizer, asm_rw) {
170 TestAsmWrite<U1>("WRITE of size 1");
171 TestAsmWrite<U2>("WRITE of size 2");
172 TestAsmWrite<U4>("WRITE of size 4");
173 #if defined(__x86_64__)
174 TestAsmWrite<U8>("WRITE of size 8");
175 #endif // defined(__x86_64__)
176 TestAsmWrite<__m128i>("WRITE of size 16");
177
178 TestAsmRead<U1>("READ of size 1");
179 TestAsmRead<U2>("READ of size 2");
180 TestAsmRead<U4>("READ of size 4");
181 #if defined(__x86_64__)
182 TestAsmRead<U8>("READ of size 8");
183 #endif // defined(__x86_64__)
184 TestAsmRead<__m128i>("READ of size 16");
185 }
186
TEST(AddressSanitizer,asm_flags)187 TEST(AddressSanitizer, asm_flags) {
188 long magic = 0x1234;
189 long r = 0x0;
190
191 #if defined(__x86_64__)
192 __asm__("xorq %%rax, %%rax \n\t"
193 "movq (%[p]), %%rax \n\t"
194 "sete %%al \n\t"
195 "movzbq %%al, %[r] \n\t"
196 : [r] "=r"(r)
197 : [p] "r"(&magic)
198 : "rax", "memory");
199 #else
200 __asm__("xorl %%eax, %%eax \n\t"
201 "movl (%[p]), %%eax \n\t"
202 "sete %%al \n\t"
203 "movzbl %%al, %[r] \n\t"
204 : [r] "=r"(r)
205 : [p] "r"(&magic)
206 : "eax", "memory");
207 #endif // defined(__x86_64__)
208
209 ASSERT_EQ(0x1, r);
210 }
211
212 #endif // defined(__x86_64__) || (defined(__i386__) && defined(__SSE2__))
213
214 #endif // defined(__linux__)
215