| OLD | NEW |
|---|
| (Empty) | |
| 1 //===- subzero/unittest/AssemblerX8664/LowLevel.cpp -----------------------===// |
| 2 // |
| 3 // The Subzero Code Generator |
| 4 // |
| 5 // This file is distributed under the University of Illinois Open Source |
| 6 // License. See LICENSE.TXT for details. |
| 7 // |
| 8 //===----------------------------------------------------------------------===// |
| 9 #include "AssemblerX8664/TestUtil.h" |
| 10 |
| 11 namespace Ice { |
| 12 namespace X8664 { |
| 13 namespace Test { |
| 14 namespace { |
| 15 |
| 16 TEST_F(AssemblerX8664LowLevelTest, Ret) { |
| 17 __ ret(); |
| 18 |
| 19 constexpr size_t ByteCount = 1; |
| 20 ASSERT_EQ(ByteCount, codeBytesSize()); |
| 21 |
| 22 verifyBytes<ByteCount>(codeBytes(), 0xc3); |
| 23 } |
| 24 |
| 25 TEST_F(AssemblerX8664LowLevelTest, RetImm) { |
| 26 __ ret(Immediate(0x20)); |
| 27 |
| 28 constexpr size_t ByteCount = 3; |
| 29 ASSERT_EQ(ByteCount, codeBytesSize()); |
| 30 |
| 31 verifyBytes<ByteCount>(codeBytes(), 0xC2, 0x20, 0x00); |
| 32 } |
| 33 |
| 34 TEST_F(AssemblerX8664LowLevelTest, CallImm4) { |
| 35 __ call(Immediate(4)); |
| 36 |
| 37 constexpr size_t ByteCount = 5; |
| 38 ASSERT_EQ(ByteCount, codeBytesSize()); |
| 39 |
| 40 verifyBytes<ByteCount>(codeBytes(), 0xe8, 0x00, 0x00, 0x00, 0x00); |
| 41 } |
| 42 |
| 43 TEST_F(AssemblerX8664LowLevelTest, PopRegs) { |
| 44 __ popl(Encoded_GPR_eax()); |
| 45 __ popl(Encoded_GPR_ebx()); |
| 46 __ popl(Encoded_GPR_ecx()); |
| 47 __ popl(Encoded_GPR_edx()); |
| 48 __ popl(Encoded_GPR_edi()); |
| 49 __ popl(Encoded_GPR_esi()); |
| 50 __ popl(Encoded_GPR_ebp()); |
| 51 __ popl(Encoded_GPR_r8()); |
| 52 __ popl(Encoded_GPR_r9()); |
| 53 __ popl(Encoded_GPR_r10()); |
| 54 __ popl(Encoded_GPR_r11()); |
| 55 __ popl(Encoded_GPR_r12()); |
| 56 __ popl(Encoded_GPR_r13()); |
| 57 __ popl(Encoded_GPR_r14()); |
| 58 __ popl(Encoded_GPR_r15()); |
| 59 |
| 60 constexpr size_t ByteCount = 23; |
| 61 ASSERT_EQ(ByteCount, codeBytesSize()); |
| 62 |
| 63 constexpr uint8_t Rex_B = 0x41; |
| 64 constexpr uint8_t PopOpcode = 0x58; |
| 65 verifyBytes<ByteCount>( |
| 66 codeBytes(), PopOpcode | Encoded_GPR_eax(), PopOpcode | Encoded_GPR_ebx(), |
| 67 PopOpcode | Encoded_GPR_ecx(), PopOpcode | Encoded_GPR_edx(), |
| 68 PopOpcode | Encoded_GPR_edi(), PopOpcode | Encoded_GPR_esi(), |
| 69 PopOpcode | Encoded_GPR_ebp(), Rex_B, PopOpcode | (Encoded_GPR_r8() & 7), |
| 70 Rex_B, PopOpcode | (Encoded_GPR_r9() & 7), Rex_B, |
| 71 PopOpcode | (Encoded_GPR_r10() & 7), Rex_B, |
| 72 PopOpcode | (Encoded_GPR_r11() & 7), Rex_B, |
| 73 PopOpcode | (Encoded_GPR_r12() & 7), Rex_B, |
| 74 PopOpcode | (Encoded_GPR_r13() & 7), Rex_B, |
| 75 PopOpcode | (Encoded_GPR_r14() & 7), Rex_B, |
| 76 PopOpcode | (Encoded_GPR_r15() & 7)); |
| 77 } |
| 78 |
| 79 TEST_F(AssemblerX8664LowLevelTest, PushRegs) { |
| 80 __ pushl(Encoded_GPR_eax()); |
| 81 __ pushl(Encoded_GPR_ebx()); |
| 82 __ pushl(Encoded_GPR_ecx()); |
| 83 __ pushl(Encoded_GPR_edx()); |
| 84 __ pushl(Encoded_GPR_edi()); |
| 85 __ pushl(Encoded_GPR_esi()); |
| 86 __ pushl(Encoded_GPR_ebp()); |
| 87 __ pushl(Encoded_GPR_r8()); |
| 88 __ pushl(Encoded_GPR_r9()); |
| 89 __ pushl(Encoded_GPR_r10()); |
| 90 __ pushl(Encoded_GPR_r11()); |
| 91 __ pushl(Encoded_GPR_r12()); |
| 92 __ pushl(Encoded_GPR_r13()); |
| 93 __ pushl(Encoded_GPR_r14()); |
| 94 __ pushl(Encoded_GPR_r15()); |
| 95 |
| 96 constexpr size_t ByteCount = 23; |
| 97 ASSERT_EQ(ByteCount, codeBytesSize()); |
| 98 |
| 99 constexpr uint8_t Rex_B = 0x41; |
| 100 constexpr uint8_t PushOpcode = 0x50; |
| 101 verifyBytes<ByteCount>( |
| 102 codeBytes(), PushOpcode | Encoded_GPR_eax(), |
| 103 PushOpcode | Encoded_GPR_ebx(), PushOpcode | Encoded_GPR_ecx(), |
| 104 PushOpcode | Encoded_GPR_edx(), PushOpcode | Encoded_GPR_edi(), |
| 105 PushOpcode | Encoded_GPR_esi(), PushOpcode | Encoded_GPR_ebp(), Rex_B, |
| 106 PushOpcode | (Encoded_GPR_r8() & 7), Rex_B, |
| 107 PushOpcode | (Encoded_GPR_r9() & 7), Rex_B, |
| 108 PushOpcode | (Encoded_GPR_r10() & 7), Rex_B, |
| 109 PushOpcode | (Encoded_GPR_r11() & 7), Rex_B, |
| 110 PushOpcode | (Encoded_GPR_r12() & 7), Rex_B, |
| 111 PushOpcode | (Encoded_GPR_r13() & 7), Rex_B, |
| 112 PushOpcode | (Encoded_GPR_r14() & 7), Rex_B, |
| 113 PushOpcode | (Encoded_GPR_r15() & 7)); |
| 114 } |
| 115 |
| 116 TEST_F(AssemblerX8664LowLevelTest, MovRegisterZero) { |
| 117 __ mov(IceType_i32, Encoded_GPR_eax(), Immediate(0x00)); |
| 118 __ mov(IceType_i32, Encoded_GPR_ebx(), Immediate(0x00)); |
| 119 __ mov(IceType_i32, Encoded_GPR_ecx(), Immediate(0x00)); |
| 120 __ mov(IceType_i32, Encoded_GPR_edx(), Immediate(0x00)); |
| 121 __ mov(IceType_i32, Encoded_GPR_edi(), Immediate(0x00)); |
| 122 __ mov(IceType_i32, Encoded_GPR_esi(), Immediate(0x00)); |
| 123 __ mov(IceType_i32, Encoded_GPR_ebp(), Immediate(0x00)); |
| 124 __ mov(IceType_i32, Encoded_GPR_r8(), Immediate(0x00)); |
| 125 __ mov(IceType_i32, Encoded_GPR_r10(), Immediate(0x00)); |
| 126 __ mov(IceType_i32, Encoded_GPR_r11(), Immediate(0x00)); |
| 127 __ mov(IceType_i32, Encoded_GPR_r12(), Immediate(0x00)); |
| 128 __ mov(IceType_i32, Encoded_GPR_r13(), Immediate(0x00)); |
| 129 __ mov(IceType_i32, Encoded_GPR_r14(), Immediate(0x00)); |
| 130 __ mov(IceType_i32, Encoded_GPR_r15(), Immediate(0x00)); |
| 131 |
| 132 constexpr uint8_t Rex_B = 0x41; |
| 133 constexpr size_t MovReg32BitImmBytes = 5; |
| 134 constexpr size_t ByteCount = 14 * MovReg32BitImmBytes + 7 /*Rex_B*/; |
| 135 |
| 136 ASSERT_EQ(ByteCount, codeBytesSize()); |
| 137 |
| 138 constexpr uint8_t MovOpcode = 0xb8; |
| 139 verifyBytes<ByteCount>( |
| 140 codeBytes(), MovOpcode | Encoded_GPR_eax(), 0x00, 0x00, 0x00, 0x00, |
| 141 MovOpcode | Encoded_GPR_ebx(), 0x00, 0x00, 0x00, 0x00, |
| 142 MovOpcode | Encoded_GPR_ecx(), 0x00, 0x00, 0x00, 0x00, |
| 143 MovOpcode | Encoded_GPR_edx(), 0x00, 0x00, 0x00, 0x00, |
| 144 MovOpcode | Encoded_GPR_edi(), 0x00, 0x00, 0x00, 0x00, |
| 145 MovOpcode | Encoded_GPR_esi(), 0x00, 0x00, 0x00, 0x00, |
| 146 MovOpcode | Encoded_GPR_ebp(), 0x00, 0x00, 0x00, 0x00, Rex_B, |
| 147 MovOpcode | (Encoded_GPR_r8() & 7), 0x00, 0x00, 0x00, 0x00, Rex_B, |
| 148 MovOpcode | (Encoded_GPR_r10() & 7), 0x00, 0x00, 0x00, 0x00, Rex_B, |
| 149 MovOpcode | (Encoded_GPR_r11() & 7), 0x00, 0x00, 0x00, 0x00, Rex_B, |
| 150 MovOpcode | (Encoded_GPR_r12() & 7), 0x00, 0x00, 0x00, 0x00, Rex_B, |
| 151 MovOpcode | (Encoded_GPR_r13() & 7), 0x00, 0x00, 0x00, 0x00, Rex_B, |
| 152 MovOpcode | (Encoded_GPR_r14() & 7), 0x00, 0x00, 0x00, 0x00, Rex_B, |
| 153 MovOpcode | (Encoded_GPR_r15() & 7), 0x00, 0x00, 0x00, 0x00); |
| 154 } |
| 155 |
| 156 TEST_F(AssemblerX8664LowLevelTest, Cmp) { |
| 157 #define TestRegReg(Inst, Dst, Src, OpType, ByteCountUntyped, ...) \ |
| 158 do { \ |
| 159 static constexpr char TestString[] = \ |
| 160 "(" #Inst ", " #Dst ", " #Src ", " #OpType ", " #ByteCountUntyped \ |
| 161 ", " #__VA_ARGS__ ")"; \ |
| 162 static constexpr uint8_t ByteCount = ByteCountUntyped; \ |
| 163 __ Inst(IceType_##OpType, Encoded_GPR_##Dst(), Encoded_GPR_##Src()); \ |
| 164 ASSERT_EQ(ByteCount, codeBytesSize()) << TestString; \ |
| 165 ASSERT_TRUE(verifyBytes<ByteCount>(codeBytes(), __VA_ARGS__)) \ |
| 166 << TestString; \ |
| 167 reset(); \ |
| 168 } while (0) |
| 169 |
| 170 #define TestRegImm(Inst, Dst, Imm, OpType, ByteCountUntyped, ...) \ |
| 171 do { \ |
| 172 static constexpr char TestString[] = \ |
| 173 "(" #Inst ", " #Dst ", " #Imm ", " #OpType ", " #ByteCountUntyped \ |
| 174 ", " #__VA_ARGS__ ")"; \ |
| 175 static constexpr uint8_t ByteCount = ByteCountUntyped; \ |
| 176 __ Inst(IceType_##OpType, Encoded_GPR_##Dst(), Immediate(Imm)); \ |
| 177 ASSERT_EQ(ByteCount, codeBytesSize()) << TestString; \ |
| 178 ASSERT_TRUE(verifyBytes<ByteCount>(codeBytes(), __VA_ARGS__)) \ |
| 179 << TestString; \ |
| 180 reset(); \ |
| 181 } while (0) |
| 182 |
| 183 #define TestRegAbsoluteAddr(Inst, Dst, Disp, OpType, ByteCountUntyped, ...) \ |
| 184 do { \ |
| 185 static constexpr char TestString[] = \ |
| 186 "(" #Inst ", " #Dst ", " #Disp ", " #OpType ", " #ByteCountUntyped \ |
| 187 ", " #__VA_ARGS__ ")"; \ |
| 188 static constexpr uint8_t ByteCount = ByteCountUntyped; \ |
| 189 __ Inst(IceType_##OpType, Encoded_GPR_##Dst(), \ |
| 190 Address(Address::ABSOLUTE, Disp)); \ |
| 191 ASSERT_EQ(ByteCount, codeBytesSize()) << TestString; \ |
| 192 ASSERT_TRUE(verifyBytes<ByteCount>(codeBytes(), __VA_ARGS__)) \ |
| 193 << TestString; \ |
| 194 reset(); \ |
| 195 } while (0) |
| 196 |
| 197 #define TestRegAddrBase(Inst, Dst, Base, Disp, OpType, ByteCountUntyped, ...) \ |
| 198 do { \ |
| 199 static constexpr char TestString[] = \ |
| 200 "(" #Inst ", " #Dst ", " #Base ", " #Disp ", " #OpType \ |
| 201 ", " #ByteCountUntyped ", " #__VA_ARGS__ ")"; \ |
| 202 static constexpr uint8_t ByteCount = ByteCountUntyped; \ |
| 203 __ Inst(IceType_##OpType, Encoded_GPR_##Dst(), \ |
| 204 Address(Encoded_GPR_##Base(), Disp)); \ |
| 205 ASSERT_EQ(ByteCount, codeBytesSize()) << TestString; \ |
| 206 ASSERT_TRUE(verifyBytes<ByteCount>(codeBytes(), __VA_ARGS__)) \ |
| 207 << TestString; \ |
| 208 reset(); \ |
| 209 } while (0) |
| 210 |
| 211 #define TestRegAddrScaledIndex(Inst, Dst, Index, Scale, Disp, OpType, \ |
| 212 ByteCountUntyped, ...) \ |
| 213 do { \ |
| 214 static constexpr char TestString[] = \ |
| 215 "(" #Inst ", " #Dst ", " #Index ", " #Scale ", " #Disp ", " #OpType \ |
| 216 ", " #ByteCountUntyped ", " #__VA_ARGS__ ")"; \ |
| 217 static constexpr uint8_t ByteCount = ByteCountUntyped; \ |
| 218 __ Inst(IceType_##OpType, Encoded_GPR_##Dst(), \ |
| 219 Address(Encoded_GPR_##Index(), Traits::TIMES_##Scale, Disp)); \ |
| 220 ASSERT_EQ(ByteCount, codeBytesSize()) << TestString; \ |
| 221 ASSERT_TRUE(verifyBytes<ByteCount>(codeBytes(), __VA_ARGS__)) \ |
| 222 << TestString; \ |
| 223 reset(); \ |
| 224 } while (0) |
| 225 |
| 226 #define TestRegAddrBaseScaledIndex(Inst, Dst, Base, Index, Scale, Disp, \ |
| 227 OpType, ByteCountUntyped, ...) \ |
| 228 do { \ |
| 229 static constexpr char TestString[] = \ |
| 230 "(" #Inst ", " #Dst ", " #Base ", " #Index ", " #Scale ", " #Disp \ |
| 231 ", " #OpType ", " #ByteCountUntyped ", " #__VA_ARGS__ ")"; \ |
| 232 static constexpr uint8_t ByteCount = ByteCountUntyped; \ |
| 233 __ Inst(IceType_##OpType, Encoded_GPR_##Dst(), \ |
| 234 Address(Encoded_GPR_##Base(), Encoded_GPR_##Index(), \ |
| 235 Traits::TIMES_##Scale, Disp)); \ |
| 236 ASSERT_EQ(ByteCount, codeBytesSize()) << TestString; \ |
| 237 ASSERT_TRUE(verifyBytes<ByteCount>(codeBytes(), __VA_ARGS__)) \ |
| 238 << TestString; \ |
| 239 reset(); \ |
| 240 } while (0) |
| 241 |
| 242 #define TestAddrBaseScaledIndexImm(Inst, Base, Index, Scale, Disp, Imm, \ |
| 243 OpType, ByteCountUntyped, ...) \ |
| 244 do { \ |
| 245 static constexpr char TestString[] = \ |
| 246 "(" #Inst ", " #Base ", " #Index ", " #Scale ", " #Disp ", " #Imm \ |
| 247 ", " #OpType ", " #ByteCountUntyped ", " #__VA_ARGS__ ")"; \ |
| 248 static constexpr uint8_t ByteCount = ByteCountUntyped; \ |
| 249 __ Inst(IceType_##OpType, \ |
| 250 Address(Encoded_GPR_##Base(), Encoded_GPR_##Index(), \ |
| 251 Traits::TIMES_##Scale, Disp), \ |
| 252 Immediate(Imm)); \ |
| 253 ASSERT_EQ(ByteCount, codeBytesSize()) << TestString; \ |
| 254 ASSERT_TRUE(verifyBytes<ByteCount>(codeBytes(), __VA_ARGS__)) \ |
| 255 << TestString; \ |
| 256 reset(); \ |
| 257 } while (0) |
| 258 |
| 259 #define TestAddrBaseScaledIndexReg(Inst, Base, Index, Scale, Disp, Src, \ |
| 260 OpType, ByteCountUntyped, ...) \ |
| 261 do { \ |
| 262 static constexpr char TestString[] = \ |
| 263 "(" #Inst ", " #Base ", " #Index ", " #Scale ", " #Disp ", " #Src \ |
| 264 ", " #OpType ", " #ByteCountUntyped ", " #__VA_ARGS__ ")"; \ |
| 265 static constexpr uint8_t ByteCount = ByteCountUntyped; \ |
| 266 __ Inst(IceType_##OpType, \ |
| 267 Address(Encoded_GPR_##Base(), Encoded_GPR_##Index(), \ |
| 268 Traits::TIMES_##Scale, Disp), \ |
| 269 Encoded_GPR_##Src()); \ |
| 270 ASSERT_EQ(ByteCount, codeBytesSize()) << TestString; \ |
| 271 ASSERT_TRUE(verifyBytes<ByteCount>(codeBytes(), __VA_ARGS__)) \ |
| 272 << TestString; \ |
| 273 reset(); \ |
| 274 } while (0) |
| 275 |
| 276 /* cmp GPR, GPR */ |
| 277 TestRegReg(cmp, eax, ecx, i32, 2, 0x3B, 0xC1); |
| 278 TestRegReg(cmp, ecx, edx, i32, 2, 0x3B, 0xCA); |
| 279 TestRegReg(cmp, edx, ebx, i32, 2, 0x3B, 0xD3); |
| 280 TestRegReg(cmp, ebx, esp, i32, 2, 0x3B, 0xDC); |
| 281 TestRegReg(cmp, esp, ebp, i32, 2, 0x3B, 0xE5); |
| 282 TestRegReg(cmp, ebp, esi, i32, 2, 0x3B, 0xEE); |
| 283 TestRegReg(cmp, esi, edi, i32, 2, 0x3B, 0xF7); |
| 284 TestRegReg(cmp, edi, r8, i32, 3, 0x41, 0x3B, 0xF8); |
| 285 TestRegReg(cmp, r8, r9, i32, 3, 0x45, 0x3B, 0xC1); |
| 286 TestRegReg(cmp, r9, r10, i32, 3, 0x45, 0x3B, 0xCA); |
| 287 TestRegReg(cmp, r10, r11, i32, 3, 0x45, 0x3B, 0xD3); |
| 288 TestRegReg(cmp, r11, r12, i32, 3, 0x45, 0x3B, 0xDC); |
| 289 TestRegReg(cmp, r12, r13, i32, 3, 0x45, 0x3B, 0xE5); |
| 290 TestRegReg(cmp, r13, r14, i32, 3, 0x45, 0x3B, 0xEE); |
| 291 TestRegReg(cmp, r14, r15, i32, 3, 0x45, 0x3B, 0xF7); |
| 292 TestRegReg(cmp, r15, eax, i32, 3, 0x44, 0x3B, 0xF8); |
| 293 |
| 294 TestRegReg(cmp, eax, ecx, i16, 3, 0x66, 0x3B, 0xC1); |
| 295 TestRegReg(cmp, ecx, edx, i16, 3, 0x66, 0x3B, 0xCA); |
| 296 TestRegReg(cmp, edx, ebx, i16, 3, 0x66, 0x3B, 0xD3); |
| 297 TestRegReg(cmp, ebx, esp, i16, 3, 0x66, 0x3B, 0xDC); |
| 298 TestRegReg(cmp, esp, ebp, i16, 3, 0x66, 0x3B, 0xE5); |
| 299 TestRegReg(cmp, ebp, esi, i16, 3, 0x66, 0x3B, 0xEE); |
| 300 TestRegReg(cmp, esi, edi, i16, 3, 0x66, 0x3B, 0xF7); |
| 301 TestRegReg(cmp, edi, r8, i16, 4, 0x66, 0x41, 0x3B, 0xF8); |
| 302 TestRegReg(cmp, r8, r9, i16, 4, 0x66, 0x45, 0x3B, 0xC1); |
| 303 TestRegReg(cmp, r9, r10, i16, 4, 0x66, 0x45, 0x3B, 0xCA); |
| 304 TestRegReg(cmp, r10, r11, i16, 4, 0x66, 0x45, 0x3B, 0xD3); |
| 305 TestRegReg(cmp, r11, r12, i16, 4, 0x66, 0x45, 0x3B, 0xDC); |
| 306 TestRegReg(cmp, r12, r13, i16, 4, 0x66, 0x45, 0x3B, 0xE5); |
| 307 TestRegReg(cmp, r13, r14, i16, 4, 0x66, 0x45, 0x3B, 0xEE); |
| 308 TestRegReg(cmp, r14, r15, i16, 4, 0x66, 0x45, 0x3B, 0xF7); |
| 309 TestRegReg(cmp, r15, eax, i16, 4, 0x66, 0x44, 0x3B, 0xF8); |
| 310 |
| 311 TestRegReg(cmp, eax, ecx, i8, 2, 0x3A, 0xC1); |
| 312 TestRegReg(cmp, ecx, edx, i8, 2, 0x3A, 0xCA); |
| 313 TestRegReg(cmp, edx, ebx, i8, 2, 0x3A, 0xD3); |
| 314 TestRegReg(cmp, ebx, esp, i8, 3, 0x40, 0x3A, 0xDC); |
| 315 TestRegReg(cmp, esp, ebp, i8, 3, 0x40, 0x3A, 0xE5); |
| 316 TestRegReg(cmp, ebp, esi, i8, 3, 0x40, 0x3A, 0xEE); |
| 317 TestRegReg(cmp, esi, edi, i8, 3, 0x40, 0x3A, 0xF7); |
| 318 TestRegReg(cmp, edi, r8, i8, 3, 0x41, 0x3A, 0xF8); |
| 319 TestRegReg(cmp, r8, r9, i8, 3, 0x45, 0x3A, 0xC1); |
| 320 TestRegReg(cmp, r9, r10, i8, 3, 0x45, 0x3A, 0xCA); |
| 321 TestRegReg(cmp, r10, r11, i8, 3, 0x45, 0x3A, 0xD3); |
| 322 TestRegReg(cmp, r11, r12, i8, 3, 0x45, 0x3A, 0xDC); |
| 323 TestRegReg(cmp, r12, r13, i8, 3, 0x45, 0x3A, 0xE5); |
| 324 TestRegReg(cmp, r13, r14, i8, 3, 0x45, 0x3A, 0xEE); |
| 325 TestRegReg(cmp, r14, r15, i8, 3, 0x45, 0x3A, 0xF7); |
| 326 TestRegReg(cmp, r15, eax, i8, 3, 0x44, 0x3A, 0xF8); |
| 327 |
| 328 /* cmp GPR, Imm8 */ |
| 329 TestRegImm(cmp, eax, 5, i32, 3, 0x83, 0xF8, 0x05); |
| 330 TestRegImm(cmp, ecx, 5, i32, 3, 0x83, 0xF9, 0x05); |
| 331 TestRegImm(cmp, edx, 5, i32, 3, 0x83, 0xFA, 0x05); |
| 332 TestRegImm(cmp, ebx, 5, i32, 3, 0x83, 0xFB, 0x05); |
| 333 TestRegImm(cmp, esp, 5, i32, 3, 0x83, 0xFC, 0x05); |
| 334 TestRegImm(cmp, ebp, 5, i32, 3, 0x83, 0xFD, 0x05); |
| 335 TestRegImm(cmp, esi, 5, i32, 3, 0x83, 0xFE, 0x05); |
| 336 TestRegImm(cmp, edi, 5, i32, 3, 0x83, 0xFF, 0x05); |
| 337 TestRegImm(cmp, r8, 5, i32, 4, 0x41, 0x83, 0xF8, 0x05); |
| 338 TestRegImm(cmp, r9, 5, i32, 4, 0x41, 0x83, 0xF9, 0x05); |
| 339 TestRegImm(cmp, r10, 5, i32, 4, 0x41, 0x83, 0xFA, 0x05); |
| 340 TestRegImm(cmp, r11, 5, i32, 4, 0x41, 0x83, 0xFB, 0x05); |
| 341 TestRegImm(cmp, r12, 5, i32, 4, 0x41, 0x83, 0xFC, 0x05); |
| 342 TestRegImm(cmp, r13, 5, i32, 4, 0x41, 0x83, 0xFD, 0x05); |
| 343 TestRegImm(cmp, r14, 5, i32, 4, 0x41, 0x83, 0xFE, 0x05); |
| 344 TestRegImm(cmp, r15, 5, i32, 4, 0x41, 0x83, 0xFF, 0x05); |
| 345 |
| 346 TestRegImm(cmp, eax, 5, i16, 4, 0x66, 0x83, 0xF8, 0x05); |
| 347 TestRegImm(cmp, ecx, 5, i16, 4, 0x66, 0x83, 0xF9, 0x05); |
| 348 TestRegImm(cmp, edx, 5, i16, 4, 0x66, 0x83, 0xFA, 0x05); |
| 349 TestRegImm(cmp, ebx, 5, i16, 4, 0x66, 0x83, 0xFB, 0x05); |
| 350 TestRegImm(cmp, esp, 5, i16, 4, 0x66, 0x83, 0xFC, 0x05); |
| 351 TestRegImm(cmp, ebp, 5, i16, 4, 0x66, 0x83, 0xFD, 0x05); |
| 352 TestRegImm(cmp, esi, 5, i16, 4, 0x66, 0x83, 0xFE, 0x05); |
| 353 TestRegImm(cmp, edi, 5, i16, 4, 0x66, 0x83, 0xFF, 0x05); |
| 354 TestRegImm(cmp, r8, 5, i16, 5, 0x66, 0x41, 0x83, 0xF8, 0x05); |
| 355 TestRegImm(cmp, r9, 5, i16, 5, 0x66, 0x41, 0x83, 0xF9, 0x05); |
| 356 TestRegImm(cmp, r10, 5, i16, 5, 0x66, 0x41, 0x83, 0xFA, 0x05); |
| 357 TestRegImm(cmp, r11, 5, i16, 5, 0x66, 0x41, 0x83, 0xFB, 0x05); |
| 358 TestRegImm(cmp, r12, 5, i16, 5, 0x66, 0x41, 0x83, 0xFC, 0x05); |
| 359 TestRegImm(cmp, r13, 5, i16, 5, 0x66, 0x41, 0x83, 0xFD, 0x05); |
| 360 TestRegImm(cmp, r14, 5, i16, 5, 0x66, 0x41, 0x83, 0xFE, 0x05); |
| 361 TestRegImm(cmp, r15, 5, i16, 5, 0x66, 0x41, 0x83, 0xFF, 0x05); |
| 362 |
| 363 TestRegImm(cmp, eax, 5, i8, 2, 0x3C, 0x05); |
| 364 TestRegImm(cmp, ecx, 5, i8, 3, 0x80, 0xF9, 0x05); |
| 365 TestRegImm(cmp, edx, 5, i8, 3, 0x80, 0xFA, 0x05); |
| 366 TestRegImm(cmp, ebx, 5, i8, 3, 0x80, 0xFB, 0x05); |
| 367 TestRegImm(cmp, esp, 5, i8, 4, 0x40, 0x80, 0xFC, 0x05); |
| 368 TestRegImm(cmp, ebp, 5, i8, 4, 0x40, 0x80, 0xFD, 0x05); |
| 369 TestRegImm(cmp, esi, 5, i8, 4, 0x40, 0x80, 0xFE, 0x05); |
| 370 TestRegImm(cmp, edi, 5, i8, 4, 0x40, 0x80, 0xFF, 0x05); |
| 371 TestRegImm(cmp, r8, 5, i8, 4, 0x41, 0x80, 0xF8, 0x05); |
| 372 TestRegImm(cmp, r9, 5, i8, 4, 0x41, 0x80, 0xF9, 0x05); |
| 373 TestRegImm(cmp, r10, 5, i8, 4, 0x41, 0x80, 0xFA, 0x05); |
| 374 TestRegImm(cmp, r11, 5, i8, 4, 0x41, 0x80, 0xFB, 0x05); |
| 375 TestRegImm(cmp, r12, 5, i8, 4, 0x41, 0x80, 0xFC, 0x05); |
| 376 TestRegImm(cmp, r13, 5, i8, 4, 0x41, 0x80, 0xFD, 0x05); |
| 377 TestRegImm(cmp, r14, 5, i8, 4, 0x41, 0x80, 0xFE, 0x05); |
| 378 TestRegImm(cmp, r15, 5, i8, 4, 0x41, 0x80, 0xFF, 0x05); |
| 379 |
| 380 /* cmp GPR, Imm16 */ |
| 381 TestRegImm(cmp, eax, 0x100, i32, 5, 0x3D, 0x00, 0x01, 0x00, 0x00); |
| 382 TestRegImm(cmp, ecx, 0x100, i32, 6, 0x81, 0xF9, 0x00, 0x01, 0x00, 0x00); |
| 383 TestRegImm(cmp, edx, 0x100, i32, 6, 0x81, 0xFA, 0x00, 0x01, 0x00, 0x00); |
| 384 TestRegImm(cmp, ebx, 0x100, i32, 6, 0x81, 0xFB, 0x00, 0x01, 0x00, 0x00); |
| 385 TestRegImm(cmp, esp, 0x100, i32, 6, 0x81, 0xFC, 0x00, 0x01, 0x00, 0x00); |
| 386 TestRegImm(cmp, ebp, 0x100, i32, 6, 0x81, 0xFD, 0x00, 0x01, 0x00, 0x00); |
| 387 TestRegImm(cmp, esi, 0x100, i32, 6, 0x81, 0xFE, 0x00, 0x01, 0x00, 0x00); |
| 388 TestRegImm(cmp, edi, 0x100, i32, 6, 0x81, 0xFF, 0x00, 0x01, 0x00, 0x00); |
| 389 TestRegImm(cmp, r8, 0x100, i32, 7, 0x41, 0x81, 0xF8, 0x00, 0x01, 0x00, 0x00); |
| 390 TestRegImm(cmp, r9, 0x100, i32, 7, 0x41, 0x81, 0xF9, 0x00, 0x01, 0x00, 0x00); |
| 391 TestRegImm(cmp, r10, 0x100, i32, 7, 0x41, 0x81, 0xFA, 0x00, 0x01, 0x00, 0x00); |
| 392 TestRegImm(cmp, r11, 0x100, i32, 7, 0x41, 0x81, 0xFB, 0x00, 0x01, 0x00, 0x00); |
| 393 TestRegImm(cmp, r12, 0x100, i32, 7, 0x41, 0x81, 0xFC, 0x00, 0x01, 0x00, 0x00); |
| 394 TestRegImm(cmp, r13, 0x100, i32, 7, 0x41, 0x81, 0xFD, 0x00, 0x01, 0x00, 0x00); |
| 395 TestRegImm(cmp, r14, 0x100, i32, 7, 0x41, 0x81, 0xFE, 0x00, 0x01, 0x00, 0x00); |
| 396 TestRegImm(cmp, r15, 0x100, i32, 7, 0x41, 0x81, 0xFF, 0x00, 0x01, 0x00, 0x00); |
| 397 |
| 398 TestRegImm(cmp, eax, 0x100, i16, 4, 0x66, 0x3D, 0x00, 0x01); |
| 399 TestRegImm(cmp, ecx, 0x100, i16, 5, 0x66, 0x81, 0xF9, 0x00, 0x01); |
| 400 TestRegImm(cmp, edx, 0x100, i16, 5, 0x66, 0x81, 0xFA, 0x00, 0x01); |
| 401 TestRegImm(cmp, ebx, 0x100, i16, 5, 0x66, 0x81, 0xFB, 0x00, 0x01); |
| 402 TestRegImm(cmp, esp, 0x100, i16, 5, 0x66, 0x81, 0xFC, 0x00, 0x01); |
| 403 TestRegImm(cmp, ebp, 0x100, i16, 5, 0x66, 0x81, 0xFD, 0x00, 0x01); |
| 404 TestRegImm(cmp, esi, 0x100, i16, 5, 0x66, 0x81, 0xFE, 0x00, 0x01); |
| 405 TestRegImm(cmp, edi, 0x100, i16, 5, 0x66, 0x81, 0xFF, 0x00, 0x01); |
| 406 TestRegImm(cmp, r8, 0x100, i16, 6, 0x66, 0x41, 0x81, 0xF8, 0x00, 0x01); |
| 407 TestRegImm(cmp, r9, 0x100, i16, 6, 0x66, 0x41, 0x81, 0xF9, 0x00, 0x01); |
| 408 TestRegImm(cmp, r10, 0x100, i16, 6, 0x66, 0x41, 0x81, 0xFA, 0x00, 0x01); |
| 409 TestRegImm(cmp, r11, 0x100, i16, 6, 0x66, 0x41, 0x81, 0xFB, 0x00, 0x01); |
| 410 TestRegImm(cmp, r12, 0x100, i16, 6, 0x66, 0x41, 0x81, 0xFC, 0x00, 0x01); |
| 411 TestRegImm(cmp, r13, 0x100, i16, 6, 0x66, 0x41, 0x81, 0xFD, 0x00, 0x01); |
| 412 TestRegImm(cmp, r14, 0x100, i16, 6, 0x66, 0x41, 0x81, 0xFE, 0x00, 0x01); |
| 413 TestRegImm(cmp, r15, 0x100, i16, 6, 0x66, 0x41, 0x81, 0xFF, 0x00, 0x01); |
| 414 |
| 415 /* cmp GPR, Absolute */ |
| 416 TestRegAbsoluteAddr(cmp, eax, 0xF00FBEEF, i32, 6, 0x3B, 0x05, 0xEF, 0xBE, |
| 417 0x0F, 0xF0); |
| 418 TestRegAbsoluteAddr(cmp, eax, 0xF00FBEEF, i16, 7, 0x66, 0x3B, 0x05, 0xEF, |
| 419 0xBE, 0x0F, 0xF0); |
| 420 TestRegAbsoluteAddr(cmp, eax, 0xF00FBEEF, i8, 6, 0x3A, 0x05, 0xEF, 0xBE, 0x0F, |
| 421 0xF0); |
| 422 TestRegAbsoluteAddr(cmp, r8, 0xF00FBEEF, i32, 7, 0x44, 0x3B, 0x05, 0xEF, 0xBE, |
| 423 0x0F, 0xF0); |
| 424 TestRegAbsoluteAddr(cmp, r8, 0xF00FBEEF, i16, 8, 0x66, 0x44, 0x3B, 0x05, 0xEF, |
| 425 0xBE, 0x0F, 0xF0); |
| 426 TestRegAbsoluteAddr(cmp, r8, 0xF00FBEEF, i8, 7, 0x44, 0x3A, 0x05, 0xEF, 0xBE, |
| 427 0x0F, 0xF0); |
| 428 |
| 429 /* cmp GPR, 0(Base) */ |
| 430 TestRegAddrBase(cmp, eax, ecx, 0, i32, 2, 0x3B, 0x01); |
| 431 TestRegAddrBase(cmp, ecx, edx, 0, i32, 2, 0x3B, 0x0A); |
| 432 TestRegAddrBase(cmp, edx, ebx, 0, i32, 2, 0x3B, 0x13); |
| 433 TestRegAddrBase(cmp, ebx, esp, 0, i32, 3, 0x3B, 0x1C, 0x24); |
| 434 TestRegAddrBase(cmp, esp, ebp, 0, i32, 3, 0x3B, 0x65, 0x00); |
| 435 TestRegAddrBase(cmp, ebp, esi, 0, i32, 2, 0x3B, 0x2E); |
| 436 TestRegAddrBase(cmp, esi, edi, 0, i32, 2, 0x3B, 0x37); |
| 437 TestRegAddrBase(cmp, edi, r8, 0, i32, 3, 0x41, 0x3B, 0x38); |
| 438 TestRegAddrBase(cmp, r8, r9, 0, i32, 3, 0x45, 0x3B, 0x01); |
| 439 TestRegAddrBase(cmp, r9, r10, 0, i32, 3, 0x45, 0x3B, 0x0A); |
| 440 TestRegAddrBase(cmp, r10, r11, 0, i32, 3, 0x45, 0x3B, 0x13); |
| 441 TestRegAddrBase(cmp, r11, r12, 0, i32, 4, 0x45, 0x3B, 0x1C, 0x24); |
| 442 TestRegAddrBase(cmp, r12, r13, 0, i32, 4, 0x45, 0x3B, 0x65, 0x00); |
| 443 TestRegAddrBase(cmp, r13, r14, 0, i32, 3, 0x45, 0x3B, 0x2E); |
| 444 TestRegAddrBase(cmp, r14, r15, 0, i32, 3, 0x45, 0x3B, 0x37); |
| 445 TestRegAddrBase(cmp, r15, eax, 0, i32, 3, 0x44, 0x3B, 0x38); |
| 446 |
| 447 TestRegAddrBase(cmp, eax, ecx, 0, i16, 3, 0x66, 0x3B, 0x01); |
| 448 TestRegAddrBase(cmp, ecx, edx, 0, i16, 3, 0x66, 0x3B, 0x0A); |
| 449 TestRegAddrBase(cmp, edx, ebx, 0, i16, 3, 0x66, 0x3B, 0x13); |
| 450 TestRegAddrBase(cmp, ebx, esp, 0, i16, 4, 0x66, 0x3B, 0x1C, 0x24); |
| 451 TestRegAddrBase(cmp, esp, ebp, 0, i16, 4, 0x66, 0x3B, 0x65, 0x00); |
| 452 TestRegAddrBase(cmp, ebp, esi, 0, i16, 3, 0x66, 0x3B, 0x2E); |
| 453 TestRegAddrBase(cmp, esi, edi, 0, i16, 3, 0x66, 0x3B, 0x37); |
| 454 TestRegAddrBase(cmp, edi, r8, 0, i16, 4, 0x66, 0x41, 0x3B, 0x38); |
| 455 TestRegAddrBase(cmp, r8, r9, 0, i16, 4, 0x66, 0x45, 0x3B, 0x01); |
| 456 TestRegAddrBase(cmp, r9, r10, 0, i16, 4, 0x66, 0x45, 0x3B, 0x0A); |
| 457 TestRegAddrBase(cmp, r10, r11, 0, i16, 4, 0x66, 0x45, 0x3B, 0x13); |
| 458 TestRegAddrBase(cmp, r11, r12, 0, i16, 5, 0x66, 0x45, 0x3B, 0x1C, 0x24); |
| 459 TestRegAddrBase(cmp, r12, r13, 0, i16, 5, 0x66, 0x45, 0x3B, 0x65, 0x00); |
| 460 TestRegAddrBase(cmp, r13, r14, 0, i16, 4, 0x66, 0x45, 0x3B, 0x2E); |
| 461 TestRegAddrBase(cmp, r14, r15, 0, i16, 4, 0x66, 0x45, 0x3B, 0x37); |
| 462 TestRegAddrBase(cmp, r15, eax, 0, i16, 4, 0x66, 0x44, 0x3B, 0x38); |
| 463 |
| 464 TestRegAddrBase(cmp, eax, ecx, 0, i8, 2, 0x3A, 0x01); |
| 465 TestRegAddrBase(cmp, ecx, edx, 0, i8, 2, 0x3A, 0x0A); |
| 466 TestRegAddrBase(cmp, edx, ebx, 0, i8, 2, 0x3A, 0x13); |
| 467 TestRegAddrBase(cmp, ebx, esp, 0, i8, 3, 0x3A, 0x1C, 0x24); |
| 468 TestRegAddrBase(cmp, esp, ebp, 0, i8, 4, 0x40, 0x3A, 0x65, 0x00); |
| 469 TestRegAddrBase(cmp, ebp, esi, 0, i8, 3, 0x40, 0x3A, 0x2E); |
| 470 TestRegAddrBase(cmp, esi, edi, 0, i8, 3, 0x40, 0x3A, 0x37); |
| 471 TestRegAddrBase(cmp, edi, r8, 0, i8, 3, 0x41, 0x3A, 0x38); |
| 472 TestRegAddrBase(cmp, r8, r9, 0, i8, 3, 0x45, 0x3A, 0x01); |
| 473 TestRegAddrBase(cmp, r9, r10, 0, i8, 3, 0x45, 0x3A, 0x0A); |
| 474 TestRegAddrBase(cmp, r10, r11, 0, i8, 3, 0x45, 0x3A, 0x13); |
| 475 TestRegAddrBase(cmp, r11, r12, 0, i8, 4, 0x45, 0x3A, 0x1C, 0x24); |
| 476 TestRegAddrBase(cmp, r12, r13, 0, i8, 4, 0x45, 0x3A, 0x65, 0x00); |
| 477 TestRegAddrBase(cmp, r13, r14, 0, i8, 3, 0x45, 0x3A, 0x2E); |
| 478 TestRegAddrBase(cmp, r14, r15, 0, i8, 3, 0x45, 0x3A, 0x37); |
| 479 TestRegAddrBase(cmp, r15, eax, 0, i8, 3, 0x44, 0x3A, 0x38); |
| 480 |
| 481 /* cmp GPR, Imm8(Base) */ |
| 482 TestRegAddrBase(cmp, eax, ecx, 0x40, i32, 3, 0x3B, 0x41, 0x40); |
| 483 TestRegAddrBase(cmp, ecx, edx, 0x40, i32, 3, 0x3B, 0x4A, 0x40); |
| 484 TestRegAddrBase(cmp, edx, ebx, 0x40, i32, 3, 0x3B, 0x53, 0x40); |
| 485 TestRegAddrBase(cmp, ebx, esp, 0x40, i32, 4, 0x3B, 0x5C, 0x24, 0x40); |
| 486 TestRegAddrBase(cmp, esp, ebp, 0x40, i32, 3, 0x3B, 0x65, 0x40); |
| 487 TestRegAddrBase(cmp, ebp, esi, 0x40, i32, 3, 0x3B, 0x6E, 0x40); |
| 488 TestRegAddrBase(cmp, esi, edi, 0x40, i32, 3, 0x3B, 0x77, 0x40); |
| 489 TestRegAddrBase(cmp, edi, r8, 0x40, i32, 4, 0x41, 0x3B, 0x78, 0x40); |
| 490 TestRegAddrBase(cmp, r8, r9, 0x40, i32, 4, 0x45, 0x3B, 0x41, 0x40); |
| 491 TestRegAddrBase(cmp, r9, r10, 0x40, i32, 4, 0x45, 0x3B, 0x4A, 0x40); |
| 492 TestRegAddrBase(cmp, r10, r11, 0x40, i32, 4, 0x45, 0x3B, 0x53, 0x40); |
| 493 TestRegAddrBase(cmp, r11, r12, 0x40, i32, 5, 0x45, 0x3B, 0x5C, 0x24, 0x40); |
| 494 TestRegAddrBase(cmp, r12, r13, 0x40, i32, 4, 0x45, 0x3B, 0x65, 0x40); |
| 495 TestRegAddrBase(cmp, r13, r14, 0x40, i32, 4, 0x45, 0x3B, 0x6E, 0x40); |
| 496 TestRegAddrBase(cmp, r14, r15, 0x40, i32, 4, 0x45, 0x3B, 0x77, 0x40); |
| 497 TestRegAddrBase(cmp, r15, eax, 0x40, i32, 4, 0x44, 0x3B, 0x78, 0x40); |
| 498 |
| 499 TestRegAddrBase(cmp, eax, ecx, 0x40, i16, 4, 0x66, 0x3B, 0x41, 0x40); |
| 500 TestRegAddrBase(cmp, ecx, edx, 0x40, i16, 4, 0x66, 0x3B, 0x4A, 0x40); |
| 501 TestRegAddrBase(cmp, edx, ebx, 0x40, i16, 4, 0x66, 0x3B, 0x53, 0x40); |
| 502 TestRegAddrBase(cmp, ebx, esp, 0x40, i16, 5, 0x66, 0x3B, 0x5C, 0x24, 0x40); |
| 503 TestRegAddrBase(cmp, esp, ebp, 0x40, i16, 4, 0x66, 0x3B, 0x65, 0x40); |
| 504 TestRegAddrBase(cmp, ebp, esi, 0x40, i16, 4, 0x66, 0x3B, 0x6E, 0x40); |
| 505 TestRegAddrBase(cmp, esi, edi, 0x40, i16, 4, 0x66, 0x3B, 0x77, 0x40); |
| 506 TestRegAddrBase(cmp, edi, r8, 0x40, i16, 5, 0x66, 0x41, 0x3B, 0x78, 0x40); |
| 507 TestRegAddrBase(cmp, r8, r9, 0x40, i16, 5, 0x66, 0x45, 0x3B, 0x41, 0x40); |
| 508 TestRegAddrBase(cmp, r9, r10, 0x40, i16, 5, 0x66, 0x45, 0x3B, 0x4A, 0x40); |
| 509 TestRegAddrBase(cmp, r10, r11, 0x40, i16, 5, 0x66, 0x45, 0x3B, 0x53, 0x40); |
| 510 TestRegAddrBase(cmp, r11, r12, 0x40, i16, 6, 0x66, 0x45, 0x3B, 0x5C, 0x24, |
| 511 0x40); |
| 512 TestRegAddrBase(cmp, r12, r13, 0x40, i16, 5, 0x66, 0x45, 0x3B, 0x65, 0x40); |
| 513 TestRegAddrBase(cmp, r13, r14, 0x40, i16, 5, 0x66, 0x45, 0x3B, 0x6E, 0x40); |
| 514 TestRegAddrBase(cmp, r14, r15, 0x40, i16, 5, 0x66, 0x45, 0x3B, 0x77, 0x40); |
| 515 TestRegAddrBase(cmp, r15, eax, 0x40, i16, 5, 0x66, 0x44, 0x3B, 0x78, 0x40); |
| 516 |
| 517 TestRegAddrBase(cmp, eax, ecx, 0x40, i8, 3, 0x3A, 0x41, 0x40); |
| 518 TestRegAddrBase(cmp, ecx, edx, 0x40, i8, 3, 0x3A, 0x4A, 0x40); |
| 519 TestRegAddrBase(cmp, edx, ebx, 0x40, i8, 3, 0x3A, 0x53, 0x40); |
| 520 TestRegAddrBase(cmp, ebx, esp, 0x40, i8, 4, 0x3A, 0x5C, 0x24, 0x40); |
| 521 TestRegAddrBase(cmp, esp, ebp, 0x40, i8, 4, 0x40, 0x3A, 0x65, 0x40); |
| 522 TestRegAddrBase(cmp, ebp, esi, 0x40, i8, 4, 0x40, 0x3A, 0x6E, 0x40); |
| 523 TestRegAddrBase(cmp, esi, edi, 0x40, i8, 4, 0x40, 0x3A, 0x77, 0x40); |
| 524 TestRegAddrBase(cmp, edi, r8, 0x40, i8, 4, 0x41, 0x3A, 0x78, 0x40); |
| 525 TestRegAddrBase(cmp, r8, r9, 0x40, i8, 4, 0x45, 0x3A, 0x41, 0x40); |
| 526 TestRegAddrBase(cmp, r9, r10, 0x40, i8, 4, 0x45, 0x3A, 0x4A, 0x40); |
| 527 TestRegAddrBase(cmp, r10, r11, 0x40, i8, 4, 0x45, 0x3A, 0x53, 0x40); |
| 528 TestRegAddrBase(cmp, r11, r12, 0x40, i8, 5, 0x45, 0x3A, 0x5C, 0x24, 0x40); |
| 529 TestRegAddrBase(cmp, r12, r13, 0x40, i8, 4, 0x45, 0x3A, 0x65, 0x40); |
| 530 TestRegAddrBase(cmp, r13, r14, 0x40, i8, 4, 0x45, 0x3A, 0x6E, 0x40); |
| 531 TestRegAddrBase(cmp, r14, r15, 0x40, i8, 4, 0x45, 0x3A, 0x77, 0x40); |
| 532 TestRegAddrBase(cmp, r15, eax, 0x40, i8, 4, 0x44, 0x3A, 0x78, 0x40); |
| 533 |
| 534 /* cmp GPR, Imm32(Base) */ |
| 535 TestRegAddrBase(cmp, eax, ecx, 0xF0, i32, 6, 0x3B, 0x81, 0xF0, 0x00, 0x00, |
| 536 0x00); |
| 537 TestRegAddrBase(cmp, ecx, edx, 0xF0, i32, 6, 0x3B, 0x8A, 0xF0, 0x00, 0x00, |
| 538 0x00); |
| 539 TestRegAddrBase(cmp, edx, ebx, 0xF0, i32, 6, 0x3B, 0x93, 0xF0, 0x00, 0x00, |
| 540 0x00); |
| 541 TestRegAddrBase(cmp, ebx, esp, 0xF0, i32, 7, 0x3B, 0x9C, 0x24, 0xF0, 0x00, |
| 542 0x00, 0x00); |
| 543 TestRegAddrBase(cmp, esp, ebp, 0xF0, i32, 6, 0x3B, 0xA5, 0xF0, 0x00, 0x00, |
| 544 0x00); |
| 545 TestRegAddrBase(cmp, ebp, esi, 0xF0, i32, 6, 0x3B, 0xAE, 0xF0, 0x00, 0x00, |
| 546 0x00); |
| 547 TestRegAddrBase(cmp, esi, edi, 0xF0, i32, 6, 0x3B, 0xB7, 0xF0, 0x00, 0x00, |
| 548 0x00); |
| 549 TestRegAddrBase(cmp, edi, r8, 0xF0, i32, 7, 0x41, 0x3B, 0xB8, 0xF0, 0x00, |
| 550 0x00, 0x00); |
| 551 TestRegAddrBase(cmp, r8, r9, 0xF0, i32, 7, 0x45, 0x3B, 0x81, 0xF0, 0x00, 0x00, |
| 552 0x00); |
| 553 TestRegAddrBase(cmp, r9, r10, 0xF0, i32, 7, 0x45, 0x3B, 0x8A, 0xF0, 0x00, |
| 554 0x00, 0x00); |
| 555 TestRegAddrBase(cmp, r10, r11, 0xF0, i32, 7, 0x45, 0x3B, 0x93, 0xF0, 0x00, |
| 556 0x00, 0x00); |
| 557 TestRegAddrBase(cmp, r11, r12, 0xF0, i32, 8, 0x45, 0x3B, 0x9C, 0x24, 0xF0, |
| 558 0x00, 0x00, 0x00); |
| 559 TestRegAddrBase(cmp, r12, r13, 0xF0, i32, 7, 0x45, 0x3B, 0xA5, 0xF0, 0x00, |
| 560 0x00, 0x00); |
| 561 TestRegAddrBase(cmp, r13, r14, 0xF0, i32, 7, 0x45, 0x3B, 0xAE, 0xF0, 0x00, |
| 562 0x00, 0x00); |
| 563 TestRegAddrBase(cmp, r14, r15, 0xF0, i32, 7, 0x45, 0x3B, 0xB7, 0xF0, 0x00, |
| 564 0x00, 0x00); |
| 565 TestRegAddrBase(cmp, r15, eax, 0xF0, i32, 7, 0x44, 0x3B, 0xB8, 0xF0, 0x00, |
| 566 0x00, 0x00); |
| 567 |
| 568 TestRegAddrBase(cmp, eax, ecx, 0xF0, i16, 7, 0x66, 0x3B, 0x81, 0xF0, 0x00, |
| 569 0x00, 0x00); |
| 570 TestRegAddrBase(cmp, ecx, edx, 0xF0, i16, 7, 0x66, 0x3B, 0x8A, 0xF0, 0x00, |
| 571 0x00, 0x00); |
| 572 TestRegAddrBase(cmp, edx, ebx, 0xF0, i16, 7, 0x66, 0x3B, 0x93, 0xF0, 0x00, |
| 573 0x00, 0x00); |
| 574 TestRegAddrBase(cmp, ebx, esp, 0xF0, i16, 8, 0x66, 0x3B, 0x9C, 0x24, 0xF0, |
| 575 0x00, 0x00, 0x00); |
| 576 TestRegAddrBase(cmp, esp, ebp, 0xF0, i16, 7, 0x66, 0x3B, 0xa5, 0xF0, 0x00, |
| 577 0x00, 0x00); |
| 578 TestRegAddrBase(cmp, ebp, esi, 0xF0, i16, 7, 0x66, 0x3B, 0xaE, 0xF0, 0x00, |
| 579 0x00, 0x00); |
| 580 TestRegAddrBase(cmp, esi, edi, 0xF0, i16, 7, 0x66, 0x3B, 0xb7, 0xF0, 0x00, |
| 581 0x00, 0x00); |
| 582 TestRegAddrBase(cmp, edi, r8, 0xF0, i16, 8, 0x66, 0x41, 0x3B, 0xb8, 0xF0, |
| 583 0x00, 0x00, 0x00); |
| 584 TestRegAddrBase(cmp, r8, r9, 0xF0, i16, 8, 0x66, 0x45, 0x3B, 0x81, 0xF0, 0x00, |
| 585 0x00, 0x00); |
| 586 TestRegAddrBase(cmp, r9, r10, 0xF0, i16, 8, 0x66, 0x45, 0x3B, 0x8A, 0xF0, |
| 587 0x00, 0x00, 0x00); |
| 588 TestRegAddrBase(cmp, r10, r11, 0xF0, i16, 8, 0x66, 0x45, 0x3B, 0x93, 0xF0, |
| 589 0x00, 0x00, 0x00); |
| 590 TestRegAddrBase(cmp, r11, r12, 0xF0, i16, 9, 0x66, 0x45, 0x3B, 0x9C, 0x24, |
| 591 0xF0, 0x00, 0x00, 0x00); |
| 592 TestRegAddrBase(cmp, r12, r13, 0xF0, i16, 8, 0x66, 0x45, 0x3B, 0xa5, 0xF0, |
| 593 0x00, 0x00, 0x00); |
| 594 TestRegAddrBase(cmp, r13, r14, 0xF0, i16, 8, 0x66, 0x45, 0x3B, 0xaE, 0xF0, |
| 595 0x00, 0x00, 0x00); |
| 596 TestRegAddrBase(cmp, r14, r15, 0xF0, i16, 8, 0x66, 0x45, 0x3B, 0xb7, 0xF0, |
| 597 0x00, 0x00, 0x00); |
| 598 TestRegAddrBase(cmp, r15, eax, 0xF0, i16, 8, 0x66, 0x44, 0x3B, 0xb8, 0xF0, |
| 599 0x00, 0x00, 0x00); |
| 600 |
| 601 TestRegAddrBase(cmp, eax, ecx, 0xF0, i8, 6, 0x3A, 0x81, 0xF0, 0x00, 0x00, |
| 602 0x00); |
| 603 TestRegAddrBase(cmp, ecx, edx, 0xF0, i8, 6, 0x3A, 0x8A, 0xF0, 0x00, 0x00, |
| 604 0x00); |
| 605 TestRegAddrBase(cmp, edx, ebx, 0xF0, i8, 6, 0x3A, 0x93, 0xF0, 0x00, 0x00, |
| 606 0x00); |
| 607 TestRegAddrBase(cmp, ebx, esp, 0xF0, i8, 7, 0x3A, 0x9C, 0x24, 0xF0, 0x00, |
| 608 0x00, 0x00); |
| 609 TestRegAddrBase(cmp, esp, ebp, 0xF0, i8, 7, 0x40, 0x3A, 0xA5, 0xF0, 0x00, |
| 610 0x00, 0x00); |
| 611 TestRegAddrBase(cmp, ebp, esi, 0xF0, i8, 7, 0x40, 0x3A, 0xAE, 0xF0, 0x00, |
| 612 0x00, 0x00); |
| 613 TestRegAddrBase(cmp, esi, edi, 0xF0, i8, 7, 0x40, 0x3A, 0xB7, 0xF0, 0x00, |
| 614 0x00, 0x00); |
| 615 TestRegAddrBase(cmp, edi, r8, 0xF0, i8, 7, 0x41, 0x3A, 0xB8, 0xF0, 0x00, 0x00, |
| 616 0x00); |
| 617 TestRegAddrBase(cmp, r8, r9, 0xF0, i8, 7, 0x45, 0x3A, 0x81, 0xF0, 0x00, 0x00, |
| 618 0x00); |
| 619 TestRegAddrBase(cmp, r9, r10, 0xF0, i8, 7, 0x45, 0x3A, 0x8A, 0xF0, 0x00, 0x00, |
| 620 0x00); |
| 621 TestRegAddrBase(cmp, r10, r11, 0xF0, i8, 7, 0x45, 0x3A, 0x93, 0xF0, 0x00, |
| 622 0x00, 0x00); |
| 623 TestRegAddrBase(cmp, r11, r12, 0xF0, i8, 8, 0x45, 0x3A, 0x9C, 0x24, 0xF0, |
| 624 0x00, 0x00, 0x00); |
| 625 TestRegAddrBase(cmp, r12, r13, 0xF0, i8, 7, 0x45, 0x3A, 0xA5, 0xF0, 0x00, |
| 626 0x00, 0x00); |
| 627 TestRegAddrBase(cmp, r13, r14, 0xF0, i8, 7, 0x45, 0x3A, 0xAE, 0xF0, 0x00, |
| 628 0x00, 0x00); |
| 629 TestRegAddrBase(cmp, r14, r15, 0xF0, i8, 7, 0x45, 0x3A, 0xB7, 0xF0, 0x00, |
| 630 0x00, 0x00); |
| 631 TestRegAddrBase(cmp, r15, eax, 0xF0, i8, 7, 0x44, 0x3A, 0xB8, 0xF0, 0x00, |
| 632 0x00, 0x00); |
| 633 |
| 634 /* cmp GPR, Imm(,Index,Scale) */ |
| 635 TestRegAddrScaledIndex(cmp, eax, ecx, 1, 0, i32, 7, 0x3B, 0x04, 0x0D, 0x00, |
| 636 0x00, 0x00, 0x00); |
| 637 TestRegAddrScaledIndex(cmp, ecx, edx, 2, 0, i32, 7, 0x3B, 0x0C, 0x55, 0x00, |
| 638 0x00, 0x00, 0x00); |
| 639 TestRegAddrScaledIndex(cmp, edx, ebx, 4, 0, i32, 7, 0x3B, 0x14, 0x9D, 0x00, |
| 640 0x00, 0x00, 0x00); |
| 641 TestRegAddrScaledIndex(cmp, r8, r9, 1, 0, i32, 8, 0x46, 0x3B, 0x04, 0x0D, |
| 642 0x00, 0x00, 0x00, 0x00); |
| 643 TestRegAddrScaledIndex(cmp, r9, r10, 2, 0, i32, 8, 0x46, 0x3B, 0x0C, 0x55, |
| 644 0x00, 0x00, 0x00, 0x00); |
| 645 TestRegAddrScaledIndex(cmp, r10, r11, 4, 0, i32, 8, 0x46, 0x3B, 0x14, 0x9D, |
| 646 0x00, 0x00, 0x00, 0x00); |
| 647 // esp cannot be an scaled index. |
| 648 TestRegAddrScaledIndex(cmp, esp, ebp, 8, 0, i32, 7, 0x3B, 0x24, 0xED, 0x00, |
| 649 0x00, 0x00, 0x00); |
| 650 TestRegAddrScaledIndex(cmp, ebp, esi, 1, 0, i32, 7, 0x3B, 0x2C, 0x35, 0x00, |
| 651 0x00, 0x00, 0x00); |
| 652 TestRegAddrScaledIndex(cmp, esi, edi, 2, 0, i32, 7, 0x3B, 0x34, 0x7D, 0x00, |
| 653 0x00, 0x00, 0x00); |
| 654 TestRegAddrScaledIndex(cmp, edi, eax, 4, 0, i32, 7, 0x3B, 0x3C, 0x85, 0x00, |
| 655 0x00, 0x00, 0x00); |
| 656 TestRegAddrScaledIndex(cmp, ebx, ecx, 8, 0, i32, 7, 0x3B, 0x1C, 0xCD, 0x00, |
| 657 0x00, 0x00, 0x00); |
| 658 TestRegAddrScaledIndex(cmp, r12, r13, 8, 0, i32, 8, 0x46, 0x3B, 0x24, 0xED, |
| 659 0x00, 0x00, 0x00, 0x00); |
| 660 TestRegAddrScaledIndex(cmp, r13, r14, 1, 0, i32, 8, 0x46, 0x3B, 0x2C, 0x35, |
| 661 0x00, 0x00, 0x00, 0x00); |
| 662 TestRegAddrScaledIndex(cmp, r14, r15, 2, 0, i32, 8, 0x46, 0x3B, 0x34, 0x7D, |
| 663 0x00, 0x00, 0x00, 0x00); |
| 664 TestRegAddrScaledIndex(cmp, r15, r8, 4, 0, i32, 8, 0x46, 0x3B, 0x3C, 0x85, |
| 665 0x00, 0x00, 0x00, 0x00); |
| 666 TestRegAddrScaledIndex(cmp, r11, r9, 8, 0, i32, 8, 0x46, 0x3B, 0x1C, 0xCD, |
| 667 0x00, 0x00, 0x00, 0x00); |
| 668 |
| 669 TestRegAddrScaledIndex(cmp, eax, ecx, 8, 0, i16, 8, 0x66, 0x3B, 0x04, 0xCD, |
| 670 0x00, 0x00, 0x00, 0x00); |
| 671 TestRegAddrScaledIndex(cmp, ecx, edx, 1, 0, i16, 8, 0x66, 0x3B, 0x0C, 0x15, |
| 672 0x00, 0x00, 0x00, 0x00); |
| 673 TestRegAddrScaledIndex(cmp, edx, ebx, 2, 0, i16, 8, 0x66, 0x3B, 0x14, 0x5D, |
| 674 0x00, 0x00, 0x00, 0x00); |
| 675 TestRegAddrScaledIndex(cmp, r8, r9, 8, 0, i16, 9, 0x66, 0x46, 0x3B, 0x04, |
| 676 0xCD, 0x00, 0x00, 0x00, 0x00); |
| 677 TestRegAddrScaledIndex(cmp, r9, r10, 1, 0, i16, 9, 0x66, 0x46, 0x3B, 0x0C, |
| 678 0x15, 0x00, 0x00, 0x00, 0x00); |
| 679 TestRegAddrScaledIndex(cmp, r10, r11, 2, 0, i16, 9, 0x66, 0x46, 0x3B, 0x14, |
| 680 0x5D, 0x00, 0x00, 0x00, 0x00); |
| 681 // esp cannot be an scaled index. |
| 682 TestRegAddrScaledIndex(cmp, esp, ebp, 4, 0, i16, 8, 0x66, 0x3B, 0x24, 0xAD, |
| 683 0x00, 0x00, 0x00, 0x00); |
| 684 TestRegAddrScaledIndex(cmp, ebp, esi, 8, 0, i16, 8, 0x66, 0x3B, 0x2C, 0xF5, |
| 685 0x00, 0x00, 0x00, 0x00); |
| 686 TestRegAddrScaledIndex(cmp, esi, edi, 1, 0, i16, 8, 0x66, 0x3B, 0x34, 0x3D, |
| 687 0x00, 0x00, 0x00, 0x00); |
| 688 TestRegAddrScaledIndex(cmp, edi, eax, 2, 0, i16, 8, 0x66, 0x3B, 0x3C, 0x45, |
| 689 0x00, 0x00, 0x00, 0x00); |
| 690 TestRegAddrScaledIndex(cmp, ebx, ecx, 8, 0, i16, 8, 0x66, 0x3B, 0x1C, 0xCD, |
| 691 0x00, 0x00, 0x00, 0x00); |
| 692 |
| 693 TestRegAddrScaledIndex(cmp, eax, ecx, 4, 0, i8, 7, 0x3A, 0x04, 0x8D, 0x00, |
| 694 0x00, 0x00, 0x00); |
| 695 TestRegAddrScaledIndex(cmp, ecx, edx, 8, 0, i8, 7, 0x3A, 0x0C, 0xD5, 0x00, |
| 696 0x00, 0x00, 0x00); |
| 697 TestRegAddrScaledIndex(cmp, edx, ebx, 1, 0, i8, 7, 0x3A, 0x14, 0x1D, 0x00, |
| 698 0x00, 0x00, 0x00); |
| 699 TestRegAddrScaledIndex(cmp, r8, r9, 4, 0, i8, 8, 0x46, 0x3A, 0x04, 0x8D, 0x00, |
| 700 0x00, 0x00, 0x00); |
| 701 TestRegAddrScaledIndex(cmp, r9, r10, 8, 0, i8, 8, 0x46, 0x3A, 0x0C, 0xD5, |
| 702 0x00, 0x00, 0x00, 0x00); |
| 703 TestRegAddrScaledIndex(cmp, r10, r11, 1, 0, i8, 8, 0x46, 0x3A, 0x14, 0x1D, |
| 704 0x00, 0x00, 0x00, 0x00); |
| 705 // esp cannot be an scaled index. |
| 706 TestRegAddrScaledIndex(cmp, esp, ebp, 2, 0, i8, 8, 0x40, 0x3A, 0x24, 0x6D, |
| 707 0x00, 0x00, 0x00, 0x00); |
| 708 TestRegAddrScaledIndex(cmp, ebp, esi, 4, 0, i8, 8, 0x40, 0x3A, 0x2C, 0xB5, |
| 709 0x00, 0x00, 0x00, 0x00); |
| 710 TestRegAddrScaledIndex(cmp, esi, edi, 8, 0, i8, 8, 0x40, 0x3A, 0x34, 0xFD, |
| 711 0x00, 0x00, 0x00, 0x00); |
| 712 TestRegAddrScaledIndex(cmp, edi, eax, 1, 0, i8, 8, 0x40, 0x3A, 0x3C, 0x05, |
| 713 0x00, 0x00, 0x00, 0x00); |
| 714 TestRegAddrScaledIndex(cmp, ebx, ecx, 8, 0, i8, 7, 0x3a, 0x1C, 0xCD, 0x00, |
| 715 0x00, 0x00, 0x00); |
| 716 TestRegAddrScaledIndex(cmp, r12, r13, 2, 0, i8, 8, 0x46, 0x3A, 0x24, 0x6D, |
| 717 0x00, 0x00, 0x00, 0x00); |
| 718 TestRegAddrScaledIndex(cmp, r13, r14, 4, 0, i8, 8, 0x46, 0x3A, 0x2C, 0xB5, |
| 719 0x00, 0x00, 0x00, 0x00); |
| 720 TestRegAddrScaledIndex(cmp, r14, r15, 8, 0, i8, 8, 0x46, 0x3A, 0x34, 0xFD, |
| 721 0x00, 0x00, 0x00, 0x00); |
| 722 TestRegAddrScaledIndex(cmp, r15, r8, 1, 0, i8, 8, 0x46, 0x3A, 0x3C, 0x05, |
| 723 0x00, 0x00, 0x00, 0x00); |
| 724 TestRegAddrScaledIndex(cmp, r11, r9, 8, 0, i8, 8, 0x46, 0x3a, 0x1C, 0xCD, |
| 725 0x00, 0x00, 0x00, 0x00); |
| 726 |
| 727 /* cmp GPR, 0(Base,Index,Scale) */ |
| 728 TestRegAddrBaseScaledIndex(cmp, eax, ecx, edx, 1, 0, i32, 3, 0x3B, 0x04, |
| 729 0x11); |
| 730 TestRegAddrBaseScaledIndex(cmp, ecx, edx, ebx, 2, 0, i32, 3, 0x3B, 0x0C, |
| 731 0x5A); |
| 732 TestRegAddrBaseScaledIndex(cmp, r8, r9, r10, 1, 0, i32, 4, 0x47, 0x3B, 0x04, |
| 733 0x11); |
| 734 TestRegAddrBaseScaledIndex(cmp, r9, r10, r11, 2, 0, i32, 4, 0x47, 0x3B, 0x0C, |
| 735 0x5A); |
| 736 // esp cannot be an scaled index. |
| 737 TestRegAddrBaseScaledIndex(cmp, ebx, esp, ebp, 4, 0, i32, 3, 0x3B, 0x1C, |
| 738 0xAC); |
| 739 TestRegAddrBaseScaledIndex(cmp, esp, ebp, esi, 8, 0, i32, 4, 0x3B, 0x64, 0xF5, |
| 740 0x00); |
| 741 TestRegAddrBaseScaledIndex(cmp, ebp, esi, edi, 1, 0, i32, 3, 0x3B, 0x2C, |
| 742 0x3E); |
| 743 TestRegAddrBaseScaledIndex(cmp, esi, edi, eax, 2, 0, i32, 3, 0x3B, 0x34, |
| 744 0x47); |
| 745 TestRegAddrBaseScaledIndex(cmp, edi, eax, ebx, 4, 0, i32, 3, 0x3B, 0x3C, |
| 746 0x98); |
| 747 TestRegAddrBaseScaledIndex(cmp, ebx, ecx, edx, 8, 0, i32, 3, 0x3B, 0x1C, |
| 748 0xD1); |
| 749 TestRegAddrBaseScaledIndex(cmp, r11, r12, r13, 4, 0, i32, 4, 0x47, 0x3B, 0x1C, |
| 750 0xAC); |
| 751 TestRegAddrBaseScaledIndex(cmp, r12, r13, r14, 8, 0, i32, 5, 0x47, 0x3B, 0x64, |
| 752 0xF5, 0x00); |
| 753 TestRegAddrBaseScaledIndex(cmp, r13, r14, r15, 1, 0, i32, 4, 0x47, 0x3B, 0x2C, |
| 754 0x3E); |
| 755 TestRegAddrBaseScaledIndex(cmp, r14, r15, r8, 2, 0, i32, 4, 0x47, 0x3B, 0x34, |
| 756 0x47); |
| 757 TestRegAddrBaseScaledIndex(cmp, r15, r8, r11, 4, 0, i32, 4, 0x47, 0x3B, 0x3C, |
| 758 0x98); |
| 759 TestRegAddrBaseScaledIndex(cmp, r11, r9, r10, 8, 0, i32, 4, 0x47, 0x3B, 0x1C, |
| 760 0xD1); |
| 761 |
| 762 TestRegAddrBaseScaledIndex(cmp, eax, ecx, edx, 1, 0, i16, 4, 0x66, 0x3B, 0x04, |
| 763 0x11); |
| 764 TestRegAddrBaseScaledIndex(cmp, ecx, edx, ebx, 2, 0, i16, 4, 0x66, 0x3B, 0x0C, |
| 765 0x5A); |
| 766 TestRegAddrBaseScaledIndex(cmp, r8, r9, r10, 1, 0, i16, 5, 0x66, 0x47, 0x3B, |
| 767 0x04, 0x11); |
| 768 TestRegAddrBaseScaledIndex(cmp, r9, r10, r11, 2, 0, i16, 5, 0x66, 0x47, 0x3B, |
| 769 0x0C, 0x5A); |
| 770 // esp cannot be an scaled index. |
| 771 TestRegAddrBaseScaledIndex(cmp, ebx, esp, ebp, 4, 0, i16, 4, 0x66, 0x3B, 0x1C, |
| 772 0xAC); |
| 773 TestRegAddrBaseScaledIndex(cmp, esp, ebp, esi, 8, 0, i16, 5, 0x66, 0x3B, 0x64, |
| 774 0xF5, 0x00); |
| 775 TestRegAddrBaseScaledIndex(cmp, ebp, esi, edi, 1, 0, i16, 4, 0x66, 0x3B, 0x2C, |
| 776 0x3E); |
| 777 TestRegAddrBaseScaledIndex(cmp, esi, edi, eax, 2, 0, i16, 4, 0x66, 0x3B, 0x34, |
| 778 0x47); |
| 779 TestRegAddrBaseScaledIndex(cmp, edi, eax, ebx, 4, 0, i16, 4, 0x66, 0x3B, 0x3C, |
| 780 0x98); |
| 781 TestRegAddrBaseScaledIndex(cmp, ebx, ecx, edx, 8, 0, i16, 4, 0x66, 0x3B, 0x1C, |
| 782 0xD1); |
| 783 TestRegAddrBaseScaledIndex(cmp, r11, r12, r13, 4, 0, i16, 5, 0x66, 0x47, 0x3B, |
| 784 0x1C, 0xAC); |
| 785 TestRegAddrBaseScaledIndex(cmp, r12, r13, r14, 8, 0, i16, 6, 0x66, 0x47, 0x3B, |
| 786 0x64, 0xF5, 0x00); |
| 787 TestRegAddrBaseScaledIndex(cmp, r13, r14, r15, 1, 0, i16, 5, 0x66, 0x47, 0x3B, |
| 788 0x2C, 0x3E); |
| 789 TestRegAddrBaseScaledIndex(cmp, r14, r15, r8, 2, 0, i16, 5, 0x66, 0x47, 0x3B, |
| 790 0x34, 0x47); |
| 791 TestRegAddrBaseScaledIndex(cmp, r15, r8, r11, 4, 0, i16, 5, 0x66, 0x47, 0x3B, |
| 792 0x3C, 0x98); |
| 793 TestRegAddrBaseScaledIndex(cmp, r11, r9, r10, 8, 0, i16, 5, 0x66, 0x47, 0x3B, |
| 794 0x1C, 0xD1); |
| 795 |
| 796 TestRegAddrBaseScaledIndex(cmp, eax, ecx, edx, 1, 0, i8, 3, 0x3A, 0x04, 0x11); |
| 797 TestRegAddrBaseScaledIndex(cmp, ecx, edx, ebx, 2, 0, i8, 3, 0x3A, 0x0C, 0x5A); |
| 798 TestRegAddrBaseScaledIndex(cmp, r8, r9, r10, 1, 0, i8, 4, 0x47, 0x3A, 0x04, |
| 799 0x11); |
| 800 TestRegAddrBaseScaledIndex(cmp, r9, r10, r11, 2, 0, i8, 4, 0x47, 0x3A, 0x0C, |
| 801 0x5A); |
| 802 // esp cannot be an scaled index. |
| 803 TestRegAddrBaseScaledIndex(cmp, ebx, esp, ebp, 4, 0, i8, 3, 0x3A, 0x1C, 0xAC); |
| 804 TestRegAddrBaseScaledIndex(cmp, esp, ebp, esi, 8, 0, i8, 5, 0x40, 0x3A, 0x64, |
| 805 0xF5, 0x00); |
| 806 TestRegAddrBaseScaledIndex(cmp, ebp, esi, edi, 1, 0, i8, 4, 0x40, 0x3A, 0x2C, |
| 807 0x3E); |
| 808 TestRegAddrBaseScaledIndex(cmp, esi, edi, eax, 2, 0, i8, 4, 0x40, 0x3A, 0x34, |
| 809 0x47); |
| 810 TestRegAddrBaseScaledIndex(cmp, edi, eax, ebx, 4, 0, i8, 4, 0x40, 0x3A, 0x3C, |
| 811 0x98); |
| 812 TestRegAddrBaseScaledIndex(cmp, ebx, ecx, edx, 8, 0, i8, 3, 0x3A, 0x1C, 0xD1); |
| 813 TestRegAddrBaseScaledIndex(cmp, r11, r12, r13, 4, 0, i8, 4, 0x47, 0x3A, 0x1C, |
| 814 0xAC); |
| 815 TestRegAddrBaseScaledIndex(cmp, r12, r13, r14, 8, 0, i8, 5, 0x47, 0x3A, 0x64, |
| 816 0xF5, 0x00); |
| 817 TestRegAddrBaseScaledIndex(cmp, r13, r14, r15, 1, 0, i8, 4, 0x47, 0x3A, 0x2C, |
| 818 0x3E); |
| 819 TestRegAddrBaseScaledIndex(cmp, r14, r15, r8, 2, 0, i8, 4, 0x47, 0x3A, 0x34, |
| 820 0x47); |
| 821 TestRegAddrBaseScaledIndex(cmp, r15, r8, r11, 4, 0, i8, 4, 0x47, 0x3A, 0x3C, |
| 822 0x98); |
| 823 TestRegAddrBaseScaledIndex(cmp, r11, r9, r10, 8, 0, i8, 4, 0x47, 0x3A, 0x1C, |
| 824 0xD1); |
| 825 |
| 826 /* cmp GPR, Imm8(Base,Index,Scale) */ |
| 827 TestRegAddrBaseScaledIndex(cmp, eax, ecx, edx, 1, 0x40, i32, 4, 0x3B, 0x44, |
| 828 0x11, 0x40); |
| 829 TestRegAddrBaseScaledIndex(cmp, ecx, edx, ebx, 2, 0x40, i32, 4, 0x3B, 0x4C, |
| 830 0x5A, 0x40); |
| 831 TestRegAddrBaseScaledIndex(cmp, r8, r9, r10, 1, 0x40, i32, 5, 0x47, 0x3B, |
| 832 0x44, 0x11, 0x40); |
| 833 TestRegAddrBaseScaledIndex(cmp, r9, r10, r11, 2, 0x40, i32, 5, 0x47, 0x3B, |
| 834 0x4C, 0x5A, 0x40); |
| 835 // esp cannot be an scaled index. |
| 836 TestRegAddrBaseScaledIndex(cmp, ebx, esp, ebp, 4, 0x40, i32, 4, 0x3B, 0x5C, |
| 837 0xAC, 0x40); |
| 838 TestRegAddrBaseScaledIndex(cmp, esp, ebp, esi, 8, 0x40, i32, 4, 0x3B, 0x64, |
| 839 0xF5, 0x40); |
| 840 TestRegAddrBaseScaledIndex(cmp, ebp, esi, edi, 1, 0x40, i32, 4, 0x3B, 0x6C, |
| 841 0x3E, 0x40); |
| 842 TestRegAddrBaseScaledIndex(cmp, esi, edi, eax, 2, 0x40, i32, 4, 0x3B, 0x74, |
| 843 0x47, 0x40); |
| 844 TestRegAddrBaseScaledIndex(cmp, edi, eax, ebx, 4, 0x40, i32, 4, 0x3B, 0x7C, |
| 845 0x98, 0x40); |
| 846 TestRegAddrBaseScaledIndex(cmp, ebx, ecx, edx, 8, 0x40, i32, 4, 0x3B, 0x5C, |
| 847 0xD1, 0x40); |
| 848 TestRegAddrBaseScaledIndex(cmp, r11, r12, r13, 4, 0x40, i32, 5, 0x47, 0x3B, |
| 849 0x5C, 0xAC, 0x40); |
| 850 TestRegAddrBaseScaledIndex(cmp, r12, r13, r14, 8, 0x40, i32, 5, 0x47, 0x3B, |
| 851 0x64, 0xF5, 0x40); |
| 852 TestRegAddrBaseScaledIndex(cmp, r13, r14, r15, 1, 0x40, i32, 5, 0x47, 0x3B, |
| 853 0x6C, 0x3E, 0x40); |
| 854 TestRegAddrBaseScaledIndex(cmp, r14, r15, r8, 2, 0x40, i32, 5, 0x47, 0x3B, |
| 855 0x74, 0x47, 0x40); |
| 856 TestRegAddrBaseScaledIndex(cmp, r15, r8, r11, 4, 0x40, i32, 5, 0x47, 0x3B, |
| 857 0x7C, 0x98, 0x40); |
| 858 TestRegAddrBaseScaledIndex(cmp, r11, r9, r10, 8, 0x40, i32, 5, 0x47, 0x3B, |
| 859 0x5C, 0xD1, 0x40); |
| 860 |
| 861 TestRegAddrBaseScaledIndex(cmp, eax, ecx, edx, 1, 0x40, i16, 5, 0x66, 0x3B, |
| 862 0x44, 0x11, 0x40); |
| 863 TestRegAddrBaseScaledIndex(cmp, ecx, edx, ebx, 2, 0x40, i16, 5, 0x66, 0x3B, |
| 864 0x4C, 0x5A, 0x40); |
| 865 TestRegAddrBaseScaledIndex(cmp, r8, r9, r10, 1, 0x40, i16, 6, 0x66, 0x47, |
| 866 0x3B, 0x44, 0x11, 0x40); |
| 867 TestRegAddrBaseScaledIndex(cmp, r9, r10, r11, 2, 0x40, i16, 6, 0x66, 0x47, |
| 868 0x3B, 0x4C, 0x5A, 0x40); |
| 869 // esp cannot be an scaled index. |
| 870 TestRegAddrBaseScaledIndex(cmp, ebx, esp, ebp, 4, 0x40, i16, 5, 0x66, 0x3B, |
| 871 0x5C, 0xAC, 0x40); |
| 872 TestRegAddrBaseScaledIndex(cmp, esp, ebp, esi, 8, 0x40, i16, 5, 0x66, 0x3B, |
| 873 0x64, 0xF5, 0x40); |
| 874 TestRegAddrBaseScaledIndex(cmp, ebp, esi, edi, 1, 0x40, i16, 5, 0x66, 0x3B, |
| 875 0x6C, 0x3E, 0x40); |
| 876 TestRegAddrBaseScaledIndex(cmp, esi, edi, eax, 2, 0x40, i16, 5, 0x66, 0x3B, |
| 877 0x74, 0x47, 0x40); |
| 878 TestRegAddrBaseScaledIndex(cmp, edi, eax, ebx, 4, 0x40, i16, 5, 0x66, 0x3B, |
| 879 0x7C, 0x98, 0x40); |
| 880 TestRegAddrBaseScaledIndex(cmp, ebx, ecx, edx, 8, 0x40, i16, 5, 0x66, 0x3B, |
| 881 0x5C, 0xD1, 0x40); |
| 882 TestRegAddrBaseScaledIndex(cmp, r11, r12, r13, 4, 0x40, i16, 6, 0x66, 0x47, |
| 883 0x3B, 0x5C, 0xAC, 0x40); |
| 884 TestRegAddrBaseScaledIndex(cmp, r12, r13, r14, 8, 0x40, i16, 6, 0x66, 0x47, |
| 885 0x3B, 0x64, 0xF5, 0x40); |
| 886 TestRegAddrBaseScaledIndex(cmp, r13, r14, r15, 1, 0x40, i16, 6, 0x66, 0x47, |
| 887 0x3B, 0x6C, 0x3E, 0x40); |
| 888 TestRegAddrBaseScaledIndex(cmp, r14, r15, r8, 2, 0x40, i16, 6, 0x66, 0x47, |
| 889 0x3B, 0x74, 0x47, 0x40); |
| 890 TestRegAddrBaseScaledIndex(cmp, r15, r8, r11, 4, 0x40, i16, 6, 0x66, 0x47, |
| 891 0x3B, 0x7C, 0x98, 0x40); |
| 892 TestRegAddrBaseScaledIndex(cmp, r11, r9, r10, 8, 0x40, i16, 6, 0x66, 0x47, |
| 893 0x3B, 0x5C, 0xD1, 0x40); |
| 894 |
| 895 TestRegAddrBaseScaledIndex(cmp, eax, ecx, edx, 1, 0x40, i8, 4, 0x3A, 0x44, |
| 896 0x11, 0x40); |
| 897 TestRegAddrBaseScaledIndex(cmp, ecx, edx, ebx, 2, 0x40, i8, 4, 0x3A, 0x4C, |
| 898 0x5A, 0x40); |
| 899 TestRegAddrBaseScaledIndex(cmp, r8, r9, r10, 1, 0x40, i8, 5, 0x47, 0x3A, 0x44, |
| 900 0x11, 0x40); |
| 901 TestRegAddrBaseScaledIndex(cmp, r9, r10, r11, 2, 0x40, i8, 5, 0x47, 0x3A, |
| 902 0x4C, 0x5A, 0x40); |
| 903 // esp cannot be an scaled index. |
| 904 TestRegAddrBaseScaledIndex(cmp, ebx, esp, ebp, 4, 0x40, i8, 4, 0x3A, 0x5C, |
| 905 0xAC, 0x40); |
| 906 TestRegAddrBaseScaledIndex(cmp, esp, ebp, esi, 8, 0x40, i8, 5, 0x40, 0x3A, |
| 907 0x64, 0xF5, 0x40); |
| 908 TestRegAddrBaseScaledIndex(cmp, ebp, esi, edi, 1, 0x40, i8, 5, 0x40, 0x3A, |
| 909 0x6C, 0x3E, 0x40); |
| 910 TestRegAddrBaseScaledIndex(cmp, esi, edi, eax, 2, 0x40, i8, 5, 0x40, 0x3A, |
| 911 0x74, 0x47, 0x40); |
| 912 TestRegAddrBaseScaledIndex(cmp, edi, eax, ebx, 4, 0x40, i8, 5, 0x40, 0x3A, |
| 913 0x7C, 0x98, 0x40); |
| 914 TestRegAddrBaseScaledIndex(cmp, ebx, ecx, edx, 8, 0x40, i8, 4, 0x3A, 0x5C, |
| 915 0xD1, 0x40); |
| 916 TestRegAddrBaseScaledIndex(cmp, r11, r12, r13, 4, 0x40, i8, 5, 0x47, 0x3A, |
| 917 0x5C, 0xAC, 0x40); |
| 918 TestRegAddrBaseScaledIndex(cmp, r12, r13, r14, 8, 0x40, i8, 5, 0x47, 0x3A, |
| 919 0x64, 0xF5, 0x40); |
| 920 TestRegAddrBaseScaledIndex(cmp, r13, r14, r15, 1, 0x40, i8, 5, 0x47, 0x3A, |
| 921 0x6C, 0x3E, 0x40); |
| 922 TestRegAddrBaseScaledIndex(cmp, r14, r15, r8, 2, 0x40, i8, 5, 0x47, 0x3A, |
| 923 0x74, 0x47, 0x40); |
| 924 TestRegAddrBaseScaledIndex(cmp, r15, r8, r11, 4, 0x40, i8, 5, 0x47, 0x3A, |
| 925 0x7C, 0x98, 0x40); |
| 926 TestRegAddrBaseScaledIndex(cmp, r11, r9, r10, 8, 0x40, i8, 5, 0x47, 0x3A, |
| 927 0x5C, 0xD1, 0x40); |
| 928 |
| 929 /* cmp GPR, Imm32(Base,Index,Scale) */ |
| 930 TestRegAddrBaseScaledIndex(cmp, eax, ecx, edx, 1, 0xF0, i32, 7, 0x3B, 0x84, |
| 931 0x11, 0xF0, 0x00, 0x00, 0x00); |
| 932 TestRegAddrBaseScaledIndex(cmp, ecx, edx, ebx, 2, 0xF0, i32, 7, 0x3B, 0x8C, |
| 933 0x5A, 0xF0, 0x00, 0x00, 0x00); |
| 934 TestRegAddrBaseScaledIndex(cmp, r8, r9, r10, 1, 0xF0, i32, 8, 0x47, 0x3B, |
| 935 0x84, 0x11, 0xF0, 0x00, 0x00, 0x00); |
| 936 TestRegAddrBaseScaledIndex(cmp, r9, r10, r11, 2, 0xF0, i32, 8, 0x47, 0x3B, |
| 937 0x8C, 0x5A, 0xF0, 0x00, 0x00, 0x00); |
| 938 // esp cannot be an scaled index. |
| 939 TestRegAddrBaseScaledIndex(cmp, ebx, esp, ebp, 4, 0xF0, i32, 7, 0x3B, 0x9C, |
| 940 0xAC, 0xF0, 0x00, 0x00, 0x00); |
| 941 TestRegAddrBaseScaledIndex(cmp, esp, ebp, esi, 8, 0xF0, i32, 7, 0x3B, 0xA4, |
| 942 0xF5, 0xF0, 0x00, 0x00, 0x00); |
| 943 TestRegAddrBaseScaledIndex(cmp, ebp, esi, edi, 1, 0xF0, i32, 7, 0x3B, 0xAC, |
| 944 0x3E, 0xF0, 0x00, 0x00, 0x00); |
| 945 TestRegAddrBaseScaledIndex(cmp, esi, edi, eax, 2, 0xF0, i32, 7, 0x3B, 0xB4, |
| 946 0x47, 0xF0, 0x00, 0x00, 0x00); |
| 947 TestRegAddrBaseScaledIndex(cmp, edi, eax, ebx, 4, 0xF0, i32, 7, 0x3B, 0xBC, |
| 948 0x98, 0xF0, 0x00, 0x00, 0x00); |
| 949 TestRegAddrBaseScaledIndex(cmp, ebx, ecx, edx, 8, 0xF0, i32, 7, 0x3B, 0x9C, |
| 950 0xD1, 0xF0, 0x00, 0x00, 0x00); |
| 951 TestRegAddrBaseScaledIndex(cmp, r11, r12, r13, 4, 0xF0, i32, 8, 0x47, 0x3B, |
| 952 0x9C, 0xAC, 0xF0, 0x00, 0x00, 0x00); |
| 953 TestRegAddrBaseScaledIndex(cmp, r12, r13, r14, 8, 0xF0, i32, 8, 0x47, 0x3B, |
| 954 0xA4, 0xF5, 0xF0, 0x00, 0x00, 0x00); |
| 955 TestRegAddrBaseScaledIndex(cmp, r13, r14, r15, 1, 0xF0, i32, 8, 0x47, 0x3B, |
| 956 0xAC, 0x3E, 0xF0, 0x00, 0x00, 0x00); |
| 957 TestRegAddrBaseScaledIndex(cmp, r14, r15, r8, 2, 0xF0, i32, 8, 0x47, 0x3B, |
| 958 0xB4, 0x47, 0xF0, 0x00, 0x00, 0x00); |
| 959 TestRegAddrBaseScaledIndex(cmp, r15, r8, r11, 4, 0xF0, i32, 8, 0x47, 0x3B, |
| 960 0xBC, 0x98, 0xF0, 0x00, 0x00, 0x00); |
| 961 TestRegAddrBaseScaledIndex(cmp, r11, r9, r10, 8, 0xF0, i32, 8, 0x47, 0x3B, |
| 962 0x9C, 0xD1, 0xF0, 0x00, 0x00, 0x00); |
| 963 |
| 964 TestRegAddrBaseScaledIndex(cmp, eax, ecx, edx, 1, 0xF0, i16, 8, 0x66, 0x3B, |
| 965 0x84, 0x11, 0xF0, 0x00, 0x00, 0x00); |
| 966 TestRegAddrBaseScaledIndex(cmp, ecx, edx, ebx, 2, 0xF0, i16, 8, 0x66, 0x3B, |
| 967 0x8C, 0x5A, 0xF0, 0x00, 0x00, 0x00); |
| 968 TestRegAddrBaseScaledIndex(cmp, r8, r9, r10, 1, 0xF0, i16, 9, 0x66, 0x47, |
| 969 0x3B, 0x84, 0x11, 0xF0, 0x00, 0x00, 0x00); |
| 970 TestRegAddrBaseScaledIndex(cmp, r9, r10, r11, 2, 0xF0, i16, 9, 0x66, 0x47, |
| 971 0x3B, 0x8C, 0x5A, 0xF0, 0x00, 0x00, 0x00); |
| 972 // esp cannot be an scaled index. |
| 973 TestRegAddrBaseScaledIndex(cmp, ebx, esp, ebp, 4, 0xF0, i16, 8, 0x66, 0x3B, |
| 974 0x9C, 0xAC, 0xF0, 0x00, 0x00, 0x00); |
| 975 TestRegAddrBaseScaledIndex(cmp, esp, ebp, esi, 8, 0xF0, i16, 8, 0x66, 0x3B, |
| 976 0xA4, 0xF5, 0xF0, 0x00, 0x00, 0x00); |
| 977 TestRegAddrBaseScaledIndex(cmp, ebp, esi, edi, 1, 0xF0, i16, 8, 0x66, 0x3B, |
| 978 0xAC, 0x3E, 0xF0, 0x00, 0x00, 0x00); |
| 979 TestRegAddrBaseScaledIndex(cmp, esi, edi, eax, 2, 0xF0, i16, 8, 0x66, 0x3B, |
| 980 0xB4, 0x47, 0xF0, 0x00, 0x00, 0x00); |
| 981 TestRegAddrBaseScaledIndex(cmp, edi, eax, ebx, 4, 0xF0, i16, 8, 0x66, 0x3B, |
| 982 0xBC, 0x98, 0xF0, 0x00, 0x00, 0x00); |
| 983 TestRegAddrBaseScaledIndex(cmp, ebx, ecx, edx, 8, 0xF0, i16, 8, 0x66, 0x3B, |
| 984 0x9C, 0xD1, 0xF0, 0x00, 0x00, 0x00); |
| 985 TestRegAddrBaseScaledIndex(cmp, r11, r12, r13, 4, 0xF0, i16, 9, 0x66, 0x47, |
| 986 0x3B, 0x9C, 0xAC, 0xF0, 0x00, 0x00, 0x00); |
| 987 TestRegAddrBaseScaledIndex(cmp, r12, r13, r14, 8, 0xF0, i16, 9, 0x66, 0x47, |
| 988 0x3B, 0xA4, 0xF5, 0xF0, 0x00, 0x00, 0x00); |
| 989 TestRegAddrBaseScaledIndex(cmp, r13, r14, r15, 1, 0xF0, i16, 9, 0x66, 0x47, |
| 990 0x3B, 0xAC, 0x3E, 0xF0, 0x00, 0x00, 0x00); |
| 991 TestRegAddrBaseScaledIndex(cmp, r14, r15, r8, 2, 0xF0, i16, 9, 0x66, 0x47, |
| 992 0x3B, 0xB4, 0x47, 0xF0, 0x00, 0x00, 0x00); |
| 993 TestRegAddrBaseScaledIndex(cmp, r15, r8, r11, 4, 0xF0, i16, 9, 0x66, 0x47, |
| 994 0x3B, 0xBC, 0x98, 0xF0, 0x00, 0x00, 0x00); |
| 995 TestRegAddrBaseScaledIndex(cmp, r11, r9, r10, 8, 0xF0, i16, 9, 0x66, 0x47, |
| 996 0x3B, 0x9C, 0xD1, 0xF0, 0x00, 0x00, 0x00); |
| 997 |
| 998 TestRegAddrBaseScaledIndex(cmp, eax, ecx, edx, 1, 0xF0, i8, 7, 0x3A, 0x84, |
| 999 0x11, 0xF0, 0x00, 0x00, 0x00); |
| 1000 TestRegAddrBaseScaledIndex(cmp, ecx, edx, ebx, 2, 0xF0, i8, 7, 0x3A, 0x8C, |
| 1001 0x5A, 0xF0, 0x00, 0x00, 0x00); |
| 1002 TestRegAddrBaseScaledIndex(cmp, r8, r9, r10, 1, 0xF0, i8, 8, 0x47, 0x3A, 0x84, |
| 1003 0x11, 0xF0, 0x00, 0x00, 0x00); |
| 1004 TestRegAddrBaseScaledIndex(cmp, r9, r10, r11, 2, 0xF0, i8, 8, 0x47, 0x3A, |
| 1005 0x8C, 0x5A, 0xF0, 0x00, 0x00, 0x00); |
| 1006 // esp cannot be an scaled index. |
| 1007 TestRegAddrBaseScaledIndex(cmp, ebx, esp, ebp, 4, 0xF0, i8, 7, 0x3A, 0x9C, |
| 1008 0xAC, 0xF0, 0x00, 0x00, 0x00); |
| 1009 TestRegAddrBaseScaledIndex(cmp, esp, ebp, esi, 8, 0xF0, i8, 8, 0x40, 0x3A, |
| 1010 0xA4, 0xF5, 0xF0, 0x00, 0x00, 0x00); |
| 1011 TestRegAddrBaseScaledIndex(cmp, ebp, esi, edi, 1, 0xF0, i8, 8, 0x40, 0x3A, |
| 1012 0xAC, 0x3E, 0xF0, 0x00, 0x00, 0x00); |
| 1013 TestRegAddrBaseScaledIndex(cmp, esi, edi, eax, 2, 0xF0, i8, 8, 0x40, 0x3A, |
| 1014 0xB4, 0x47, 0xF0, 0x00, 0x00, 0x00); |
| 1015 TestRegAddrBaseScaledIndex(cmp, edi, eax, ebx, 4, 0xF0, i8, 8, 0x40, 0x3A, |
| 1016 0xBC, 0x98, 0xF0, 0x00, 0x00, 0x00); |
| 1017 TestRegAddrBaseScaledIndex(cmp, ebx, ecx, edx, 8, 0xF0, i8, 7, 0x3A, 0x9C, |
| 1018 0xD1, 0xF0, 0x00, 0x00, 0x00); |
| 1019 TestRegAddrBaseScaledIndex(cmp, r11, r12, r13, 4, 0xF0, i8, 8, 0x47, 0x3A, |
| 1020 0x9C, 0xAC, 0xF0, 0x00, 0x00, 0x00); |
| 1021 TestRegAddrBaseScaledIndex(cmp, r12, r13, r14, 8, 0xF0, i8, 8, 0x47, 0x3A, |
| 1022 0xA4, 0xF5, 0xF0, 0x00, 0x00, 0x00); |
| 1023 TestRegAddrBaseScaledIndex(cmp, r13, r14, r15, 1, 0xF0, i8, 8, 0x47, 0x3A, |
| 1024 0xAC, 0x3E, 0xF0, 0x00, 0x00, 0x00); |
| 1025 TestRegAddrBaseScaledIndex(cmp, r14, r15, r8, 2, 0xF0, i8, 8, 0x47, 0x3A, |
| 1026 0xB4, 0x47, 0xF0, 0x00, 0x00, 0x00); |
| 1027 TestRegAddrBaseScaledIndex(cmp, r15, r8, r11, 4, 0xF0, i8, 8, 0x47, 0x3A, |
| 1028 0xBC, 0x98, 0xF0, 0x00, 0x00, 0x00); |
| 1029 TestRegAddrBaseScaledIndex(cmp, r11, r9, r10, 8, 0xF0, i8, 8, 0x47, 0x3A, |
| 1030 0x9C, 0xD1, 0xF0, 0x00, 0x00, 0x00); |
| 1031 |
| 1032 /* cmp Addr, Imm */ |
| 1033 // Note: at this point we trust the assembler knows how to encode addresses, |
| 1034 // so no more exhaustive addressing mode testing. |
| 1035 TestAddrBaseScaledIndexImm(cmp, eax, ecx, 1, 0xF0, 0x12, i32, 8, 0x83, 0xBC, |
| 1036 0x08, 0xF0, 0x00, 0x00, 0x00, 0x12); |
| 1037 TestAddrBaseScaledIndexImm(cmp, ecx, edx, 1, 0xF0, 0xF0, i32, 11, 0x81, 0xBC, |
| 1038 0x11, 0xF0, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, |
| 1039 0x00); |
| 1040 TestAddrBaseScaledIndexImm(cmp, r8, r9, 1, 0xF0, 0x12, i32, 9, 0x43, 0x83, |
| 1041 0xBC, 0x08, 0xF0, 0x00, 0x00, 0x00, 0x12); |
| 1042 TestAddrBaseScaledIndexImm(cmp, r9, r10, 1, 0xF0, 0xF0, i32, 12, 0x43, 0x81, |
| 1043 0xBC, 0x11, 0xF0, 0x00, 0x00, 0x00, 0xF0, 0x00, |
| 1044 0x00, 0x00); |
| 1045 |
| 1046 TestAddrBaseScaledIndexImm(cmp, eax, ecx, 1, 0xF0, 0x12, i16, 9, 0x66, 0x83, |
| 1047 0xBC, 0x08, 0xF0, 0x00, 0x00, 0x00, 0x12); |
| 1048 TestAddrBaseScaledIndexImm(cmp, ecx, edx, 1, 0xF0, 0xF0, i16, 10, 0x66, 0x81, |
| 1049 0xBC, 0x11, 0xF0, 0x00, 0x00, 0x00, 0xF0, 0x00); |
| 1050 TestAddrBaseScaledIndexImm(cmp, r8, r9, 1, 0xF0, 0x12, i16, 10, 0x66, 0x43, |
| 1051 0x83, 0xBC, 0x08, 0xF0, 0x00, 0x00, 0x00, 0x12); |
| 1052 TestAddrBaseScaledIndexImm(cmp, r9, r10, 1, 0xF0, 0xF0, i16, 11, 0x66, 0x43, |
| 1053 0x81, 0xBC, 0x11, 0xF0, 0x00, 0x00, 0x00, 0xF0, |
| 1054 0x00); |
| 1055 |
| 1056 TestAddrBaseScaledIndexImm(cmp, eax, ecx, 1, 0xF0, 0x12, i8, 8, 0x80, 0xBC, |
| 1057 0x08, 0xF0, 0x00, 0x00, 0x00, 0x12); |
| 1058 TestAddrBaseScaledIndexImm(cmp, r8, r9, 1, 0xF0, 0x12, i8, 9, 0x43, 0x80, |
| 1059 0xBC, 0x08, 0xF0, 0x00, 0x00, 0x00, 0x12); |
| 1060 |
| 1061 /* cmp Addr, GPR */ |
| 1062 TestAddrBaseScaledIndexReg(cmp, eax, ecx, 1, 0xF0, edx, i32, 7, 0x39, 0x94, |
| 1063 0x08, 0xF0, 0x00, 0x00, 0x00); |
| 1064 TestAddrBaseScaledIndexReg(cmp, r8, r9, 1, 0xF0, r10, i32, 8, 0x47, 0x39, |
| 1065 0x94, 0x08, 0xF0, 0x00, 0x00, 0x00); |
| 1066 |
| 1067 TestAddrBaseScaledIndexReg(cmp, eax, ecx, 1, 0xF0, edx, i16, 8, 0x66, 0x39, |
| 1068 0x94, 0x08, 0xF0, 0x00, 0x00, 0x00); |
| 1069 TestAddrBaseScaledIndexReg(cmp, r8, r9, 1, 0xF0, r10, i16, 9, 0x66, 0x47, |
| 1070 0x39, 0x94, 0x08, 0xF0, 0x00, 0x00, 0x00); |
| 1071 |
| 1072 TestAddrBaseScaledIndexReg(cmp, eax, ecx, 1, 0xF0, edx, i8, 7, 0x38, 0x94, |
| 1073 0x08, 0xF0, 0x00, 0x00, 0x00); |
| 1074 TestAddrBaseScaledIndexReg(cmp, r8, r9, 1, 0xF0, r10, i8, 8, 0x47, 0x38, 0x94, |
| 1075 0x08, 0xF0, 0x00, 0x00, 0x00); |
| 1076 |
| 1077 #undef TestAddrBaseScaledIndexReg |
| 1078 #undef TestAddrBaseScaledIndexImm |
| 1079 #undef TestRegAddrBaseScaledIndex |
| 1080 #undef TestRegAddrScaledIndex |
| 1081 #undef TestRegAddrBase |
| 1082 #undef TestRegAbsoluteAddr |
| 1083 #undef TestRegImm |
| 1084 #undef TestRegReg |
| 1085 } |
| 1086 |
| 1087 TEST_F(AssemblerX8664Test, ScratchpadGettersAndSetters) { |
| 1088 const uint32_t S0 = allocateDword(); |
| 1089 const uint32_t S1 = allocateDword(); |
| 1090 const uint32_t S2 = allocateDword(); |
| 1091 const uint32_t S3 = allocateDword(); |
| 1092 AssembledTest test = assemble(); |
| 1093 test.setDwordTo(S0, 0xBEEF0000u); |
| 1094 test.setDwordTo(S1, 0xDEADu); |
| 1095 test.setDwordTo(S2, 0x20406080u); |
| 1096 ASSERT_EQ(0xBEEF0000u, test.contentsOfDword(S0)); |
| 1097 ASSERT_EQ(0xDEADu, test.contentsOfDword(S1)); |
| 1098 ASSERT_EQ(0x20406080u, test.contentsOfDword(S2)); |
| 1099 ASSERT_EQ(0xDEADBEEF0000ull, test.contentsOfQword(S0)); |
| 1100 ASSERT_EQ(0x204060800000DEADull, test.contentsOfQword(S1)); |
| 1101 |
| 1102 test.setQwordTo(S1, 0x1234567890ABCDEFull); |
| 1103 ASSERT_EQ(0x1234567890ABCDEFull, test.contentsOfQword(S1)); |
| 1104 test.setDwordTo(S0, 0xBEEF0000u); |
| 1105 ASSERT_EQ(0x90ABCDEFull, test.contentsOfDword(S1)); |
| 1106 ASSERT_EQ(0x12345678ull, test.contentsOfDword(S2)); |
| 1107 |
| 1108 test.setDwordTo(S0, 1.0f); |
| 1109 ASSERT_FLOAT_EQ(1.0f, test.contentsOfDword<float>(S0)); |
| 1110 test.setQwordTo(S0, 3.14); |
| 1111 ASSERT_DOUBLE_EQ(3.14, test.contentsOfQword<double>(S0)); |
| 1112 |
| 1113 test.setDqwordTo(S0, Dqword(1.0f, 2.0f, 3.0f, 4.0f)); |
| 1114 ASSERT_EQ(Dqword(1.0f, 2.0f, 3.0f, 4.0f), test.contentsOfDqword(S0)); |
| 1115 EXPECT_FLOAT_EQ(1.0f, test.contentsOfDword<float>(S0)); |
| 1116 EXPECT_FLOAT_EQ(2.0f, test.contentsOfDword<float>(S1)); |
| 1117 EXPECT_FLOAT_EQ(3.0f, test.contentsOfDword<float>(S2)); |
| 1118 EXPECT_FLOAT_EQ(4.0f, test.contentsOfDword<float>(S3)); |
| 1119 } |
| 1120 |
| 1121 } // end of anonymous namespace |
| 1122 } // end of namespace Test |
| 1123 } // end of namespace X8664 |
| 1124 } // end of namespace Ice |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1224173006:
Adds the x86-64 assembler. (Closed)
Base URL: https://chromium.googlesource.com/native_client/pnacl-subzero.git@master