1 //===- subzero/unittest/AssemblerX8632/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 "AssemblerX8632/TestUtil.h" 10 11 namespace Ice { 12 namespace X8632 { 13 namespace Test { 14 namespace { 15 16 TEST_F(AssemblerX8632LowLevelTest, 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(AssemblerX8632LowLevelTest, 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(AssemblerX8632LowLevelTest, 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(AssemblerX8632LowLevelTest, PopRegs) { 44 __ popl(GPRRegister::Encoded_Reg_eax); 45 __ popl(GPRRegister::Encoded_Reg_ebx); 46 __ popl(GPRRegister::Encoded_Reg_ecx); 47 __ popl(GPRRegister::Encoded_Reg_edx); 48 __ popl(GPRRegister::Encoded_Reg_edi); 49 __ popl(GPRRegister::Encoded_Reg_esi); 50 __ popl(GPRRegister::Encoded_Reg_ebp); 51 52 constexpr size_t ByteCount = 7; 53 ASSERT_EQ(ByteCount, codeBytesSize()); 54 55 constexpr uint8_t PopOpcode = 0x58; 56 verifyBytes<ByteCount>(codeBytes(), PopOpcode | GPRRegister::Encoded_Reg_eax, 57 PopOpcode | GPRRegister::Encoded_Reg_ebx, 58 PopOpcode | GPRRegister::Encoded_Reg_ecx, 59 PopOpcode | GPRRegister::Encoded_Reg_edx, 60 PopOpcode | GPRRegister::Encoded_Reg_edi, 61 PopOpcode | GPRRegister::Encoded_Reg_esi, 62 PopOpcode | GPRRegister::Encoded_Reg_ebp); 63 } 64 65 TEST_F(AssemblerX8632LowLevelTest, PushRegs) { 66 __ pushl(GPRRegister::Encoded_Reg_eax); 67 __ pushl(GPRRegister::Encoded_Reg_ebx); 68 __ pushl(GPRRegister::Encoded_Reg_ecx); 69 __ pushl(GPRRegister::Encoded_Reg_edx); 70 __ pushl(GPRRegister::Encoded_Reg_edi); 71 __ pushl(GPRRegister::Encoded_Reg_esi); 72 __ pushl(GPRRegister::Encoded_Reg_ebp); 73 74 constexpr size_t ByteCount = 7; 75 ASSERT_EQ(ByteCount, codeBytesSize()); 76 77 constexpr uint8_t PushOpcode = 0x50; 78 verifyBytes<ByteCount>(codeBytes(), PushOpcode | GPRRegister::Encoded_Reg_eax, 79 PushOpcode | GPRRegister::Encoded_Reg_ebx, 80 PushOpcode | GPRRegister::Encoded_Reg_ecx, 81 PushOpcode | GPRRegister::Encoded_Reg_edx, 82 PushOpcode | GPRRegister::Encoded_Reg_edi, 83 PushOpcode | GPRRegister::Encoded_Reg_esi, 84 PushOpcode | GPRRegister::Encoded_Reg_ebp); 85 } 86 87 TEST_F(AssemblerX8632LowLevelTest, MovRegisterZero) { 88 __ mov(IceType_i32, GPRRegister::Encoded_Reg_eax, Immediate(0x00)); 89 __ mov(IceType_i32, GPRRegister::Encoded_Reg_ebx, Immediate(0x00)); 90 __ mov(IceType_i32, GPRRegister::Encoded_Reg_ecx, Immediate(0x00)); 91 __ mov(IceType_i32, GPRRegister::Encoded_Reg_edx, Immediate(0x00)); 92 __ mov(IceType_i32, GPRRegister::Encoded_Reg_edi, Immediate(0x00)); 93 __ mov(IceType_i32, GPRRegister::Encoded_Reg_esi, Immediate(0x00)); 94 95 constexpr size_t MovReg32BitImmBytes = 5; 96 constexpr size_t ByteCount = 6 * MovReg32BitImmBytes; 97 ASSERT_EQ(ByteCount, codeBytesSize()); 98 99 constexpr uint8_t MovOpcode = 0xb8; 100 verifyBytes<ByteCount>( 101 codeBytes(), MovOpcode | GPRRegister::Encoded_Reg_eax, 0x00, 0x00, 0x00, 102 0x00, MovOpcode | GPRRegister::Encoded_Reg_ebx, 0x00, 0x00, 0x00, 0x00, 103 MovOpcode | GPRRegister::Encoded_Reg_ecx, 0x00, 0x00, 0x00, 0x00, 104 MovOpcode | GPRRegister::Encoded_Reg_edx, 0x00, 0x00, 0x00, 0x00, 105 MovOpcode | GPRRegister::Encoded_Reg_edi, 0x00, 0x00, 0x00, 0x00, 106 MovOpcode | GPRRegister::Encoded_Reg_esi, 0x00, 0x00, 0x00, 0x00); 107 } 108 109 TEST_F(AssemblerX8632LowLevelTest, Cmp) { 110 #define TestRegReg(Inst, Dst, Src, OpType, ByteCountUntyped, ...) \ 111 do { \ 112 static constexpr char TestString[] = \ 113 "(" #Inst ", " #Dst ", " #Src ", " #OpType ", " #ByteCountUntyped \ 114 ", " #__VA_ARGS__ ")"; \ 115 static constexpr uint8_t ByteCount = ByteCountUntyped; \ 116 __ Inst(IceType_##OpType, GPRRegister::Encoded_Reg_##Dst, \ 117 GPRRegister::Encoded_Reg_##Src); \ 118 ASSERT_EQ(ByteCount, codeBytesSize()) << TestString; \ 119 ASSERT_TRUE(verifyBytes<ByteCount>(codeBytes(), __VA_ARGS__)) \ 120 << TestString; \ 121 reset(); \ 122 } while (0) 123 124 #define TestRegImm(Inst, Dst, Imm, OpType, ByteCountUntyped, ...) \ 125 do { \ 126 static constexpr char TestString[] = \ 127 "(" #Inst ", " #Dst ", " #Imm ", " #OpType ", " #ByteCountUntyped \ 128 ", " #__VA_ARGS__ ")"; \ 129 static constexpr uint8_t ByteCount = ByteCountUntyped; \ 130 __ Inst(IceType_##OpType, GPRRegister::Encoded_Reg_##Dst, Immediate(Imm)); \ 131 ASSERT_EQ(ByteCount, codeBytesSize()) << TestString; \ 132 ASSERT_TRUE(verifyBytes<ByteCount>(codeBytes(), __VA_ARGS__)) \ 133 << TestString; \ 134 reset(); \ 135 } while (0) 136 137 #define TestRegAbsoluteAddr(Inst, Dst, Disp, OpType, ByteCountUntyped, ...) \ 138 do { \ 139 static constexpr char TestString[] = \ 140 "(" #Inst ", " #Dst ", " #Disp ", " #OpType ", " #ByteCountUntyped \ 141 ", " #__VA_ARGS__ ")"; \ 142 static constexpr uint8_t ByteCount = ByteCountUntyped; \ 143 __ Inst(IceType_##OpType, GPRRegister::Encoded_Reg_##Dst, \ 144 Address(Disp, AssemblerFixup::NoFixup)); \ 145 ASSERT_EQ(ByteCount, codeBytesSize()) << TestString; \ 146 ASSERT_TRUE(verifyBytes<ByteCount>(codeBytes(), __VA_ARGS__)) \ 147 << TestString; \ 148 reset(); \ 149 } while (0) 150 151 #define TestRegAddrBase(Inst, Dst, Base, Disp, OpType, ByteCountUntyped, ...) \ 152 do { \ 153 static constexpr char TestString[] = \ 154 "(" #Inst ", " #Dst ", " #Base ", " #Disp ", " #OpType \ 155 ", " #ByteCountUntyped ", " #__VA_ARGS__ ")"; \ 156 static constexpr uint8_t ByteCount = ByteCountUntyped; \ 157 __ Inst(IceType_##OpType, GPRRegister::Encoded_Reg_##Dst, \ 158 Address(GPRRegister::Encoded_Reg_##Base, Disp, \ 159 AssemblerFixup::NoFixup)); \ 160 ASSERT_EQ(ByteCount, codeBytesSize()) << TestString; \ 161 ASSERT_TRUE(verifyBytes<ByteCount>(codeBytes(), __VA_ARGS__)) \ 162 << TestString; \ 163 reset(); \ 164 } while (0) 165 166 #define TestRegAddrScaledIndex(Inst, Dst, Index, Scale, Disp, OpType, \ 167 ByteCountUntyped, ...) \ 168 do { \ 169 static constexpr char TestString[] = \ 170 "(" #Inst ", " #Dst ", " #Index ", " #Scale ", " #Disp ", " #OpType \ 171 ", " #ByteCountUntyped ", " #__VA_ARGS__ ")"; \ 172 static constexpr uint8_t ByteCount = ByteCountUntyped; \ 173 __ Inst(IceType_##OpType, GPRRegister::Encoded_Reg_##Dst, \ 174 Address(GPRRegister::Encoded_Reg_##Index, Traits::TIMES_##Scale, \ 175 Disp, AssemblerFixup::NoFixup)); \ 176 ASSERT_EQ(ByteCount, codeBytesSize()) << TestString; \ 177 ASSERT_TRUE(verifyBytes<ByteCount>(codeBytes(), __VA_ARGS__)) \ 178 << TestString; \ 179 reset(); \ 180 } while (0) 181 182 #define TestRegAddrBaseScaledIndex(Inst, Dst, Base, Index, Scale, Disp, \ 183 OpType, ByteCountUntyped, ...) \ 184 do { \ 185 static constexpr char TestString[] = \ 186 "(" #Inst ", " #Dst ", " #Base ", " #Index ", " #Scale ", " #Disp \ 187 ", " #OpType ", " #ByteCountUntyped ", " #__VA_ARGS__ ")"; \ 188 static constexpr uint8_t ByteCount = ByteCountUntyped; \ 189 __ Inst(IceType_##OpType, GPRRegister::Encoded_Reg_##Dst, \ 190 Address(GPRRegister::Encoded_Reg_##Base, \ 191 GPRRegister::Encoded_Reg_##Index, Traits::TIMES_##Scale, \ 192 Disp, AssemblerFixup::NoFixup)); \ 193 ASSERT_EQ(ByteCount, codeBytesSize()) << TestString; \ 194 ASSERT_TRUE(verifyBytes<ByteCount>(codeBytes(), __VA_ARGS__)) \ 195 << TestString; \ 196 reset(); \ 197 } while (0) 198 199 #define TestAddrBaseScaledIndexImm(Inst, Base, Index, Scale, Disp, Imm, \ 200 OpType, ByteCountUntyped, ...) \ 201 do { \ 202 static constexpr char TestString[] = \ 203 "(" #Inst ", " #Base ", " #Index ", " #Scale ", " #Disp ", " #Imm \ 204 ", " #OpType ", " #ByteCountUntyped ", " #__VA_ARGS__ ")"; \ 205 static constexpr uint8_t ByteCount = ByteCountUntyped; \ 206 __ Inst(IceType_##OpType, \ 207 Address(GPRRegister::Encoded_Reg_##Base, \ 208 GPRRegister::Encoded_Reg_##Index, Traits::TIMES_##Scale, \ 209 Disp, AssemblerFixup::NoFixup), \ 210 Immediate(Imm)); \ 211 ASSERT_EQ(ByteCount, codeBytesSize()) << TestString; \ 212 ASSERT_TRUE(verifyBytes<ByteCount>(codeBytes(), __VA_ARGS__)) \ 213 << TestString; \ 214 reset(); \ 215 } while (0) 216 217 #define TestAddrBaseScaledIndexReg(Inst, Base, Index, Scale, Disp, Src, \ 218 OpType, ByteCountUntyped, ...) \ 219 do { \ 220 static constexpr char TestString[] = \ 221 "(" #Inst ", " #Base ", " #Index ", " #Scale ", " #Disp ", " #Src \ 222 ", " #OpType ", " #ByteCountUntyped ", " #__VA_ARGS__ ")"; \ 223 static constexpr uint8_t ByteCount = ByteCountUntyped; \ 224 __ Inst(IceType_##OpType, \ 225 Address(GPRRegister::Encoded_Reg_##Base, \ 226 GPRRegister::Encoded_Reg_##Index, Traits::TIMES_##Scale, \ 227 Disp, AssemblerFixup::NoFixup), \ 228 GPRRegister::Encoded_Reg_##Src); \ 229 ASSERT_EQ(ByteCount, codeBytesSize()) << TestString; \ 230 ASSERT_TRUE(verifyBytes<ByteCount>(codeBytes(), __VA_ARGS__)) \ 231 << TestString; \ 232 reset(); \ 233 } while (0) 234 235 /* cmp GPR, GPR */ 236 TestRegReg(cmp, eax, ecx, i32, 2, 0x3B, 0xC1); 237 TestRegReg(cmp, ecx, edx, i32, 2, 0x3B, 0xCA); 238 TestRegReg(cmp, edx, ebx, i32, 2, 0x3B, 0xD3); 239 TestRegReg(cmp, ebx, esp, i32, 2, 0x3B, 0xDC); 240 TestRegReg(cmp, esp, ebp, i32, 2, 0x3B, 0xE5); 241 TestRegReg(cmp, ebp, esi, i32, 2, 0x3B, 0xEE); 242 TestRegReg(cmp, esi, edi, i32, 2, 0x3B, 0xF7); 243 TestRegReg(cmp, edi, eax, i32, 2, 0x3B, 0xF8); 244 245 TestRegReg(cmp, eax, ecx, i16, 3, 0x66, 0x3B, 0xC1); 246 TestRegReg(cmp, ecx, edx, i16, 3, 0x66, 0x3B, 0xCA); 247 TestRegReg(cmp, edx, ebx, i16, 3, 0x66, 0x3B, 0xD3); 248 TestRegReg(cmp, ebx, esp, i16, 3, 0x66, 0x3B, 0xDC); 249 TestRegReg(cmp, esp, ebp, i16, 3, 0x66, 0x3B, 0xE5); 250 TestRegReg(cmp, ebp, esi, i16, 3, 0x66, 0x3B, 0xEE); 251 TestRegReg(cmp, esi, edi, i16, 3, 0x66, 0x3B, 0xF7); 252 TestRegReg(cmp, edi, eax, i16, 3, 0x66, 0x3B, 0xF8); 253 254 TestRegReg(cmp, eax, ecx, i8, 2, 0x3A, 0xC1); 255 TestRegReg(cmp, ecx, edx, i8, 2, 0x3A, 0xCA); 256 TestRegReg(cmp, edx, ebx, i8, 2, 0x3A, 0xD3); 257 TestRegReg(cmp, ebx, esp, i8, 2, 0x3A, 0xDC); 258 TestRegReg(cmp, esp, ebp, i8, 2, 0x3A, 0xE5); 259 TestRegReg(cmp, ebp, esi, i8, 2, 0x3A, 0xEE); 260 TestRegReg(cmp, esi, edi, i8, 2, 0x3A, 0xF7); 261 TestRegReg(cmp, edi, eax, i8, 2, 0x3A, 0xF8); 262 263 /* cmp GPR, Imm8 */ 264 TestRegImm(cmp, eax, 5, i32, 3, 0x83, 0xF8, 0x05); 265 TestRegImm(cmp, ecx, 5, i32, 3, 0x83, 0xF9, 0x05); 266 TestRegImm(cmp, edx, 5, i32, 3, 0x83, 0xFA, 0x05); 267 TestRegImm(cmp, ebx, 5, i32, 3, 0x83, 0xFB, 0x05); 268 TestRegImm(cmp, esp, 5, i32, 3, 0x83, 0xFC, 0x05); 269 TestRegImm(cmp, ebp, 5, i32, 3, 0x83, 0xFD, 0x05); 270 TestRegImm(cmp, esi, 5, i32, 3, 0x83, 0xFE, 0x05); 271 TestRegImm(cmp, edi, 5, i32, 3, 0x83, 0xFF, 0x05); 272 273 TestRegImm(cmp, eax, 5, i16, 4, 0x66, 0x83, 0xF8, 0x05); 274 TestRegImm(cmp, ecx, 5, i16, 4, 0x66, 0x83, 0xF9, 0x05); 275 TestRegImm(cmp, edx, 5, i16, 4, 0x66, 0x83, 0xFA, 0x05); 276 TestRegImm(cmp, ebx, 5, i16, 4, 0x66, 0x83, 0xFB, 0x05); 277 TestRegImm(cmp, esp, 5, i16, 4, 0x66, 0x83, 0xFC, 0x05); 278 TestRegImm(cmp, ebp, 5, i16, 4, 0x66, 0x83, 0xFD, 0x05); 279 TestRegImm(cmp, esi, 5, i16, 4, 0x66, 0x83, 0xFE, 0x05); 280 TestRegImm(cmp, edi, 5, i16, 4, 0x66, 0x83, 0xFF, 0x05); 281 282 TestRegImm(cmp, eax, 5, i8, 2, 0x3C, 0x05); 283 TestRegImm(cmp, ecx, 5, i8, 3, 0x80, 0xF9, 0x05); 284 TestRegImm(cmp, edx, 5, i8, 3, 0x80, 0xFA, 0x05); 285 TestRegImm(cmp, ebx, 5, i8, 3, 0x80, 0xFB, 0x05); 286 TestRegImm(cmp, esp, 5, i8, 3, 0x80, 0xFC, 0x05); 287 TestRegImm(cmp, ebp, 5, i8, 3, 0x80, 0xFD, 0x05); 288 TestRegImm(cmp, esi, 5, i8, 3, 0x80, 0xFE, 0x05); 289 TestRegImm(cmp, edi, 5, i8, 3, 0x80, 0xFF, 0x05); 290 291 /* cmp GPR, Imm16 */ 292 TestRegImm(cmp, eax, 0x100, i32, 5, 0x3D, 0x00, 0x01, 0x00, 0x00); 293 TestRegImm(cmp, ecx, 0x100, i32, 6, 0x81, 0xF9, 0x00, 0x01, 0x00, 0x00); 294 TestRegImm(cmp, edx, 0x100, i32, 6, 0x81, 0xFA, 0x00, 0x01, 0x00, 0x00); 295 TestRegImm(cmp, ebx, 0x100, i32, 6, 0x81, 0xFB, 0x00, 0x01, 0x00, 0x00); 296 TestRegImm(cmp, esp, 0x100, i32, 6, 0x81, 0xFC, 0x00, 0x01, 0x00, 0x00); 297 TestRegImm(cmp, ebp, 0x100, i32, 6, 0x81, 0xFD, 0x00, 0x01, 0x00, 0x00); 298 TestRegImm(cmp, esi, 0x100, i32, 6, 0x81, 0xFE, 0x00, 0x01, 0x00, 0x00); 299 TestRegImm(cmp, edi, 0x100, i32, 6, 0x81, 0xFF, 0x00, 0x01, 0x00, 0x00); 300 301 TestRegImm(cmp, eax, 0x100, i16, 4, 0x66, 0x3D, 0x00, 0x01); 302 TestRegImm(cmp, ecx, 0x100, i16, 5, 0x66, 0x81, 0xF9, 0x00, 0x01); 303 TestRegImm(cmp, edx, 0x100, i16, 5, 0x66, 0x81, 0xFA, 0x00, 0x01); 304 TestRegImm(cmp, ebx, 0x100, i16, 5, 0x66, 0x81, 0xFB, 0x00, 0x01); 305 TestRegImm(cmp, esp, 0x100, i16, 5, 0x66, 0x81, 0xFC, 0x00, 0x01); 306 TestRegImm(cmp, ebp, 0x100, i16, 5, 0x66, 0x81, 0xFD, 0x00, 0x01); 307 TestRegImm(cmp, esi, 0x100, i16, 5, 0x66, 0x81, 0xFE, 0x00, 0x01); 308 TestRegImm(cmp, edi, 0x100, i16, 5, 0x66, 0x81, 0xFF, 0x00, 0x01); 309 310 /* cmp GPR, Absolute */ 311 TestRegAbsoluteAddr(cmp, eax, 0xF00FBEEF, i32, 6, 0x3B, 0x05, 0xEF, 0xBE, 312 0x0F, 0xF0); 313 TestRegAbsoluteAddr(cmp, eax, 0xF00FBEEF, i16, 7, 0x66, 0x3B, 0x05, 0xEF, 314 0xBE, 0x0F, 0xF0); 315 TestRegAbsoluteAddr(cmp, eax, 0xF00FBEEF, i8, 6, 0x3A, 0x05, 0xEF, 0xBE, 0x0F, 316 0xF0); 317 318 /* cmp GPR, 0(Base) */ 319 TestRegAddrBase(cmp, eax, ecx, 0, i32, 2, 0x3B, 0x01); 320 TestRegAddrBase(cmp, ecx, edx, 0, i32, 2, 0x3B, 0x0A); 321 TestRegAddrBase(cmp, edx, ebx, 0, i32, 2, 0x3B, 0x13); 322 TestRegAddrBase(cmp, ebx, esp, 0, i32, 3, 0x3B, 0x1C, 0x24); 323 TestRegAddrBase(cmp, esp, ebp, 0, i32, 3, 0x3B, 0x65, 0x00); 324 TestRegAddrBase(cmp, ebp, esi, 0, i32, 2, 0x3B, 0x2E); 325 TestRegAddrBase(cmp, esi, edi, 0, i32, 2, 0x3B, 0x37); 326 TestRegAddrBase(cmp, edi, eax, 0, i32, 2, 0x3B, 0x38); 327 328 TestRegAddrBase(cmp, eax, ecx, 0, i16, 3, 0x66, 0x3B, 0x01); 329 TestRegAddrBase(cmp, ecx, edx, 0, i16, 3, 0x66, 0x3B, 0x0A); 330 TestRegAddrBase(cmp, edx, ebx, 0, i16, 3, 0x66, 0x3B, 0x13); 331 TestRegAddrBase(cmp, ebx, esp, 0, i16, 4, 0x66, 0x3B, 0x1C, 0x24); 332 TestRegAddrBase(cmp, esp, ebp, 0, i16, 4, 0x66, 0x3B, 0x65, 0x00); 333 TestRegAddrBase(cmp, ebp, esi, 0, i16, 3, 0x66, 0x3B, 0x2E); 334 TestRegAddrBase(cmp, esi, edi, 0, i16, 3, 0x66, 0x3B, 0x37); 335 TestRegAddrBase(cmp, edi, eax, 0, i16, 3, 0x66, 0x3B, 0x38); 336 337 TestRegAddrBase(cmp, eax, ecx, 0, i8, 2, 0x3A, 0x01); 338 TestRegAddrBase(cmp, ecx, edx, 0, i8, 2, 0x3A, 0x0A); 339 TestRegAddrBase(cmp, edx, ebx, 0, i8, 2, 0x3A, 0x13); 340 TestRegAddrBase(cmp, ebx, esp, 0, i8, 3, 0x3A, 0x1C, 0x24); 341 TestRegAddrBase(cmp, esp, ebp, 0, i8, 3, 0x3A, 0x65, 0x00); 342 TestRegAddrBase(cmp, ebp, esi, 0, i8, 2, 0x3A, 0x2E); 343 TestRegAddrBase(cmp, esi, edi, 0, i8, 2, 0x3A, 0x37); 344 TestRegAddrBase(cmp, edi, eax, 0, i8, 2, 0x3A, 0x38); 345 346 /* cmp GPR, Imm8(Base) */ 347 TestRegAddrBase(cmp, eax, ecx, 0x40, i32, 3, 0x3B, 0x41, 0x40); 348 TestRegAddrBase(cmp, ecx, edx, 0x40, i32, 3, 0x3B, 0x4A, 0x40); 349 TestRegAddrBase(cmp, edx, ebx, 0x40, i32, 3, 0x3B, 0x53, 0x40); 350 TestRegAddrBase(cmp, ebx, esp, 0x40, i32, 4, 0x3B, 0x5C, 0x24, 0x40); 351 TestRegAddrBase(cmp, esp, ebp, 0x40, i32, 3, 0x3B, 0x65, 0x40); 352 TestRegAddrBase(cmp, ebp, esi, 0x40, i32, 3, 0x3B, 0x6E, 0x40); 353 TestRegAddrBase(cmp, esi, edi, 0x40, i32, 3, 0x3B, 0x77, 0x40); 354 TestRegAddrBase(cmp, edi, eax, 0x40, i32, 3, 0x3B, 0x78, 0x40); 355 356 TestRegAddrBase(cmp, eax, ecx, 0x40, i16, 4, 0x66, 0x3B, 0x41, 0x40); 357 TestRegAddrBase(cmp, ecx, edx, 0x40, i16, 4, 0x66, 0x3B, 0x4A, 0x40); 358 TestRegAddrBase(cmp, edx, ebx, 0x40, i16, 4, 0x66, 0x3B, 0x53, 0x40); 359 TestRegAddrBase(cmp, ebx, esp, 0x40, i16, 5, 0x66, 0x3B, 0x5C, 0x24, 0x40); 360 TestRegAddrBase(cmp, esp, ebp, 0x40, i16, 4, 0x66, 0x3B, 0x65, 0x40); 361 TestRegAddrBase(cmp, ebp, esi, 0x40, i16, 4, 0x66, 0x3B, 0x6E, 0x40); 362 TestRegAddrBase(cmp, esi, edi, 0x40, i16, 4, 0x66, 0x3B, 0x77, 0x40); 363 TestRegAddrBase(cmp, edi, eax, 0x40, i16, 4, 0x66, 0x3B, 0x78, 0x40); 364 365 TestRegAddrBase(cmp, eax, ecx, 0x40, i8, 3, 0x3A, 0x41, 0x40); 366 TestRegAddrBase(cmp, ecx, edx, 0x40, i8, 3, 0x3A, 0x4A, 0x40); 367 TestRegAddrBase(cmp, edx, ebx, 0x40, i8, 3, 0x3A, 0x53, 0x40); 368 TestRegAddrBase(cmp, ebx, esp, 0x40, i8, 4, 0x3A, 0x5C, 0x24, 0x40); 369 TestRegAddrBase(cmp, esp, ebp, 0x40, i8, 3, 0x3A, 0x65, 0x40); 370 TestRegAddrBase(cmp, ebp, esi, 0x40, i8, 3, 0x3A, 0x6E, 0x40); 371 TestRegAddrBase(cmp, esi, edi, 0x40, i8, 3, 0x3A, 0x77, 0x40); 372 TestRegAddrBase(cmp, edi, eax, 0x40, i8, 3, 0x3A, 0x78, 0x40); 373 374 /* cmp GPR, Imm32(Base) */ 375 TestRegAddrBase(cmp, eax, ecx, 0xF0, i32, 6, 0x3B, 0x81, 0xF0, 0x00, 0x00, 376 0x00); 377 TestRegAddrBase(cmp, ecx, edx, 0xF0, i32, 6, 0x3B, 0x8A, 0xF0, 0x00, 0x00, 378 0x00); 379 TestRegAddrBase(cmp, edx, ebx, 0xF0, i32, 6, 0x3B, 0x93, 0xF0, 0x00, 0x00, 380 0x00); 381 TestRegAddrBase(cmp, ebx, esp, 0xF0, i32, 7, 0x3B, 0x9C, 0x24, 0xF0, 0x00, 382 0x00, 0x00); 383 TestRegAddrBase(cmp, esp, ebp, 0xF0, i32, 6, 0x3B, 0xA5, 0xF0, 0x00, 0x00, 384 0x00); 385 TestRegAddrBase(cmp, ebp, esi, 0xF0, i32, 6, 0x3B, 0xAE, 0xF0, 0x00, 0x00, 386 0x00); 387 TestRegAddrBase(cmp, esi, edi, 0xF0, i32, 6, 0x3B, 0xB7, 0xF0, 0x00, 0x00, 388 0x00); 389 TestRegAddrBase(cmp, edi, eax, 0xF0, i32, 6, 0x3B, 0xB8, 0xF0, 0x00, 0x00, 390 0x00); 391 392 TestRegAddrBase(cmp, eax, ecx, 0xF0, i16, 7, 0x66, 0x3B, 0x81, 0xF0, 0x00, 393 0x00, 0x00); 394 TestRegAddrBase(cmp, ecx, edx, 0xF0, i16, 7, 0x66, 0x3B, 0x8A, 0xF0, 0x00, 395 0x00, 0x00); 396 TestRegAddrBase(cmp, edx, ebx, 0xF0, i16, 7, 0x66, 0x3B, 0x93, 0xF0, 0x00, 397 0x00, 0x00); 398 TestRegAddrBase(cmp, ebx, esp, 0xF0, i16, 8, 0x66, 0x3B, 0x9C, 0x24, 0xF0, 399 0x00, 0x00, 0x00); 400 TestRegAddrBase(cmp, esp, ebp, 0xF0, i16, 7, 0x66, 0x3B, 0xa5, 0xF0, 0x00, 401 0x00, 0x00); 402 TestRegAddrBase(cmp, ebp, esi, 0xF0, i16, 7, 0x66, 0x3B, 0xaE, 0xF0, 0x00, 403 0x00, 0x00); 404 TestRegAddrBase(cmp, esi, edi, 0xF0, i16, 7, 0x66, 0x3B, 0xb7, 0xF0, 0x00, 405 0x00, 0x00); 406 TestRegAddrBase(cmp, edi, eax, 0xF0, i16, 7, 0x66, 0x3B, 0xb8, 0xF0, 0x00, 407 0x00, 0x00); 408 409 TestRegAddrBase(cmp, eax, ecx, 0xF0, i8, 6, 0x3A, 0x81, 0xF0, 0x00, 0x00, 410 0x00); 411 TestRegAddrBase(cmp, ecx, edx, 0xF0, i8, 6, 0x3A, 0x8A, 0xF0, 0x00, 0x00, 412 0x00); 413 TestRegAddrBase(cmp, edx, ebx, 0xF0, i8, 6, 0x3A, 0x93, 0xF0, 0x00, 0x00, 414 0x00); 415 TestRegAddrBase(cmp, ebx, esp, 0xF0, i8, 7, 0x3A, 0x9C, 0x24, 0xF0, 0x00, 416 0x00, 0x00); 417 TestRegAddrBase(cmp, esp, ebp, 0xF0, i8, 6, 0x3A, 0xA5, 0xF0, 0x00, 0x00, 418 0x00); 419 TestRegAddrBase(cmp, ebp, esi, 0xF0, i8, 6, 0x3A, 0xAE, 0xF0, 0x00, 0x00, 420 0x00); 421 TestRegAddrBase(cmp, esi, edi, 0xF0, i8, 6, 0x3A, 0xB7, 0xF0, 0x00, 0x00, 422 0x00); 423 TestRegAddrBase(cmp, edi, eax, 0xF0, i8, 6, 0x3A, 0xB8, 0xF0, 0x00, 0x00, 424 0x00); 425 426 /* cmp GPR, Imm(,Index,Scale) */ 427 TestRegAddrScaledIndex(cmp, eax, ecx, 1, 0, i32, 7, 0x3B, 0x04, 0x0D, 0x00, 428 0x00, 0x00, 0x00); 429 TestRegAddrScaledIndex(cmp, ecx, edx, 2, 0, i32, 7, 0x3B, 0x0C, 0x55, 0x00, 430 0x00, 0x00, 0x00); 431 TestRegAddrScaledIndex(cmp, edx, ebx, 4, 0, i32, 7, 0x3B, 0x14, 0x9D, 0x00, 432 0x00, 0x00, 0x00); 433 // esp cannot be an scaled index. 434 TestRegAddrScaledIndex(cmp, esp, ebp, 8, 0, i32, 7, 0x3B, 0x24, 0xED, 0x00, 435 0x00, 0x00, 0x00); 436 TestRegAddrScaledIndex(cmp, ebp, esi, 1, 0, i32, 7, 0x3B, 0x2C, 0x35, 0x00, 437 0x00, 0x00, 0x00); 438 TestRegAddrScaledIndex(cmp, esi, edi, 2, 0, i32, 7, 0x3B, 0x34, 0x7D, 0x00, 439 0x00, 0x00, 0x00); 440 TestRegAddrScaledIndex(cmp, edi, eax, 4, 0, i32, 7, 0x3B, 0x3C, 0x85, 0x00, 441 0x00, 0x00, 0x00); 442 TestRegAddrScaledIndex(cmp, ebx, ecx, 8, 0, i32, 7, 0x3B, 0x1C, 0xCD, 0x00, 443 0x00, 0x00, 0x00); 444 445 TestRegAddrScaledIndex(cmp, eax, ecx, 8, 0, i16, 8, 0x66, 0x3B, 0x04, 0xCD, 446 0x00, 0x00, 0x00, 0x00); 447 TestRegAddrScaledIndex(cmp, ecx, edx, 1, 0, i16, 8, 0x66, 0x3B, 0x0C, 0x15, 448 0x00, 0x00, 0x00, 0x00); 449 TestRegAddrScaledIndex(cmp, edx, ebx, 2, 0, i16, 8, 0x66, 0x3B, 0x14, 0x5D, 450 0x00, 0x00, 0x00, 0x00); 451 // esp cannot be an scaled index. 452 TestRegAddrScaledIndex(cmp, esp, ebp, 4, 0, i16, 8, 0x66, 0x3B, 0x24, 0xAD, 453 0x00, 0x00, 0x00, 0x00); 454 TestRegAddrScaledIndex(cmp, ebp, esi, 8, 0, i16, 8, 0x66, 0x3B, 0x2C, 0xF5, 455 0x00, 0x00, 0x00, 0x00); 456 TestRegAddrScaledIndex(cmp, esi, edi, 1, 0, i16, 8, 0x66, 0x3B, 0x34, 0x3D, 457 0x00, 0x00, 0x00, 0x00); 458 TestRegAddrScaledIndex(cmp, edi, eax, 2, 0, i16, 8, 0x66, 0x3B, 0x3C, 0x45, 459 0x00, 0x00, 0x00, 0x00); 460 TestRegAddrScaledIndex(cmp, ebx, ecx, 8, 0, i16, 8, 0x66, 0x3B, 0x1C, 0xCD, 461 0x00, 0x00, 0x00, 0x00); 462 463 TestRegAddrScaledIndex(cmp, eax, ecx, 4, 0, i8, 7, 0x3A, 0x04, 0x8D, 0x00, 464 0x00, 0x00, 0x00); 465 TestRegAddrScaledIndex(cmp, ecx, edx, 8, 0, i8, 7, 0x3A, 0x0C, 0xD5, 0x00, 466 0x00, 0x00, 0x00); 467 TestRegAddrScaledIndex(cmp, edx, ebx, 1, 0, i8, 7, 0x3A, 0x14, 0x1D, 0x00, 468 0x00, 0x00, 0x00); 469 // esp cannot be an scaled index. 470 TestRegAddrScaledIndex(cmp, esp, ebp, 2, 0, i8, 7, 0x3A, 0x24, 0x6D, 0x00, 471 0x00, 0x00, 0x00); 472 TestRegAddrScaledIndex(cmp, ebp, esi, 4, 0, i8, 7, 0x3A, 0x2C, 0xB5, 0x00, 473 0x00, 0x00, 0x00); 474 TestRegAddrScaledIndex(cmp, esi, edi, 8, 0, i8, 7, 0x3A, 0x34, 0xFD, 0x00, 475 0x00, 0x00, 0x00); 476 TestRegAddrScaledIndex(cmp, edi, eax, 1, 0, i8, 7, 0x3A, 0x3C, 0x05, 0x00, 477 0x00, 0x00, 0x00); 478 TestRegAddrScaledIndex(cmp, ebx, ecx, 8, 0, i8, 7, 0x3a, 0x1C, 0xCD, 0x00, 479 0x00, 0x00, 0x00); 480 481 /* cmp GPR, 0(Base,Index,Scale) */ 482 TestRegAddrBaseScaledIndex(cmp, eax, ecx, edx, 1, 0, i32, 3, 0x3B, 0x04, 483 0x11); 484 TestRegAddrBaseScaledIndex(cmp, ecx, edx, ebx, 2, 0, i32, 3, 0x3B, 0x0C, 485 0x5A); 486 // esp cannot be an scaled index. 487 TestRegAddrBaseScaledIndex(cmp, ebx, esp, ebp, 4, 0, i32, 3, 0x3B, 0x1C, 488 0xAC); 489 TestRegAddrBaseScaledIndex(cmp, esp, ebp, esi, 8, 0, i32, 4, 0x3B, 0x64, 0xF5, 490 0x00); 491 TestRegAddrBaseScaledIndex(cmp, ebp, esi, edi, 1, 0, i32, 3, 0x3B, 0x2C, 492 0x3E); 493 TestRegAddrBaseScaledIndex(cmp, esi, edi, eax, 2, 0, i32, 3, 0x3B, 0x34, 494 0x47); 495 TestRegAddrBaseScaledIndex(cmp, edi, eax, ebx, 4, 0, i32, 3, 0x3B, 0x3C, 496 0x98); 497 TestRegAddrBaseScaledIndex(cmp, ebx, ecx, edx, 8, 0, i32, 3, 0x3B, 0x1C, 498 0xD1); 499 500 TestRegAddrBaseScaledIndex(cmp, eax, ecx, edx, 1, 0, i16, 4, 0x66, 0x3B, 0x04, 501 0x11); 502 TestRegAddrBaseScaledIndex(cmp, ecx, edx, ebx, 2, 0, i16, 4, 0x66, 0x3B, 0x0C, 503 0x5A); 504 // esp cannot be an scaled index. 505 TestRegAddrBaseScaledIndex(cmp, ebx, esp, ebp, 4, 0, i16, 4, 0x66, 0x3B, 0x1C, 506 0xAC); 507 TestRegAddrBaseScaledIndex(cmp, esp, ebp, esi, 8, 0, i16, 5, 0x66, 0x3B, 0x64, 508 0xF5, 0x00); 509 TestRegAddrBaseScaledIndex(cmp, ebp, esi, edi, 1, 0, i16, 4, 0x66, 0x3B, 0x2C, 510 0x3E); 511 TestRegAddrBaseScaledIndex(cmp, esi, edi, eax, 2, 0, i16, 4, 0x66, 0x3B, 0x34, 512 0x47); 513 TestRegAddrBaseScaledIndex(cmp, edi, eax, ebx, 4, 0, i16, 4, 0x66, 0x3B, 0x3C, 514 0x98); 515 TestRegAddrBaseScaledIndex(cmp, ebx, ecx, edx, 8, 0, i16, 4, 0x66, 0x3B, 0x1C, 516 0xD1); 517 518 TestRegAddrBaseScaledIndex(cmp, eax, ecx, edx, 1, 0, i8, 3, 0x3A, 0x04, 0x11); 519 TestRegAddrBaseScaledIndex(cmp, ecx, edx, ebx, 2, 0, i8, 3, 0x3A, 0x0C, 0x5A); 520 // esp cannot be an scaled index. 521 TestRegAddrBaseScaledIndex(cmp, ebx, esp, ebp, 4, 0, i8, 3, 0x3A, 0x1C, 0xAC); 522 TestRegAddrBaseScaledIndex(cmp, esp, ebp, esi, 8, 0, i8, 4, 0x3A, 0x64, 0xF5, 523 0x00); 524 TestRegAddrBaseScaledIndex(cmp, ebp, esi, edi, 1, 0, i8, 3, 0x3A, 0x2C, 0x3E); 525 TestRegAddrBaseScaledIndex(cmp, esi, edi, eax, 2, 0, i8, 3, 0x3A, 0x34, 0x47); 526 TestRegAddrBaseScaledIndex(cmp, edi, eax, ebx, 4, 0, i8, 3, 0x3A, 0x3C, 0x98); 527 TestRegAddrBaseScaledIndex(cmp, ebx, ecx, edx, 8, 0, i8, 3, 0x3A, 0x1C, 0xD1); 528 529 /* cmp GPR, Imm8(Base,Index,Scale) */ 530 TestRegAddrBaseScaledIndex(cmp, eax, ecx, edx, 1, 0x40, i32, 4, 0x3B, 0x44, 531 0x11, 0x40); 532 TestRegAddrBaseScaledIndex(cmp, ecx, edx, ebx, 2, 0x40, i32, 4, 0x3B, 0x4C, 533 0x5A, 0x40); 534 // esp cannot be an scaled index. 535 TestRegAddrBaseScaledIndex(cmp, ebx, esp, ebp, 4, 0x40, i32, 4, 0x3B, 0x5C, 536 0xAC, 0x40); 537 TestRegAddrBaseScaledIndex(cmp, esp, ebp, esi, 8, 0x40, i32, 4, 0x3B, 0x64, 538 0xF5, 0x40); 539 TestRegAddrBaseScaledIndex(cmp, ebp, esi, edi, 1, 0x40, i32, 4, 0x3B, 0x6C, 540 0x3E, 0x40); 541 TestRegAddrBaseScaledIndex(cmp, esi, edi, eax, 2, 0x40, i32, 4, 0x3B, 0x74, 542 0x47, 0x40); 543 TestRegAddrBaseScaledIndex(cmp, edi, eax, ebx, 4, 0x40, i32, 4, 0x3B, 0x7C, 544 0x98, 0x40); 545 TestRegAddrBaseScaledIndex(cmp, ebx, ecx, edx, 8, 0x40, i32, 4, 0x3B, 0x5C, 546 0xD1, 0x40); 547 548 TestRegAddrBaseScaledIndex(cmp, eax, ecx, edx, 1, 0x40, i16, 5, 0x66, 0x3B, 549 0x44, 0x11, 0x40); 550 TestRegAddrBaseScaledIndex(cmp, ecx, edx, ebx, 2, 0x40, i16, 5, 0x66, 0x3B, 551 0x4C, 0x5A, 0x40); 552 // esp cannot be an scaled index. 553 TestRegAddrBaseScaledIndex(cmp, ebx, esp, ebp, 4, 0x40, i16, 5, 0x66, 0x3B, 554 0x5C, 0xAC, 0x40); 555 TestRegAddrBaseScaledIndex(cmp, esp, ebp, esi, 8, 0x40, i16, 5, 0x66, 0x3B, 556 0x64, 0xF5, 0x40); 557 TestRegAddrBaseScaledIndex(cmp, ebp, esi, edi, 1, 0x40, i16, 5, 0x66, 0x3B, 558 0x6C, 0x3E, 0x40); 559 TestRegAddrBaseScaledIndex(cmp, esi, edi, eax, 2, 0x40, i16, 5, 0x66, 0x3B, 560 0x74, 0x47, 0x40); 561 TestRegAddrBaseScaledIndex(cmp, edi, eax, ebx, 4, 0x40, i16, 5, 0x66, 0x3B, 562 0x7C, 0x98, 0x40); 563 TestRegAddrBaseScaledIndex(cmp, ebx, ecx, edx, 8, 0x40, i16, 5, 0x66, 0x3B, 564 0x5C, 0xD1, 0x40); 565 566 TestRegAddrBaseScaledIndex(cmp, eax, ecx, edx, 1, 0x40, i8, 4, 0x3A, 0x44, 567 0x11, 0x40); 568 TestRegAddrBaseScaledIndex(cmp, ecx, edx, ebx, 2, 0x40, i8, 4, 0x3A, 0x4C, 569 0x5A, 0x40); 570 // esp cannot be an scaled index. 571 TestRegAddrBaseScaledIndex(cmp, ebx, esp, ebp, 4, 0x40, i8, 4, 0x3A, 0x5C, 572 0xAC, 0x40); 573 TestRegAddrBaseScaledIndex(cmp, esp, ebp, esi, 8, 0x40, i8, 4, 0x3A, 0x64, 574 0xF5, 0x40); 575 TestRegAddrBaseScaledIndex(cmp, ebp, esi, edi, 1, 0x40, i8, 4, 0x3A, 0x6C, 576 0x3E, 0x40); 577 TestRegAddrBaseScaledIndex(cmp, esi, edi, eax, 2, 0x40, i8, 4, 0x3A, 0x74, 578 0x47, 0x40); 579 TestRegAddrBaseScaledIndex(cmp, edi, eax, ebx, 4, 0x40, i8, 4, 0x3A, 0x7C, 580 0x98, 0x40); 581 TestRegAddrBaseScaledIndex(cmp, ebx, ecx, edx, 8, 0x40, i8, 4, 0x3A, 0x5C, 582 0xD1, 0x40); 583 584 /* cmp GPR, Imm32(Base,Index,Scale) */ 585 TestRegAddrBaseScaledIndex(cmp, eax, ecx, edx, 1, 0xF0, i32, 7, 0x3B, 0x84, 586 0x11, 0xF0, 0x00, 0x00, 0x00); 587 TestRegAddrBaseScaledIndex(cmp, ecx, edx, ebx, 2, 0xF0, i32, 7, 0x3B, 0x8C, 588 0x5A, 0xF0, 0x00, 0x00, 0x00); 589 // esp cannot be an scaled index. 590 TestRegAddrBaseScaledIndex(cmp, ebx, esp, ebp, 4, 0xF0, i32, 7, 0x3B, 0x9C, 591 0xAC, 0xF0, 0x00, 0x00, 0x00); 592 TestRegAddrBaseScaledIndex(cmp, esp, ebp, esi, 8, 0xF0, i32, 7, 0x3B, 0xA4, 593 0xF5, 0xF0, 0x00, 0x00, 0x00); 594 TestRegAddrBaseScaledIndex(cmp, ebp, esi, edi, 1, 0xF0, i32, 7, 0x3B, 0xAC, 595 0x3E, 0xF0, 0x00, 0x00, 0x00); 596 TestRegAddrBaseScaledIndex(cmp, esi, edi, eax, 2, 0xF0, i32, 7, 0x3B, 0xB4, 597 0x47, 0xF0, 0x00, 0x00, 0x00); 598 TestRegAddrBaseScaledIndex(cmp, edi, eax, ebx, 4, 0xF0, i32, 7, 0x3B, 0xBC, 599 0x98, 0xF0, 0x00, 0x00, 0x00); 600 TestRegAddrBaseScaledIndex(cmp, ebx, ecx, edx, 8, 0xF0, i32, 7, 0x3B, 0x9C, 601 0xD1, 0xF0, 0x00, 0x00, 0x00); 602 603 TestRegAddrBaseScaledIndex(cmp, eax, ecx, edx, 1, 0xF0, i16, 8, 0x66, 0x3B, 604 0x84, 0x11, 0xF0, 0x00, 0x00, 0x00); 605 TestRegAddrBaseScaledIndex(cmp, ecx, edx, ebx, 2, 0xF0, i16, 8, 0x66, 0x3B, 606 0x8C, 0x5A, 0xF0, 0x00, 0x00, 0x00); 607 // esp cannot be an scaled index. 608 TestRegAddrBaseScaledIndex(cmp, ebx, esp, ebp, 4, 0xF0, i16, 8, 0x66, 0x3B, 609 0x9C, 0xAC, 0xF0, 0x00, 0x00, 0x00); 610 TestRegAddrBaseScaledIndex(cmp, esp, ebp, esi, 8, 0xF0, i16, 8, 0x66, 0x3B, 611 0xA4, 0xF5, 0xF0, 0x00, 0x00, 0x00); 612 TestRegAddrBaseScaledIndex(cmp, ebp, esi, edi, 1, 0xF0, i16, 8, 0x66, 0x3B, 613 0xAC, 0x3E, 0xF0, 0x00, 0x00, 0x00); 614 TestRegAddrBaseScaledIndex(cmp, esi, edi, eax, 2, 0xF0, i16, 8, 0x66, 0x3B, 615 0xB4, 0x47, 0xF0, 0x00, 0x00, 0x00); 616 TestRegAddrBaseScaledIndex(cmp, edi, eax, ebx, 4, 0xF0, i16, 8, 0x66, 0x3B, 617 0xBC, 0x98, 0xF0, 0x00, 0x00, 0x00); 618 TestRegAddrBaseScaledIndex(cmp, ebx, ecx, edx, 8, 0xF0, i16, 8, 0x66, 0x3B, 619 0x9C, 0xD1, 0xF0, 0x00, 0x00, 0x00); 620 621 TestRegAddrBaseScaledIndex(cmp, eax, ecx, edx, 1, 0xF0, i8, 7, 0x3A, 0x84, 622 0x11, 0xF0, 0x00, 0x00, 0x00); 623 TestRegAddrBaseScaledIndex(cmp, ecx, edx, ebx, 2, 0xF0, i8, 7, 0x3A, 0x8C, 624 0x5A, 0xF0, 0x00, 0x00, 0x00); 625 // esp cannot be an scaled index. 626 TestRegAddrBaseScaledIndex(cmp, ebx, esp, ebp, 4, 0xF0, i8, 7, 0x3A, 0x9C, 627 0xAC, 0xF0, 0x00, 0x00, 0x00); 628 TestRegAddrBaseScaledIndex(cmp, esp, ebp, esi, 8, 0xF0, i8, 7, 0x3A, 0xA4, 629 0xF5, 0xF0, 0x00, 0x00, 0x00); 630 TestRegAddrBaseScaledIndex(cmp, ebp, esi, edi, 1, 0xF0, i8, 7, 0x3A, 0xAC, 631 0x3E, 0xF0, 0x00, 0x00, 0x00); 632 TestRegAddrBaseScaledIndex(cmp, esi, edi, eax, 2, 0xF0, i8, 7, 0x3A, 0xB4, 633 0x47, 0xF0, 0x00, 0x00, 0x00); 634 TestRegAddrBaseScaledIndex(cmp, edi, eax, ebx, 4, 0xF0, i8, 7, 0x3A, 0xBC, 635 0x98, 0xF0, 0x00, 0x00, 0x00); 636 TestRegAddrBaseScaledIndex(cmp, ebx, ecx, edx, 8, 0xF0, i8, 7, 0x3A, 0x9C, 637 0xD1, 0xF0, 0x00, 0x00, 0x00); 638 639 /* cmp Addr, Imm */ 640 // Note: at this point we trust the assembler knows how to encode addresses, 641 // so no more exhaustive addressing mode testing. 642 TestAddrBaseScaledIndexImm(cmp, eax, ecx, 1, 0xF0, 0x12, i32, 8, 0x83, 0xBC, 643 0x08, 0xF0, 0x00, 0x00, 0x00, 0x12); 644 TestAddrBaseScaledIndexImm(cmp, ecx, edx, 1, 0xF0, 0xF0, i32, 11, 0x81, 0xBC, 645 0x11, 0xF0, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 646 0x00); 647 648 TestAddrBaseScaledIndexImm(cmp, eax, ecx, 1, 0xF0, 0x12, i16, 9, 0x66, 0x83, 649 0xBC, 0x08, 0xF0, 0x00, 0x00, 0x00, 0x12); 650 TestAddrBaseScaledIndexImm(cmp, ecx, edx, 1, 0xF0, 0xF0, i16, 10, 0x66, 0x81, 651 0xBC, 0x11, 0xF0, 0x00, 0x00, 0x00, 0xF0, 0x00); 652 653 TestAddrBaseScaledIndexImm(cmp, eax, ecx, 1, 0xF0, 0x12, i8, 8, 0x80, 0xBC, 654 0x08, 0xF0, 0x00, 0x00, 0x00, 0x12); 655 656 /* cmp Addr, GPR */ 657 TestAddrBaseScaledIndexReg(cmp, eax, ecx, 1, 0xF0, edx, i32, 7, 0x39, 0x94, 658 0x08, 0xF0, 0x00, 0x00, 0x00); 659 660 TestAddrBaseScaledIndexReg(cmp, eax, ecx, 1, 0xF0, edx, i16, 8, 0x66, 0x39, 661 0x94, 0x08, 0xF0, 0x00, 0x00, 0x00); 662 663 TestAddrBaseScaledIndexReg(cmp, eax, ecx, 1, 0xF0, edx, i8, 7, 0x38, 0x94, 664 0x08, 0xF0, 0x00, 0x00, 0x00); 665 666 #undef TestAddrBaseScaledIndexReg 667 #undef TestAddrBaseScaledIndexImm 668 #undef TestRegAddrBaseScaledIndex 669 #undef TestRegAddrScaledIndex 670 #undef TestRegAddrBase 671 #undef TestRegAbsoluteAddr 672 #undef TestRegImm 673 #undef TestRegReg 674 } 675 676 TEST_F(AssemblerX8632Test, ScratchpadGettersAndSetters) { 677 const uint32_t S0 = allocateDword(); 678 const uint32_t S1 = allocateDword(); 679 const uint32_t S2 = allocateDword(); 680 const uint32_t S3 = allocateDword(); 681 AssembledTest test = assemble(); 682 test.setDwordTo(S0, 0xBEEF0000u); 683 test.setDwordTo(S1, 0xDEADu); 684 test.setDwordTo(S2, 0x20406080u); 685 ASSERT_EQ(0xBEEF0000u, test.contentsOfDword(S0)); 686 ASSERT_EQ(0xDEADu, test.contentsOfDword(S1)); 687 ASSERT_EQ(0x20406080u, test.contentsOfDword(S2)); 688 ASSERT_EQ(0xDEADBEEF0000ull, test.contentsOfQword(S0)); 689 ASSERT_EQ(0x204060800000DEADull, test.contentsOfQword(S1)); 690 691 test.setQwordTo(S1, 0x1234567890ABCDEFull); 692 ASSERT_EQ(0x1234567890ABCDEFull, test.contentsOfQword(S1)); 693 test.setDwordTo(S0, 0xBEEF0000u); 694 ASSERT_EQ(0x90ABCDEFull, test.contentsOfDword(S1)); 695 ASSERT_EQ(0x12345678ull, test.contentsOfDword(S2)); 696 697 test.setDwordTo(S0, 1.0f); 698 ASSERT_FLOAT_EQ(1.0f, test.contentsOfDword<float>(S0)); 699 test.setQwordTo(S0, 3.14); 700 ASSERT_DOUBLE_EQ(3.14, test.contentsOfQword<double>(S0)); 701 702 test.setDqwordTo(S0, Dqword(1.0f, 2.0f, 3.0f, 4.0f)); 703 ASSERT_EQ(Dqword(1.0f, 2.0f, 3.0f, 4.0f), test.contentsOfDqword(S0)); 704 EXPECT_FLOAT_EQ(1.0f, test.contentsOfDword<float>(S0)); 705 EXPECT_FLOAT_EQ(2.0f, test.contentsOfDword<float>(S1)); 706 EXPECT_FLOAT_EQ(3.0f, test.contentsOfDword<float>(S2)); 707 EXPECT_FLOAT_EQ(4.0f, test.contentsOfDword<float>(S3)); 708 } 709 710 } // end of anonymous namespace 711 } // end of namespace Test 712 } // end of namespace X8632 713 } // end of namespace Ice 714
