//===- subzero/unittest/AssemblerX8632/LowLevel.cpp -----------------------===//
//
//                        The Subzero Code Generator
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "AssemblerX8632/TestUtil.h"

namespace Ice {
namespace X8632 {
namespace Test {
namespace {

TEST_F(AssemblerX8632LowLevelTest, Ret) {
  __ ret();

  constexpr size_t ByteCount = 1;
  ASSERT_EQ(ByteCount, codeBytesSize());

  verifyBytes<ByteCount>(codeBytes(), 0xc3);
}

TEST_F(AssemblerX8632LowLevelTest, RetImm) {
  __ ret(Immediate(0x20));

  constexpr size_t ByteCount = 3;
  ASSERT_EQ(ByteCount, codeBytesSize());

  verifyBytes<ByteCount>(codeBytes(), 0xC2, 0x20, 0x00);
}

TEST_F(AssemblerX8632LowLevelTest, CallImm4) {
  __ call(Immediate(4));

  constexpr size_t ByteCount = 5;
  ASSERT_EQ(ByteCount, codeBytesSize());

  verifyBytes<ByteCount>(codeBytes(), 0xe8, 0x00, 0x00, 0x00, 0x00);
}

TEST_F(AssemblerX8632LowLevelTest, PopRegs) {
  __ popl(GPRRegister::Encoded_Reg_eax);
  __ popl(GPRRegister::Encoded_Reg_ebx);
  __ popl(GPRRegister::Encoded_Reg_ecx);
  __ popl(GPRRegister::Encoded_Reg_edx);
  __ popl(GPRRegister::Encoded_Reg_edi);
  __ popl(GPRRegister::Encoded_Reg_esi);
  __ popl(GPRRegister::Encoded_Reg_ebp);

  constexpr size_t ByteCount = 7;
  ASSERT_EQ(ByteCount, codeBytesSize());

  constexpr uint8_t PopOpcode = 0x58;
  verifyBytes<ByteCount>(codeBytes(), PopOpcode | GPRRegister::Encoded_Reg_eax,
                         PopOpcode | GPRRegister::Encoded_Reg_ebx,
                         PopOpcode | GPRRegister::Encoded_Reg_ecx,
                         PopOpcode | GPRRegister::Encoded_Reg_edx,
                         PopOpcode | GPRRegister::Encoded_Reg_edi,
                         PopOpcode | GPRRegister::Encoded_Reg_esi,
                         PopOpcode | GPRRegister::Encoded_Reg_ebp);
}

TEST_F(AssemblerX8632LowLevelTest, PushRegs) {
  __ pushl(GPRRegister::Encoded_Reg_eax);
  __ pushl(GPRRegister::Encoded_Reg_ebx);
  __ pushl(GPRRegister::Encoded_Reg_ecx);
  __ pushl(GPRRegister::Encoded_Reg_edx);
  __ pushl(GPRRegister::Encoded_Reg_edi);
  __ pushl(GPRRegister::Encoded_Reg_esi);
  __ pushl(GPRRegister::Encoded_Reg_ebp);

  constexpr size_t ByteCount = 7;
  ASSERT_EQ(ByteCount, codeBytesSize());

  constexpr uint8_t PushOpcode = 0x50;
  verifyBytes<ByteCount>(codeBytes(), PushOpcode | GPRRegister::Encoded_Reg_eax,
                         PushOpcode | GPRRegister::Encoded_Reg_ebx,
                         PushOpcode | GPRRegister::Encoded_Reg_ecx,
                         PushOpcode | GPRRegister::Encoded_Reg_edx,
                         PushOpcode | GPRRegister::Encoded_Reg_edi,
                         PushOpcode | GPRRegister::Encoded_Reg_esi,
                         PushOpcode | GPRRegister::Encoded_Reg_ebp);
}

TEST_F(AssemblerX8632LowLevelTest, MovRegisterZero) {
  __ mov(IceType_i32, GPRRegister::Encoded_Reg_eax, Immediate(0x00));
  __ mov(IceType_i32, GPRRegister::Encoded_Reg_ebx, Immediate(0x00));
  __ mov(IceType_i32, GPRRegister::Encoded_Reg_ecx, Immediate(0x00));
  __ mov(IceType_i32, GPRRegister::Encoded_Reg_edx, Immediate(0x00));
  __ mov(IceType_i32, GPRRegister::Encoded_Reg_edi, Immediate(0x00));
  __ mov(IceType_i32, GPRRegister::Encoded_Reg_esi, Immediate(0x00));

  constexpr size_t MovReg32BitImmBytes = 5;
  constexpr size_t ByteCount = 6 * MovReg32BitImmBytes;
  ASSERT_EQ(ByteCount, codeBytesSize());

  constexpr uint8_t MovOpcode = 0xb8;
  verifyBytes<ByteCount>(
      codeBytes(), MovOpcode | GPRRegister::Encoded_Reg_eax, 0x00, 0x00, 0x00,
      0x00, MovOpcode | GPRRegister::Encoded_Reg_ebx, 0x00, 0x00, 0x00, 0x00,
      MovOpcode | GPRRegister::Encoded_Reg_ecx, 0x00, 0x00, 0x00, 0x00,
      MovOpcode | GPRRegister::Encoded_Reg_edx, 0x00, 0x00, 0x00, 0x00,
      MovOpcode | GPRRegister::Encoded_Reg_edi, 0x00, 0x00, 0x00, 0x00,
      MovOpcode | GPRRegister::Encoded_Reg_esi, 0x00, 0x00, 0x00, 0x00);
}

TEST_F(AssemblerX8632LowLevelTest, Cmp) {
#define TestRegReg(Inst, Dst, Src, OpType, ByteCountUntyped, ...)              \
  do {                                                                         \
    static constexpr char TestString[] =                                       \
        "(" #Inst ", " #Dst ", " #Src ", " #OpType ", " #ByteCountUntyped      \
        ",  " #__VA_ARGS__ ")";                                                \
    static constexpr uint8_t ByteCount = ByteCountUntyped;                     \
    __ Inst(IceType_##OpType, GPRRegister::Encoded_Reg_##Dst,                  \
            GPRRegister::Encoded_Reg_##Src);                                   \
    ASSERT_EQ(ByteCount, codeBytesSize()) << TestString;                       \
    ASSERT_TRUE(verifyBytes<ByteCount>(codeBytes(), __VA_ARGS__))              \
        << TestString;                                                         \
    reset();                                                                   \
  } while (0)

#define TestRegImm(Inst, Dst, Imm, OpType, ByteCountUntyped, ...)              \
  do {                                                                         \
    static constexpr char TestString[] =                                       \
        "(" #Inst ", " #Dst ", " #Imm ", " #OpType ", " #ByteCountUntyped      \
        ",  " #__VA_ARGS__ ")";                                                \
    static constexpr uint8_t ByteCount = ByteCountUntyped;                     \
    __ Inst(IceType_##OpType, GPRRegister::Encoded_Reg_##Dst, Immediate(Imm)); \
    ASSERT_EQ(ByteCount, codeBytesSize()) << TestString;                       \
    ASSERT_TRUE(verifyBytes<ByteCount>(codeBytes(), __VA_ARGS__))              \
        << TestString;                                                         \
    reset();                                                                   \
  } while (0)

#define TestRegAbsoluteAddr(Inst, Dst, Disp, OpType, ByteCountUntyped, ...)    \
  do {                                                                         \
    static constexpr char TestString[] =                                       \
        "(" #Inst ", " #Dst ", " #Disp ", " #OpType ", " #ByteCountUntyped     \
        ",  " #__VA_ARGS__ ")";                                                \
    static constexpr uint8_t ByteCount = ByteCountUntyped;                     \
    __ Inst(IceType_##OpType, GPRRegister::Encoded_Reg_##Dst,                  \
            Address(Disp, AssemblerFixup::NoFixup));                           \
    ASSERT_EQ(ByteCount, codeBytesSize()) << TestString;                       \
    ASSERT_TRUE(verifyBytes<ByteCount>(codeBytes(), __VA_ARGS__))              \
        << TestString;                                                         \
    reset();                                                                   \
  } while (0)

#define TestRegAddrBase(Inst, Dst, Base, Disp, OpType, ByteCountUntyped, ...)  \
  do {                                                                         \
    static constexpr char TestString[] =                                       \
        "(" #Inst ", " #Dst ", " #Base ", " #Disp ", " #OpType                 \
        ", " #ByteCountUntyped ",  " #__VA_ARGS__ ")";                         \
    static constexpr uint8_t ByteCount = ByteCountUntyped;                     \
    __ Inst(IceType_##OpType, GPRRegister::Encoded_Reg_##Dst,                  \
            Address(GPRRegister::Encoded_Reg_##Base, Disp,                     \
                    AssemblerFixup::NoFixup));                                 \
    ASSERT_EQ(ByteCount, codeBytesSize()) << TestString;                       \
    ASSERT_TRUE(verifyBytes<ByteCount>(codeBytes(), __VA_ARGS__))              \
        << TestString;                                                         \
    reset();                                                                   \
  } while (0)

#define TestRegAddrScaledIndex(Inst, Dst, Index, Scale, Disp, OpType,          \
                               ByteCountUntyped, ...)                          \
  do {                                                                         \
    static constexpr char TestString[] =                                       \
        "(" #Inst ", " #Dst ", " #Index ", " #Scale ", " #Disp ", " #OpType    \
        ", " #ByteCountUntyped ",  " #__VA_ARGS__ ")";                         \
    static constexpr uint8_t ByteCount = ByteCountUntyped;                     \
    __ Inst(IceType_##OpType, GPRRegister::Encoded_Reg_##Dst,                  \
            Address(GPRRegister::Encoded_Reg_##Index, Traits::TIMES_##Scale,   \
                    Disp, AssemblerFixup::NoFixup));                           \
    ASSERT_EQ(ByteCount, codeBytesSize()) << TestString;                       \
    ASSERT_TRUE(verifyBytes<ByteCount>(codeBytes(), __VA_ARGS__))              \
        << TestString;                                                         \
    reset();                                                                   \
  } while (0)

#define TestRegAddrBaseScaledIndex(Inst, Dst, Base, Index, Scale, Disp,        \
                                   OpType, ByteCountUntyped, ...)              \
  do {                                                                         \
    static constexpr char TestString[] =                                       \
        "(" #Inst ", " #Dst ", " #Base ", " #Index ", " #Scale ", " #Disp      \
        ", " #OpType ", " #ByteCountUntyped ",  " #__VA_ARGS__ ")";            \
    static constexpr uint8_t ByteCount = ByteCountUntyped;                     \
    __ Inst(IceType_##OpType, GPRRegister::Encoded_Reg_##Dst,                  \
            Address(GPRRegister::Encoded_Reg_##Base,                           \
                    GPRRegister::Encoded_Reg_##Index, Traits::TIMES_##Scale,   \
                    Disp, AssemblerFixup::NoFixup));                           \
    ASSERT_EQ(ByteCount, codeBytesSize()) << TestString;                       \
    ASSERT_TRUE(verifyBytes<ByteCount>(codeBytes(), __VA_ARGS__))              \
        << TestString;                                                         \
    reset();                                                                   \
  } while (0)

#define TestAddrBaseScaledIndexImm(Inst, Base, Index, Scale, Disp, Imm,        \
                                   OpType, ByteCountUntyped, ...)              \
  do {                                                                         \
    static constexpr char TestString[] =                                       \
        "(" #Inst ", " #Base ", " #Index ", " #Scale ", " #Disp ", " #Imm      \
        ", " #OpType ", " #ByteCountUntyped ",  " #__VA_ARGS__ ")";            \
    static constexpr uint8_t ByteCount = ByteCountUntyped;                     \
    __ Inst(IceType_##OpType,                                                  \
            Address(GPRRegister::Encoded_Reg_##Base,                           \
                    GPRRegister::Encoded_Reg_##Index, Traits::TIMES_##Scale,   \
                    Disp, AssemblerFixup::NoFixup),                            \
            Immediate(Imm));                                                   \
    ASSERT_EQ(ByteCount, codeBytesSize()) << TestString;                       \
    ASSERT_TRUE(verifyBytes<ByteCount>(codeBytes(), __VA_ARGS__))              \
        << TestString;                                                         \
    reset();                                                                   \
  } while (0)

#define TestAddrBaseScaledIndexReg(Inst, Base, Index, Scale, Disp, Src,        \
                                   OpType, ByteCountUntyped, ...)              \
  do {                                                                         \
    static constexpr char TestString[] =                                       \
        "(" #Inst ", " #Base ", " #Index ", " #Scale ", " #Disp ", " #Src      \
        ", " #OpType ", " #ByteCountUntyped ",  " #__VA_ARGS__ ")";            \
    static constexpr uint8_t ByteCount = ByteCountUntyped;                     \
    __ Inst(IceType_##OpType,                                                  \
            Address(GPRRegister::Encoded_Reg_##Base,                           \
                    GPRRegister::Encoded_Reg_##Index, Traits::TIMES_##Scale,   \
                    Disp, AssemblerFixup::NoFixup),                            \
            GPRRegister::Encoded_Reg_##Src);                                   \
    ASSERT_EQ(ByteCount, codeBytesSize()) << TestString;                       \
    ASSERT_TRUE(verifyBytes<ByteCount>(codeBytes(), __VA_ARGS__))              \
        << TestString;                                                         \
    reset();                                                                   \
  } while (0)

  /* cmp GPR, GPR */
  TestRegReg(cmp, eax, ecx, i32, 2, 0x3B, 0xC1);
  TestRegReg(cmp, ecx, edx, i32, 2, 0x3B, 0xCA);
  TestRegReg(cmp, edx, ebx, i32, 2, 0x3B, 0xD3);
  TestRegReg(cmp, ebx, esp, i32, 2, 0x3B, 0xDC);
  TestRegReg(cmp, esp, ebp, i32, 2, 0x3B, 0xE5);
  TestRegReg(cmp, ebp, esi, i32, 2, 0x3B, 0xEE);
  TestRegReg(cmp, esi, edi, i32, 2, 0x3B, 0xF7);
  TestRegReg(cmp, edi, eax, i32, 2, 0x3B, 0xF8);

  TestRegReg(cmp, eax, ecx, i16, 3, 0x66, 0x3B, 0xC1);
  TestRegReg(cmp, ecx, edx, i16, 3, 0x66, 0x3B, 0xCA);
  TestRegReg(cmp, edx, ebx, i16, 3, 0x66, 0x3B, 0xD3);
  TestRegReg(cmp, ebx, esp, i16, 3, 0x66, 0x3B, 0xDC);
  TestRegReg(cmp, esp, ebp, i16, 3, 0x66, 0x3B, 0xE5);
  TestRegReg(cmp, ebp, esi, i16, 3, 0x66, 0x3B, 0xEE);
  TestRegReg(cmp, esi, edi, i16, 3, 0x66, 0x3B, 0xF7);
  TestRegReg(cmp, edi, eax, i16, 3, 0x66, 0x3B, 0xF8);

  TestRegReg(cmp, eax, ecx, i8, 2, 0x3A, 0xC1);
  TestRegReg(cmp, ecx, edx, i8, 2, 0x3A, 0xCA);
  TestRegReg(cmp, edx, ebx, i8, 2, 0x3A, 0xD3);
  TestRegReg(cmp, ebx, esp, i8, 2, 0x3A, 0xDC);
  TestRegReg(cmp, esp, ebp, i8, 2, 0x3A, 0xE5);
  TestRegReg(cmp, ebp, esi, i8, 2, 0x3A, 0xEE);
  TestRegReg(cmp, esi, edi, i8, 2, 0x3A, 0xF7);
  TestRegReg(cmp, edi, eax, i8, 2, 0x3A, 0xF8);

  /* cmp GPR, Imm8 */
  TestRegImm(cmp, eax, 5, i32, 3, 0x83, 0xF8, 0x05);
  TestRegImm(cmp, ecx, 5, i32, 3, 0x83, 0xF9, 0x05);
  TestRegImm(cmp, edx, 5, i32, 3, 0x83, 0xFA, 0x05);
  TestRegImm(cmp, ebx, 5, i32, 3, 0x83, 0xFB, 0x05);
  TestRegImm(cmp, esp, 5, i32, 3, 0x83, 0xFC, 0x05);
  TestRegImm(cmp, ebp, 5, i32, 3, 0x83, 0xFD, 0x05);
  TestRegImm(cmp, esi, 5, i32, 3, 0x83, 0xFE, 0x05);
  TestRegImm(cmp, edi, 5, i32, 3, 0x83, 0xFF, 0x05);

  TestRegImm(cmp, eax, 5, i16, 4, 0x66, 0x83, 0xF8, 0x05);
  TestRegImm(cmp, ecx, 5, i16, 4, 0x66, 0x83, 0xF9, 0x05);
  TestRegImm(cmp, edx, 5, i16, 4, 0x66, 0x83, 0xFA, 0x05);
  TestRegImm(cmp, ebx, 5, i16, 4, 0x66, 0x83, 0xFB, 0x05);
  TestRegImm(cmp, esp, 5, i16, 4, 0x66, 0x83, 0xFC, 0x05);
  TestRegImm(cmp, ebp, 5, i16, 4, 0x66, 0x83, 0xFD, 0x05);
  TestRegImm(cmp, esi, 5, i16, 4, 0x66, 0x83, 0xFE, 0x05);
  TestRegImm(cmp, edi, 5, i16, 4, 0x66, 0x83, 0xFF, 0x05);

  TestRegImm(cmp, eax, 5, i8, 2, 0x3C, 0x05);
  TestRegImm(cmp, ecx, 5, i8, 3, 0x80, 0xF9, 0x05);
  TestRegImm(cmp, edx, 5, i8, 3, 0x80, 0xFA, 0x05);
  TestRegImm(cmp, ebx, 5, i8, 3, 0x80, 0xFB, 0x05);
  TestRegImm(cmp, esp, 5, i8, 3, 0x80, 0xFC, 0x05);
  TestRegImm(cmp, ebp, 5, i8, 3, 0x80, 0xFD, 0x05);
  TestRegImm(cmp, esi, 5, i8, 3, 0x80, 0xFE, 0x05);
  TestRegImm(cmp, edi, 5, i8, 3, 0x80, 0xFF, 0x05);

  /* cmp GPR, Imm16 */
  TestRegImm(cmp, eax, 0x100, i32, 5, 0x3D, 0x00, 0x01, 0x00, 0x00);
  TestRegImm(cmp, ecx, 0x100, i32, 6, 0x81, 0xF9, 0x00, 0x01, 0x00, 0x00);
  TestRegImm(cmp, edx, 0x100, i32, 6, 0x81, 0xFA, 0x00, 0x01, 0x00, 0x00);
  TestRegImm(cmp, ebx, 0x100, i32, 6, 0x81, 0xFB, 0x00, 0x01, 0x00, 0x00);
  TestRegImm(cmp, esp, 0x100, i32, 6, 0x81, 0xFC, 0x00, 0x01, 0x00, 0x00);
  TestRegImm(cmp, ebp, 0x100, i32, 6, 0x81, 0xFD, 0x00, 0x01, 0x00, 0x00);
  TestRegImm(cmp, esi, 0x100, i32, 6, 0x81, 0xFE, 0x00, 0x01, 0x00, 0x00);
  TestRegImm(cmp, edi, 0x100, i32, 6, 0x81, 0xFF, 0x00, 0x01, 0x00, 0x00);

  TestRegImm(cmp, eax, 0x100, i16, 4, 0x66, 0x3D, 0x00, 0x01);
  TestRegImm(cmp, ecx, 0x100, i16, 5, 0x66, 0x81, 0xF9, 0x00, 0x01);
  TestRegImm(cmp, edx, 0x100, i16, 5, 0x66, 0x81, 0xFA, 0x00, 0x01);
  TestRegImm(cmp, ebx, 0x100, i16, 5, 0x66, 0x81, 0xFB, 0x00, 0x01);
  TestRegImm(cmp, esp, 0x100, i16, 5, 0x66, 0x81, 0xFC, 0x00, 0x01);
  TestRegImm(cmp, ebp, 0x100, i16, 5, 0x66, 0x81, 0xFD, 0x00, 0x01);
  TestRegImm(cmp, esi, 0x100, i16, 5, 0x66, 0x81, 0xFE, 0x00, 0x01);
  TestRegImm(cmp, edi, 0x100, i16, 5, 0x66, 0x81, 0xFF, 0x00, 0x01);

  /* cmp GPR, Absolute */
  TestRegAbsoluteAddr(cmp, eax, 0xF00FBEEF, i32, 6, 0x3B, 0x05, 0xEF, 0xBE,
                      0x0F, 0xF0);
  TestRegAbsoluteAddr(cmp, eax, 0xF00FBEEF, i16, 7, 0x66, 0x3B, 0x05, 0xEF,
                      0xBE, 0x0F, 0xF0);
  TestRegAbsoluteAddr(cmp, eax, 0xF00FBEEF, i8, 6, 0x3A, 0x05, 0xEF, 0xBE, 0x0F,
                      0xF0);

  /* cmp GPR, 0(Base) */
  TestRegAddrBase(cmp, eax, ecx, 0, i32, 2, 0x3B, 0x01);
  TestRegAddrBase(cmp, ecx, edx, 0, i32, 2, 0x3B, 0x0A);
  TestRegAddrBase(cmp, edx, ebx, 0, i32, 2, 0x3B, 0x13);
  TestRegAddrBase(cmp, ebx, esp, 0, i32, 3, 0x3B, 0x1C, 0x24);
  TestRegAddrBase(cmp, esp, ebp, 0, i32, 3, 0x3B, 0x65, 0x00);
  TestRegAddrBase(cmp, ebp, esi, 0, i32, 2, 0x3B, 0x2E);
  TestRegAddrBase(cmp, esi, edi, 0, i32, 2, 0x3B, 0x37);
  TestRegAddrBase(cmp, edi, eax, 0, i32, 2, 0x3B, 0x38);

  TestRegAddrBase(cmp, eax, ecx, 0, i16, 3, 0x66, 0x3B, 0x01);
  TestRegAddrBase(cmp, ecx, edx, 0, i16, 3, 0x66, 0x3B, 0x0A);
  TestRegAddrBase(cmp, edx, ebx, 0, i16, 3, 0x66, 0x3B, 0x13);
  TestRegAddrBase(cmp, ebx, esp, 0, i16, 4, 0x66, 0x3B, 0x1C, 0x24);
  TestRegAddrBase(cmp, esp, ebp, 0, i16, 4, 0x66, 0x3B, 0x65, 0x00);
  TestRegAddrBase(cmp, ebp, esi, 0, i16, 3, 0x66, 0x3B, 0x2E);
  TestRegAddrBase(cmp, esi, edi, 0, i16, 3, 0x66, 0x3B, 0x37);
  TestRegAddrBase(cmp, edi, eax, 0, i16, 3, 0x66, 0x3B, 0x38);

  TestRegAddrBase(cmp, eax, ecx, 0, i8, 2, 0x3A, 0x01);
  TestRegAddrBase(cmp, ecx, edx, 0, i8, 2, 0x3A, 0x0A);
  TestRegAddrBase(cmp, edx, ebx, 0, i8, 2, 0x3A, 0x13);
  TestRegAddrBase(cmp, ebx, esp, 0, i8, 3, 0x3A, 0x1C, 0x24);
  TestRegAddrBase(cmp, esp, ebp, 0, i8, 3, 0x3A, 0x65, 0x00);
  TestRegAddrBase(cmp, ebp, esi, 0, i8, 2, 0x3A, 0x2E);
  TestRegAddrBase(cmp, esi, edi, 0, i8, 2, 0x3A, 0x37);
  TestRegAddrBase(cmp, edi, eax, 0, i8, 2, 0x3A, 0x38);

  /* cmp GPR, Imm8(Base) */
  TestRegAddrBase(cmp, eax, ecx, 0x40, i32, 3, 0x3B, 0x41, 0x40);
  TestRegAddrBase(cmp, ecx, edx, 0x40, i32, 3, 0x3B, 0x4A, 0x40);
  TestRegAddrBase(cmp, edx, ebx, 0x40, i32, 3, 0x3B, 0x53, 0x40);
  TestRegAddrBase(cmp, ebx, esp, 0x40, i32, 4, 0x3B, 0x5C, 0x24, 0x40);
  TestRegAddrBase(cmp, esp, ebp, 0x40, i32, 3, 0x3B, 0x65, 0x40);
  TestRegAddrBase(cmp, ebp, esi, 0x40, i32, 3, 0x3B, 0x6E, 0x40);
  TestRegAddrBase(cmp, esi, edi, 0x40, i32, 3, 0x3B, 0x77, 0x40);
  TestRegAddrBase(cmp, edi, eax, 0x40, i32, 3, 0x3B, 0x78, 0x40);

  TestRegAddrBase(cmp, eax, ecx, 0x40, i16, 4, 0x66, 0x3B, 0x41, 0x40);
  TestRegAddrBase(cmp, ecx, edx, 0x40, i16, 4, 0x66, 0x3B, 0x4A, 0x40);
  TestRegAddrBase(cmp, edx, ebx, 0x40, i16, 4, 0x66, 0x3B, 0x53, 0x40);
  TestRegAddrBase(cmp, ebx, esp, 0x40, i16, 5, 0x66, 0x3B, 0x5C, 0x24, 0x40);
  TestRegAddrBase(cmp, esp, ebp, 0x40, i16, 4, 0x66, 0x3B, 0x65, 0x40);
  TestRegAddrBase(cmp, ebp, esi, 0x40, i16, 4, 0x66, 0x3B, 0x6E, 0x40);
  TestRegAddrBase(cmp, esi, edi, 0x40, i16, 4, 0x66, 0x3B, 0x77, 0x40);
  TestRegAddrBase(cmp, edi, eax, 0x40, i16, 4, 0x66, 0x3B, 0x78, 0x40);

  TestRegAddrBase(cmp, eax, ecx, 0x40, i8, 3, 0x3A, 0x41, 0x40);
  TestRegAddrBase(cmp, ecx, edx, 0x40, i8, 3, 0x3A, 0x4A, 0x40);
  TestRegAddrBase(cmp, edx, ebx, 0x40, i8, 3, 0x3A, 0x53, 0x40);
  TestRegAddrBase(cmp, ebx, esp, 0x40, i8, 4, 0x3A, 0x5C, 0x24, 0x40);
  TestRegAddrBase(cmp, esp, ebp, 0x40, i8, 3, 0x3A, 0x65, 0x40);
  TestRegAddrBase(cmp, ebp, esi, 0x40, i8, 3, 0x3A, 0x6E, 0x40);
  TestRegAddrBase(cmp, esi, edi, 0x40, i8, 3, 0x3A, 0x77, 0x40);
  TestRegAddrBase(cmp, edi, eax, 0x40, i8, 3, 0x3A, 0x78, 0x40);

  /* cmp GPR, Imm32(Base) */
  TestRegAddrBase(cmp, eax, ecx, 0xF0, i32, 6, 0x3B, 0x81, 0xF0, 0x00, 0x00,
                  0x00);
  TestRegAddrBase(cmp, ecx, edx, 0xF0, i32, 6, 0x3B, 0x8A, 0xF0, 0x00, 0x00,
                  0x00);
  TestRegAddrBase(cmp, edx, ebx, 0xF0, i32, 6, 0x3B, 0x93, 0xF0, 0x00, 0x00,
                  0x00);
  TestRegAddrBase(cmp, ebx, esp, 0xF0, i32, 7, 0x3B, 0x9C, 0x24, 0xF0, 0x00,
                  0x00, 0x00);
  TestRegAddrBase(cmp, esp, ebp, 0xF0, i32, 6, 0x3B, 0xA5, 0xF0, 0x00, 0x00,
                  0x00);
  TestRegAddrBase(cmp, ebp, esi, 0xF0, i32, 6, 0x3B, 0xAE, 0xF0, 0x00, 0x00,
                  0x00);
  TestRegAddrBase(cmp, esi, edi, 0xF0, i32, 6, 0x3B, 0xB7, 0xF0, 0x00, 0x00,
                  0x00);
  TestRegAddrBase(cmp, edi, eax, 0xF0, i32, 6, 0x3B, 0xB8, 0xF0, 0x00, 0x00,
                  0x00);

  TestRegAddrBase(cmp, eax, ecx, 0xF0, i16, 7, 0x66, 0x3B, 0x81, 0xF0, 0x00,
                  0x00, 0x00);
  TestRegAddrBase(cmp, ecx, edx, 0xF0, i16, 7, 0x66, 0x3B, 0x8A, 0xF0, 0x00,
                  0x00, 0x00);
  TestRegAddrBase(cmp, edx, ebx, 0xF0, i16, 7, 0x66, 0x3B, 0x93, 0xF0, 0x00,
                  0x00, 0x00);
  TestRegAddrBase(cmp, ebx, esp, 0xF0, i16, 8, 0x66, 0x3B, 0x9C, 0x24, 0xF0,
                  0x00, 0x00, 0x00);
  TestRegAddrBase(cmp, esp, ebp, 0xF0, i16, 7, 0x66, 0x3B, 0xa5, 0xF0, 0x00,
                  0x00, 0x00);
  TestRegAddrBase(cmp, ebp, esi, 0xF0, i16, 7, 0x66, 0x3B, 0xaE, 0xF0, 0x00,
                  0x00, 0x00);
  TestRegAddrBase(cmp, esi, edi, 0xF0, i16, 7, 0x66, 0x3B, 0xb7, 0xF0, 0x00,
                  0x00, 0x00);
  TestRegAddrBase(cmp, edi, eax, 0xF0, i16, 7, 0x66, 0x3B, 0xb8, 0xF0, 0x00,
                  0x00, 0x00);

  TestRegAddrBase(cmp, eax, ecx, 0xF0, i8, 6, 0x3A, 0x81, 0xF0, 0x00, 0x00,
                  0x00);
  TestRegAddrBase(cmp, ecx, edx, 0xF0, i8, 6, 0x3A, 0x8A, 0xF0, 0x00, 0x00,
                  0x00);
  TestRegAddrBase(cmp, edx, ebx, 0xF0, i8, 6, 0x3A, 0x93, 0xF0, 0x00, 0x00,
                  0x00);
  TestRegAddrBase(cmp, ebx, esp, 0xF0, i8, 7, 0x3A, 0x9C, 0x24, 0xF0, 0x00,
                  0x00, 0x00);
  TestRegAddrBase(cmp, esp, ebp, 0xF0, i8, 6, 0x3A, 0xA5, 0xF0, 0x00, 0x00,
                  0x00);
  TestRegAddrBase(cmp, ebp, esi, 0xF0, i8, 6, 0x3A, 0xAE, 0xF0, 0x00, 0x00,
                  0x00);
  TestRegAddrBase(cmp, esi, edi, 0xF0, i8, 6, 0x3A, 0xB7, 0xF0, 0x00, 0x00,
                  0x00);
  TestRegAddrBase(cmp, edi, eax, 0xF0, i8, 6, 0x3A, 0xB8, 0xF0, 0x00, 0x00,
                  0x00);

  /* cmp GPR, Imm(,Index,Scale) */
  TestRegAddrScaledIndex(cmp, eax, ecx, 1, 0, i32, 7, 0x3B, 0x04, 0x0D, 0x00,
                         0x00, 0x00, 0x00);
  TestRegAddrScaledIndex(cmp, ecx, edx, 2, 0, i32, 7, 0x3B, 0x0C, 0x55, 0x00,
                         0x00, 0x00, 0x00);
  TestRegAddrScaledIndex(cmp, edx, ebx, 4, 0, i32, 7, 0x3B, 0x14, 0x9D, 0x00,
                         0x00, 0x00, 0x00);
  // esp cannot be an scaled index.
  TestRegAddrScaledIndex(cmp, esp, ebp, 8, 0, i32, 7, 0x3B, 0x24, 0xED, 0x00,
                         0x00, 0x00, 0x00);
  TestRegAddrScaledIndex(cmp, ebp, esi, 1, 0, i32, 7, 0x3B, 0x2C, 0x35, 0x00,
                         0x00, 0x00, 0x00);
  TestRegAddrScaledIndex(cmp, esi, edi, 2, 0, i32, 7, 0x3B, 0x34, 0x7D, 0x00,
                         0x00, 0x00, 0x00);
  TestRegAddrScaledIndex(cmp, edi, eax, 4, 0, i32, 7, 0x3B, 0x3C, 0x85, 0x00,
                         0x00, 0x00, 0x00);
  TestRegAddrScaledIndex(cmp, ebx, ecx, 8, 0, i32, 7, 0x3B, 0x1C, 0xCD, 0x00,
                         0x00, 0x00, 0x00);

  TestRegAddrScaledIndex(cmp, eax, ecx, 8, 0, i16, 8, 0x66, 0x3B, 0x04, 0xCD,
                         0x00, 0x00, 0x00, 0x00);
  TestRegAddrScaledIndex(cmp, ecx, edx, 1, 0, i16, 8, 0x66, 0x3B, 0x0C, 0x15,
                         0x00, 0x00, 0x00, 0x00);
  TestRegAddrScaledIndex(cmp, edx, ebx, 2, 0, i16, 8, 0x66, 0x3B, 0x14, 0x5D,
                         0x00, 0x00, 0x00, 0x00);
  // esp cannot be an scaled index.
  TestRegAddrScaledIndex(cmp, esp, ebp, 4, 0, i16, 8, 0x66, 0x3B, 0x24, 0xAD,
                         0x00, 0x00, 0x00, 0x00);
  TestRegAddrScaledIndex(cmp, ebp, esi, 8, 0, i16, 8, 0x66, 0x3B, 0x2C, 0xF5,
                         0x00, 0x00, 0x00, 0x00);
  TestRegAddrScaledIndex(cmp, esi, edi, 1, 0, i16, 8, 0x66, 0x3B, 0x34, 0x3D,
                         0x00, 0x00, 0x00, 0x00);
  TestRegAddrScaledIndex(cmp, edi, eax, 2, 0, i16, 8, 0x66, 0x3B, 0x3C, 0x45,
                         0x00, 0x00, 0x00, 0x00);
  TestRegAddrScaledIndex(cmp, ebx, ecx, 8, 0, i16, 8, 0x66, 0x3B, 0x1C, 0xCD,
                         0x00, 0x00, 0x00, 0x00);

  TestRegAddrScaledIndex(cmp, eax, ecx, 4, 0, i8, 7, 0x3A, 0x04, 0x8D, 0x00,
                         0x00, 0x00, 0x00);
  TestRegAddrScaledIndex(cmp, ecx, edx, 8, 0, i8, 7, 0x3A, 0x0C, 0xD5, 0x00,
                         0x00, 0x00, 0x00);
  TestRegAddrScaledIndex(cmp, edx, ebx, 1, 0, i8, 7, 0x3A, 0x14, 0x1D, 0x00,
                         0x00, 0x00, 0x00);
  // esp cannot be an scaled index.
  TestRegAddrScaledIndex(cmp, esp, ebp, 2, 0, i8, 7, 0x3A, 0x24, 0x6D, 0x00,
                         0x00, 0x00, 0x00);
  TestRegAddrScaledIndex(cmp, ebp, esi, 4, 0, i8, 7, 0x3A, 0x2C, 0xB5, 0x00,
                         0x00, 0x00, 0x00);
  TestRegAddrScaledIndex(cmp, esi, edi, 8, 0, i8, 7, 0x3A, 0x34, 0xFD, 0x00,
                         0x00, 0x00, 0x00);
  TestRegAddrScaledIndex(cmp, edi, eax, 1, 0, i8, 7, 0x3A, 0x3C, 0x05, 0x00,
                         0x00, 0x00, 0x00);
  TestRegAddrScaledIndex(cmp, ebx, ecx, 8, 0, i8, 7, 0x3a, 0x1C, 0xCD, 0x00,
                         0x00, 0x00, 0x00);

  /* cmp GPR, 0(Base,Index,Scale) */
  TestRegAddrBaseScaledIndex(cmp, eax, ecx, edx, 1, 0, i32, 3, 0x3B, 0x04,
                             0x11);
  TestRegAddrBaseScaledIndex(cmp, ecx, edx, ebx, 2, 0, i32, 3, 0x3B, 0x0C,
                             0x5A);
  // esp cannot be an scaled index.
  TestRegAddrBaseScaledIndex(cmp, ebx, esp, ebp, 4, 0, i32, 3, 0x3B, 0x1C,
                             0xAC);
  TestRegAddrBaseScaledIndex(cmp, esp, ebp, esi, 8, 0, i32, 4, 0x3B, 0x64, 0xF5,
                             0x00);
  TestRegAddrBaseScaledIndex(cmp, ebp, esi, edi, 1, 0, i32, 3, 0x3B, 0x2C,
                             0x3E);
  TestRegAddrBaseScaledIndex(cmp, esi, edi, eax, 2, 0, i32, 3, 0x3B, 0x34,
                             0x47);
  TestRegAddrBaseScaledIndex(cmp, edi, eax, ebx, 4, 0, i32, 3, 0x3B, 0x3C,
                             0x98);
  TestRegAddrBaseScaledIndex(cmp, ebx, ecx, edx, 8, 0, i32, 3, 0x3B, 0x1C,
                             0xD1);

  TestRegAddrBaseScaledIndex(cmp, eax, ecx, edx, 1, 0, i16, 4, 0x66, 0x3B, 0x04,
                             0x11);
  TestRegAddrBaseScaledIndex(cmp, ecx, edx, ebx, 2, 0, i16, 4, 0x66, 0x3B, 0x0C,
                             0x5A);
  // esp cannot be an scaled index.
  TestRegAddrBaseScaledIndex(cmp, ebx, esp, ebp, 4, 0, i16, 4, 0x66, 0x3B, 0x1C,
                             0xAC);
  TestRegAddrBaseScaledIndex(cmp, esp, ebp, esi, 8, 0, i16, 5, 0x66, 0x3B, 0x64,
                             0xF5, 0x00);
  TestRegAddrBaseScaledIndex(cmp, ebp, esi, edi, 1, 0, i16, 4, 0x66, 0x3B, 0x2C,
                             0x3E);
  TestRegAddrBaseScaledIndex(cmp, esi, edi, eax, 2, 0, i16, 4, 0x66, 0x3B, 0x34,
                             0x47);
  TestRegAddrBaseScaledIndex(cmp, edi, eax, ebx, 4, 0, i16, 4, 0x66, 0x3B, 0x3C,
                             0x98);
  TestRegAddrBaseScaledIndex(cmp, ebx, ecx, edx, 8, 0, i16, 4, 0x66, 0x3B, 0x1C,
                             0xD1);

  TestRegAddrBaseScaledIndex(cmp, eax, ecx, edx, 1, 0, i8, 3, 0x3A, 0x04, 0x11);
  TestRegAddrBaseScaledIndex(cmp, ecx, edx, ebx, 2, 0, i8, 3, 0x3A, 0x0C, 0x5A);
  // esp cannot be an scaled index.
  TestRegAddrBaseScaledIndex(cmp, ebx, esp, ebp, 4, 0, i8, 3, 0x3A, 0x1C, 0xAC);
  TestRegAddrBaseScaledIndex(cmp, esp, ebp, esi, 8, 0, i8, 4, 0x3A, 0x64, 0xF5,
                             0x00);
  TestRegAddrBaseScaledIndex(cmp, ebp, esi, edi, 1, 0, i8, 3, 0x3A, 0x2C, 0x3E);
  TestRegAddrBaseScaledIndex(cmp, esi, edi, eax, 2, 0, i8, 3, 0x3A, 0x34, 0x47);
  TestRegAddrBaseScaledIndex(cmp, edi, eax, ebx, 4, 0, i8, 3, 0x3A, 0x3C, 0x98);
  TestRegAddrBaseScaledIndex(cmp, ebx, ecx, edx, 8, 0, i8, 3, 0x3A, 0x1C, 0xD1);

  /* cmp GPR, Imm8(Base,Index,Scale) */
  TestRegAddrBaseScaledIndex(cmp, eax, ecx, edx, 1, 0x40, i32, 4, 0x3B, 0x44,
                             0x11, 0x40);
  TestRegAddrBaseScaledIndex(cmp, ecx, edx, ebx, 2, 0x40, i32, 4, 0x3B, 0x4C,
                             0x5A, 0x40);
  // esp cannot be an scaled index.
  TestRegAddrBaseScaledIndex(cmp, ebx, esp, ebp, 4, 0x40, i32, 4, 0x3B, 0x5C,
                             0xAC, 0x40);
  TestRegAddrBaseScaledIndex(cmp, esp, ebp, esi, 8, 0x40, i32, 4, 0x3B, 0x64,
                             0xF5, 0x40);
  TestRegAddrBaseScaledIndex(cmp, ebp, esi, edi, 1, 0x40, i32, 4, 0x3B, 0x6C,
                             0x3E, 0x40);
  TestRegAddrBaseScaledIndex(cmp, esi, edi, eax, 2, 0x40, i32, 4, 0x3B, 0x74,
                             0x47, 0x40);
  TestRegAddrBaseScaledIndex(cmp, edi, eax, ebx, 4, 0x40, i32, 4, 0x3B, 0x7C,
                             0x98, 0x40);
  TestRegAddrBaseScaledIndex(cmp, ebx, ecx, edx, 8, 0x40, i32, 4, 0x3B, 0x5C,
                             0xD1, 0x40);

  TestRegAddrBaseScaledIndex(cmp, eax, ecx, edx, 1, 0x40, i16, 5, 0x66, 0x3B,
                             0x44, 0x11, 0x40);
  TestRegAddrBaseScaledIndex(cmp, ecx, edx, ebx, 2, 0x40, i16, 5, 0x66, 0x3B,
                             0x4C, 0x5A, 0x40);
  // esp cannot be an scaled index.
  TestRegAddrBaseScaledIndex(cmp, ebx, esp, ebp, 4, 0x40, i16, 5, 0x66, 0x3B,
                             0x5C, 0xAC, 0x40);
  TestRegAddrBaseScaledIndex(cmp, esp, ebp, esi, 8, 0x40, i16, 5, 0x66, 0x3B,
                             0x64, 0xF5, 0x40);
  TestRegAddrBaseScaledIndex(cmp, ebp, esi, edi, 1, 0x40, i16, 5, 0x66, 0x3B,
                             0x6C, 0x3E, 0x40);
  TestRegAddrBaseScaledIndex(cmp, esi, edi, eax, 2, 0x40, i16, 5, 0x66, 0x3B,
                             0x74, 0x47, 0x40);
  TestRegAddrBaseScaledIndex(cmp, edi, eax, ebx, 4, 0x40, i16, 5, 0x66, 0x3B,
                             0x7C, 0x98, 0x40);
  TestRegAddrBaseScaledIndex(cmp, ebx, ecx, edx, 8, 0x40, i16, 5, 0x66, 0x3B,
                             0x5C, 0xD1, 0x40);

  TestRegAddrBaseScaledIndex(cmp, eax, ecx, edx, 1, 0x40, i8, 4, 0x3A, 0x44,
                             0x11, 0x40);
  TestRegAddrBaseScaledIndex(cmp, ecx, edx, ebx, 2, 0x40, i8, 4, 0x3A, 0x4C,
                             0x5A, 0x40);
  // esp cannot be an scaled index.
  TestRegAddrBaseScaledIndex(cmp, ebx, esp, ebp, 4, 0x40, i8, 4, 0x3A, 0x5C,
                             0xAC, 0x40);
  TestRegAddrBaseScaledIndex(cmp, esp, ebp, esi, 8, 0x40, i8, 4, 0x3A, 0x64,
                             0xF5, 0x40);
  TestRegAddrBaseScaledIndex(cmp, ebp, esi, edi, 1, 0x40, i8, 4, 0x3A, 0x6C,
                             0x3E, 0x40);
  TestRegAddrBaseScaledIndex(cmp, esi, edi, eax, 2, 0x40, i8, 4, 0x3A, 0x74,
                             0x47, 0x40);
  TestRegAddrBaseScaledIndex(cmp, edi, eax, ebx, 4, 0x40, i8, 4, 0x3A, 0x7C,
                             0x98, 0x40);
  TestRegAddrBaseScaledIndex(cmp, ebx, ecx, edx, 8, 0x40, i8, 4, 0x3A, 0x5C,
                             0xD1, 0x40);

  /* cmp GPR, Imm32(Base,Index,Scale) */
  TestRegAddrBaseScaledIndex(cmp, eax, ecx, edx, 1, 0xF0, i32, 7, 0x3B, 0x84,
                             0x11, 0xF0, 0x00, 0x00, 0x00);
  TestRegAddrBaseScaledIndex(cmp, ecx, edx, ebx, 2, 0xF0, i32, 7, 0x3B, 0x8C,
                             0x5A, 0xF0, 0x00, 0x00, 0x00);
  // esp cannot be an scaled index.
  TestRegAddrBaseScaledIndex(cmp, ebx, esp, ebp, 4, 0xF0, i32, 7, 0x3B, 0x9C,
                             0xAC, 0xF0, 0x00, 0x00, 0x00);
  TestRegAddrBaseScaledIndex(cmp, esp, ebp, esi, 8, 0xF0, i32, 7, 0x3B, 0xA4,
                             0xF5, 0xF0, 0x00, 0x00, 0x00);
  TestRegAddrBaseScaledIndex(cmp, ebp, esi, edi, 1, 0xF0, i32, 7, 0x3B, 0xAC,
                             0x3E, 0xF0, 0x00, 0x00, 0x00);
  TestRegAddrBaseScaledIndex(cmp, esi, edi, eax, 2, 0xF0, i32, 7, 0x3B, 0xB4,
                             0x47, 0xF0, 0x00, 0x00, 0x00);
  TestRegAddrBaseScaledIndex(cmp, edi, eax, ebx, 4, 0xF0, i32, 7, 0x3B, 0xBC,
                             0x98, 0xF0, 0x00, 0x00, 0x00);
  TestRegAddrBaseScaledIndex(cmp, ebx, ecx, edx, 8, 0xF0, i32, 7, 0x3B, 0x9C,
                             0xD1, 0xF0, 0x00, 0x00, 0x00);

  TestRegAddrBaseScaledIndex(cmp, eax, ecx, edx, 1, 0xF0, i16, 8, 0x66, 0x3B,
                             0x84, 0x11, 0xF0, 0x00, 0x00, 0x00);
  TestRegAddrBaseScaledIndex(cmp, ecx, edx, ebx, 2, 0xF0, i16, 8, 0x66, 0x3B,
                             0x8C, 0x5A, 0xF0, 0x00, 0x00, 0x00);
  // esp cannot be an scaled index.
  TestRegAddrBaseScaledIndex(cmp, ebx, esp, ebp, 4, 0xF0, i16, 8, 0x66, 0x3B,
                             0x9C, 0xAC, 0xF0, 0x00, 0x00, 0x00);
  TestRegAddrBaseScaledIndex(cmp, esp, ebp, esi, 8, 0xF0, i16, 8, 0x66, 0x3B,
                             0xA4, 0xF5, 0xF0, 0x00, 0x00, 0x00);
  TestRegAddrBaseScaledIndex(cmp, ebp, esi, edi, 1, 0xF0, i16, 8, 0x66, 0x3B,
                             0xAC, 0x3E, 0xF0, 0x00, 0x00, 0x00);
  TestRegAddrBaseScaledIndex(cmp, esi, edi, eax, 2, 0xF0, i16, 8, 0x66, 0x3B,
                             0xB4, 0x47, 0xF0, 0x00, 0x00, 0x00);
  TestRegAddrBaseScaledIndex(cmp, edi, eax, ebx, 4, 0xF0, i16, 8, 0x66, 0x3B,
                             0xBC, 0x98, 0xF0, 0x00, 0x00, 0x00);
  TestRegAddrBaseScaledIndex(cmp, ebx, ecx, edx, 8, 0xF0, i16, 8, 0x66, 0x3B,
                             0x9C, 0xD1, 0xF0, 0x00, 0x00, 0x00);

  TestRegAddrBaseScaledIndex(cmp, eax, ecx, edx, 1, 0xF0, i8, 7, 0x3A, 0x84,
                             0x11, 0xF0, 0x00, 0x00, 0x00);
  TestRegAddrBaseScaledIndex(cmp, ecx, edx, ebx, 2, 0xF0, i8, 7, 0x3A, 0x8C,
                             0x5A, 0xF0, 0x00, 0x00, 0x00);
  // esp cannot be an scaled index.
  TestRegAddrBaseScaledIndex(cmp, ebx, esp, ebp, 4, 0xF0, i8, 7, 0x3A, 0x9C,
                             0xAC, 0xF0, 0x00, 0x00, 0x00);
  TestRegAddrBaseScaledIndex(cmp, esp, ebp, esi, 8, 0xF0, i8, 7, 0x3A, 0xA4,
                             0xF5, 0xF0, 0x00, 0x00, 0x00);
  TestRegAddrBaseScaledIndex(cmp, ebp, esi, edi, 1, 0xF0, i8, 7, 0x3A, 0xAC,
                             0x3E, 0xF0, 0x00, 0x00, 0x00);
  TestRegAddrBaseScaledIndex(cmp, esi, edi, eax, 2, 0xF0, i8, 7, 0x3A, 0xB4,
                             0x47, 0xF0, 0x00, 0x00, 0x00);
  TestRegAddrBaseScaledIndex(cmp, edi, eax, ebx, 4, 0xF0, i8, 7, 0x3A, 0xBC,
                             0x98, 0xF0, 0x00, 0x00, 0x00);
  TestRegAddrBaseScaledIndex(cmp, ebx, ecx, edx, 8, 0xF0, i8, 7, 0x3A, 0x9C,
                             0xD1, 0xF0, 0x00, 0x00, 0x00);

  /* cmp Addr, Imm */
  // Note: at this point we trust the assembler knows how to encode addresses,
  // so no more exhaustive addressing mode testing.
  TestAddrBaseScaledIndexImm(cmp, eax, ecx, 1, 0xF0, 0x12, i32, 8, 0x83, 0xBC,
                             0x08, 0xF0, 0x00, 0x00, 0x00, 0x12);
  TestAddrBaseScaledIndexImm(cmp, ecx, edx, 1, 0xF0, 0xF0, i32, 11, 0x81, 0xBC,
                             0x11, 0xF0, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00,
                             0x00);

  TestAddrBaseScaledIndexImm(cmp, eax, ecx, 1, 0xF0, 0x12, i16, 9, 0x66, 0x83,
                             0xBC, 0x08, 0xF0, 0x00, 0x00, 0x00, 0x12);
  TestAddrBaseScaledIndexImm(cmp, ecx, edx, 1, 0xF0, 0xF0, i16, 10, 0x66, 0x81,
                             0xBC, 0x11, 0xF0, 0x00, 0x00, 0x00, 0xF0, 0x00);

  TestAddrBaseScaledIndexImm(cmp, eax, ecx, 1, 0xF0, 0x12, i8, 8, 0x80, 0xBC,
                             0x08, 0xF0, 0x00, 0x00, 0x00, 0x12);

  /* cmp Addr, GPR */
  TestAddrBaseScaledIndexReg(cmp, eax, ecx, 1, 0xF0, edx, i32, 7, 0x39, 0x94,
                             0x08, 0xF0, 0x00, 0x00, 0x00);

  TestAddrBaseScaledIndexReg(cmp, eax, ecx, 1, 0xF0, edx, i16, 8, 0x66, 0x39,
                             0x94, 0x08, 0xF0, 0x00, 0x00, 0x00);

  TestAddrBaseScaledIndexReg(cmp, eax, ecx, 1, 0xF0, edx, i8, 7, 0x38, 0x94,
                             0x08, 0xF0, 0x00, 0x00, 0x00);

#undef TestAddrBaseScaledIndexReg
#undef TestAddrBaseScaledIndexImm
#undef TestRegAddrBaseScaledIndex
#undef TestRegAddrScaledIndex
#undef TestRegAddrBase
#undef TestRegAbsoluteAddr
#undef TestRegImm
#undef TestRegReg
}

TEST_F(AssemblerX8632Test, ScratchpadGettersAndSetters) {
  const uint32_t S0 = allocateDword();
  const uint32_t S1 = allocateDword();
  const uint32_t S2 = allocateDword();
  const uint32_t S3 = allocateDword();
  AssembledTest test = assemble();
  test.setDwordTo(S0, 0xBEEF0000u);
  test.setDwordTo(S1, 0xDEADu);
  test.setDwordTo(S2, 0x20406080u);
  ASSERT_EQ(0xBEEF0000u, test.contentsOfDword(S0));
  ASSERT_EQ(0xDEADu, test.contentsOfDword(S1));
  ASSERT_EQ(0x20406080u, test.contentsOfDword(S2));
  ASSERT_EQ(0xDEADBEEF0000ull, test.contentsOfQword(S0));
  ASSERT_EQ(0x204060800000DEADull, test.contentsOfQword(S1));

  test.setQwordTo(S1, 0x1234567890ABCDEFull);
  ASSERT_EQ(0x1234567890ABCDEFull, test.contentsOfQword(S1));
  test.setDwordTo(S0, 0xBEEF0000u);
  ASSERT_EQ(0x90ABCDEFull, test.contentsOfDword(S1));
  ASSERT_EQ(0x12345678ull, test.contentsOfDword(S2));

  test.setDwordTo(S0, 1.0f);
  ASSERT_FLOAT_EQ(1.0f, test.contentsOfDword<float>(S0));
  test.setQwordTo(S0, 3.14);
  ASSERT_DOUBLE_EQ(3.14, test.contentsOfQword<double>(S0));

  test.setDqwordTo(S0, Dqword(1.0f, 2.0f, 3.0f, 4.0f));
  ASSERT_EQ(Dqword(1.0f, 2.0f, 3.0f, 4.0f), test.contentsOfDqword(S0));
  EXPECT_FLOAT_EQ(1.0f, test.contentsOfDword<float>(S0));
  EXPECT_FLOAT_EQ(2.0f, test.contentsOfDword<float>(S1));
  EXPECT_FLOAT_EQ(3.0f, test.contentsOfDword<float>(S2));
  EXPECT_FLOAT_EQ(4.0f, test.contentsOfDword<float>(S3));
}

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