Subzero. X8664. Enables RIP-based addressing mode.

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 186 matching lines @@
 #undef TestImplSize
 #undef TestImplAddrReg
 }
 
 TEST_F(AssemblerX8664LowLevelTest, Xadd) {
   static constexpr bool NotLocked = false;
   static constexpr bool Locked = true;
 
   // Ensures that xadd emits a lock prefix accordingly.
   {
-    __ xadd(IceType_i8, Address(0x1FF00, AssemblerFixup::NoFixup),
-            Encoded_GPR_r14(), NotLocked);
+    __ xadd(IceType_i8, Address::Absolute(0x1FF00), Encoded_GPR_r14(),
+            NotLocked);
     static constexpr uint8_t ByteCountNotLocked8 = 10;
     ASSERT_EQ(ByteCountNotLocked8, codeBytesSize());
     ASSERT_TRUE(verifyBytes<ByteCountNotLocked8>(codeBytes(), 0x67, 0x44, 0x0F,
                                                  0xC0, 0x34, 0x25, 0x00, 0xFF,
                                                  0x01, 0x00));
     reset();
 
-    __ xadd(IceType_i8, Address(0x1FF00, AssemblerFixup::NoFixup),
-            Encoded_GPR_r14(), Locked);
+    __ xadd(IceType_i8, Address::Absolute(0x1FF00), Encoded_GPR_r14(), Locked);
     static constexpr uint8_t ByteCountLocked8 = 1 + ByteCountNotLocked8;
     ASSERT_EQ(ByteCountLocked8, codeBytesSize());
     ASSERT_TRUE(verifyBytes<ByteCountLocked8>(codeBytes(), 0xF0, 0x67, 0x44,
                                               0x0F, 0xC0, 0x34, 0x25, 0x00,
                                               0xFF, 0x01, 0x00));
     reset();
   }
 
   {
-    __ xadd(IceType_i16, Address(0x1FF00, AssemblerFixup::NoFixup),
-            Encoded_GPR_r14(), NotLocked);
+    __ xadd(IceType_i16, Address::Absolute(0x1FF00), Encoded_GPR_r14(),
+            NotLocked);
     static constexpr uint8_t ByteCountNotLocked16 = 11;
     ASSERT_EQ(ByteCountNotLocked16, codeBytesSize());
     ASSERT_TRUE(verifyBytes<ByteCountNotLocked16>(codeBytes(), 0x66, 0x67, 0x44,
                                                   0x0F, 0xC1, 0x34, 0x25, 0x00,
                                                   0xFF, 0x01, 0x00));
     reset();
 
-    __ xadd(IceType_i16, Address(0x1FF00, AssemblerFixup::NoFixup),
-            Encoded_GPR_r14(), Locked);
+    __ xadd(IceType_i16, Address::Absolute(0x1FF00), Encoded_GPR_r14(), Locked);
     static constexpr uint8_t ByteCountLocked16 = 1 + ByteCountNotLocked16;
     ASSERT_EQ(ByteCountLocked16, codeBytesSize());
     ASSERT_TRUE(verifyBytes<ByteCountLocked16>(codeBytes(), 0x66, 0xF0, 0x67,
                                                0x44, 0x0F, 0xC1, 0x34, 0x25,
                                                0x00, 0xFF, 0x01, 0x00));
     reset();
   }
 
   {
-    __ xadd(IceType_i32, Address(0x1FF00, AssemblerFixup::NoFixup),
-            Encoded_GPR_r14(), NotLocked);
+    __ xadd(IceType_i32, Address::Absolute(0x1FF00), Encoded_GPR_r14(),
+            NotLocked);
     static constexpr uint8_t ByteCountNotLocked32 = 10;
     ASSERT_EQ(ByteCountNotLocked32, codeBytesSize());
     ASSERT_TRUE(verifyBytes<ByteCountNotLocked32>(codeBytes(), 0x67, 0x44, 0x0F,
                                                   0xC1, 0x34, 0x25, 0x00, 0xFF,
                                                   0x01, 0x00));
     reset();
 
-    __ xadd(IceType_i32, Address(0x1FF00, AssemblerFixup::NoFixup),
-            Encoded_GPR_r14(), Locked);
+    __ xadd(IceType_i32, Address::Absolute(0x1FF00), Encoded_GPR_r14(), Locked);
     static constexpr uint8_t ByteCountLocked32 = 1 + ByteCountNotLocked32;
     ASSERT_EQ(ByteCountLocked32, codeBytesSize());
     ASSERT_TRUE(verifyBytes<ByteCountLocked32>(codeBytes(), 0xF0, 0x67, 0x44,
                                                0x0F, 0xC1, 0x34, 0x25, 0x00,
                                                0xFF, 0x01, 0x00));
     reset();
   }
 }
 
 TEST_F(AssemblerX8664LowLevelTest, EmitSegmentOverride) {
@@ skipping 62 matching lines @@
   TestImpl(0x98987676543210ull, 0x1, 0x98987676543211ull, Locked);
 
 #undef TestImpl
 }
 
 TEST_F(AssemblerX8664LowLevelTest, Cmpxchg8b) {
   static constexpr bool NotLocked = false;
   static constexpr bool Locked = true;
 
   // Ensures that cmpxchg8b emits a lock prefix accordingly.
-  __ cmpxchg8b(Address(0x1FF00, AssemblerFixup::NoFixup), NotLocked);
+  __ cmpxchg8b(Address::Absolute(0x1FF00), NotLocked);
   static constexpr uint8_t ByteCountNotLocked = 9;
   ASSERT_EQ(ByteCountNotLocked, codeBytesSize());
   ASSERT_TRUE(verifyBytes<ByteCountNotLocked>(
       codeBytes(), 0x67, 0x0F, 0xC7, 0x0C, 0x25, 0x00, 0xFF, 0x01, 0x00));
   reset();
 
-  __ cmpxchg8b(Address(0x1FF00, AssemblerFixup::NoFixup), Locked);
+  __ cmpxchg8b(Address::Absolute(0x1FF00), Locked);
   static constexpr uint8_t ByteCountLocked = 1 + ByteCountNotLocked;
   ASSERT_EQ(ByteCountLocked, codeBytesSize());
   ASSERT_TRUE(verifyBytes<ByteCountLocked>(codeBytes(), 0xF0, 0x67, 0x0F, 0xC7,
                                            0x0C, 0x25, 0x00, 0xFF, 0x01, 0x00));
   reset();
 }
 
 TEST_F(AssemblerX8664Test, Cmpxchg) {
   static constexpr bool NotLocked = false;
   static constexpr bool Locked = true;
@@ skipping 79 matching lines @@
 #undef TestImplValue
 #undef TestImplAddrReg
 }
 
 TEST_F(AssemblerX8664LowLevelTest, Cmpxchg) {
   static constexpr bool NotLocked = false;
   static constexpr bool Locked = true;
 
   // Ensures that cmpxchg emits a lock prefix accordingly.
   {
-    __ cmpxchg(IceType_i8, Address(0x1FF00, AssemblerFixup::NoFixup),
-               Encoded_GPR_r14(), NotLocked);
+    __ cmpxchg(IceType_i8, Address::Absolute(0x1FF00), Encoded_GPR_r14(),
+               NotLocked);
     static constexpr uint8_t ByteCountNotLocked8 = 10;
     ASSERT_EQ(ByteCountNotLocked8, codeBytesSize());
     ASSERT_TRUE(verifyBytes<ByteCountNotLocked8>(codeBytes(), 0x67, 0x44, 0x0F,
                                                  0xB0, 0x34, 0x25, 0x00, 0xFF,
                                                  0x01, 0x00));
     reset();
 
-    __ cmpxchg(IceType_i8, Address(0x1FF00, AssemblerFixup::NoFixup),
-               Encoded_GPR_r14(), Locked);
+    __ cmpxchg(IceType_i8, Address::Absolute(0x1FF00), Encoded_GPR_r14(),
+               Locked);
     static constexpr uint8_t ByteCountLocked8 = 1 + ByteCountNotLocked8;
     ASSERT_EQ(ByteCountLocked8, codeBytesSize());
     ASSERT_TRUE(verifyBytes<ByteCountLocked8>(codeBytes(), 0xF0, 0x67, 0x44,
                                               0x0F, 0xB0, 0x34, 0x25, 0x00,
                                               0xFF, 0x01, 0x00));
     reset();
   }
 
   {
-    __ cmpxchg(IceType_i16, Address(0x1FF00, AssemblerFixup::NoFixup),
-               Encoded_GPR_r14(), NotLocked);
+    __ cmpxchg(IceType_i16, Address::Absolute(0x1FF00), Encoded_GPR_r14(),
+               NotLocked);
     static constexpr uint8_t ByteCountNotLocked16 = 11;
     ASSERT_EQ(ByteCountNotLocked16, codeBytesSize());
     ASSERT_TRUE(verifyBytes<ByteCountNotLocked16>(codeBytes(), 0x66, 0x67, 0x44,
                                                   0x0F, 0xB1, 0x34, 0x25, 0x00,
                                                   0xFF, 0x01, 0x00));
     reset();
 
-    __ cmpxchg(IceType_i16, Address(0x1FF00, AssemblerFixup::NoFixup),
-               Encoded_GPR_r14(), Locked);
+    __ cmpxchg(IceType_i16, Address::Absolute(0x1FF00), Encoded_GPR_r14(),
+               Locked);
     static constexpr uint8_t ByteCountLocked16 = 1 + ByteCountNotLocked16;
     ASSERT_EQ(ByteCountLocked16, codeBytesSize());
     ASSERT_TRUE(verifyBytes<ByteCountLocked16>(codeBytes(), 0x66, 0xF0, 0x67,
                                                0x44, 0x0F, 0xB1, 0x34, 0x25,
                                                0x00, 0xFF, 0x01, 0x00));
     reset();
   }
 
   {
-    __ cmpxchg(IceType_i32, Address(0x1FF00, AssemblerFixup::NoFixup),
-               Encoded_GPR_r14(), NotLocked);
+    __ cmpxchg(IceType_i32, Address::Absolute(0x1FF00), Encoded_GPR_r14(),
+               NotLocked);
     static constexpr uint8_t ByteCountNotLocked32 = 10;
     ASSERT_EQ(ByteCountNotLocked32, codeBytesSize());
     ASSERT_TRUE(verifyBytes<ByteCountNotLocked32>(codeBytes(), 0x67, 0x44, 0x0F,
                                                   0xB1, 0x34, 0x25, 0x00, 0xFF,
                                                   0x01, 0x00));
     reset();
 
-    __ cmpxchg(IceType_i32, Address(0x1FF00, AssemblerFixup::NoFixup),
-               Encoded_GPR_r14(), Locked);
+    __ cmpxchg(IceType_i32, Address::Absolute(0x1FF00), Encoded_GPR_r14(),
+               Locked);
     static constexpr uint8_t ByteCountLocked32 = 1 + ByteCountNotLocked32;
     ASSERT_EQ(ByteCountLocked32, codeBytesSize());
     ASSERT_TRUE(verifyBytes<ByteCountLocked32>(codeBytes(), 0xF0, 0x67, 0x44,
                                                0x0F, 0xB1, 0x34, 0x25, 0x00,
                                                0xFF, 0x01, 0x00));
     reset();
   }
 }
 
 } // end of anonymous namespace
 } // end of namespace Test
 } // end of namespace X8664
 } // end of namespace Ice