Enhance address mode recovery

unittest/AssemblerX8664/Locked.cpp

 //===- subzero/unittest/AssemblerX8664/Locked.cpp -------------------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 #include "AssemblerX8664/TestUtil.h"
 
@@ skipping 183 matching lines @@
   TestImpl(r15);
 
 #undef TestImpl
 #undef TestImplSize
 #undef TestImplAddrReg
 }
 
 TEST_F(AssemblerX8664LowLevelTest, 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), Encoded_GPR_r14(),
-            NotLocked);
+    __ xadd(IceType_i8, Address(0x1FF00, Fixup), Encoded_GPR_r14(), NotLocked);
     static constexpr uint8_t ByteCountNotLocked8 = 8;
     ASSERT_EQ(ByteCountNotLocked8, codeBytesSize());
     ASSERT_TRUE(verifyBytes<ByteCountNotLocked8>(codeBytes(), 0x44, 0x0F, 0xC0,
                                                  0x35, 0x00, 0xFF, 0x01, 0x00));
     reset();
 
-    __ xadd(IceType_i8, Address::Absolute(0x1FF00), Encoded_GPR_r14(), Locked);
+    __ xadd(IceType_i8, Address(0x1FF00, Fixup), Encoded_GPR_r14(), Locked);
     static constexpr uint8_t ByteCountLocked8 = 1 + ByteCountNotLocked8;
     ASSERT_EQ(ByteCountLocked8, codeBytesSize());
     ASSERT_TRUE(verifyBytes<ByteCountLocked8>(
         codeBytes(), 0xF0, 0x44, 0x0F, 0xC0, 0x35, 0x00, 0xFF, 0x01, 0x00));
     reset();
   }
 
   {
-    __ xadd(IceType_i16, Address::Absolute(0x1FF00), Encoded_GPR_r14(),
-            NotLocked);
+    __ xadd(IceType_i16, Address(0x1FF00, Fixup), Encoded_GPR_r14(), NotLocked);
     static constexpr uint8_t ByteCountNotLocked16 = 9;
     ASSERT_EQ(ByteCountNotLocked16, codeBytesSize());
     ASSERT_TRUE(verifyBytes<ByteCountNotLocked16>(
         codeBytes(), 0x66, 0x44, 0x0F, 0xC1, 0x35, 0x00, 0xFF, 0x01, 0x00));
     reset();
 
-    __ xadd(IceType_i16, Address::Absolute(0x1FF00), Encoded_GPR_r14(), Locked);
+    __ xadd(IceType_i16, Address(0x1FF00, Fixup), Encoded_GPR_r14(), Locked);
     static constexpr uint8_t ByteCountLocked16 = 1 + ByteCountNotLocked16;
     ASSERT_EQ(ByteCountLocked16, codeBytesSize());
     ASSERT_TRUE(verifyBytes<ByteCountLocked16>(codeBytes(), 0x66, 0xF0, 0x44,
                                                0x0F, 0xC1, 0x35, 0x00, 0xFF,
                                                0x01, 0x00));
     reset();
   }
 
   {
-    __ xadd(IceType_i32, Address::Absolute(0x1FF00), Encoded_GPR_r14(),
-            NotLocked);
+    __ xadd(IceType_i32, Address(0x1FF00, Fixup), Encoded_GPR_r14(), NotLocked);
     static constexpr uint8_t ByteCountNotLocked32 = 8;
     ASSERT_EQ(ByteCountNotLocked32, codeBytesSize());
     ASSERT_TRUE(verifyBytes<ByteCountNotLocked32>(
         codeBytes(), 0x44, 0x0F, 0xC1, 0x35, 0x00, 0xFF, 0x01, 0x00));
     reset();
 
-    __ xadd(IceType_i32, Address::Absolute(0x1FF00), Encoded_GPR_r14(), Locked);
+    __ xadd(IceType_i32, Address(0x1FF00, Fixup), Encoded_GPR_r14(), Locked);
     static constexpr uint8_t ByteCountLocked32 = 1 + ByteCountNotLocked32;
     ASSERT_EQ(ByteCountLocked32, codeBytesSize());
     ASSERT_TRUE(verifyBytes<ByteCountLocked32>(
         codeBytes(), 0xF0, 0x44, 0x0F, 0xC1, 0x35, 0x00, 0xFF, 0x01, 0x00));
     reset();
   }
 }
 
 TEST_F(AssemblerX8664LowLevelTest, EmitSegmentOverride) {
 #define TestImpl(Prefix)                                                       \
@@ skipping 59 matching lines @@
   TestImpl(0x98987676543210ull, 0x1, 0x98987676543210ull, Locked);
   TestImpl(0x98987676543210ull, 0x1, 0x98987676543211ull, NotLocked);
   TestImpl(0x98987676543210ull, 0x1, 0x98987676543211ull, Locked);
 
 #undef TestImpl
 }
 
 TEST_F(AssemblerX8664LowLevelTest, 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());
   ASSERT_TRUE(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());
   ASSERT_TRUE(verifyBytes<ByteCountLocked>(codeBytes(), 0xF0, 0x0F, 0xC7, 0x0D,
                                            0x00, 0xFF, 0x01, 0x00));
   reset();
 }
 
 TEST_F(AssemblerX8664Test, Cmpxchg) {
   static constexpr bool NotLocked = false;
   static constexpr bool Locked = true;
@@ skipping 76 matching lines @@
   TestImpl(r15, NotLocked);
 
 #undef TestImpl
 #undef TestImplValue
 #undef TestImplAddrReg
 }
 
 TEST_F(AssemblerX8664LowLevelTest, 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), Encoded_GPR_r14(),
+    __ cmpxchg(IceType_i8, Address(0x1FF00, Fixup), Encoded_GPR_r14(),
                NotLocked);
     static constexpr uint8_t ByteCountNotLocked8 = 8;
     ASSERT_EQ(ByteCountNotLocked8, codeBytesSize());
     ASSERT_TRUE(verifyBytes<ByteCountNotLocked8>(codeBytes(), 0x44, 0x0F, 0xB0,
                                                  0x35, 0x00, 0xFF, 0x01, 0x00));
     reset();
 
-    __ cmpxchg(IceType_i8, Address::Absolute(0x1FF00), Encoded_GPR_r14(),
-               Locked);
+    __ cmpxchg(IceType_i8, Address(0x1FF00, Fixup), Encoded_GPR_r14(), Locked);
     static constexpr uint8_t ByteCountLocked8 = 1 + ByteCountNotLocked8;
     ASSERT_EQ(ByteCountLocked8, codeBytesSize());
     ASSERT_TRUE(verifyBytes<ByteCountLocked8>(
         codeBytes(), 0xF0, 0x44, 0x0F, 0xB0, 0x35, 0x00, 0xFF, 0x01, 0x00));
     reset();
   }
 
   {
-    __ cmpxchg(IceType_i16, Address::Absolute(0x1FF00), Encoded_GPR_r14(),
+    __ cmpxchg(IceType_i16, Address(0x1FF00, Fixup), Encoded_GPR_r14(),
                NotLocked);
     static constexpr uint8_t ByteCountNotLocked16 = 9;
     ASSERT_EQ(ByteCountNotLocked16, codeBytesSize());
     ASSERT_TRUE(verifyBytes<ByteCountNotLocked16>(
         codeBytes(), 0x66, 0x44, 0x0F, 0xB1, 0x35, 0x00, 0xFF, 0x01, 0x00));
     reset();
 
-    __ cmpxchg(IceType_i16, Address::Absolute(0x1FF00), Encoded_GPR_r14(),
-               Locked);
+    __ cmpxchg(IceType_i16, Address(0x1FF00, Fixup), Encoded_GPR_r14(), Locked);
     static constexpr uint8_t ByteCountLocked16 = 1 + ByteCountNotLocked16;
     ASSERT_EQ(ByteCountLocked16, codeBytesSize());
     ASSERT_TRUE(verifyBytes<ByteCountLocked16>(codeBytes(), 0x66, 0xF0, 0x44,
                                                0x0F, 0xB1, 0x35, 0x00, 0xFF,
                                                0x01, 0x00));
     reset();
   }
 
   {
-    __ cmpxchg(IceType_i32, Address::Absolute(0x1FF00), Encoded_GPR_r14(),
+    __ cmpxchg(IceType_i32, Address(0x1FF00, Fixup), Encoded_GPR_r14(),
                NotLocked);
     static constexpr uint8_t ByteCountNotLocked32 = 8;
     ASSERT_EQ(ByteCountNotLocked32, codeBytesSize());
     ASSERT_TRUE(verifyBytes<ByteCountNotLocked32>(
         codeBytes(), 0x44, 0x0F, 0xB1, 0x35, 0x00, 0xFF, 0x01, 0x00));
     reset();
 
-    __ cmpxchg(IceType_i32, Address::Absolute(0x1FF00), Encoded_GPR_r14(),
-               Locked);
+    __ cmpxchg(IceType_i32, Address(0x1FF00, Fixup), Encoded_GPR_r14(), Locked);
     static constexpr uint8_t ByteCountLocked32 = 1 + ByteCountNotLocked32;
     ASSERT_EQ(ByteCountLocked32, codeBytesSize());
     ASSERT_TRUE(verifyBytes<ByteCountLocked32>(
         codeBytes(), 0xF0, 0x44, 0x0F, 0xB1, 0x35, 0x00, 0xFF, 0x01, 0x00));
     reset();
   }
 }
 
 } // end of anonymous namespace
 } // end of namespace Test
 } // end of namespace X8664
 } // end of namespace Ice