Inline memove for small constant sizes and refactor memcpy and memset.

unittest/AssemblerX8632/Locked.cpp

 //===- subzero/unittest/AssemblerX8632/Locked.cpp -------------------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 #include "AssemblerX8632/TestUtil.h"
 
@@ skipping 64 matching lines @@
   TestImpl(eax);
   TestImpl(ebx);
   TestImpl(ecx);
   TestImpl(edx);
   TestImpl(esi);
   TestImpl(edi);
 
 #undef TestImpl
 #undef TestImplSize
 #undef TestImplAddrReg
+
+#define TestImplRegReg(Reg0, Value0, Reg1, Value1, Size)                       \
+  do {                                                                         \
+    static constexpr char TestString[] =                                       \
+        "(" #Reg0 "," #Value0 ", " #Reg1 ", " #Value1 ", " #Size ")";          \
+    const uint32_t V0 = (Value0)&Mask##Size;                                   \
+    const uint32_t V1 = (Value1)&Mask##Size;                                   \
+                                                                               \
+    __ mov(IceType_i##Size, GPRRegister::Encoded_Reg_##Reg0,                   \
+           Immediate(Value0));                                                 \
+    __ mov(IceType_i##Size, GPRRegister::Encoded_Reg_##Reg1,                   \
+           Immediate(Value1));                                                 \
+    __ xchg(IceType_i##Size, GPRRegister::Encoded_Reg_##Reg0,                  \
+            GPRRegister::Encoded_Reg_##Reg1);                                  \
+    __ And(IceType_i32, GPRRegister::Encoded_Reg_##Reg0,                       \
+           Immediate(Mask##Size));                                             \
+    __ And(IceType_i32, GPRRegister::Encoded_Reg_##Reg1,                       \
+           Immediate(Mask##Size));                                             \
+                                                                               \
+    AssembledTest test = assemble();                                           \
+    test.run();                                                                \
+                                                                               \
+    ASSERT_EQ(V0, test.Reg1()) << TestString;                                  \
+    ASSERT_EQ(V1, test.Reg0()) << TestString;                                  \
+    reset();                                                                   \
+  } while (0)
+
+#define TestImplSize(Reg0, Reg1, Size)                                         \
+  do {                                                                         \
+    TestImplRegReg(Reg0, 0xa2b34567, Reg1, 0x0507ddee, Size);                  \
+  } while (0)
+
+#define TestImpl(Reg0, Reg1)                                                   \
+  do {                                                                         \
+    if (GPRRegister::Encoded_Reg_##Reg0 < 4 &&                                 \
+        GPRRegister::Encoded_Reg_##Reg1 < 4) {                                 \
+      TestImplSize(Reg0, Reg1, 8);                                             \
+    }                                                                          \
+    TestImplSize(Reg0, Reg1, 16);                                              \
+    TestImplSize(Reg0, Reg1, 32);                                              \
+  } while (0)
+
+  TestImpl(eax, ebx);
+  TestImpl(edx, eax);
+  TestImpl(ecx, edx);
+  TestImpl(esi, eax);
+  TestImpl(edx, edi);
+
+#undef TestImpl
+#undef TestImplSize
+#undef TestImplRegReg
 }
 
 TEST_F(AssemblerX8632Test, Xadd) {
   static constexpr bool NotLocked = false;
   static constexpr bool Locked = true;
 
   static constexpr uint32_t Mask8 = 0x000000FF;
   static constexpr uint32_t Mask16 = 0x0000FFFF;
   static constexpr uint32_t Mask32 = 0xFFFFFFFF;
 
@@ skipping 305 matching lines @@
     verifyBytes<ByteCountLocked32>(codeBytes(), 0xF0, 0x0F, 0xB1, 0x35, 0x00,
                                    0xFF, 0x01, 0x00);
     reset();
   }
 }
 
 } // end of anonymous namespace
 } // end of namespace Test
 } // end of namespace X8632
 } // end of namespace Ice