Enhance address mode recovery

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 179 matching lines @@
   TestImpl(edi);
 
 #undef TestImpl
 #undef TestImplSize
 #undef TestImplAddrReg
 }
 
 TEST_F(AssemblerX8632LowLevelTest, Xadd) {
   static constexpr bool NotLocked = false;
   static constexpr bool Locked = true;
+  static constexpr AssemblerFixup *Fixup = nullptr;
 
   // Ensures that xadd emits a lock prefix accordingly.
   {
-    __ xadd(IceType_i8, Address::Absolute(0x1FF00),
-            GPRRegister::Encoded_Reg_esi, NotLocked);
+    __ xadd(IceType_i8, Address(0x1FF00, Fixup), GPRRegister::Encoded_Reg_esi,
+            NotLocked);
     static constexpr uint8_t ByteCountNotLocked8 = 7;
     ASSERT_EQ(ByteCountNotLocked8, codeBytesSize());
     verifyBytes<ByteCountNotLocked8>(codeBytes(), 0x0F, 0xC0, 0x35, 0x00, 0xFF,
                                      0x01, 0x00);
     reset();
 
-    __ xadd(IceType_i8, Address::Absolute(0x1FF00),
-            GPRRegister::Encoded_Reg_esi, Locked);
+    __ xadd(IceType_i8, Address(0x1FF00, Fixup), GPRRegister::Encoded_Reg_esi,
+            Locked);
     static constexpr uint8_t ByteCountLocked8 = 1 + ByteCountNotLocked8;
     ASSERT_EQ(ByteCountLocked8, codeBytesSize());
     verifyBytes<ByteCountLocked8>(codeBytes(), 0xF0, 0x0F, 0xC0, 0x35, 0x00,
                                   0xFF, 0x01, 0x00);
     reset();
   }
 
   {
-    __ xadd(IceType_i16, Address::Absolute(0x1FF00),
-            GPRRegister::Encoded_Reg_esi, NotLocked);
+    __ xadd(IceType_i16, Address(0x1FF00, Fixup), GPRRegister::Encoded_Reg_esi,
+            NotLocked);
     static constexpr uint8_t ByteCountNotLocked16 = 8;
     ASSERT_EQ(ByteCountNotLocked16, codeBytesSize());
     verifyBytes<ByteCountNotLocked16>(codeBytes(), 0x66, 0x0F, 0xC1, 0x35, 0x00,
                                       0xFF, 0x01, 0x00);
     reset();
 
-    __ xadd(IceType_i16, Address::Absolute(0x1FF00),
-            GPRRegister::Encoded_Reg_esi, Locked);
+    __ xadd(IceType_i16, Address(0x1FF00, Fixup), GPRRegister::Encoded_Reg_esi,
+            Locked);
     static constexpr uint8_t ByteCountLocked16 = 1 + ByteCountNotLocked16;
     ASSERT_EQ(ByteCountLocked16, codeBytesSize());
     verifyBytes<ByteCountLocked16>(codeBytes(), 0x66, 0xF0, 0x0F, 0xC1, 0x35,
                                    0x00, 0xFF, 0x01, 0x00);
     reset();
   }
 
   {
-    __ xadd(IceType_i32, Address::Absolute(0x1FF00),
-            GPRRegister::Encoded_Reg_esi, NotLocked);
+    __ xadd(IceType_i32, Address(0x1FF00, Fixup), GPRRegister::Encoded_Reg_esi,
+            NotLocked);
     static constexpr uint8_t ByteCountNotLocked32 = 7;
     ASSERT_EQ(ByteCountNotLocked32, codeBytesSize());
     verifyBytes<ByteCountNotLocked32>(codeBytes(), 0x0F, 0xC1, 0x35, 0x00, 0xFF,
                                       0x01, 0x00);
     reset();
 
-    __ xadd(IceType_i32, Address::Absolute(0x1FF00),
-            GPRRegister::Encoded_Reg_esi, Locked);
+    __ xadd(IceType_i32, Address(0x1FF00, Fixup), GPRRegister::Encoded_Reg_esi,
+            Locked);
     static constexpr uint8_t ByteCountLocked32 = 1 + ByteCountNotLocked32;
     ASSERT_EQ(ByteCountLocked32, codeBytesSize());
     verifyBytes<ByteCountLocked32>(codeBytes(), 0xF0, 0x0F, 0xC1, 0x35, 0x00,
                                    0xFF, 0x01, 0x00);
     reset();
   }
 }
 
 TEST_F(AssemblerX8632Test, Cmpxchg8b) {
   static constexpr bool NotLocked = false;
@@ skipping 39 matching lines @@
   TestImpl(0x98987676543210ull, 0x1, 0x98987676543210ull, Locked);
   TestImpl(0x98987676543210ull, 0x1, 0x98987676543211ull, NotLocked);
   TestImpl(0x98987676543210ull, 0x1, 0x98987676543211ull, Locked);
 
 #undef TestImpl
 }
 
 TEST_F(AssemblerX8632LowLevelTest, Cmpxchg8b) {
   static constexpr bool NotLocked = false;
   static constexpr bool Locked = true;
+  static constexpr AssemblerFixup *Fixup = nullptr;
 
   // Ensures that cmpxchg8b emits a lock prefix accordingly.
-  __ cmpxchg8b(Address::Absolute(0x1FF00), NotLocked);
+  __ cmpxchg8b(Address(0x1FF00, Fixup), NotLocked);
   static constexpr uint8_t ByteCountNotLocked = 7;
   ASSERT_EQ(ByteCountNotLocked, codeBytesSize());
   verifyBytes<ByteCountNotLocked>(codeBytes(), 0x0F, 0xC7, 0x0D, 0x00, 0xFF,
                                   0x01, 0x00);
   reset();
 
-  __ cmpxchg8b(Address::Absolute(0x1FF00), Locked);
+  __ cmpxchg8b(Address(0x1FF00, Fixup), Locked);
   static constexpr uint8_t ByteCountLocked = 1 + ByteCountNotLocked;
   ASSERT_EQ(ByteCountLocked, codeBytesSize());
   verifyBytes<ByteCountLocked>(codeBytes(), 0xF0, 0x0F, 0xC7, 0x0D, 0x00, 0xFF,
                                0x01, 0x00);
   reset();
 }
 
 TEST_F(AssemblerX8632Test, Cmpxchg) {
   static constexpr bool NotLocked = false;
   static constexpr bool Locked = true;
@@ skipping 62 matching lines @@
   TestImpl(edi, NotLocked);
 
 #undef TestImpl
 #undef TestImplValue
 #undef TestImplAddrReg
 }
 
 TEST_F(AssemblerX8632LowLevelTest, Cmpxchg) {
   static constexpr bool NotLocked = false;
   static constexpr bool Locked = true;
+  static constexpr AssemblerFixup *Fixup = nullptr;
 
   // Ensures that cmpxchg emits a lock prefix accordingly.
   {
-    __ cmpxchg(IceType_i8, Address::Absolute(0x1FF00),
+    __ cmpxchg(IceType_i8, Address(0x1FF00, Fixup),
                GPRRegister::Encoded_Reg_esi, NotLocked);
     static constexpr uint8_t ByteCountNotLocked8 = 7;
     ASSERT_EQ(ByteCountNotLocked8, codeBytesSize());
     verifyBytes<ByteCountNotLocked8>(codeBytes(), 0x0F, 0xB0, 0x35, 0x00, 0xFF,
                                      0x01, 0x00);
     reset();
 
-    __ cmpxchg(IceType_i8, Address::Absolute(0x1FF00),
+    __ cmpxchg(IceType_i8, Address(0x1FF00, Fixup),
                GPRRegister::Encoded_Reg_esi, Locked);
     static constexpr uint8_t ByteCountLocked8 = 1 + ByteCountNotLocked8;
     ASSERT_EQ(ByteCountLocked8, codeBytesSize());
     verifyBytes<ByteCountLocked8>(codeBytes(), 0xF0, 0x0F, 0xB0, 0x35, 0x00,
                                   0xFF, 0x01, 0x00);
     reset();
   }
 
   {
-    __ cmpxchg(IceType_i16, Address::Absolute(0x1FF00),
+    __ cmpxchg(IceType_i16, Address(0x1FF00, Fixup),
                GPRRegister::Encoded_Reg_esi, NotLocked);
     static constexpr uint8_t ByteCountNotLocked16 = 8;
     ASSERT_EQ(ByteCountNotLocked16, codeBytesSize());
     verifyBytes<ByteCountNotLocked16>(codeBytes(), 0x66, 0x0F, 0xB1, 0x35, 0x00,
                                       0xFF, 0x01, 0x00);
     reset();
 
-    __ cmpxchg(IceType_i16, Address::Absolute(0x1FF00),
+    __ cmpxchg(IceType_i16, Address(0x1FF00, Fixup),
                GPRRegister::Encoded_Reg_esi, Locked);
     static constexpr uint8_t ByteCountLocked16 = 1 + ByteCountNotLocked16;
     ASSERT_EQ(ByteCountLocked16, codeBytesSize());
     verifyBytes<ByteCountLocked16>(codeBytes(), 0x66, 0xF0, 0x0F, 0xB1, 0x35,
                                    0x00, 0xFF, 0x01, 0x00);
     reset();
   }
 
   {
-    __ cmpxchg(IceType_i32, Address::Absolute(0x1FF00),
+    __ cmpxchg(IceType_i32, Address(0x1FF00, Fixup),
                GPRRegister::Encoded_Reg_esi, NotLocked);
     static constexpr uint8_t ByteCountNotLocked32 = 7;
     ASSERT_EQ(ByteCountNotLocked32, codeBytesSize());
     verifyBytes<ByteCountNotLocked32>(codeBytes(), 0x0F, 0xB1, 0x35, 0x00, 0xFF,
                                       0x01, 0x00);
     reset();
 
-    __ cmpxchg(IceType_i32, Address::Absolute(0x1FF00),
+    __ cmpxchg(IceType_i32, Address(0x1FF00, Fixup),
                GPRRegister::Encoded_Reg_esi, Locked);
     static constexpr uint8_t ByteCountLocked32 = 1 + ByteCountNotLocked32;
     ASSERT_EQ(ByteCountLocked32, codeBytesSize());
     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