[compiler rt] Win64 GetInstructionSize additional register MOV + stack alignment AND

[mcgov]

Summary

Current interception code does not cover all of the required registers on Windows for a specific flavor of MOV, so this patch adds cases to identify the following 5-byte instructions on 64-bit Windows:

mov QWORD PTR [rsp + XX], rdx <- second integer argument
mov QWORD PTR [rsp + XX], r9 <- third integer argument
mov QWORD PTR [rsp + XX], r8 <- fourth integer argument

The instruction for MOV [...] RCX is already covered in the previous version.

[mcgov]

Added stack alignment instruction which is common on msvc /Od executables

[rnk]

lgtm

Honestly, I don't really feel the need to add an interceptor test for this encoding. It's just testing that we've put the bytes in two places.

[mcgov]

Added tests for interception of new functions (just in case).

compiler-rt/trunk/lib/interception/interception_win.cc

switch (0x00FFFFFF & *(u32*)address) {
     case 0xc98b4c:    // 4C 8B C9 : mov r9, rcx
     case 0xd2b60f:    // 0f b6 d2 : movzx edx, dl
     case 0xca2b48:    // 48 2b ca : sub rcx, rdx
     case 0x10b70f:    // 0f b7 10 : movzx edx, WORD PTR [rax]
     case 0xc00b4d:    // 3d 0b c0 : or r8, r8
     case 0xd18b48:    // 48 8b d1 : mov rdx, rcx
     case 0xdc8b4c:    // 4c 8b dc : mov r11, rsp
     case 0xd18b4c:    // 4c 8b d1 : mov r10, rcx
+    case 0xE0E483:    // 83 E4 E0 : and esp, 0xFFFFFFE0
       return 3;
 
     case 0xec8348:    // 48 83 ec XX : sub rsp, XX
     case 0xf88349:    // 49 83 f8 XX : cmp r8, XX
     case 0x588948:    // 48 89 58 XX : mov QWORD PTR[rax + XX], rbx
       return 4;
 
     case 0xec8148:    // 48 81 EC XX XX XX XX : sub rsp, XXXXXXXX
#if SANITIZER_WINDOWS64
   }
 
   switch (*(u32*)(address)) {
     case 0x24448b48:  // 48 8b 44 24 XX : mov rax, QWORD ptr [rsp + XX]
     case 0x246c8948:  // 48 89 6C 24 XX : mov QWORD ptr [rsp + XX], rbp
     case 0x245c8948:  // 48 89 5c 24 XX : mov QWORD PTR [rsp + XX], rbx
     case 0x24748948:  // 48 89 74 24 XX : mov QWORD PTR [rsp + XX], rsi
     case 0x244C8948:  // 48 89 4C 24 XX : mov QWORD PTR [rsp + XX], rcx
+    case 0x24548948:  // 48 89 54 24 XX : mov QWORD PTR [rsp + XX], rdx
+    case 0x244c894c:  // 4c 89 4c 24 XX : mov QWORD PTR [rsp + XX], r9
+    case 0x2444894c:  // 4c 89 44 24 XX : mov QWORD PTR [rsp + XX], r8
       return 5;
     case 0x24648348:  // 48 83 64 24 XX : and QWORD PTR [rsp + XX], YY
       return 6;
   }
 
 #else
 
   switch (*(u8*)address) {

compiler-rt/trunk/lib/interception/tests/interception_win_test.cc

const u8 kUnpatchableCode5[] = {
     0xC3,                           // ret
 };
 
 const u8 kUnpatchableCode6[] = {
     0xE8, 0xCC, 0xCC, 0xCC, 0xCC,   // call <func>
     0x90, 0x90, 0x90, 0x90,
 };
 
+const u8 kPatchableCode6[] = {
+    0x48, 0x89, 0x54, 0x24, 0xBB, // mov QWORD PTR [rsp + 0xBB], rdx
+    0x33, 0xC9,                   // xor ecx,ecx
+    0xC3,                         // ret
+};
+
+const u8 kPatchableCode7[] = {
+    0x4c, 0x89, 0x4c, 0x24, 0xBB,  // mov QWORD PTR [rsp + 0xBB], r9
+    0x33, 0xC9,                   // xor ecx,ecx
+    0xC3,                         // ret
+};
+
+const u8 kPatchableCode8[] = {
+    0x4c, 0x89, 0x44, 0x24, 0xBB, // mov QWORD PTR [rsp + 0xBB], r8
+    0x33, 0xC9,                   // xor ecx,ecx
+    0xC3,                         // ret
+};
+
 // A buffer holding the dynamically generated code under test.
 u8* ActiveCode;
 const size_t ActiveCodeLength = 4096;
 
 int InterceptorFunction(int x);
 
 /// Allocate code memory more than 2GB away from Base.
 u8 *AllocateCode2GBAway(u8 *Base) {
TEST(Interception, PatchableFunction) {
   EXPECT_TRUE(TestFunctionPatching(kPatchableCode2, override));
 #if SANITIZER_WINDOWS64
   EXPECT_FALSE(TestFunctionPatching(kPatchableCode3, override));
 #else
   EXPECT_TRUE(TestFunctionPatching(kPatchableCode3, override));
 #endif
   EXPECT_TRUE(TestFunctionPatching(kPatchableCode4, override));
   EXPECT_TRUE(TestFunctionPatching(kPatchableCode5, override));
-
 #if SANITIZER_WINDOWS64
   EXPECT_TRUE(TestFunctionPatching(kLoadGlobalCode, override));
 #endif
 
   EXPECT_FALSE(TestFunctionPatching(kUnpatchableCode1, override));
   EXPECT_FALSE(TestFunctionPatching(kUnpatchableCode2, override));
   EXPECT_FALSE(TestFunctionPatching(kUnpatchableCode3, override));
   EXPECT_FALSE(TestFunctionPatching(kUnpatchableCode4, override));

 TEST(Interception, PatchableFunctionWithHotPatch) {
   TestOverrideFunction override = OverrideFunctionWithHotPatch;
   FunctionPrefixKind prefix = FunctionPrefixHotPatch;
 
   EXPECT_TRUE(TestFunctionPatching(kPatchableCode1, override, prefix));
   EXPECT_FALSE(TestFunctionPatching(kPatchableCode2, override, prefix));
   EXPECT_FALSE(TestFunctionPatching(kPatchableCode3, override, prefix));
   EXPECT_FALSE(TestFunctionPatching(kPatchableCode4, override, prefix));
-
+#ifdef _WIN64
+  EXPECT_TRUE(TestFunctionPatching(kPatchableCode6, override, prefix));
+  EXPECT_TRUE(TestFunctionPatching(kPatchableCode7, override, prefix));
+  EXPECT_TRUE(TestFunctionPatching(kPatchableCode8, override, prefix));
+#endif
   EXPECT_FALSE(TestFunctionPatching(kUnpatchableCode1, override, prefix));
   EXPECT_TRUE(TestFunctionPatching(kUnpatchableCode2, override, prefix));
   EXPECT_FALSE(TestFunctionPatching(kUnpatchableCode3, override, prefix));
   EXPECT_FALSE(TestFunctionPatching(kUnpatchableCode4, override, prefix));
   EXPECT_FALSE(TestFunctionPatching(kUnpatchableCode5, override, prefix));
   EXPECT_FALSE(TestFunctionPatching(kUnpatchableCode6, override, prefix));
 }