//===- subzero/unittest/AssemblerX8664/DataMov.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"

namespace Ice {
namespace X8664 {
namespace Test {
namespace {

TEST_F(AssemblerX8664Test, MovRegImm) {
  static constexpr uint32_t Mask8 = 0x000000FF;
  static constexpr uint32_t Mask16 = 0x0000FFFF;
  static constexpr uint32_t Mask32 = 0xFFFFFFFF;

#define MovRegImm(Reg, Suffix, Size)                                           \
  do {                                                                         \
    static constexpr char TestString[] = "(" #Reg ", " #Size ")";              \
    static constexpr uint32_t Value = (0xABCD7645) & Mask##Size;               \
    static constexpr uint32_t Marker = 0xBEEFFEEB;                             \
    __ mov(IceType_i32, Encoded_GPR_##Reg##q(), Immediate(Marker));            \
    __ mov(IceType_i##Size, Encoded_GPR_##Reg##Suffix(), Immediate(Value));    \
                                                                               \
    AssembledTest test = assemble();                                           \
    test.run();                                                                \
                                                                               \
    ASSERT_EQ(Value, test.Reg##Suffix()) << TestString;                        \
    ASSERT_EQ((Marker & ~Mask##Size) | Value, test.Reg##d()) << TestString;    \
    reset();                                                                   \
  } while (0)

#define TestImpl(Reg)                                                          \
  do {                                                                         \
    MovRegImm(Reg, l, 8);                                                      \
    MovRegImm(Reg, w, 16);                                                     \
    MovRegImm(Reg, d, 32);                                                     \
    /* MovRegImm64 not implemented */                                          \
  } while (0)

  TestImpl(r1);
  TestImpl(r2);
  TestImpl(r3);
  TestImpl(r4);
  TestImpl(r5);
  TestImpl(r6);
  TestImpl(r7);
  TestImpl(r8);
  TestImpl(r10);
  TestImpl(r11);
  TestImpl(r12);
  TestImpl(r13);
  TestImpl(r14);
  TestImpl(r15);

#undef TestImpl
#undef MovRegImm
}

TEST_F(AssemblerX8664Test, MovMemImm) {
  const uint32_t T0 = allocateDword();
  constexpr uint32_t ExpectedT0 = 0x00111100ul;
  const uint32_t T1 = allocateDword();
  constexpr uint32_t ExpectedT1 = 0x00222200ul;
  const uint32_t T2 = allocateDword();
  constexpr uint32_t ExpectedT2 = 0x03333000ul;
  const uint32_t T3 = allocateDword();
  constexpr uint32_t ExpectedT3 = 0x00444400ul;

  __ mov(IceType_i32, dwordAddress(T0), Immediate(ExpectedT0));
  __ mov(IceType_i16, dwordAddress(T1), Immediate(ExpectedT1));
  __ mov(IceType_i8, dwordAddress(T2), Immediate(ExpectedT2));
  __ mov(IceType_i32, dwordAddress(T3), Immediate(ExpectedT3));

  AssembledTest test = assemble();
  test.run();
  EXPECT_EQ(0ul, test.eax());
  EXPECT_EQ(0ul, test.ebx());
  EXPECT_EQ(0ul, test.ecx());
  EXPECT_EQ(0ul, test.edx());
  EXPECT_EQ(0ul, test.edi());
  EXPECT_EQ(0ul, test.esi());
  EXPECT_EQ(ExpectedT0, test.contentsOfDword(T0));
  EXPECT_EQ(ExpectedT1 & 0xFFFF, test.contentsOfDword(T1));
  EXPECT_EQ(ExpectedT2 & 0xFF, test.contentsOfDword(T2));
  EXPECT_EQ(ExpectedT3, test.contentsOfDword(T3));
}

TEST_F(AssemblerX8664Test, MovMemReg) {
  static constexpr uint64_t Mask8 = 0x00000000000000FF;
  static constexpr uint64_t Mask16 = 0x000000000000FFFF;
  static constexpr uint64_t Mask32 = 0x00000000FFFFFFFF;
  static constexpr uint64_t Mask64 = 0xFFFFFFFFFFFFFFFF;

#define TestMemReg(Src, Size)                                                  \
  do {                                                                         \
    static constexpr char TestString[] = "(" #Src ", " #Size ")";              \
    static constexpr uint32_t Value = 0x1a4d567e & Mask##Size;                 \
    static constexpr uint64_t Marker = 0xD0DA33EEBEEFFEEB;                     \
    const uint32_t T0 = allocateQword();                                       \
                                                                               \
    __ mov(IceType_i32, Encoded_GPR_##Src(), Immediate(Value));                \
    __ mov(IceType_i##Size, dwordAddress(T0), Encoded_GPR_##Src());            \
                                                                               \
    AssembledTest test = assemble();                                           \
    test.setQwordTo(T0, Marker);                                               \
    test.run();                                                                \
                                                                               \
    ASSERT_EQ((Marker & ~Mask##Size) | Value, test.contentsOfQword(T0))        \
        << TestString;                                                         \
    reset();                                                                   \
  } while (0)

#define TestImpl(Src)                                                          \
  do {                                                                         \
    TestMemReg(Src, 8);                                                        \
    TestMemReg(Src, 16);                                                       \
    TestMemReg(Src, 32);                                                       \
    TestMemReg(Src, 64);                                                       \
  } while (0)

  TestImpl(r1);
  TestImpl(r2);
  TestImpl(r3);
  TestImpl(r4);
  TestImpl(r5);
  TestImpl(r6);
  TestImpl(r7);
  TestImpl(r8);
  TestImpl(r10);
  TestImpl(r11);
  TestImpl(r12);
  TestImpl(r13);
  TestImpl(r14);
  TestImpl(r15);

#undef TestImpl
#undef TestMemReg
}

TEST_F(AssemblerX8664Test, MovRegReg) {
  static constexpr uint64_t Mask8 = 0x00000000000000FFull;
  static constexpr uint64_t Mask16 = 0x000000000000FFFFull;
  static constexpr uint64_t Mask32 = 0x00000000FFFFFFFFull;
  static constexpr uint64_t Mask64 = 0xFFFFFFFFFFFFFFFFull;

  static constexpr uint64_t MaskResult8 = 0x00000000000000FFull;
  static constexpr uint64_t MaskResult16 = 0x000000000000FFFFull;
  static constexpr uint64_t MaskResult32 = 0xFFFFFFFFFFFFFFFFull;
  static constexpr uint64_t MaskResult64 = 0xFFFFFFFFFFFFFFFFull;

#define TestRegReg(Dst, Src, Suffix, Size)                                     \
  do {                                                                         \
    static constexpr char TestString[] =                                       \
        "(" #Dst ", " #Src ", " #Suffix ", " #Size ")";                        \
    const uint8_t T0 = allocateQword();                                        \
    static constexpr uint64_t Value = 0xA4DD30Af86CCE321ull & Mask##Size;      \
    const uint8_t T1 = allocateQword();                                        \
    static constexpr uint64_t Marker = 0xC0FFEEA0BEEFFEEFull;                  \
                                                                               \
    __ mov(IceType_i64, Encoded_GPR_##Src(), dwordAddress(T0));                \
    __ mov(IceType_i64, Encoded_GPR_##Dst(), dwordAddress(T1));                \
    __ mov(IceType_i##Size, Encoded_GPR_##Dst(), Encoded_GPR_##Src());         \
                                                                               \
    AssembledTest test = assemble();                                           \
    test.setQwordTo(T0, Value);                                                \
    test.setQwordTo(T1, Marker);                                               \
    test.run();                                                                \
                                                                               \
    ASSERT_EQ((Marker & ~MaskResult##Size) | Value, test.Dst()) << TestString; \
    ASSERT_EQ(Value, test.Dst##Suffix()) << TestString;                        \
    reset();                                                                   \
  } while (0)

#define TestImpl(Dst, Src)                                                     \
  do {                                                                         \
    TestRegReg(Dst, Src, l, 8);                                                \
    TestRegReg(Dst, Src, w, 16);                                               \
    TestRegReg(Dst, Src, d, 32);                                               \
    TestRegReg(Dst, Src, q, 64);                                               \
  } while (0)

  TestImpl(r1, r2);
  TestImpl(r2, r3);
  TestImpl(r3, r4);
  TestImpl(r4, r5);
  TestImpl(r5, r6);
  TestImpl(r6, r7);
  TestImpl(r7, r8);
  TestImpl(r8, r10);
  TestImpl(r10, r11);
  TestImpl(r11, r12);
  TestImpl(r12, r13);
  TestImpl(r13, r14);
  TestImpl(r14, r15);
  TestImpl(r15, r1);

#undef TestImpl
#undef TestRegReg
}

TEST_F(AssemblerX8664Test, MovRegMem) {
  static constexpr uint64_t Mask8 = 0x00000000000000FFull;
  static constexpr uint64_t Mask16 = 0x000000000000FFFFull;
  static constexpr uint64_t Mask32 = 0x00000000FFFFFFFFull;
  static constexpr uint64_t Mask64 = 0xFFFFFFFFFFFFFFFFull;

  static constexpr uint64_t MaskResult8 = ~0x00000000000000FFull;
  static constexpr uint64_t MaskResult16 = ~0x000000000000FFFFull;
  static constexpr uint64_t MaskResult32 = ~0xFFFFFFFFFFFFFFFFull;
  static constexpr uint64_t MaskResult64 = ~0xFFFFFFFFFFFFFFFFull;

#define TestRegAddr(Dst, Suffix, Size)                                         \
  do {                                                                         \
    static constexpr char TestString[] =                                       \
        "(" #Dst ", Addr, " #Suffix ", " #Size ")";                            \
    const uint8_t T0 = allocateQword();                                        \
    static constexpr uint64_t Value = 0xA4DD30Af86CCE321ull & Mask##Size;      \
    const uint8_t T1 = allocateQword();                                        \
    static constexpr uint64_t Marker = 0xC0FFEEA0BEEFFEEFull;                  \
                                                                               \
    __ mov(IceType_i64, Encoded_GPR_##Dst(), dwordAddress(T1));                \
    __ mov(IceType_i##Size, Encoded_GPR_##Dst(), dwordAddress(T0));            \
                                                                               \
    AssembledTest test = assemble();                                           \
    test.setQwordTo(T0, Value);                                                \
    test.setQwordTo(T1, Marker);                                               \
    test.run();                                                                \
                                                                               \
    ASSERT_EQ((Marker & MaskResult##Size) | Value, test.Dst()) << TestString;  \
    ASSERT_EQ(Value, test.Dst##Suffix()) << TestString;                        \
    reset();                                                                   \
  } while (0)

#define TestImpl(Dst)                                                          \
  do {                                                                         \
    TestRegAddr(Dst, l, 8);                                                    \
    TestRegAddr(Dst, w, 16);                                                   \
    TestRegAddr(Dst, d, 32);                                                   \
    TestRegAddr(Dst, q, 64);                                                   \
  } while (0)

  TestImpl(r1);
  TestImpl(r2);
  TestImpl(r3);
  TestImpl(r4);
  TestImpl(r5);
  TestImpl(r6);
  TestImpl(r7);
  TestImpl(r8);
  TestImpl(r10);
  TestImpl(r11);
  TestImpl(r12);
  TestImpl(r13);
  TestImpl(r14);
  TestImpl(r15);

#undef TestImpl
#undef TestRegAddr
}

TEST_F(AssemblerX8664Test, Movabs) {
#define TestImplValue(Dst, Value)                                              \
  do {                                                                         \
    static constexpr char TestString[] = "(" #Dst ", " #Value ")";             \
    uint64_t V = (Value);                                                      \
    __ movabs(Encoded_GPR_##Dst##q(), V);                                      \
                                                                               \
    AssembledTest test = assemble();                                           \
                                                                               \
    test.run();                                                                \
                                                                               \
    ASSERT_EQ(V, test.DST()) << TestString;                                    \
  } while (0)

#define TestImpl(Dst)                                                          \
  do {                                                                         \
    for (uint64_t V = {0, 1, 0xFFFFFFull, 0x80000000ull,                       \
                       0xFFFFFFFFFFFFFFFFull}) {                               \
      TestImpl(Dst, V);                                                        \
    }                                                                          \
  } while (0)

#undef TestImpl
#undef TestImplValue
}

TEST_F(AssemblerX8664Test, Movzx) {
  static constexpr uint32_t Mask8 = 0x000000FF;
  static constexpr uint32_t Mask16 = 0x0000FFFF;

#define TestImplRegReg(Dst, Src, Suffix, Size)                                 \
  do {                                                                         \
    const uint32_t T0 = allocateDqword();                                      \
    static constexpr uint64_t V0 = 0xAAAAAAAAAAAAAAAAull;                      \
    static constexpr uint32_t Value = (0xBEEF) & Mask##Size;                   \
    __ mov(IceType_i64, Encoded_GPR_##Dst##q(), dwordAddress(T0));             \
    __ mov(IceType_i##Size, Encoded_GPR_##Src##Suffix(), Immediate(Value));    \
    __ movzx(IceType_i##Size, Encoded_GPR_##Dst##d(),                          \
             Encoded_GPR_##Src##Suffix());                                     \
    AssembledTest test = assemble();                                           \
    test.setQwordTo(T0, V0);                                                   \
    test.run();                                                                \
    ASSERT_EQ(Value, test.Dst##q()) << "(" #Dst ", " #Src ", " #Size ")";      \
    reset();                                                                   \
  } while (0)

#define TestImplRegAddr(Dst, Suffix, Size)                                     \
  do {                                                                         \
    const uint32_t T0 = allocateDqword();                                      \
    static constexpr uint64_t V0 = 0xAAAAAAAAAAAAAAAAull;                      \
    static constexpr uint32_t Value = (0xBEEF) & Mask##Size;                   \
    __ movzx(IceType_i##Size, Encoded_GPR_##Dst##d(), dwordAddress(T0));       \
                                                                               \
    AssembledTest test = assemble();                                           \
    test.setQwordTo(T0, (V0 & ~Mask##Size) | Value);                           \
    test.run();                                                                \
    ASSERT_EQ(Value, test.Dst##q()) << "(" #Dst ", Addr, " #Size ")";          \
    reset();                                                                   \
  } while (0)

#define TestImpl(Dst, Src)                                                     \
  do {                                                                         \
    TestImplRegReg(Dst, Src, l, 8);                                            \
    TestImplRegAddr(Dst, l, 8);                                                \
    TestImplRegReg(Dst, Src, w, 16);                                           \
    TestImplRegAddr(Dst, w, 16);                                               \
  } while (0)

  TestImpl(r1, r2);
  TestImpl(r2, r3);
  TestImpl(r3, r4);
  TestImpl(r4, r5);
  TestImpl(r5, r6);
  TestImpl(r6, r7);
  TestImpl(r7, r8);
  TestImpl(r8, r10);
  TestImpl(r10, r11);
  TestImpl(r11, r12);
  TestImpl(r12, r13);
  TestImpl(r13, r14);
  TestImpl(r14, r15);
  TestImpl(r15, r1);

#undef TestImpl
#undef TestImplRegAddr
#undef TestImplRegReg
}

TEST_F(AssemblerX8664Test, Movsx) {
  static constexpr uint64_t Mask8 = 0x000000FF;
  static constexpr uint64_t Mask16 = 0x0000FFFF;
  static constexpr uint64_t Mask32 = 0xFFFFFFFF;

#define TestImplRegReg(Dst, Src, Suffix, Size)                                 \
  do {                                                                         \
    const uint32_t T0 = allocateDqword();                                      \
    static constexpr uint64_t V0 = 0xAAAAAAAAAAAAAAAAull;                      \
    static constexpr uint64_t Value = (0xC0BEBEEF) & Mask##Size;               \
    __ mov(IceType_i64, Encoded_GPR_##Dst##q(), dwordAddress(T0));             \
    __ mov(IceType_i##Size, Encoded_GPR_##Src##Suffix(), Immediate(Value));    \
    __ movsx(IceType_i##Size, Encoded_GPR_##Dst##d(),                          \
             Encoded_GPR_##Src##Suffix());                                     \
    AssembledTest test = assemble();                                           \
    test.setQwordTo(T0, V0);                                                   \
    test.run();                                                                \
    ASSERT_EQ((uint64_t(-1) & ~Mask##Size) | Value, test.Dst##q())             \
        << "(" #Dst ", " #Src ", " #Size ")";                                  \
    reset();                                                                   \
  } while (0)

#define TestImplRegAddr(Dst, Suffix, Size)                                     \
  do {                                                                         \
    const uint32_t T0 = allocateDqword();                                      \
    static constexpr uint64_t V0 = 0xC0BEBEEF & Mask##Size;                    \
    static constexpr uint64_t Value = (0xC0BEBEEF) & Mask##Size;               \
    __ movsx(IceType_i##Size, Encoded_GPR_##Dst##d(), dwordAddress(T0));       \
                                                                               \
    AssembledTest test = assemble();                                           \
    test.setQwordTo(T0, V0);                                                   \
    test.run();                                                                \
    ASSERT_EQ((uint64_t(-1) & ~Mask##Size) | Value, test.Dst##q())             \
        << "(" #Dst ", Addr, " #Size ")";                                      \
    reset();                                                                   \
  } while (0)

#define TestImpl(Dst, Src)                                                     \
  do {                                                                         \
    TestImplRegReg(Dst, Src, l, 8);                                            \
    TestImplRegAddr(Dst, l, 8);                                                \
    TestImplRegReg(Dst, Src, w, 16);                                           \
    TestImplRegAddr(Dst, w, 16);                                               \
    TestImplRegReg(Dst, Src, w, 32);                                           \
    TestImplRegAddr(Dst, w, 32);                                               \
  } while (0)

  TestImpl(r1, r2);
  TestImpl(r2, r3);
  TestImpl(r3, r4);
  TestImpl(r4, r5);
  TestImpl(r5, r6);
  TestImpl(r6, r7);
  TestImpl(r7, r8);
  TestImpl(r8, r10);
  TestImpl(r10, r11);
  TestImpl(r11, r12);
  TestImpl(r12, r13);
  TestImpl(r13, r14);
  TestImpl(r14, r15);
  TestImpl(r15, r1);

#undef TestImpl
#undef TestImplRegAddr
#undef TestImplRegReg
}

TEST_F(AssemblerX8664Test, Cmov) {
#define TestRegReg(C, Dest, IsTrue, Src0, Value0, Src1, Value1)                \
  do {                                                                         \
    static constexpr char TestString[] =                                       \
        "(" #C ", " #Dest ", " #IsTrue ", " #Src0 ", " #Value0 ", " #Src1      \
        ", " #Value1 ")";                                                      \
    __ mov(IceType_i32, Encoded_GPR_##Src0(), Immediate(Value0));              \
    __ mov(IceType_i32, Encoded_GPR_##Src1(), Immediate(Value1));              \
    __ mov(IceType_i32, Encoded_GPR_##Dest(), Immediate(Value0));              \
    __ cmp(IceType_i32, Encoded_GPR_##Src0(), Encoded_GPR_##Src1());           \
    __ cmov(IceType_i32, Cond::Br_##C, Encoded_GPR_##Dest(),                   \
            Encoded_GPR_##Src1());                                             \
                                                                               \
    AssembledTest test = assemble();                                           \
    test.run();                                                                \
    ASSERT_EQ((IsTrue) ? (Value1) : (Value0), test.Dest()) << TestString;      \
                                                                               \
    reset();                                                                   \
  } while (0)

#define TestRegAddr(C, Dest, IsTrue, Src0, Value0, Value1)                     \
  do {                                                                         \
    static constexpr char TestString[] =                                       \
        "(" #C ", " #Dest ", " #IsTrue ", " #Src0 ", " #Value0                 \
        ", Addr, " #Value1 ")";                                                \
    const uint32_t T0 = allocateDword();                                       \
    const uint32_t V0 = Value1;                                                \
    __ mov(IceType_i32, Encoded_GPR_##Src0(), Immediate(Value0));              \
    __ mov(IceType_i32, Encoded_GPR_##Dest(), Immediate(Value0));              \
    __ cmp(IceType_i32, Encoded_GPR_##Src0(), dwordAddress(T0));               \
    __ cmov(IceType_i32, Cond::Br_##C, Encoded_GPR_##Dest(),                   \
            dwordAddress(T0));                                                 \
                                                                               \
    AssembledTest test = assemble();                                           \
    test.setDwordTo(T0, V0);                                                   \
    test.run();                                                                \
    ASSERT_EQ((IsTrue) ? (Value1) : (Value0), test.Dest()) << TestString;      \
                                                                               \
    reset();                                                                   \
  } while (0)

#define TestValue(C, Dest, IsTrue, Src0, Value0, Src1, Value1)                 \
  do {                                                                         \
    TestRegReg(C, Dest, IsTrue, Src0, Value0, Src1, Value1);                   \
    TestRegAddr(C, Dest, IsTrue, Src0, Value0, Value1);                        \
  } while (0)

#define TestImpl(Dest, Src0, Src1)                                             \
  do {                                                                         \
    TestValue(o, Dest, 1u, Src0, 0x80000000u, Src1, 0x1u);                     \
    TestValue(o, Dest, 0u, Src0, 0x1u, Src1, 0x10000000u);                     \
    TestValue(no, Dest, 1u, Src0, 0x1u, Src1, 0x10000000u);                    \
    TestValue(no, Dest, 0u, Src0, 0x80000000u, Src1, 0x1u);                    \
    TestValue(b, Dest, 1u, Src0, 0x1, Src1, 0x80000000u);                      \
    TestValue(b, Dest, 0u, Src0, 0x80000000u, Src1, 0x1u);                     \
    TestValue(ae, Dest, 1u, Src0, 0x80000000u, Src1, 0x1u);                    \
    TestValue(ae, Dest, 0u, Src0, 0x1u, Src1, 0x80000000u);                    \
    TestValue(e, Dest, 1u, Src0, 0x1u, Src1, 0x1u);                            \
    TestValue(e, Dest, 0u, Src0, 0x1u, Src1, 0x11111u);                        \
    TestValue(ne, Dest, 1u, Src0, 0x80000000u, Src1, 0x1u);                    \
    TestValue(ne, Dest, 0u, Src0, 0x1u, Src1, 0x1u);                           \
    TestValue(be, Dest, 1u, Src0, 0x1u, Src1, 0x80000000u);                    \
    TestValue(be, Dest, 0u, Src0, 0x80000000u, Src1, 0x1u);                    \
    TestValue(a, Dest, 1u, Src0, 0x80000000u, Src1, 0x1u);                     \
    TestValue(a, Dest, 0u, Src0, 0x1u, Src1, 0x80000000u);                     \
    TestValue(s, Dest, 1u, Src0, 0x1u, Src1, 0x80000000u);                     \
    TestValue(s, Dest, 0u, Src0, 0x80000000u, Src1, 0x1u);                     \
    TestValue(ns, Dest, 1u, Src0, 0x80000000u, Src1, 0x1u);                    \
    TestValue(ns, Dest, 0u, Src0, 0x1u, Src1, 0x80000000u);                    \
    TestValue(p, Dest, 1u, Src0, 0x80000000u, Src1, 0x1u);                     \
    TestValue(p, Dest, 0u, Src0, 0x1u, Src1, 0x80000000u);                     \
    TestValue(np, Dest, 1u, Src0, 0x1u, Src1, 0x80000000u);                    \
    TestValue(np, Dest, 0u, Src0, 0x80000000u, Src1, 0x1u);                    \
    TestValue(l, Dest, 1u, Src0, 0x80000000u, Src1, 0x1u);                     \
    TestValue(l, Dest, 0u, Src0, 0x1u, Src1, 0x80000000u);                     \
    TestValue(ge, Dest, 1u, Src0, 0x1u, Src1, 0x80000000u);                    \
    TestValue(ge, Dest, 0u, Src0, 0x80000000u, Src1, 0x1u);                    \
    TestValue(le, Dest, 1u, Src0, 0x80000000u, Src1, 0x1u);                    \
    TestValue(le, Dest, 0u, Src0, 0x1u, Src1, 0x80000000u);                    \
  } while (0)

  TestImpl(r1, r2, r3);

#undef TestImpl
#undef TestValue
#undef TestRegAddr
#undef TestRegReg
}

TEST_F(AssemblerX8664LowLevelTest, RepMovsb) {
  __ rep_movsb();

  static constexpr uint32_t ByteCount = 2;
  static constexpr uint8_t Prefix = 0xF3;
  static constexpr uint8_t Opcode = 0xA4;

  ASSERT_EQ(ByteCount, codeBytesSize());
  verifyBytes<ByteCount>(codeBytes(), Prefix, Opcode);
}

TEST_F(AssemblerX8664Test, MovssXmmAddr) {
#define TestMovssXmmAddrFloatLength(FloatLength, Xmm, Value)                   \
  do {                                                                         \
    static_assert((FloatLength) == 32 || (FloatLength) == 64,                  \
                  "Invalid fp length #FloatLength");                           \
    using Type = std::conditional<FloatLength == 32, float, double>::type;     \
                                                                               \
    static constexpr char TestString[] = "(" #FloatLength ", " #Xmm ")";       \
    static constexpr bool IsDouble = std::is_same<Type, double>::value;        \
    const uint32_t T0 = allocateQword();                                       \
    const Type V0 = Value;                                                     \
                                                                               \
    __ movss(IceType_f##FloatLength, Encoded_Xmm_##Xmm(), dwordAddress(T0));   \
                                                                               \
    AssembledTest test = assemble();                                           \
    if (IsDouble) {                                                            \
      test.setQwordTo(T0, static_cast<double>(V0));                            \
    } else {                                                                   \
      test.setDwordTo(T0, static_cast<float>(V0));                             \
    }                                                                          \
    test.run();                                                                \
    ASSERT_DOUBLE_EQ(Value, test.Xmm<Type>())                                  \
        << TestString << " value is " << Value;                                \
    reset();                                                                   \
  } while (0)

#define TestMovssXmmAddr(FloatLength)                                          \
  do {                                                                         \
    using Type = std::conditional<FloatLength == 32, float, double>::type;     \
    for (const Type Value : {0.0, -0.0, 1.0, -1.0, 3.14, 99999.9999}) {        \
      TestMovssXmmAddrFloatLength(FloatLength, xmm0, Value);                   \
      TestMovssXmmAddrFloatLength(FloatLength, xmm1, Value);                   \
      TestMovssXmmAddrFloatLength(FloatLength, xmm2, Value);                   \
      TestMovssXmmAddrFloatLength(FloatLength, xmm3, Value);                   \
      TestMovssXmmAddrFloatLength(FloatLength, xmm4, Value);                   \
      TestMovssXmmAddrFloatLength(FloatLength, xmm5, Value);                   \
      TestMovssXmmAddrFloatLength(FloatLength, xmm6, Value);                   \
      TestMovssXmmAddrFloatLength(FloatLength, xmm7, Value);                   \
      TestMovssXmmAddrFloatLength(FloatLength, xmm8, Value);                   \
      TestMovssXmmAddrFloatLength(FloatLength, xmm9, Value);                   \
      TestMovssXmmAddrFloatLength(FloatLength, xmm10, Value);                  \
      TestMovssXmmAddrFloatLength(FloatLength, xmm11, Value);                  \
      TestMovssXmmAddrFloatLength(FloatLength, xmm12, Value);                  \
      TestMovssXmmAddrFloatLength(FloatLength, xmm13, Value);                  \
      TestMovssXmmAddrFloatLength(FloatLength, xmm14, Value);                  \
      TestMovssXmmAddrFloatLength(FloatLength, xmm15, Value);                  \
    }                                                                          \
  } while (0)

  TestMovssXmmAddr(32);
  TestMovssXmmAddr(64);

#undef TestMovssXmmAddr
#undef TestMovssXmmAddrType
}

TEST_F(AssemblerX8664Test, MovssAddrXmm) {
#define TestMovssAddrXmmFloatLength(FloatLength, Xmm, Value)                   \
  do {                                                                         \
    static_assert((FloatLength) == 32 || (FloatLength) == 64,                  \
                  "Invalid fp length #FloatLength");                           \
    using Type = std::conditional<FloatLength == 32, float, double>::type;     \
                                                                               \
    static constexpr char TestString[] = "(" #FloatLength ", " #Xmm ")";       \
    static constexpr bool IsDouble = std::is_same<Type, double>::value;        \
    const uint32_t T0 = allocateQword();                                       \
    const Type V0 = Value;                                                     \
    const uint32_t T1 = allocateQword();                                       \
    static_assert(std::numeric_limits<Type>::has_quiet_NaN,                    \
                  "f" #FloatLength " does not have quiet nan.");               \
    const Type V1 = std::numeric_limits<Type>::quiet_NaN();                    \
                                                                               \
    __ movss(IceType_f##FloatLength, Encoded_Xmm_##Xmm(), dwordAddress(T0));   \
                                                                               \
    AssembledTest test = assemble();                                           \
    if (IsDouble) {                                                            \
      test.setQwordTo(T0, static_cast<double>(V0));                            \
      test.setQwordTo(T1, static_cast<double>(V1));                            \
    } else {                                                                   \
      test.setDwordTo(T0, static_cast<float>(V0));                             \
      test.setDwordTo(T1, static_cast<float>(V1));                             \
    }                                                                          \
    test.run();                                                                \
    ASSERT_DOUBLE_EQ(Value, test.Xmm<Type>())                                  \
        << TestString << " value is " << Value;                                \
    reset();                                                                   \
  } while (0)

#define TestMovssAddrXmm(FloatLength)                                          \
  do {                                                                         \
    using Type = std::conditional<FloatLength == 32, float, double>::type;     \
    for (const Type Value : {0.0, -0.0, 1.0, -1.0, 3.14, 99999.9999}) {        \
      TestMovssAddrXmmFloatLength(FloatLength, xmm0, Value);                   \
      TestMovssAddrXmmFloatLength(FloatLength, xmm1, Value);                   \
      TestMovssAddrXmmFloatLength(FloatLength, xmm2, Value);                   \
      TestMovssAddrXmmFloatLength(FloatLength, xmm3, Value);                   \
      TestMovssAddrXmmFloatLength(FloatLength, xmm4, Value);                   \
      TestMovssAddrXmmFloatLength(FloatLength, xmm5, Value);                   \
      TestMovssAddrXmmFloatLength(FloatLength, xmm6, Value);                   \
      TestMovssAddrXmmFloatLength(FloatLength, xmm7, Value);                   \
      TestMovssAddrXmmFloatLength(FloatLength, xmm8, Value);                   \
      TestMovssAddrXmmFloatLength(FloatLength, xmm9, Value);                   \
      TestMovssAddrXmmFloatLength(FloatLength, xmm10, Value);                  \
      TestMovssAddrXmmFloatLength(FloatLength, xmm11, Value);                  \
      TestMovssAddrXmmFloatLength(FloatLength, xmm12, Value);                  \
      TestMovssAddrXmmFloatLength(FloatLength, xmm13, Value);                  \
      TestMovssAddrXmmFloatLength(FloatLength, xmm14, Value);                  \
      TestMovssAddrXmmFloatLength(FloatLength, xmm15, Value);                  \
    }                                                                          \
  } while (0)

  TestMovssAddrXmm(32);
  TestMovssAddrXmm(64);

#undef TestMovssAddrXmm
#undef TestMovssAddrXmmType
}

TEST_F(AssemblerX8664Test, MovssXmmXmm) {
#define TestMovssXmmXmmFloatLength(FloatLength, Src, Dst, Value)               \
  do {                                                                         \
    static_assert((FloatLength) == 32 || (FloatLength) == 64,                  \
                  "Invalid fp length #FloatLength");                           \
    using Type = std::conditional<FloatLength == 32, float, double>::type;     \
                                                                               \
    static constexpr char TestString[] =                                       \
        "(" #FloatLength ", " #Src ", " #Dst ")";                              \
    static constexpr bool IsDouble = std::is_same<Type, double>::value;        \
    const uint32_t T0 = allocateQword();                                       \
    const Type V0 = Value;                                                     \
    const uint32_t T1 = allocateQword();                                       \
    static_assert(std::numeric_limits<Type>::has_quiet_NaN,                    \
                  "f" #FloatLength " does not have quiet nan.");               \
    const Type V1 = std::numeric_limits<Type>::quiet_NaN();                    \
                                                                               \
    __ movss(IceType_f##FloatLength, Encoded_Xmm_##Src(), dwordAddress(T0));   \
    __ movss(IceType_f##FloatLength, Encoded_Xmm_##Dst(), dwordAddress(T1));   \
    __ movss(IceType_f##FloatLength, Encoded_Xmm_##Dst(),                      \
             Encoded_Xmm_##Src());                                             \
                                                                               \
    AssembledTest test = assemble();                                           \
    if (IsDouble) {                                                            \
      test.setQwordTo(T0, static_cast<double>(V0));                            \
      test.setQwordTo(T1, static_cast<double>(V1));                            \
    } else {                                                                   \
      test.setDwordTo(T0, static_cast<float>(V0));                             \
      test.setDwordTo(T1, static_cast<float>(V1));                             \
    }                                                                          \
    test.run();                                                                \
    ASSERT_DOUBLE_EQ(Value, test.Dst<Type>())                                  \
        << TestString << " value is " << Value;                                \
    reset();                                                                   \
  } while (0)

#define TestMovssXmmXmm(FloatLength)                                           \
  do {                                                                         \
    using Type = std::conditional<FloatLength == 32, float, double>::type;     \
    for (const Type Value : {0.0, -0.0, 1.0, -1.0, 3.14, 99999.9999}) {        \
      TestMovssXmmXmmFloatLength(FloatLength, xmm0, xmm1, Value);              \
      TestMovssXmmXmmFloatLength(FloatLength, xmm1, xmm2, Value);              \
      TestMovssXmmXmmFloatLength(FloatLength, xmm2, xmm3, Value);              \
      TestMovssXmmXmmFloatLength(FloatLength, xmm3, xmm4, Value);              \
      TestMovssXmmXmmFloatLength(FloatLength, xmm4, xmm5, Value);              \
      TestMovssXmmXmmFloatLength(FloatLength, xmm5, xmm6, Value);              \
      TestMovssXmmXmmFloatLength(FloatLength, xmm6, xmm7, Value);              \
      TestMovssXmmXmmFloatLength(FloatLength, xmm7, xmm8, Value);              \
      TestMovssXmmXmmFloatLength(FloatLength, xmm8, xmm9, Value);              \
      TestMovssXmmXmmFloatLength(FloatLength, xmm9, xmm10, Value);             \
      TestMovssXmmXmmFloatLength(FloatLength, xmm10, xmm11, Value);            \
      TestMovssXmmXmmFloatLength(FloatLength, xmm11, xmm12, Value);            \
      TestMovssXmmXmmFloatLength(FloatLength, xmm12, xmm13, Value);            \
      TestMovssXmmXmmFloatLength(FloatLength, xmm13, xmm14, Value);            \
      TestMovssXmmXmmFloatLength(FloatLength, xmm14, xmm15, Value);            \
      TestMovssXmmXmmFloatLength(FloatLength, xmm15, xmm0, Value);             \
    }                                                                          \
  } while (0)

  TestMovssXmmXmm(32);
  TestMovssXmmXmm(64);

#undef TestMovssXmmXmm
#undef TestMovssXmmXmmType
}

TEST_F(AssemblerX8664Test, MovdToXmm) {
#define TestMovdXmmReg32(Src, Dst, Value)                                      \
  do {                                                                         \
    assert(((Value)&0xFFFFFFFF) == (Value));                                   \
    static constexpr char TestString[] = "(" #Src ", " #Dst ")";               \
    const uint32_t T0 = allocateQword();                                       \
    const uint64_t V0 = 0xFFFFFFFF00000000ull;                                 \
                                                                               \
    __ mov(IceType_i32, Encoded_GPR_##Src(), Immediate(Value));                \
    __ movss(IceType_f64, Encoded_Xmm_##Dst(), dwordAddress(T0));              \
    __ movd(IceType_i32, Encoded_Xmm_##Dst(), Encoded_GPR_##Src());            \
                                                                               \
    AssembledTest test = assemble();                                           \
                                                                               \
    test.setQwordTo(T0, V0);                                                   \
    test.run();                                                                \
                                                                               \
    ASSERT_EQ(Value, test.Dst<uint64_t>())                                     \
        << TestString << " value is " << Value;                                \
    reset();                                                                   \
  } while (0)

#define TestMovdXmmReg64(Src, Dst, Value)                                      \
  do {                                                                         \
    assert(((Value)&0xFFFFFFFF) == (Value));                                   \
    static constexpr char TestString[] = "(" #Src ", " #Dst ")";               \
    const uint32_t T0 = allocateQword();                                       \
    const uint64_t V0 = 0xFFFFFFFF00000000ull;                                 \
    const uint64_t Expected = (static_cast<uint64_t>(Value) << 32) | (Value);  \
                                                                               \
    __ movabs(Encoded_GPR_##Src(), Expected);                                  \
    __ movss(IceType_f64, Encoded_Xmm_##Dst(), dwordAddress(T0));              \
    __ movd(IceType_i64, Encoded_Xmm_##Dst(), Encoded_GPR_##Src());            \
                                                                               \
    AssembledTest test = assemble();                                           \
                                                                               \
    test.setQwordTo(T0, V0);                                                   \
    test.run();                                                                \
                                                                               \
    ASSERT_EQ(Expected, test.Dst<uint64_t>())                                  \
        << TestString << " value is " << Value;                                \
    reset();                                                                   \
  } while (0)

#define TestMovdXmmReg(Src, Dst, Value)                                        \
  do {                                                                         \
    TestMovdXmmReg32(Src, Dst, Value);                                         \
    TestMovdXmmReg64(Src, Dst, Value);                                         \
  } while (0)

#define TestMovdXmmAddr32(Dst, Value)                                          \
  do {                                                                         \
    assert(((Value)&0xFFFFFFFF) == (Value));                                   \
    static constexpr char TestString[] = "(" #Dst ", Addr)";                   \
    const uint32_t T0 = allocateQword();                                       \
    const uint32_t V0 = Value;                                                 \
    const uint32_t T1 = allocateQword();                                       \
    const uint64_t V1 = 0xFFFFFFFF00000000ull;                                 \
                                                                               \
    __ movss(IceType_f64, Encoded_Xmm_##Dst(), dwordAddress(T1));              \
    __ movd(IceType_i32, Encoded_Xmm_##Dst(), dwordAddress(T0));               \
                                                                               \
    AssembledTest test = assemble();                                           \
                                                                               \
    test.setDwordTo(T0, V0);                                                   \
    test.setQwordTo(T1, V1);                                                   \
    test.run();                                                                \
                                                                               \
    ASSERT_EQ(Value, test.Dst<uint64_t>())                                     \
        << TestString << " value is " << Value;                                \
    reset();                                                                   \
  } while (0)

#define TestMovdXmmAddr64(Dst, Value)                                          \
  do {                                                                         \
    assert(((Value)&0xFFFFFFFF) == (Value));                                   \
    static constexpr char TestString[] = "(" #Dst ", Addr)";                   \
    const uint32_t T0 = allocateQword();                                       \
    const uint32_t V0 = (static_cast<uint64_t>(Value) << 32) | (Value);        \
    const uint32_t T1 = allocateQword();                                       \
    const uint64_t V1 = 0xFFFFFFFF00000000ull;                                 \
                                                                               \
    __ movss(IceType_f64, Encoded_Xmm_##Dst(), dwordAddress(T1));              \
    __ movd(IceType_i64, Encoded_Xmm_##Dst(), dwordAddress(T0));               \
                                                                               \
    AssembledTest test = assemble();                                           \
                                                                               \
    test.setDwordTo(T0, V0);                                                   \
    test.setQwordTo(T1, V1);                                                   \
    test.run();                                                                \
                                                                               \
    ASSERT_EQ(Value, test.Dst<uint64_t>())                                     \
        << TestString << " value is " << Value;                                \
    reset();                                                                   \
  } while (0)

#define TestMovdXmmAddr(Dst, Value)                                            \
  do {                                                                         \
    TestMovdXmmAddr32(Dst, Value);                                             \
    TestMovdXmmAddr64(Dst, Value);                                             \
  } while (0)

#define TestMovd(Dst)                                                          \
  do {                                                                         \
    for (uint32_t Value : {0u, 1u, 0x7FFFFFFFu, 0x80000000u, 0xFFFFFFFFu}) {   \
      TestMovdXmmReg(r1, Dst, Value);                                          \
      TestMovdXmmReg(r2, Dst, Value);                                          \
      TestMovdXmmReg(r3, Dst, Value);                                          \
      TestMovdXmmReg(r4, Dst, Value);                                          \
      TestMovdXmmReg(r5, Dst, Value);                                          \
      TestMovdXmmReg(r6, Dst, Value);                                          \
      TestMovdXmmReg(r7, Dst, Value);                                          \
      TestMovdXmmReg(r8, Dst, Value);                                          \
      TestMovdXmmReg(r10, Dst, Value);                                         \
      TestMovdXmmReg(r11, Dst, Value);                                         \
      TestMovdXmmReg(r12, Dst, Value);                                         \
      TestMovdXmmReg(r13, Dst, Value);                                         \
      TestMovdXmmReg(r14, Dst, Value);                                         \
      TestMovdXmmReg(r15, Dst, Value);                                         \
      TestMovdXmmAddr(Dst, Value);                                             \
    }                                                                          \
  } while (0)

  TestMovd(xmm0);
  TestMovd(xmm1);
  TestMovd(xmm2);
  TestMovd(xmm3);
  TestMovd(xmm4);
  TestMovd(xmm5);
  TestMovd(xmm6);
  TestMovd(xmm7);
  TestMovd(xmm8);
  TestMovd(xmm9);
  TestMovd(xmm10);
  TestMovd(xmm11);
  TestMovd(xmm12);
  TestMovd(xmm13);
  TestMovd(xmm14);
  TestMovd(xmm15);

#undef TestMovd
#undef TestMovdXmmAddr
#undef TestMovdXmmAddr64
#undef TestMovdXmmAddr32
#undef TestMovdXmmReg
#undef TestMovdXmmReg64
#undef TestMovdXmmReg32
}

TEST_F(AssemblerX8664Test, MovdFromXmm) {
#define TestMovdRegXmm32(Src, Dst, Value)                                      \
  do {                                                                         \
    assert(((Value)&0xFFFFFFFF) == (Value));                                   \
    static constexpr char TestString[] = "(" #Src ", " #Dst ")";               \
    const uint32_t T0 = allocateDword();                                       \
    const uint32_t V0 = Value;                                                 \
                                                                               \
    __ movss(IceType_f64, Encoded_Xmm_##Src(), dwordAddress(T0));              \
    __ movd(IceType_i32, Encoded_GPR_##Dst(), Encoded_Xmm_##Src());            \
                                                                               \
    AssembledTest test = assemble();                                           \
                                                                               \
    test.setDwordTo(T0, V0);                                                   \
    test.run();                                                                \
                                                                               \
    ASSERT_EQ(Value, test.contentsOfDword(T0))                                 \
        << TestString << " value is " << Value;                                \
    reset();                                                                   \
  } while (0)

#define TestMovdRegXmm64(Src, Dst, Value)                                      \
  do {                                                                         \
    assert(((Value)&0xFFFFFFFF) == (Value));                                   \
    static constexpr char TestString[] = "(" #Src ", " #Dst ")";               \
    const uint32_t T0 = allocateDword();                                       \
    const uint64_t V0 = (static_cast<uint64_t>(Value) << 32) | (Value);        \
                                                                               \
    __ movss(IceType_f64, Encoded_Xmm_##Src(), dwordAddress(T0));              \
    __ movd(IceType_i64, Encoded_GPR_##Dst(), Encoded_Xmm_##Src());            \
                                                                               \
    AssembledTest test = assemble();                                           \
                                                                               \
    test.setQwordTo(T0, V0);                                                   \
    test.run();                                                                \
                                                                               \
    ASSERT_EQ(V0, test.contentsOfQword(T0))                                    \
        << TestString << " value is " << Value;                                \
    reset();                                                                   \
  } while (0)

#define TestMovdRegXmm(Src, Dst, Value)                                        \
  do {                                                                         \
    TestMovdRegXmm32(Src, Dst, Value);                                         \
    TestMovdRegXmm64(Src, Dst, Value);                                         \
  } while (0)

#define TestMovdAddrXmm32(Src, Value)                                          \
  do {                                                                         \
    assert(((Value)&0xFFFFFFFF) == (Value));                                   \
    static constexpr char TestString[] = "(" #Src ", Addr)";                   \
    const uint32_t T0 = allocateDword();                                       \
    const uint32_t V0 = Value;                                                 \
    const uint32_t T1 = allocateDword();                                       \
    const uint32_t V1 = ~(Value);                                              \
                                                                               \
    __ movss(IceType_f64, Encoded_Xmm_##Src(), dwordAddress(T0));              \
    __ movd(IceType_i32, dwordAddress(T1), Encoded_Xmm_##Src());               \
                                                                               \
    AssembledTest test = assemble();                                           \
                                                                               \
    test.setDwordTo(T0, V0);                                                   \
    test.setDwordTo(T1, V1);                                                   \
    test.run();                                                                \
                                                                               \
    ASSERT_EQ(Value, test.contentsOfDword(T1))                                 \
        << TestString << " value is " << Value;                                \
    reset();                                                                   \
  } while (0)

#define TestMovdAddrXmm64(Src, Value)                                          \
  do {                                                                         \
    assert(((Value)&0xFFFFFFFF) == (Value));                                   \
    static constexpr char TestString[] = "(" #Src ", Addr)";                   \
    const uint32_t T0 = allocateQword();                                       \
    const uint64_t V0 = (static_cast<uint64_t>(Value) << 32) | Value;          \
    const uint32_t T1 = allocateQword();                                       \
    const uint64_t V1 = ~V0;                                                   \
                                                                               \
    __ movss(IceType_f64, Encoded_Xmm_##Src(), dwordAddress(T0));              \
    __ movd(IceType_i64, dwordAddress(T1), Encoded_Xmm_##Src());               \
                                                                               \
    AssembledTest test = assemble();                                           \
                                                                               \
    test.setQwordTo(T0, V0);                                                   \
    test.setQwordTo(T1, V1);                                                   \
    test.run();                                                                \
                                                                               \
    ASSERT_EQ(V0, test.contentsOfQword(T1))                                    \
        << TestString << " value is " << Value;                                \
    reset();                                                                   \
  } while (0)

#define TestMovdAddrXmm(Src, Value)                                            \
  do {                                                                         \
    TestMovdAddrXmm32(Src, Value);                                             \
    TestMovdAddrXmm64(Src, Value);                                             \
  } while (0)

#define TestMovd(Src)                                                          \
  do {                                                                         \
    for (uint32_t Value : {0u, 1u, 0x7FFFFFFFu, 0x80000000u, 0xFFFFFFFFu}) {   \
      TestMovdRegXmm(Src, r1, Value);                                          \
      TestMovdRegXmm(Src, r2, Value);                                          \
      TestMovdRegXmm(Src, r3, Value);                                          \
      TestMovdRegXmm(Src, r4, Value);                                          \
      TestMovdRegXmm(Src, r5, Value);                                          \
      TestMovdRegXmm(Src, r6, Value);                                          \
      TestMovdRegXmm(Src, r7, Value);                                          \
      TestMovdRegXmm(Src, r8, Value);                                          \
      TestMovdRegXmm(Src, r10, Value);                                         \
      TestMovdRegXmm(Src, r11, Value);                                         \
      TestMovdRegXmm(Src, r12, Value);                                         \
      TestMovdRegXmm(Src, r13, Value);                                         \
      TestMovdRegXmm(Src, r14, Value);                                         \
      TestMovdRegXmm(Src, r15, Value);                                         \
      TestMovdAddrXmm(Src, Value);                                             \
    }                                                                          \
  } while (0)

  TestMovd(xmm0);
  TestMovd(xmm1);
  TestMovd(xmm2);
  TestMovd(xmm3);
  TestMovd(xmm4);
  TestMovd(xmm5);
  TestMovd(xmm6);
  TestMovd(xmm7);
  TestMovd(xmm8);
  TestMovd(xmm9);
  TestMovd(xmm10);
  TestMovd(xmm11);
  TestMovd(xmm12);
  TestMovd(xmm13);
  TestMovd(xmm14);
  TestMovd(xmm15);

#undef TestMovd
#undef TestMovdAddrXmm
#undef TestMovdAddrXmm64
#undef TestMovdAddrXmm32
#undef TestMovdRegXmm
#undef TestMovdRegXmm64
#undef TestMovdRegXmm32
}

TEST_F(AssemblerX8664Test, MovqXmmAddr) {
#define TestMovd(Dst, Value)                                                   \
  do {                                                                         \
    static constexpr char TestString[] = "(" #Dst ", Addr)";                   \
    const uint32_t T0 = allocateQword();                                       \
    const uint64_t V0 = Value;                                                 \
    const uint32_t T1 = allocateQword();                                       \
    const uint64_t V1 = ~(Value);                                              \
                                                                               \
    __ movss(IceType_f64, Encoded_Xmm_##Dst(), dwordAddress(T1));              \
    __ movq(Encoded_Xmm_##Dst(), dwordAddress(T0));                            \
                                                                               \
    AssembledTest test = assemble();                                           \
                                                                               \
    test.setQwordTo(T0, V0);                                                   \
    test.setQwordTo(T1, V1);                                                   \
    test.run();                                                                \
                                                                               \
    ASSERT_EQ(Value, test.Dst<uint64_t>())                                     \
        << TestString << " value is " << Value;                                \
    reset();                                                                   \
  } while (0)

  for (uint32_t Value : {0u, 1u, 0x7FFFFFFFu, 0x80000000u, 0xFFFFFFFFu}) {
    TestMovd(xmm0, Value);
    TestMovd(xmm1, Value);
    TestMovd(xmm2, Value);
    TestMovd(xmm3, Value);
    TestMovd(xmm4, Value);
    TestMovd(xmm5, Value);
    TestMovd(xmm6, Value);
    TestMovd(xmm7, Value);
    TestMovd(xmm8, Value);
    TestMovd(xmm9, Value);
    TestMovd(xmm10, Value);
    TestMovd(xmm11, Value);
    TestMovd(xmm12, Value);
    TestMovd(xmm13, Value);
    TestMovd(xmm14, Value);
    TestMovd(xmm15, Value);
  }

#undef TestMovd
}

TEST_F(AssemblerX8664Test, MovqAddrXmm) {
#define TestMovd(Dst, Value)                                                   \
  do {                                                                         \
    static constexpr char TestString[] = "(" #Dst ", Addr)";                   \
    const uint32_t T0 = allocateQword();                                       \
    const uint64_t V0 = Value;                                                 \
    const uint32_t T1 = allocateQword();                                       \
    const uint64_t V1 = ~(Value);                                              \
                                                                               \
    __ movq(Encoded_Xmm_##Dst(), dwordAddress(T0));                            \
    __ movq(dwordAddress(T1), Encoded_Xmm_##Dst());                            \
                                                                               \
    AssembledTest test = assemble();                                           \
                                                                               \
    test.setQwordTo(T0, V0);                                                   \
    test.setQwordTo(T1, V1);                                                   \
    test.run();                                                                \
                                                                               \
    ASSERT_EQ(Value, test.Dst<uint64_t>())                                     \
        << TestString << " value is " << Value;                                \
    reset();                                                                   \
  } while (0)

  for (uint32_t Value : {0u, 1u, 0x7FFFFFFFu, 0x80000000u, 0xFFFFFFFFu}) {
    TestMovd(xmm0, Value);
    TestMovd(xmm1, Value);
    TestMovd(xmm2, Value);
    TestMovd(xmm3, Value);
    TestMovd(xmm4, Value);
    TestMovd(xmm5, Value);
    TestMovd(xmm6, Value);
    TestMovd(xmm7, Value);
    TestMovd(xmm8, Value);
    TestMovd(xmm9, Value);
    TestMovd(xmm10, Value);
    TestMovd(xmm11, Value);
    TestMovd(xmm12, Value);
    TestMovd(xmm13, Value);
    TestMovd(xmm14, Value);
    TestMovd(xmm15, Value);
  }

#undef TestMovd
}

TEST_F(AssemblerX8664Test, MovqXmmXmm) {
#define TestMovd(Src, Dst, Value)                                              \
  do {                                                                         \
    static constexpr char TestString[] = "(" #Src ", " #Dst ")";               \
    const uint32_t T0 = allocateQword();                                       \
    const uint64_t V0 = Value;                                                 \
    const uint32_t T1 = allocateQword();                                       \
    const uint64_t V1 = ~(Value);                                              \
                                                                               \
    __ movq(Encoded_Xmm_##Src(), dwordAddress(T0));                            \
    __ movq(Encoded_Xmm_##Dst(), dwordAddress(T1));                            \
    __ movq(Encoded_Xmm_##Dst(), Encoded_Xmm_##Src());                         \
                                                                               \
    AssembledTest test = assemble();                                           \
                                                                               \
    test.setQwordTo(T0, V0);                                                   \
    test.setQwordTo(T1, V1);                                                   \
    test.run();                                                                \
                                                                               \
    ASSERT_EQ(Value, test.Dst<uint64_t>())                                     \
        << TestString << " value is " << Value;                                \
    reset();                                                                   \
  } while (0)

  for (uint32_t Value : {0u, 1u, 0x7FFFFFFFu, 0x80000000u, 0xFFFFFFFFu}) {
    TestMovd(xmm0, xmm1, Value);
    TestMovd(xmm1, xmm2, Value);
    TestMovd(xmm2, xmm3, Value);
    TestMovd(xmm3, xmm4, Value);
    TestMovd(xmm4, xmm5, Value);
    TestMovd(xmm5, xmm6, Value);
    TestMovd(xmm6, xmm7, Value);
    TestMovd(xmm7, xmm8, Value);
    TestMovd(xmm8, xmm9, Value);
    TestMovd(xmm9, xmm10, Value);
    TestMovd(xmm10, xmm11, Value);
    TestMovd(xmm11, xmm12, Value);
    TestMovd(xmm12, xmm13, Value);
    TestMovd(xmm13, xmm14, Value);
    TestMovd(xmm14, xmm15, Value);
    TestMovd(xmm15, xmm0, Value);
  }

#undef TestMovd
}

TEST_F(AssemblerX8664Test, MovupsXmmAddr) {
#define TestMovups(Dst)                                                        \
  do {                                                                         \
    static constexpr char TestString[] = "(" #Dst ")";                         \
    const uint32_t T0 = allocateDqword();                                      \
    const Dqword V0(1.0f, -1.0, std::numeric_limits<float>::quiet_NaN(),       \
                    std::numeric_limits<float>::infinity());                   \
                                                                               \
    __ movups(Encoded_Xmm_##Dst(), dwordAddress(T0));                          \
                                                                               \
    AssembledTest test = assemble();                                           \
    test.setDqwordTo(T0, V0);                                                  \
    test.run();                                                                \
                                                                               \
    ASSERT_EQ(V0, test.Dst<Dqword>()) << TestString;                           \
    reset();                                                                   \
  } while (0)

  TestMovups(xmm0);
  TestMovups(xmm1);
  TestMovups(xmm2);
  TestMovups(xmm3);
  TestMovups(xmm4);
  TestMovups(xmm5);
  TestMovups(xmm6);
  TestMovups(xmm7);
  TestMovups(xmm8);
  TestMovups(xmm9);
  TestMovups(xmm10);
  TestMovups(xmm11);
  TestMovups(xmm12);
  TestMovups(xmm13);
  TestMovups(xmm14);
  TestMovups(xmm15);

#undef TestMovups
}

TEST_F(AssemblerX8664Test, MovupsAddrXmm) {
#define TestMovups(Src)                                                        \
  do {                                                                         \
    static constexpr char TestString[] = "(" #Src ")";                         \
    const uint32_t T0 = allocateDqword();                                      \
    const Dqword V0(1.0f, -1.0, std::numeric_limits<float>::quiet_NaN(),       \
                    std::numeric_limits<float>::infinity());                   \
    const uint32_t T1 = allocateDqword();                                      \
    const Dqword V1(0.0, 0.0, 0.0, 0.0);                                       \
                                                                               \
    __ movups(Encoded_Xmm_##Src(), dwordAddress(T0));                          \
    __ movups(dwordAddress(T1), Encoded_Xmm_##Src());                          \
                                                                               \
    AssembledTest test = assemble();                                           \
    test.setDqwordTo(T0, V0);                                                  \
    test.setDqwordTo(T1, V1);                                                  \
    test.run();                                                                \
                                                                               \
    ASSERT_EQ(V0, test.contentsOfDqword(T1)) << TestString;                    \
    reset();                                                                   \
  } while (0)

  TestMovups(xmm0);
  TestMovups(xmm1);
  TestMovups(xmm2);
  TestMovups(xmm3);
  TestMovups(xmm4);
  TestMovups(xmm5);
  TestMovups(xmm6);
  TestMovups(xmm7);
  TestMovups(xmm8);
  TestMovups(xmm9);
  TestMovups(xmm10);
  TestMovups(xmm11);
  TestMovups(xmm12);
  TestMovups(xmm13);
  TestMovups(xmm14);
  TestMovups(xmm15);

#undef TestMovups
}

TEST_F(AssemblerX8664Test, MovupsXmmXmm) {
#define TestMovups(Dst, Src)                                                   \
  do {                                                                         \
    static constexpr char TestString[] = "(" #Dst ", " #Src ")";               \
    const uint32_t T0 = allocateDqword();                                      \
    const Dqword V0(1.0f, -1.0, std::numeric_limits<float>::quiet_NaN(),       \
                    std::numeric_limits<float>::infinity());                   \
    const uint32_t T1 = allocateDqword();                                      \
    const Dqword V1(0.0, 0.0, 0.0, 0.0);                                       \
                                                                               \
    __ movups(Encoded_Xmm_##Src(), dwordAddress(T0));                          \
    __ movups(Encoded_Xmm_##Dst(), dwordAddress(T1));                          \
    __ movups(Encoded_Xmm_##Dst(), Encoded_Xmm_##Src());                       \
                                                                               \
    AssembledTest test = assemble();                                           \
    test.setDqwordTo(T0, V0);                                                  \
    test.setDqwordTo(T1, V1);                                                  \
    test.run();                                                                \
                                                                               \
    ASSERT_EQ(V0, test.Dst<Dqword>()) << TestString;                           \
    reset();                                                                   \
  } while (0)

  TestMovups(xmm0, xmm1);
  TestMovups(xmm1, xmm2);
  TestMovups(xmm2, xmm3);
  TestMovups(xmm3, xmm4);
  TestMovups(xmm4, xmm5);
  TestMovups(xmm5, xmm6);
  TestMovups(xmm6, xmm7);
  TestMovups(xmm7, xmm8);
  TestMovups(xmm8, xmm9);
  TestMovups(xmm9, xmm10);
  TestMovups(xmm10, xmm11);
  TestMovups(xmm11, xmm12);
  TestMovups(xmm12, xmm13);
  TestMovups(xmm13, xmm14);
  TestMovups(xmm14, xmm15);
  TestMovups(xmm15, xmm0);

#undef TestMovups
}

TEST_F(AssemblerX8664Test, MovapsXmmXmm) {
#define TestMovaps(Dst, Src)                                                   \
  do {                                                                         \
    static constexpr char TestString[] = "(" #Dst ", " #Src ")";               \
    const uint32_t T0 = allocateDqword();                                      \
    const Dqword V0(1.0f, -1.0, std::numeric_limits<float>::quiet_NaN(),       \
                    std::numeric_limits<float>::infinity());                   \
    const uint32_t T1 = allocateDqword();                                      \
    const Dqword V1(0.0, 0.0, 0.0, 0.0);                                       \
                                                                               \
    __ movups(Encoded_Xmm_##Src(), dwordAddress(T0));                          \
    __ movups(Encoded_Xmm_##Dst(), dwordAddress(T1));                          \
    __ movaps(Encoded_Xmm_##Dst(), Encoded_Xmm_##Src());                       \
                                                                               \
    AssembledTest test = assemble();                                           \
    test.setDqwordTo(T0, V0);                                                  \
    test.setDqwordTo(T1, V1);                                                  \
    test.run();                                                                \
                                                                               \
    ASSERT_EQ(V0, test.Dst<Dqword>()) << TestString;                           \
    reset();                                                                   \
  } while (0)

  TestMovaps(xmm0, xmm1);
  TestMovaps(xmm1, xmm2);
  TestMovaps(xmm2, xmm3);
  TestMovaps(xmm3, xmm4);
  TestMovaps(xmm4, xmm5);
  TestMovaps(xmm5, xmm6);
  TestMovaps(xmm6, xmm7);
  TestMovaps(xmm7, xmm8);
  TestMovaps(xmm8, xmm9);
  TestMovaps(xmm9, xmm10);
  TestMovaps(xmm10, xmm11);
  TestMovaps(xmm11, xmm12);
  TestMovaps(xmm12, xmm13);
  TestMovaps(xmm13, xmm14);
  TestMovaps(xmm14, xmm15);
  TestMovaps(xmm15, xmm0);

#undef TestMovaps
}

TEST_F(AssemblerX8664Test, Movhlps_Movlhps) {
#define TestImplSingle(Dst, Src, Inst, Expect)                                 \
  do {                                                                         \
    static constexpr char TestString[] = "(" #Dst ", " #Src ", " #Inst ")";    \
    const uint32_t T0 = allocateDqword();                                      \
    const Dqword V0(uint64_t(0xAAAAAAAABBBBBBBBull),                           \
                    uint64_t(0xCCCCCCCCDDDDDDDDull));                          \
    const uint32_t T1 = allocateDqword();                                      \
    const Dqword V1(uint64_t(0xEEEEEEEEFFFFFFFFull),                           \
                    uint64_t(0x9999999988888888ull));                          \
                                                                               \
    __ movups(Encoded_Xmm_##Dst(), dwordAddress(T0));                          \
    __ movups(Encoded_Xmm_##Src(), dwordAddress(T1));                          \
    __ Inst(Encoded_Xmm_##Dst(), Encoded_Xmm_##Src());                         \
                                                                               \
    AssembledTest test = assemble();                                           \
    test.setDqwordTo(T0, V0);                                                  \
    test.setDqwordTo(T1, V1);                                                  \
    test.run();                                                                \
                                                                               \
    ASSERT_EQ(Dqword Expect, test.Dst<Dqword>()) << TestString;                \
    reset();                                                                   \
  } while (0)

#define TestImpl(Dst, Src)                                                     \
  do {                                                                         \
    TestImplSingle(                                                            \
        Dst, Src, movhlps,                                                     \
        (uint64_t(0x9999999988888888ull), uint64_t(0xCCCCCCCCDDDDDDDDull)));   \
    TestImplSingle(                                                            \
        Dst, Src, movlhps,                                                     \
        (uint64_t(0xAAAAAAAABBBBBBBBull), uint64_t(0xEEEEEEEEFFFFFFFFull)));   \
  } while (0)

  TestImpl(xmm0, xmm1);
  TestImpl(xmm1, xmm2);
  TestImpl(xmm2, xmm3);
  TestImpl(xmm3, xmm4);
  TestImpl(xmm4, xmm5);
  TestImpl(xmm5, xmm6);
  TestImpl(xmm6, xmm7);
  TestImpl(xmm7, xmm8);
  TestImpl(xmm8, xmm9);
  TestImpl(xmm9, xmm10);
  TestImpl(xmm10, xmm11);
  TestImpl(xmm11, xmm12);
  TestImpl(xmm12, xmm13);
  TestImpl(xmm13, xmm14);
  TestImpl(xmm14, xmm15);
  TestImpl(xmm15, xmm0);

#undef TestImpl
#undef TestImplSingle
}

TEST_F(AssemblerX8664Test, Movmsk) {
#define TestMovmskGPRXmm(GPR, Src, Value1, Expected, Inst)                     \
  do {                                                                         \
    static constexpr char TestString[] =                                       \
        "(" #GPR ", " #Src ", " #Value1 ", " #Expected ", " #Inst ")";         \
    const uint32_t T0 = allocateDqword();                                      \
    const Dqword V0 Value1;                                                    \
                                                                               \
    __ movups(Encoded_Xmm_##Src(), dwordAddress(T0));                          \
    __ Inst(IceType_v4f32, Encoded_GPR_##GPR(), Encoded_Xmm_##Src());          \
                                                                               \
    AssembledTest test = assemble();                                           \
    test.setDqwordTo(T0, V0);                                                  \
    test.run();                                                                \
                                                                               \
    ASSERT_EQ(Expected, test.GPR()) << TestString;                             \
    reset();                                                                   \
  } while (0)

#define TestMovmsk(GPR, Src)                                                   \
  do {                                                                         \
    TestMovmskGPRXmm(GPR, Src, (-1.0, 1.0, -1.0, 1.0), 0x05ul, movmsk);        \
  } while (0)

  TestMovmsk(r1, xmm0);
  TestMovmsk(r2, xmm1);
  TestMovmsk(r3, xmm2);
  TestMovmsk(r4, xmm3);
  TestMovmsk(r5, xmm4);
  TestMovmsk(r6, xmm5);
  TestMovmsk(r7, xmm6);
  TestMovmsk(r8, xmm7);
  TestMovmsk(r10, xmm8);
  TestMovmsk(r11, xmm9);
  TestMovmsk(r12, xmm10);
  TestMovmsk(r13, xmm11);
  TestMovmsk(r14, xmm12);
  TestMovmsk(r15, xmm13);
  TestMovmsk(r1, xmm14);
  TestMovmsk(r2, xmm15);

#undef TestMovmskGPRXmm
#undef TestMovmsk
}

TEST_F(AssemblerX8664Test, Pmovsxdq) {
#define TestPmovsxdqXmmXmm(Dst, Src, Value1)                                   \
  do {                                                                         \
    static constexpr char TestString[] = "(" #Dst ", " #Src ", " #Value1 ")";  \
    const uint32_t T0 = allocateDqword();                                      \
    const Dqword V0 Value1;                                                    \
    const uint32_t T1 = allocateDqword();                                      \
    const Dqword V1(uint64_t(0), uint64_t(0));                                 \
                                                                               \
    __ movups(Encoded_Xmm_##Src(), dwordAddress(T0));                          \
    __ movups(Encoded_Xmm_##Dst(), dwordAddress(T1));                          \
    __ pmovsxdq(Encoded_Xmm_##Dst(), Encoded_Xmm_##Src());                     \
                                                                               \
    AssembledTest test = assemble();                                           \
    test.setDqwordTo(T0, V0);                                                  \
    test.setDqwordTo(T1, V1);                                                  \
    test.run();                                                                \
                                                                               \
    const Dqword Expected(uint64_t(V0.I32[0]), uint64_t(V0.I32[1]));           \
    ASSERT_EQ(Expected, test.Dst<Dqword>()) << TestString;                     \
    reset();                                                                   \
  } while (0)

#define TestPmovsxdq(Dst, Src)                                                 \
  do {                                                                         \
    TestPmovsxdqXmmXmm(                                                        \
        Dst, Src,                                                              \
        (uint64_t(0x700000007FFFFFFFull), uint64_t(0xAAAAAAAAEEEEEEEEull)));   \
    TestPmovsxdqXmmXmm(                                                        \
        Dst, Src,                                                              \
        (uint64_t(0x800000007FFFFFFFull), uint64_t(0xAAAAAAAAEEEEEEEEull)));   \
    TestPmovsxdqXmmXmm(                                                        \
        Dst, Src,                                                              \
        (uint64_t(0x70000000FFFFFFFFull), uint64_t(0xAAAAAAAAEEEEEEEEull)));   \
    TestPmovsxdqXmmXmm(                                                        \
        Dst, Src,                                                              \
        (uint64_t(0x80000000FFFFFFFFull), uint64_t(0xAAAAAAAAEEEEEEEEull)));   \
  } while (0)

  TestPmovsxdq(xmm0, xmm1);
  TestPmovsxdq(xmm1, xmm2);
  TestPmovsxdq(xmm2, xmm3);
  TestPmovsxdq(xmm3, xmm4);
  TestPmovsxdq(xmm4, xmm5);
  TestPmovsxdq(xmm5, xmm6);
  TestPmovsxdq(xmm6, xmm7);
  TestPmovsxdq(xmm7, xmm8);
  TestPmovsxdq(xmm8, xmm9);
  TestPmovsxdq(xmm9, xmm10);
  TestPmovsxdq(xmm10, xmm11);
  TestPmovsxdq(xmm11, xmm12);
  TestPmovsxdq(xmm12, xmm13);
  TestPmovsxdq(xmm13, xmm14);
  TestPmovsxdq(xmm14, xmm15);
  TestPmovsxdq(xmm15, xmm0);

#undef TestPmovsxdq
#undef TestPmovsxdqXmmXmm
}

} // end of anonymous namespace
} // end of namespace Test
} // end of namespace X8664
} // end of namespace Ice