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