1 /* 2 * Copyright (C) 2011 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #include "assembler_x86.h" 18 19 #include "base/arena_allocator.h" 20 #include "base/stl_util.h" 21 #include "utils/assembler_test.h" 22 23 namespace art { 24 25 TEST(AssemblerX86, CreateBuffer) { 26 ArenaPool pool; 27 ArenaAllocator arena(&pool); 28 AssemblerBuffer buffer(&arena); 29 AssemblerBuffer::EnsureCapacity ensured(&buffer); 30 buffer.Emit<uint8_t>(0x42); 31 ASSERT_EQ(static_cast<size_t>(1), buffer.Size()); 32 buffer.Emit<int32_t>(42); 33 ASSERT_EQ(static_cast<size_t>(5), buffer.Size()); 34 } 35 36 class AssemblerX86Test : public AssemblerTest<x86::X86Assembler, x86::Register, 37 x86::XmmRegister, x86::Immediate> { 38 public: 39 typedef AssemblerTest<x86::X86Assembler, x86::Register, 40 x86::XmmRegister, x86::Immediate> Base; 41 42 protected: 43 std::string GetArchitectureString() OVERRIDE { 44 return "x86"; 45 } 46 47 std::string GetAssemblerParameters() OVERRIDE { 48 return " --32"; 49 } 50 51 std::string GetDisassembleParameters() OVERRIDE { 52 return " -D -bbinary -mi386 --no-show-raw-insn"; 53 } 54 55 void SetUpHelpers() OVERRIDE { 56 if (registers_.size() == 0) { 57 registers_.insert(end(registers_), 58 { // NOLINT(whitespace/braces) 59 new x86::Register(x86::EAX), 60 new x86::Register(x86::EBX), 61 new x86::Register(x86::ECX), 62 new x86::Register(x86::EDX), 63 new x86::Register(x86::EBP), 64 new x86::Register(x86::ESP), 65 new x86::Register(x86::ESI), 66 new x86::Register(x86::EDI) 67 }); 68 } 69 70 if (fp_registers_.size() == 0) { 71 fp_registers_.insert(end(fp_registers_), 72 { // NOLINT(whitespace/braces) 73 new x86::XmmRegister(x86::XMM0), 74 new x86::XmmRegister(x86::XMM1), 75 new x86::XmmRegister(x86::XMM2), 76 new x86::XmmRegister(x86::XMM3), 77 new x86::XmmRegister(x86::XMM4), 78 new x86::XmmRegister(x86::XMM5), 79 new x86::XmmRegister(x86::XMM6), 80 new x86::XmmRegister(x86::XMM7) 81 }); 82 } 83 } 84 85 void TearDown() OVERRIDE { 86 AssemblerTest::TearDown(); 87 STLDeleteElements(®isters_); 88 STLDeleteElements(&fp_registers_); 89 } 90 91 std::vector<x86::Register*> GetRegisters() OVERRIDE { 92 return registers_; 93 } 94 95 std::vector<x86::XmmRegister*> GetFPRegisters() OVERRIDE { 96 return fp_registers_; 97 } 98 99 x86::Immediate CreateImmediate(int64_t imm_value) OVERRIDE { 100 return x86::Immediate(imm_value); 101 } 102 103 private: 104 std::vector<x86::Register*> registers_; 105 std::vector<x86::XmmRegister*> fp_registers_; 106 }; 107 108 109 TEST_F(AssemblerX86Test, Movl) { 110 GetAssembler()->movl(x86::EAX, x86::EBX); 111 const char* expected = "mov %ebx, %eax\n"; 112 DriverStr(expected, "movl"); 113 } 114 115 TEST_F(AssemblerX86Test, Movntl) { 116 GetAssembler()->movntl(x86::Address(x86::EDI, x86::EBX, x86::TIMES_4, 12), x86::EAX); 117 GetAssembler()->movntl(x86::Address(x86::EDI, 0), x86::EAX); 118 const char* expected = 119 "movntil %EAX, 0xc(%EDI,%EBX,4)\n" 120 "movntil %EAX, (%EDI)\n"; 121 122 DriverStr(expected, "movntl"); 123 } 124 125 TEST_F(AssemblerX86Test, psrlq) { 126 GetAssembler()->psrlq(x86::XMM0, CreateImmediate(32)); 127 const char* expected = "psrlq $0x20, %xmm0\n"; 128 DriverStr(expected, "psrlq"); 129 } 130 131 TEST_F(AssemblerX86Test, punpckldq) { 132 GetAssembler()->punpckldq(x86::XMM0, x86::XMM1); 133 const char* expected = "punpckldq %xmm1, %xmm0\n"; 134 DriverStr(expected, "punpckldq"); 135 } 136 137 TEST_F(AssemblerX86Test, LoadLongConstant) { 138 GetAssembler()->LoadLongConstant(x86::XMM0, 51); 139 const char* expected = 140 "push $0x0\n" 141 "push $0x33\n" 142 "movsd 0(%esp), %xmm0\n" 143 "add $8, %esp\n"; 144 DriverStr(expected, "LoadLongConstant"); 145 } 146 147 TEST_F(AssemblerX86Test, LockCmpxchgl) { 148 GetAssembler()->LockCmpxchgl(x86::Address( 149 x86::Register(x86::EDI), x86::Register(x86::EBX), x86::TIMES_4, 12), 150 x86::Register(x86::ESI)); 151 GetAssembler()->LockCmpxchgl(x86::Address( 152 x86::Register(x86::EDI), x86::Register(x86::ESI), x86::TIMES_4, 12), 153 x86::Register(x86::ESI)); 154 GetAssembler()->LockCmpxchgl(x86::Address( 155 x86::Register(x86::EDI), x86::Register(x86::ESI), x86::TIMES_4, 12), 156 x86::Register(x86::EDI)); 157 GetAssembler()->LockCmpxchgl(x86::Address( 158 x86::Register(x86::EBP), 0), x86::Register(x86::ESI)); 159 GetAssembler()->LockCmpxchgl(x86::Address( 160 x86::Register(x86::EBP), x86::Register(x86::ESI), x86::TIMES_1, 0), 161 x86::Register(x86::ESI)); 162 const char* expected = 163 "lock cmpxchgl %ESI, 0xc(%EDI,%EBX,4)\n" 164 "lock cmpxchgl %ESI, 0xc(%EDI,%ESI,4)\n" 165 "lock cmpxchgl %EDI, 0xc(%EDI,%ESI,4)\n" 166 "lock cmpxchgl %ESI, (%EBP)\n" 167 "lock cmpxchgl %ESI, (%EBP,%ESI,1)\n"; 168 169 DriverStr(expected, "lock_cmpxchgl"); 170 } 171 172 TEST_F(AssemblerX86Test, LockCmpxchg8b) { 173 GetAssembler()->LockCmpxchg8b(x86::Address( 174 x86::Register(x86::EDI), x86::Register(x86::EBX), x86::TIMES_4, 12)); 175 GetAssembler()->LockCmpxchg8b(x86::Address( 176 x86::Register(x86::EDI), x86::Register(x86::ESI), x86::TIMES_4, 12)); 177 GetAssembler()->LockCmpxchg8b(x86::Address( 178 x86::Register(x86::EDI), x86::Register(x86::ESI), x86::TIMES_4, 12)); 179 GetAssembler()->LockCmpxchg8b(x86::Address(x86::Register(x86::EBP), 0)); 180 GetAssembler()->LockCmpxchg8b(x86::Address( 181 x86::Register(x86::EBP), x86::Register(x86::ESI), x86::TIMES_1, 0)); 182 const char* expected = 183 "lock cmpxchg8b 0xc(%EDI,%EBX,4)\n" 184 "lock cmpxchg8b 0xc(%EDI,%ESI,4)\n" 185 "lock cmpxchg8b 0xc(%EDI,%ESI,4)\n" 186 "lock cmpxchg8b (%EBP)\n" 187 "lock cmpxchg8b (%EBP,%ESI,1)\n"; 188 189 DriverStr(expected, "lock_cmpxchg8b"); 190 } 191 192 TEST_F(AssemblerX86Test, FPUIntegerLoad) { 193 GetAssembler()->filds(x86::Address(x86::Register(x86::ESP), 4)); 194 GetAssembler()->fildl(x86::Address(x86::Register(x86::ESP), 12)); 195 const char* expected = 196 "fildl 0x4(%ESP)\n" 197 "fildll 0xc(%ESP)\n"; 198 DriverStr(expected, "FPUIntegerLoad"); 199 } 200 201 TEST_F(AssemblerX86Test, FPUIntegerStore) { 202 GetAssembler()->fistps(x86::Address(x86::Register(x86::ESP), 16)); 203 GetAssembler()->fistpl(x86::Address(x86::Register(x86::ESP), 24)); 204 const char* expected = 205 "fistpl 0x10(%ESP)\n" 206 "fistpll 0x18(%ESP)\n"; 207 DriverStr(expected, "FPUIntegerStore"); 208 } 209 210 TEST_F(AssemblerX86Test, Repnescasw) { 211 GetAssembler()->repne_scasw(); 212 const char* expected = "repne scasw\n"; 213 DriverStr(expected, "Repnescasw"); 214 } 215 216 TEST_F(AssemblerX86Test, Repecmpsw) { 217 GetAssembler()->repe_cmpsw(); 218 const char* expected = "repe cmpsw\n"; 219 DriverStr(expected, "Repecmpsw"); 220 } 221 222 TEST_F(AssemblerX86Test, Repecmpsl) { 223 GetAssembler()->repe_cmpsl(); 224 const char* expected = "repe cmpsl\n"; 225 DriverStr(expected, "Repecmpsl"); 226 } 227 228 TEST_F(AssemblerX86Test, RepneScasw) { 229 GetAssembler()->repne_scasw(); 230 const char* expected = "repne scasw\n"; 231 DriverStr(expected, "repne_scasw"); 232 } 233 234 TEST_F(AssemblerX86Test, RepMovsw) { 235 GetAssembler()->rep_movsw(); 236 const char* expected = "rep movsw\n"; 237 DriverStr(expected, "rep_movsw"); 238 } 239 240 TEST_F(AssemblerX86Test, Bsfl) { 241 DriverStr(RepeatRR(&x86::X86Assembler::bsfl, "bsfl %{reg2}, %{reg1}"), "bsfl"); 242 } 243 244 TEST_F(AssemblerX86Test, BsflAddress) { 245 GetAssembler()->bsfl(x86::Register(x86::EDI), x86::Address( 246 x86::Register(x86::EDI), x86::Register(x86::EBX), x86::TIMES_4, 12)); 247 const char* expected = 248 "bsfl 0xc(%EDI,%EBX,4), %EDI\n"; 249 250 DriverStr(expected, "bsfl_address"); 251 } 252 253 TEST_F(AssemblerX86Test, Bsrl) { 254 DriverStr(RepeatRR(&x86::X86Assembler::bsrl, "bsrl %{reg2}, %{reg1}"), "bsrl"); 255 } 256 257 TEST_F(AssemblerX86Test, BsrlAddress) { 258 GetAssembler()->bsrl(x86::Register(x86::EDI), x86::Address( 259 x86::Register(x86::EDI), x86::Register(x86::EBX), x86::TIMES_4, 12)); 260 const char* expected = 261 "bsrl 0xc(%EDI,%EBX,4), %EDI\n"; 262 263 DriverStr(expected, "bsrl_address"); 264 } 265 266 TEST_F(AssemblerX86Test, Popcntl) { 267 DriverStr(RepeatRR(&x86::X86Assembler::popcntl, "popcntl %{reg2}, %{reg1}"), "popcntl"); 268 } 269 270 TEST_F(AssemblerX86Test, PopcntlAddress) { 271 GetAssembler()->popcntl(x86::Register(x86::EDI), x86::Address( 272 x86::Register(x86::EDI), x86::Register(x86::EBX), x86::TIMES_4, 12)); 273 const char* expected = 274 "popcntl 0xc(%EDI,%EBX,4), %EDI\n"; 275 276 DriverStr(expected, "popcntl_address"); 277 } 278 279 // Rorl only allows CL as the shift count. 280 std::string rorl_fn(AssemblerX86Test::Base* assembler_test, x86::X86Assembler* assembler) { 281 std::ostringstream str; 282 283 std::vector<x86::Register*> registers = assembler_test->GetRegisters(); 284 285 x86::Register shifter(x86::ECX); 286 for (auto reg : registers) { 287 assembler->rorl(*reg, shifter); 288 str << "rorl %cl, %" << assembler_test->GetRegisterName(*reg) << "\n"; 289 } 290 291 return str.str(); 292 } 293 294 TEST_F(AssemblerX86Test, RorlReg) { 295 DriverFn(&rorl_fn, "rorl"); 296 } 297 298 TEST_F(AssemblerX86Test, RorlImm) { 299 DriverStr(RepeatRI(&x86::X86Assembler::rorl, 1U, "rorl ${imm}, %{reg}"), "rorli"); 300 } 301 302 // Roll only allows CL as the shift count. 303 std::string roll_fn(AssemblerX86Test::Base* assembler_test, x86::X86Assembler* assembler) { 304 std::ostringstream str; 305 306 std::vector<x86::Register*> registers = assembler_test->GetRegisters(); 307 308 x86::Register shifter(x86::ECX); 309 for (auto reg : registers) { 310 assembler->roll(*reg, shifter); 311 str << "roll %cl, %" << assembler_test->GetRegisterName(*reg) << "\n"; 312 } 313 314 return str.str(); 315 } 316 317 TEST_F(AssemblerX86Test, RollReg) { 318 DriverFn(&roll_fn, "roll"); 319 } 320 321 TEST_F(AssemblerX86Test, RollImm) { 322 DriverStr(RepeatRI(&x86::X86Assembler::roll, 1U, "roll ${imm}, %{reg}"), "rolli"); 323 } 324 325 TEST_F(AssemblerX86Test, UComissAddr) { 326 GetAssembler()->ucomiss(x86::XmmRegister(x86::XMM0), x86::Address(x86::EAX, 0)); 327 const char* expected = "ucomiss 0(%EAX), %xmm0\n"; 328 DriverStr(expected, "ucomiss"); 329 } 330 331 TEST_F(AssemblerX86Test, UComisdAddr) { 332 GetAssembler()->ucomisd(x86::XmmRegister(x86::XMM0), x86::Address(x86::EAX, 0)); 333 const char* expected = "ucomisd 0(%EAX), %xmm0\n"; 334 DriverStr(expected, "ucomisd"); 335 } 336 337 338 TEST_F(AssemblerX86Test, CmovlAddress) { 339 GetAssembler()->cmovl(x86::kEqual, x86::Register(x86::EAX), x86::Address( 340 x86::Register(x86::EDI), x86::Register(x86::EBX), x86::TIMES_4, 12)); 341 GetAssembler()->cmovl(x86::kNotEqual, x86::Register(x86::EDI), x86::Address( 342 x86::Register(x86::ESI), x86::Register(x86::EBX), x86::TIMES_4, 12)); 343 GetAssembler()->cmovl(x86::kEqual, x86::Register(x86::EDI), x86::Address( 344 x86::Register(x86::EDI), x86::Register(x86::EAX), x86::TIMES_4, 12)); 345 const char* expected = 346 "cmovzl 0xc(%EDI,%EBX,4), %eax\n" 347 "cmovnzl 0xc(%ESI,%EBX,4), %edi\n" 348 "cmovzl 0xc(%EDI,%EAX,4), %edi\n"; 349 350 DriverStr(expected, "cmovl_address"); 351 } 352 353 ///////////////// 354 // Near labels // 355 ///////////////// 356 357 TEST_F(AssemblerX86Test, Jecxz) { 358 x86::NearLabel target; 359 GetAssembler()->jecxz(&target); 360 GetAssembler()->addl(x86::EDI, x86::Address(x86::ESP, 4)); 361 GetAssembler()->Bind(&target); 362 const char* expected = 363 "jecxz 1f\n" 364 "addl 4(%ESP),%EDI\n" 365 "1:\n"; 366 367 DriverStr(expected, "jecxz"); 368 } 369 370 TEST_F(AssemblerX86Test, NearLabel) { 371 // Test both forward and backward branches. 372 x86::NearLabel start, target; 373 GetAssembler()->Bind(&start); 374 GetAssembler()->j(x86::kEqual, &target); 375 GetAssembler()->jmp(&target); 376 GetAssembler()->jecxz(&target); 377 GetAssembler()->addl(x86::EDI, x86::Address(x86::ESP, 4)); 378 GetAssembler()->Bind(&target); 379 GetAssembler()->j(x86::kNotEqual, &start); 380 GetAssembler()->jmp(&start); 381 const char* expected = 382 "1: je 2f\n" 383 "jmp 2f\n" 384 "jecxz 2f\n" 385 "addl 4(%ESP),%EDI\n" 386 "2: jne 1b\n" 387 "jmp 1b\n"; 388 389 DriverStr(expected, "near_label"); 390 } 391 392 } // namespace art 393
