[asan-assembly-instrumentation] Added end-to-end-test for rep movs instructions.

[ygorshenin]

Summary

Added end-to-end-test for rep movs instructions.

[eugenis]

LGTM

[eugenis]

r214396.

lib/asan/tests/asan_asm_test.cc

 #if defined(__x86_64__) || (defined(__i386__) && defined(__SSE2__))
 
 #include <emmintrin.h>
 
 namespace {
 
 template<typename T> void asm_write(T *ptr, T val);
 template<typename T> T asm_read(T *ptr);
+template<typename T> void asm_rep_movs(T *dst, T *src, size_t n);
 
 } // End of anonymous namespace
 
 #endif // defined(__x86_64__) || (defined(__i386__) && defined(__SSE2__))
 
 #if defined(__x86_64__)
 
 namespace {
__asm__(                                         \
     Mov " (%[ptr]), %[res]  \n\t"                  \
     : [res] Reg (res)                              \
     : [ptr] "r" (ptr)                              \
     : "memory"                                     \
   );                                               \
   return res;                                      \
 }
 
+#define DECLARE_ASM_REP_MOVS(Type, Movs)                                       \
+  template <> void asm_rep_movs<Type>(Type * dst, Type * src, size_t size) {   \
+    __asm__("rep " Movs " \n\t"                                                \
+            :                                                                  \
+            : "D"(dst), "S"(src), "c"(size)                                    \
+            : "rsi", "rdi", "rcx", "memory");                                  \
+  }
+
 DECLARE_ASM_WRITE(U8, "8", "movq", "r");
 DECLARE_ASM_READ(U8, "8", "movq", "=r");
+DECLARE_ASM_REP_MOVS(U8, "movsq");
 
 } // End of anonymous namespace
 
 #endif // defined(__x86_64__)
 
 #if defined(__i386__) && defined(__SSE2__)
 
 namespace {
__asm__(                                         \
     Mov " (%[ptr]), %[res]  \n\t"                  \
     : [res] Reg (res)                              \
     : [ptr] "r" (ptr)                              \
     : "memory"                                     \
   );                                               \
   return res;                                      \
 }
 
+#define DECLARE_ASM_REP_MOVS(Type, Movs)                                       \
+  template <> void asm_rep_movs<Type>(Type * dst, Type * src, size_t size) {   \
+    __asm__("rep " Movs " \n\t"                                                \
+            :                                                                  \
+            : "D"(dst), "S"(src), "c"(size)                                    \
+            : "esi", "edi", "ecx", "memory");                                  \
+  }
+
 } // End of anonymous namespace
 
 #endif  // defined(__i386__) && defined(__SSE2__)
 
 #if defined(__x86_64__) || (defined(__i386__) && defined(__SSE2__))
 
 namespace {
 
 DECLARE_ASM_WRITE(U1, "1", "movb", "r");
 DECLARE_ASM_WRITE(U2, "2", "movw", "r");
 DECLARE_ASM_WRITE(U4, "4", "movl", "r");
 DECLARE_ASM_WRITE(__m128i, "16", "movaps", "x");
 
 DECLARE_ASM_READ(U1, "1", "movb", "=r");
 DECLARE_ASM_READ(U2, "2", "movw", "=r");
 DECLARE_ASM_READ(U4, "4", "movl", "=r");
 DECLARE_ASM_READ(__m128i, "16", "movaps", "=x");
 
+DECLARE_ASM_REP_MOVS(U1, "movsb");
+DECLARE_ASM_REP_MOVS(U2, "movsw");
+DECLARE_ASM_REP_MOVS(U4, "movsl");
+
 template<typename T> void TestAsmWrite(const char *DeathPattern) {
   T *buf = new T;
   EXPECT_DEATH(asm_write(&buf[1], static_cast<T>(0)), DeathPattern);
   T var = 0x12;
   asm_write(&var, static_cast<T>(0x21));
   ASSERT_EQ(static_cast<T>(0x21), var);
   delete buf;
 }
U4 AsmLoad(U4 *a) {
   __asm__("movl (%[a]), %[r]  \n\t" : [r] "=r" (r) : [a] "r" (a) : "memory");
   return r;
 }
 
 void AsmStore(U4 r, U4 *a) {
   __asm__("movl %[r], (%[a])  \n\t" : : [a] "r" (a), [r] "r" (r) : "memory");
 }
 
+template <typename T>
+void TestAsmRepMovs(const char *DeathPatternRead,
+                    const char *DeathPatternWrite) {
+  T src_good[4] = { 0x0, 0x1, 0x2, 0x3 };
+  T dst_good[4] = {};
+  asm_rep_movs(dst_good, src_good, 4);
+  ASSERT_EQ(static_cast<T>(0x0), dst_good[0]);
+  ASSERT_EQ(static_cast<T>(0x1), dst_good[1]);
+  ASSERT_EQ(static_cast<T>(0x2), dst_good[2]);
+  ASSERT_EQ(static_cast<T>(0x3), dst_good[3]);
+
+  T dst_bad[3];
+  EXPECT_DEATH(asm_rep_movs(dst_bad, src_good, 4), DeathPatternWrite);
+
+  T src_bad[3] = { 0x0, 0x1, 0x2 };
+  EXPECT_DEATH(asm_rep_movs(dst_good, src_bad, 4), DeathPatternRead);
+
+  T* dp = dst_bad + 4;
+  T* sp = src_bad + 4;
+  asm_rep_movs(dp, sp, 0);
+}
+
 } // End of anonymous namespace
 
 TEST(AddressSanitizer, asm_load_store) {
   U4* buf = new U4[2];
   EXPECT_DEATH(AsmLoad(&buf[3]), "READ of size 4");
   EXPECT_DEATH(AsmStore(0x1234, &buf[3]), "WRITE of size 4");
   delete [] buf;
 }
__asm__("xorl %%eax, %%eax  \n\t"
           : [r] "=r"(r)
           : [p] "r"(&magic)
           : "eax", "memory");
 #endif // defined(__x86_64__)
 
   ASSERT_EQ(0x1, r);
 }
 
+TEST(AddressSanitizer, asm_rep_movs) {
+  TestAsmRepMovs<U1>("READ of size 1", "WRITE of size 1");
+  TestAsmRepMovs<U2>("READ of size 2", "WRITE of size 2");
+  TestAsmRepMovs<U4>("READ of size 4", "WRITE of size 4");
+#if defined(__x86_64__)
+  TestAsmRepMovs<U8>("READ of size 8", "WRITE of size 8");
+#endif  // defined(__x86_64__)
+}
+
 #endif // defined(__x86_64__) || (defined(__i386__) && defined(__SSE2__))
 
 #endif // defined(__linux__)