1 /* 2 * Copyright (C) 2014 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_64.h" 18 19 #include <inttypes.h> 20 #include <map> 21 #include <random> 22 23 #include "base/bit_utils.h" 24 #include "base/stl_util.h" 25 #include "jni_macro_assembler_x86_64.h" 26 #include "utils/assembler_test.h" 27 #include "utils/jni_macro_assembler_test.h" 28 29 namespace art { 30 31 TEST(AssemblerX86_64, CreateBuffer) { 32 ArenaPool pool; 33 ArenaAllocator allocator(&pool); 34 AssemblerBuffer buffer(&allocator); 35 AssemblerBuffer::EnsureCapacity ensured(&buffer); 36 buffer.Emit<uint8_t>(0x42); 37 ASSERT_EQ(static_cast<size_t>(1), buffer.Size()); 38 buffer.Emit<int32_t>(42); 39 ASSERT_EQ(static_cast<size_t>(5), buffer.Size()); 40 } 41 42 #ifdef ART_TARGET_ANDROID 43 static constexpr size_t kRandomIterations = 1000; // Devices might be puny, don't stress them... 44 #else 45 static constexpr size_t kRandomIterations = 100000; // Hosts are pretty powerful. 46 #endif 47 48 TEST(AssemblerX86_64, SignExtension) { 49 // 32bit. 50 for (int32_t i = 0; i < 128; i++) { 51 EXPECT_TRUE(IsInt<8>(i)) << i; 52 } 53 for (int32_t i = 128; i < 255; i++) { 54 EXPECT_FALSE(IsInt<8>(i)) << i; 55 } 56 // Do some higher ones randomly. 57 std::random_device rd; 58 std::default_random_engine e1(rd()); 59 std::uniform_int_distribution<int32_t> uniform_dist(256, INT32_MAX); 60 for (size_t i = 0; i < kRandomIterations; i++) { 61 int32_t value = uniform_dist(e1); 62 EXPECT_FALSE(IsInt<8>(value)) << value; 63 } 64 65 // Negative ones. 66 for (int32_t i = -1; i >= -128; i--) { 67 EXPECT_TRUE(IsInt<8>(i)) << i; 68 } 69 70 for (int32_t i = -129; i > -256; i--) { 71 EXPECT_FALSE(IsInt<8>(i)) << i; 72 } 73 74 // Do some lower ones randomly. 75 std::uniform_int_distribution<int32_t> uniform_dist2(INT32_MIN, -256); 76 for (size_t i = 0; i < 100; i++) { 77 int32_t value = uniform_dist2(e1); 78 EXPECT_FALSE(IsInt<8>(value)) << value; 79 } 80 81 // 64bit. 82 for (int64_t i = 0; i < 128; i++) { 83 EXPECT_TRUE(IsInt<8>(i)) << i; 84 } 85 for (int32_t i = 128; i < 255; i++) { 86 EXPECT_FALSE(IsInt<8>(i)) << i; 87 } 88 // Do some higher ones randomly. 89 std::uniform_int_distribution<int64_t> uniform_dist3(256, INT64_MAX); 90 for (size_t i = 0; i < 100; i++) { 91 int64_t value = uniform_dist3(e1); 92 EXPECT_FALSE(IsInt<8>(value)) << value; 93 } 94 95 // Negative ones. 96 for (int64_t i = -1; i >= -128; i--) { 97 EXPECT_TRUE(IsInt<8>(i)) << i; 98 } 99 100 for (int64_t i = -129; i > -256; i--) { 101 EXPECT_FALSE(IsInt<8>(i)) << i; 102 } 103 104 // Do some lower ones randomly. 105 std::uniform_int_distribution<int64_t> uniform_dist4(INT64_MIN, -256); 106 for (size_t i = 0; i < kRandomIterations; i++) { 107 int64_t value = uniform_dist4(e1); 108 EXPECT_FALSE(IsInt<8>(value)) << value; 109 } 110 111 int64_t value = INT64_C(0x1200000010); 112 x86_64::Immediate imm(value); 113 EXPECT_FALSE(imm.is_int8()); 114 EXPECT_FALSE(imm.is_int16()); 115 EXPECT_FALSE(imm.is_int32()); 116 value = INT64_C(0x8000000000000001); 117 x86_64::Immediate imm2(value); 118 EXPECT_FALSE(imm2.is_int8()); 119 EXPECT_FALSE(imm2.is_int16()); 120 EXPECT_FALSE(imm2.is_int32()); 121 } 122 123 struct X86_64CpuRegisterCompare { 124 bool operator()(const x86_64::CpuRegister& a, const x86_64::CpuRegister& b) const { 125 return a.AsRegister() < b.AsRegister(); 126 } 127 }; 128 129 // 130 // Test fixture. 131 // 132 133 class AssemblerX86_64Test : public AssemblerTest<x86_64::X86_64Assembler, 134 x86_64::Address, 135 x86_64::CpuRegister, 136 x86_64::XmmRegister, 137 x86_64::Immediate> { 138 public: 139 typedef AssemblerTest<x86_64::X86_64Assembler, 140 x86_64::Address, 141 x86_64::CpuRegister, 142 x86_64::XmmRegister, 143 x86_64::Immediate> Base; 144 145 protected: 146 // Get the typically used name for this architecture, e.g., aarch64, x86-64, ... 147 std::string GetArchitectureString() OVERRIDE { 148 return "x86_64"; 149 } 150 151 std::string GetDisassembleParameters() OVERRIDE { 152 return " -D -bbinary -mi386:x86-64 -Mx86-64,addr64,data32 --no-show-raw-insn"; 153 } 154 155 void SetUpHelpers() OVERRIDE { 156 if (addresses_singleton_.size() == 0) { 157 // One addressing mode to test the repeat drivers. 158 addresses_singleton_.push_back( 159 x86_64::Address(x86_64::CpuRegister(x86_64::RAX), 160 x86_64::CpuRegister(x86_64::RBX), x86_64::TIMES_1, -1)); 161 } 162 163 if (addresses_.size() == 0) { 164 // Several addressing modes. 165 addresses_.push_back( 166 x86_64::Address(x86_64::CpuRegister(x86_64::RDI), 167 x86_64::CpuRegister(x86_64::RAX), x86_64::TIMES_1, 15)); 168 addresses_.push_back( 169 x86_64::Address(x86_64::CpuRegister(x86_64::RDI), 170 x86_64::CpuRegister(x86_64::RBX), x86_64::TIMES_2, 16)); 171 addresses_.push_back( 172 x86_64::Address(x86_64::CpuRegister(x86_64::RDI), 173 x86_64::CpuRegister(x86_64::RCX), x86_64::TIMES_4, 17)); 174 addresses_.push_back( 175 x86_64::Address(x86_64::CpuRegister(x86_64::RDI), 176 x86_64::CpuRegister(x86_64::RDX), x86_64::TIMES_8, 18)); 177 addresses_.push_back(x86_64::Address(x86_64::CpuRegister(x86_64::RAX), -1)); 178 addresses_.push_back(x86_64::Address(x86_64::CpuRegister(x86_64::RBX), 0)); 179 addresses_.push_back(x86_64::Address(x86_64::CpuRegister(x86_64::RSI), 1)); 180 addresses_.push_back(x86_64::Address(x86_64::CpuRegister(x86_64::RDI), 987654321)); 181 // Several addressing modes with the special ESP. 182 addresses_.push_back( 183 x86_64::Address(x86_64::CpuRegister(x86_64::RSP), 184 x86_64::CpuRegister(x86_64::RAX), x86_64::TIMES_1, 15)); 185 addresses_.push_back( 186 x86_64::Address(x86_64::CpuRegister(x86_64::RSP), 187 x86_64::CpuRegister(x86_64::RBX), x86_64::TIMES_2, 16)); 188 addresses_.push_back( 189 x86_64::Address(x86_64::CpuRegister(x86_64::RSP), 190 x86_64::CpuRegister(x86_64::RCX), x86_64::TIMES_4, 17)); 191 addresses_.push_back( 192 x86_64::Address(x86_64::CpuRegister(x86_64::RSP), 193 x86_64::CpuRegister(x86_64::RDX), x86_64::TIMES_8, 18)); 194 addresses_.push_back(x86_64::Address(x86_64::CpuRegister(x86_64::RSP), -1)); 195 addresses_.push_back(x86_64::Address(x86_64::CpuRegister(x86_64::RSP), 0)); 196 addresses_.push_back(x86_64::Address(x86_64::CpuRegister(x86_64::RSP), 1)); 197 addresses_.push_back(x86_64::Address(x86_64::CpuRegister(x86_64::RSP), 987654321)); 198 // Several addressing modes with the higher registers. 199 addresses_.push_back( 200 x86_64::Address(x86_64::CpuRegister(x86_64::R8), 201 x86_64::CpuRegister(x86_64::R15), x86_64::TIMES_2, -1)); 202 addresses_.push_back(x86_64::Address(x86_64::CpuRegister(x86_64::R15), 123456789)); 203 } 204 205 if (registers_.size() == 0) { 206 registers_.push_back(new x86_64::CpuRegister(x86_64::RAX)); 207 registers_.push_back(new x86_64::CpuRegister(x86_64::RBX)); 208 registers_.push_back(new x86_64::CpuRegister(x86_64::RCX)); 209 registers_.push_back(new x86_64::CpuRegister(x86_64::RDX)); 210 registers_.push_back(new x86_64::CpuRegister(x86_64::RBP)); 211 registers_.push_back(new x86_64::CpuRegister(x86_64::RSP)); 212 registers_.push_back(new x86_64::CpuRegister(x86_64::RSI)); 213 registers_.push_back(new x86_64::CpuRegister(x86_64::RDI)); 214 registers_.push_back(new x86_64::CpuRegister(x86_64::R8)); 215 registers_.push_back(new x86_64::CpuRegister(x86_64::R9)); 216 registers_.push_back(new x86_64::CpuRegister(x86_64::R10)); 217 registers_.push_back(new x86_64::CpuRegister(x86_64::R11)); 218 registers_.push_back(new x86_64::CpuRegister(x86_64::R12)); 219 registers_.push_back(new x86_64::CpuRegister(x86_64::R13)); 220 registers_.push_back(new x86_64::CpuRegister(x86_64::R14)); 221 registers_.push_back(new x86_64::CpuRegister(x86_64::R15)); 222 223 secondary_register_names_.emplace(x86_64::CpuRegister(x86_64::RAX), "eax"); 224 secondary_register_names_.emplace(x86_64::CpuRegister(x86_64::RBX), "ebx"); 225 secondary_register_names_.emplace(x86_64::CpuRegister(x86_64::RCX), "ecx"); 226 secondary_register_names_.emplace(x86_64::CpuRegister(x86_64::RDX), "edx"); 227 secondary_register_names_.emplace(x86_64::CpuRegister(x86_64::RBP), "ebp"); 228 secondary_register_names_.emplace(x86_64::CpuRegister(x86_64::RSP), "esp"); 229 secondary_register_names_.emplace(x86_64::CpuRegister(x86_64::RSI), "esi"); 230 secondary_register_names_.emplace(x86_64::CpuRegister(x86_64::RDI), "edi"); 231 secondary_register_names_.emplace(x86_64::CpuRegister(x86_64::R8), "r8d"); 232 secondary_register_names_.emplace(x86_64::CpuRegister(x86_64::R9), "r9d"); 233 secondary_register_names_.emplace(x86_64::CpuRegister(x86_64::R10), "r10d"); 234 secondary_register_names_.emplace(x86_64::CpuRegister(x86_64::R11), "r11d"); 235 secondary_register_names_.emplace(x86_64::CpuRegister(x86_64::R12), "r12d"); 236 secondary_register_names_.emplace(x86_64::CpuRegister(x86_64::R13), "r13d"); 237 secondary_register_names_.emplace(x86_64::CpuRegister(x86_64::R14), "r14d"); 238 secondary_register_names_.emplace(x86_64::CpuRegister(x86_64::R15), "r15d"); 239 240 tertiary_register_names_.emplace(x86_64::CpuRegister(x86_64::RAX), "ax"); 241 tertiary_register_names_.emplace(x86_64::CpuRegister(x86_64::RBX), "bx"); 242 tertiary_register_names_.emplace(x86_64::CpuRegister(x86_64::RCX), "cx"); 243 tertiary_register_names_.emplace(x86_64::CpuRegister(x86_64::RDX), "dx"); 244 tertiary_register_names_.emplace(x86_64::CpuRegister(x86_64::RBP), "bp"); 245 tertiary_register_names_.emplace(x86_64::CpuRegister(x86_64::RSP), "sp"); 246 tertiary_register_names_.emplace(x86_64::CpuRegister(x86_64::RSI), "si"); 247 tertiary_register_names_.emplace(x86_64::CpuRegister(x86_64::RDI), "di"); 248 tertiary_register_names_.emplace(x86_64::CpuRegister(x86_64::R8), "r8w"); 249 tertiary_register_names_.emplace(x86_64::CpuRegister(x86_64::R9), "r9w"); 250 tertiary_register_names_.emplace(x86_64::CpuRegister(x86_64::R10), "r10w"); 251 tertiary_register_names_.emplace(x86_64::CpuRegister(x86_64::R11), "r11w"); 252 tertiary_register_names_.emplace(x86_64::CpuRegister(x86_64::R12), "r12w"); 253 tertiary_register_names_.emplace(x86_64::CpuRegister(x86_64::R13), "r13w"); 254 tertiary_register_names_.emplace(x86_64::CpuRegister(x86_64::R14), "r14w"); 255 tertiary_register_names_.emplace(x86_64::CpuRegister(x86_64::R15), "r15w"); 256 257 quaternary_register_names_.emplace(x86_64::CpuRegister(x86_64::RAX), "al"); 258 quaternary_register_names_.emplace(x86_64::CpuRegister(x86_64::RBX), "bl"); 259 quaternary_register_names_.emplace(x86_64::CpuRegister(x86_64::RCX), "cl"); 260 quaternary_register_names_.emplace(x86_64::CpuRegister(x86_64::RDX), "dl"); 261 quaternary_register_names_.emplace(x86_64::CpuRegister(x86_64::RBP), "bpl"); 262 quaternary_register_names_.emplace(x86_64::CpuRegister(x86_64::RSP), "spl"); 263 quaternary_register_names_.emplace(x86_64::CpuRegister(x86_64::RSI), "sil"); 264 quaternary_register_names_.emplace(x86_64::CpuRegister(x86_64::RDI), "dil"); 265 quaternary_register_names_.emplace(x86_64::CpuRegister(x86_64::R8), "r8b"); 266 quaternary_register_names_.emplace(x86_64::CpuRegister(x86_64::R9), "r9b"); 267 quaternary_register_names_.emplace(x86_64::CpuRegister(x86_64::R10), "r10b"); 268 quaternary_register_names_.emplace(x86_64::CpuRegister(x86_64::R11), "r11b"); 269 quaternary_register_names_.emplace(x86_64::CpuRegister(x86_64::R12), "r12b"); 270 quaternary_register_names_.emplace(x86_64::CpuRegister(x86_64::R13), "r13b"); 271 quaternary_register_names_.emplace(x86_64::CpuRegister(x86_64::R14), "r14b"); 272 quaternary_register_names_.emplace(x86_64::CpuRegister(x86_64::R15), "r15b"); 273 274 fp_registers_.push_back(new x86_64::XmmRegister(x86_64::XMM0)); 275 fp_registers_.push_back(new x86_64::XmmRegister(x86_64::XMM1)); 276 fp_registers_.push_back(new x86_64::XmmRegister(x86_64::XMM2)); 277 fp_registers_.push_back(new x86_64::XmmRegister(x86_64::XMM3)); 278 fp_registers_.push_back(new x86_64::XmmRegister(x86_64::XMM4)); 279 fp_registers_.push_back(new x86_64::XmmRegister(x86_64::XMM5)); 280 fp_registers_.push_back(new x86_64::XmmRegister(x86_64::XMM6)); 281 fp_registers_.push_back(new x86_64::XmmRegister(x86_64::XMM7)); 282 fp_registers_.push_back(new x86_64::XmmRegister(x86_64::XMM8)); 283 fp_registers_.push_back(new x86_64::XmmRegister(x86_64::XMM9)); 284 fp_registers_.push_back(new x86_64::XmmRegister(x86_64::XMM10)); 285 fp_registers_.push_back(new x86_64::XmmRegister(x86_64::XMM11)); 286 fp_registers_.push_back(new x86_64::XmmRegister(x86_64::XMM12)); 287 fp_registers_.push_back(new x86_64::XmmRegister(x86_64::XMM13)); 288 fp_registers_.push_back(new x86_64::XmmRegister(x86_64::XMM14)); 289 fp_registers_.push_back(new x86_64::XmmRegister(x86_64::XMM15)); 290 } 291 } 292 293 void TearDown() OVERRIDE { 294 AssemblerTest::TearDown(); 295 STLDeleteElements(®isters_); 296 STLDeleteElements(&fp_registers_); 297 } 298 299 std::vector<x86_64::Address> GetAddresses() { 300 return addresses_; 301 } 302 303 std::vector<x86_64::CpuRegister*> GetRegisters() OVERRIDE { 304 return registers_; 305 } 306 307 std::vector<x86_64::XmmRegister*> GetFPRegisters() OVERRIDE { 308 return fp_registers_; 309 } 310 311 x86_64::Immediate CreateImmediate(int64_t imm_value) OVERRIDE { 312 return x86_64::Immediate(imm_value); 313 } 314 315 std::string GetSecondaryRegisterName(const x86_64::CpuRegister& reg) OVERRIDE { 316 CHECK(secondary_register_names_.find(reg) != secondary_register_names_.end()); 317 return secondary_register_names_[reg]; 318 } 319 320 std::string GetTertiaryRegisterName(const x86_64::CpuRegister& reg) OVERRIDE { 321 CHECK(tertiary_register_names_.find(reg) != tertiary_register_names_.end()); 322 return tertiary_register_names_[reg]; 323 } 324 325 std::string GetQuaternaryRegisterName(const x86_64::CpuRegister& reg) OVERRIDE { 326 CHECK(quaternary_register_names_.find(reg) != quaternary_register_names_.end()); 327 return quaternary_register_names_[reg]; 328 } 329 330 std::vector<x86_64::Address> addresses_singleton_; 331 332 private: 333 std::vector<x86_64::Address> addresses_; 334 std::vector<x86_64::CpuRegister*> registers_; 335 std::map<x86_64::CpuRegister, std::string, X86_64CpuRegisterCompare> secondary_register_names_; 336 std::map<x86_64::CpuRegister, std::string, X86_64CpuRegisterCompare> tertiary_register_names_; 337 std::map<x86_64::CpuRegister, std::string, X86_64CpuRegisterCompare> quaternary_register_names_; 338 std::vector<x86_64::XmmRegister*> fp_registers_; 339 }; 340 341 // 342 // Test some repeat drivers used in the tests. 343 // 344 345 TEST_F(AssemblerX86_64Test, RepeatI4) { 346 EXPECT_EQ("$0\n$-1\n$18\n$4660\n$-4660\n$305419896\n$-305419896\n", 347 RepeatI(/*f*/ nullptr, /*imm_bytes*/ 4U, "${imm}")); 348 } 349 350 TEST_F(AssemblerX86_64Test, RepeatI8) { 351 EXPECT_EQ("$0\n$-1\n$18\n$4660\n$-4660\n$305419896\n$-305419896\n" 352 "$20015998343868\n$-20015998343868\n$1311768467463790320\n" 353 "$-1311768467463790320\n", 354 RepeatI(/*f*/ nullptr, /*imm_bytes*/ 8U, "${imm}")); 355 } 356 357 TEST_F(AssemblerX86_64Test, Repeatr) { 358 EXPECT_EQ("%eax\n%ebx\n%ecx\n%edx\n%ebp\n%esp\n%esi\n%edi\n" 359 "%r8d\n%r9d\n%r10d\n%r11d\n%r12d\n%r13d\n%r14d\n%r15d\n", 360 Repeatr(/*f*/ nullptr, "%{reg}")); 361 } 362 363 TEST_F(AssemblerX86_64Test, RepeatrI) { 364 EXPECT_NE(RepeatrI(/*f*/ nullptr, /*imm_bytes*/ 1U, "%{reg} ${imm}"). 365 find("%eax $0\n%eax $-1\n%eax $18\n%ebx $0\n%ebx $-1\n%ebx $18\n" 366 "%ecx $0\n%ecx $-1\n%ecx $18\n%edx $0\n%edx $-1\n%edx $18\n"), 367 std::string::npos); 368 } 369 370 TEST_F(AssemblerX86_64Test, Repeatrr) { 371 EXPECT_NE(Repeatrr(/*f*/ nullptr, "%{reg1} %{reg2}") 372 .find("%eax %eax\n%eax %ebx\n%eax %ecx\n%eax %edx\n" 373 "%eax %ebp\n%eax %esp\n%eax %esi\n%eax %edi\n"), 374 std::string::npos); 375 } 376 377 TEST_F(AssemblerX86_64Test, Repeatrb) { 378 EXPECT_NE(Repeatrb(/*f*/ nullptr, "%{reg1} %{reg2}"). 379 find("%eax %al\n%eax %bl\n%eax %cl\n%eax %dl\n%eax %bpl\n" 380 "%eax %spl\n%eax %sil\n%eax %dil\n%eax %r8b\n%eax %r9b\n"), 381 std::string::npos); 382 } 383 384 TEST_F(AssemblerX86_64Test, RepeatrF) { 385 EXPECT_NE(RepeatrF(/*f*/ nullptr, "%{reg1} %{reg2}") 386 .find("%eax %xmm0\n%eax %xmm1\n%eax %xmm2\n%eax %xmm3\n" 387 "%eax %xmm4\n%eax %xmm5\n%eax %xmm6\n%eax %xmm7\n"), 388 std::string::npos); 389 } 390 391 TEST_F(AssemblerX86_64Test, RepeatR) { 392 EXPECT_EQ("%rax\n%rbx\n%rcx\n%rdx\n%rbp\n%rsp\n%rsi\n%rdi\n" 393 "%r8\n%r9\n%r10\n%r11\n%r12\n%r13\n%r14\n%r15\n", 394 RepeatR(/*f*/ nullptr, "%{reg}")); 395 } 396 397 TEST_F(AssemblerX86_64Test, RepeatRI) { 398 EXPECT_NE(RepeatRI(/*f*/ nullptr, /*imm_bytes*/ 1U, "%{reg} ${imm}") 399 .find("%rax $0\n%rax $-1\n%rax $18\n%rbx $0\n%rbx $-1\n%rbx $18\n" 400 "%rcx $0\n%rcx $-1\n%rcx $18\n%rdx $0\n%rdx $-1\n%rdx $18\n"), 401 std::string::npos); 402 } 403 404 TEST_F(AssemblerX86_64Test, RepeatRr) { 405 EXPECT_NE(RepeatRr(/*f*/ nullptr, "%{reg1} %{reg2}") 406 .find("%rax %eax\n%rax %ebx\n%rax %ecx\n%rax %edx\n%rax %ebp\n" 407 "%rax %esp\n%rax %esi\n%rax %edi\n%rax %r8d\n%rax %r9d\n"), 408 std::string::npos); 409 } 410 411 TEST_F(AssemblerX86_64Test, RepeatRR) { 412 EXPECT_NE(RepeatRR(/*f*/ nullptr, "%{reg1} %{reg2}") 413 .find("%rax %rax\n%rax %rbx\n%rax %rcx\n%rax %rdx\n%rax %rbp\n" 414 "%rax %rsp\n%rax %rsi\n%rax %rdi\n%rax %r8\n%rax %r9\n"), 415 std::string::npos); 416 } 417 418 TEST_F(AssemblerX86_64Test, RepeatRF) { 419 EXPECT_NE(RepeatRF(/*f*/ nullptr, "%{reg1} %{reg2}") 420 .find("%rax %xmm0\n%rax %xmm1\n%rax %xmm2\n%rax %xmm3\n%rax %xmm4\n" 421 "%rax %xmm5\n%rax %xmm6\n%rax %xmm7\n%rax %xmm8\n%rax %xmm9\n"), 422 std::string::npos); 423 } 424 425 TEST_F(AssemblerX86_64Test, RepeatFF) { 426 EXPECT_NE(RepeatFF(/*f*/ nullptr, "%{reg1} %{reg2}") 427 .find("%xmm0 %xmm0\n%xmm0 %xmm1\n%xmm0 %xmm2\n%xmm0 %xmm3\n%xmm0 %xmm4\n" 428 "%xmm0 %xmm5\n%xmm0 %xmm6\n%xmm0 %xmm7\n%xmm0 %xmm8\n%xmm0 %xmm9\n"), 429 std::string::npos); 430 } 431 432 TEST_F(AssemblerX86_64Test, RepeatFFI) { 433 EXPECT_NE(RepeatFFI(/*f*/ nullptr, /*imm_bytes*/ 1U, "%{reg1} %{reg2} ${imm}") 434 .find("%xmm0 %xmm0 $0\n%xmm0 %xmm0 $-1\n%xmm0 %xmm0 $18\n" 435 "%xmm0 %xmm1 $0\n%xmm0 %xmm1 $-1\n%xmm0 %xmm1 $18\n"), 436 std::string::npos); 437 } 438 439 TEST_F(AssemblerX86_64Test, RepeatA) { 440 EXPECT_EQ("-1(%rax,%rbx,1)\n", RepeatA(/*f*/ nullptr, addresses_singleton_, "{mem}")); 441 } 442 443 TEST_F(AssemblerX86_64Test, RepeatAFull) { 444 EXPECT_EQ("15(%rdi,%rax,1)\n16(%rdi,%rbx,2)\n17(%rdi,%rcx,4)\n18(%rdi,%rdx,8)\n" 445 "-1(%rax)\n(%rbx)\n1(%rsi)\n987654321(%rdi)\n15(%rsp,%rax,1)\n" 446 "16(%rsp,%rbx,2)\n17(%rsp,%rcx,4)\n18(%rsp,%rdx,8)\n-1(%rsp)\n" 447 "(%rsp)\n1(%rsp)\n987654321(%rsp)\n-1(%r8,%r15,2)\n123456789(%r15)\n", 448 RepeatA(/*f*/ nullptr, "{mem}")); 449 } 450 451 TEST_F(AssemblerX86_64Test, RepeatAI) { 452 EXPECT_EQ("-1(%rax,%rbx,1) $0\n-1(%rax,%rbx,1) $-1\n-1(%rax,%rbx,1) $18\n", 453 RepeatAI(/*f*/ nullptr, /*imm_bytes*/ 1U, addresses_singleton_, "{mem} ${imm}")); 454 } 455 456 TEST_F(AssemblerX86_64Test, RepeatRA) { 457 EXPECT_NE(RepeatRA(/*f*/ nullptr, addresses_singleton_, "%{reg} {mem}") 458 .find("%rax -1(%rax,%rbx,1)\n%rbx -1(%rax,%rbx,1)\n%rcx -1(%rax,%rbx,1)\n" 459 "%rdx -1(%rax,%rbx,1)\n%rbp -1(%rax,%rbx,1)\n%rsp -1(%rax,%rbx,1)\n"), 460 std::string::npos); 461 } 462 463 TEST_F(AssemblerX86_64Test, RepeatrA) { 464 EXPECT_NE(RepeatrA(/*f*/ nullptr, addresses_singleton_, "%{reg} {mem}") 465 .find("%eax -1(%rax,%rbx,1)\n%ebx -1(%rax,%rbx,1)\n%ecx -1(%rax,%rbx,1)\n" 466 "%edx -1(%rax,%rbx,1)\n%ebp -1(%rax,%rbx,1)\n%esp -1(%rax,%rbx,1)\n"), 467 std::string::npos); 468 } 469 470 TEST_F(AssemblerX86_64Test, RepeatAR) { 471 EXPECT_NE(RepeatAR(/*f*/ nullptr, addresses_singleton_, "{mem} %{reg}") 472 .find("-1(%rax,%rbx,1) %rax\n-1(%rax,%rbx,1) %rbx\n-1(%rax,%rbx,1) %rcx\n" 473 "-1(%rax,%rbx,1) %rdx\n-1(%rax,%rbx,1) %rbp\n-1(%rax,%rbx,1) %rsp\n"), 474 std::string::npos); 475 } 476 477 TEST_F(AssemblerX86_64Test, RepeatAr) { 478 EXPECT_NE(RepeatAr(/*f*/ nullptr, addresses_singleton_, "{mem} %{reg}") 479 .find("-1(%rax,%rbx,1) %eax\n-1(%rax,%rbx,1) %ebx\n-1(%rax,%rbx,1) %ecx\n" 480 "-1(%rax,%rbx,1) %edx\n-1(%rax,%rbx,1) %ebp\n-1(%rax,%rbx,1) %esp\n"), 481 std::string::npos); 482 } 483 484 TEST_F(AssemblerX86_64Test, RepeatFA) { 485 EXPECT_NE(RepeatFA(/*f*/ nullptr, addresses_singleton_, "%{reg} {mem}"). 486 find("%xmm0 -1(%rax,%rbx,1)\n%xmm1 -1(%rax,%rbx,1)\n%xmm2 -1(%rax,%rbx,1)\n" 487 "%xmm3 -1(%rax,%rbx,1)\n%xmm4 -1(%rax,%rbx,1)\n%xmm5 -1(%rax,%rbx,1)\n"), 488 std::string::npos); 489 } 490 491 TEST_F(AssemblerX86_64Test, RepeatAF) { 492 EXPECT_NE(RepeatAF(/*f*/ nullptr, addresses_singleton_, "{mem} %{reg}") 493 .find("-1(%rax,%rbx,1) %xmm0\n-1(%rax,%rbx,1) %xmm1\n-1(%rax,%rbx,1) %xmm2\n" 494 "-1(%rax,%rbx,1) %xmm3\n-1(%rax,%rbx,1) %xmm4\n-1(%rax,%rbx,1) %xmm5\n"), 495 std::string::npos); 496 } 497 498 // 499 // Actual x86-64 instruction assembler tests. 500 // 501 502 TEST_F(AssemblerX86_64Test, Toolchain) { 503 EXPECT_TRUE(CheckTools()); 504 } 505 506 TEST_F(AssemblerX86_64Test, PopqAllAddresses) { 507 // Make sure all addressing modes combinations are tested at least once. 508 std::vector<x86_64::Address> all_addresses; 509 for (x86_64::CpuRegister* base : GetRegisters()) { 510 // Base only. 511 all_addresses.push_back(x86_64::Address(*base, -1)); 512 all_addresses.push_back(x86_64::Address(*base, 0)); 513 all_addresses.push_back(x86_64::Address(*base, 1)); 514 all_addresses.push_back(x86_64::Address(*base, 123456789)); 515 for (x86_64::CpuRegister* index : GetRegisters()) { 516 if (index->AsRegister() == x86_64::RSP) { 517 // Index cannot be RSP. 518 continue; 519 } else if (base->AsRegister() == index->AsRegister()) { 520 // Index only. 521 all_addresses.push_back(x86_64::Address(*index, x86_64::TIMES_1, -1)); 522 all_addresses.push_back(x86_64::Address(*index, x86_64::TIMES_2, 0)); 523 all_addresses.push_back(x86_64::Address(*index, x86_64::TIMES_4, 1)); 524 all_addresses.push_back(x86_64::Address(*index, x86_64::TIMES_8, 123456789)); 525 } 526 // Base and index. 527 all_addresses.push_back(x86_64::Address(*base, *index, x86_64::TIMES_1, -1)); 528 all_addresses.push_back(x86_64::Address(*base, *index, x86_64::TIMES_2, 0)); 529 all_addresses.push_back(x86_64::Address(*base, *index, x86_64::TIMES_4, 1)); 530 all_addresses.push_back(x86_64::Address(*base, *index, x86_64::TIMES_8, 123456789)); 531 } 532 } 533 DriverStr(RepeatA(&x86_64::X86_64Assembler::popq, all_addresses, "popq {mem}"), "popq"); 534 } 535 536 TEST_F(AssemblerX86_64Test, PushqRegs) { 537 DriverStr(RepeatR(&x86_64::X86_64Assembler::pushq, "pushq %{reg}"), "pushq"); 538 } 539 540 TEST_F(AssemblerX86_64Test, PushqImm) { 541 DriverStr(RepeatI(&x86_64::X86_64Assembler::pushq, /*imm_bytes*/ 4U, 542 "pushq ${imm}"), "pushqi"); 543 } 544 545 TEST_F(AssemblerX86_64Test, MovqRegs) { 546 DriverStr(RepeatRR(&x86_64::X86_64Assembler::movq, "movq %{reg2}, %{reg1}"), "movq"); 547 } 548 549 TEST_F(AssemblerX86_64Test, MovqImm) { 550 DriverStr(RepeatRI(&x86_64::X86_64Assembler::movq, /*imm_bytes*/ 8U, 551 "movq ${imm}, %{reg}"), "movqi"); 552 } 553 554 TEST_F(AssemblerX86_64Test, MovlRegs) { 555 DriverStr(Repeatrr(&x86_64::X86_64Assembler::movl, "mov %{reg2}, %{reg1}"), "movl"); 556 } 557 558 TEST_F(AssemblerX86_64Test, MovlImm) { 559 DriverStr(RepeatrI(&x86_64::X86_64Assembler::movl, /*imm_bytes*/ 4U, 560 "mov ${imm}, %{reg}"), "movli"); 561 } 562 563 TEST_F(AssemblerX86_64Test, AddqRegs) { 564 DriverStr(RepeatRR(&x86_64::X86_64Assembler::addq, "addq %{reg2}, %{reg1}"), "addq"); 565 } 566 567 TEST_F(AssemblerX86_64Test, AddqImm) { 568 DriverStr(RepeatRI(&x86_64::X86_64Assembler::addq, /*imm_bytes*/ 4U, 569 "addq ${imm}, %{reg}"), "addqi"); 570 } 571 572 TEST_F(AssemblerX86_64Test, AddlRegs) { 573 DriverStr(Repeatrr(&x86_64::X86_64Assembler::addl, "add %{reg2}, %{reg1}"), "addl"); 574 } 575 576 TEST_F(AssemblerX86_64Test, AddlImm) { 577 DriverStr(RepeatrI(&x86_64::X86_64Assembler::addl, /*imm_bytes*/ 4U, 578 "add ${imm}, %{reg}"), "addli"); 579 } 580 581 TEST_F(AssemblerX86_64Test, Addw) { 582 DriverStr( 583 RepeatAI(&x86_64::X86_64Assembler::addw, /*imm_bytes*/2U, "addw ${imm}, {mem}"), "addw"); 584 } 585 586 TEST_F(AssemblerX86_64Test, ImulqReg1) { 587 DriverStr(RepeatR(&x86_64::X86_64Assembler::imulq, "imulq %{reg}"), "imulq"); 588 } 589 590 TEST_F(AssemblerX86_64Test, ImulqRegs) { 591 DriverStr(RepeatRR(&x86_64::X86_64Assembler::imulq, "imulq %{reg2}, %{reg1}"), "imulq"); 592 } 593 594 TEST_F(AssemblerX86_64Test, ImulqImm) { 595 DriverStr(RepeatRI(&x86_64::X86_64Assembler::imulq, /*imm_bytes*/ 4U, 596 "imulq ${imm}, %{reg}, %{reg}"), 597 "imulqi"); 598 } 599 600 TEST_F(AssemblerX86_64Test, ImullRegs) { 601 DriverStr(Repeatrr(&x86_64::X86_64Assembler::imull, "imul %{reg2}, %{reg1}"), "imull"); 602 } 603 604 TEST_F(AssemblerX86_64Test, ImullImm) { 605 DriverStr(RepeatrI(&x86_64::X86_64Assembler::imull, /*imm_bytes*/ 4U, 606 "imull ${imm}, %{reg}, %{reg}"), 607 "imulli"); 608 } 609 610 TEST_F(AssemblerX86_64Test, Mull) { 611 DriverStr(Repeatr(&x86_64::X86_64Assembler::mull, "mull %{reg}"), "mull"); 612 } 613 614 TEST_F(AssemblerX86_64Test, SubqRegs) { 615 DriverStr(RepeatRR(&x86_64::X86_64Assembler::subq, "subq %{reg2}, %{reg1}"), "subq"); 616 } 617 618 TEST_F(AssemblerX86_64Test, SubqImm) { 619 DriverStr(RepeatRI(&x86_64::X86_64Assembler::subq, /*imm_bytes*/ 4U, 620 "subq ${imm}, %{reg}"), "subqi"); 621 } 622 623 TEST_F(AssemblerX86_64Test, SublRegs) { 624 DriverStr(Repeatrr(&x86_64::X86_64Assembler::subl, "sub %{reg2}, %{reg1}"), "subl"); 625 } 626 627 TEST_F(AssemblerX86_64Test, SublImm) { 628 DriverStr(RepeatrI(&x86_64::X86_64Assembler::subl, /*imm_bytes*/ 4U, 629 "sub ${imm}, %{reg}"), "subli"); 630 } 631 632 // Shll only allows CL as the shift count. 633 std::string shll_fn(AssemblerX86_64Test::Base* assembler_test, x86_64::X86_64Assembler* assembler) { 634 std::ostringstream str; 635 std::vector<x86_64::CpuRegister*> registers = assembler_test->GetRegisters(); 636 x86_64::CpuRegister shifter(x86_64::RCX); 637 for (auto reg : registers) { 638 assembler->shll(*reg, shifter); 639 str << "shll %cl, %" << assembler_test->GetSecondaryRegisterName(*reg) << "\n"; 640 } 641 return str.str(); 642 } 643 644 TEST_F(AssemblerX86_64Test, ShllReg) { 645 DriverFn(&shll_fn, "shll"); 646 } 647 648 TEST_F(AssemblerX86_64Test, ShllImm) { 649 DriverStr(RepeatrI(&x86_64::X86_64Assembler::shll, /*imm_bytes*/ 1U, 650 "shll ${imm}, %{reg}"), "shlli"); 651 } 652 653 // Shlq only allows CL as the shift count. 654 std::string shlq_fn(AssemblerX86_64Test::Base* assembler_test, x86_64::X86_64Assembler* assembler) { 655 std::ostringstream str; 656 std::vector<x86_64::CpuRegister*> registers = assembler_test->GetRegisters(); 657 x86_64::CpuRegister shifter(x86_64::RCX); 658 for (auto reg : registers) { 659 assembler->shlq(*reg, shifter); 660 str << "shlq %cl, %" << assembler_test->GetRegisterName(*reg) << "\n"; 661 } 662 return str.str(); 663 } 664 665 TEST_F(AssemblerX86_64Test, ShlqReg) { 666 DriverFn(&shlq_fn, "shlq"); 667 } 668 669 TEST_F(AssemblerX86_64Test, ShlqImm) { 670 DriverStr(RepeatRI(&x86_64::X86_64Assembler::shlq, /*imm_bytes*/ 1U, 671 "shlq ${imm}, %{reg}"), "shlqi"); 672 } 673 674 // Shrl only allows CL as the shift count. 675 std::string shrl_fn(AssemblerX86_64Test::Base* assembler_test, x86_64::X86_64Assembler* assembler) { 676 std::ostringstream str; 677 std::vector<x86_64::CpuRegister*> registers = assembler_test->GetRegisters(); 678 x86_64::CpuRegister shifter(x86_64::RCX); 679 for (auto reg : registers) { 680 assembler->shrl(*reg, shifter); 681 str << "shrl %cl, %" << assembler_test->GetSecondaryRegisterName(*reg) << "\n"; 682 } 683 return str.str(); 684 } 685 686 TEST_F(AssemblerX86_64Test, ShrlReg) { 687 DriverFn(&shrl_fn, "shrl"); 688 } 689 690 TEST_F(AssemblerX86_64Test, ShrlImm) { 691 DriverStr(RepeatrI(&x86_64::X86_64Assembler::shrl, /*imm_bytes*/ 1U, "shrl ${imm}, %{reg}"), "shrli"); 692 } 693 694 // Shrq only allows CL as the shift count. 695 std::string shrq_fn(AssemblerX86_64Test::Base* assembler_test, x86_64::X86_64Assembler* assembler) { 696 std::ostringstream str; 697 std::vector<x86_64::CpuRegister*> registers = assembler_test->GetRegisters(); 698 x86_64::CpuRegister shifter(x86_64::RCX); 699 for (auto reg : registers) { 700 assembler->shrq(*reg, shifter); 701 str << "shrq %cl, %" << assembler_test->GetRegisterName(*reg) << "\n"; 702 } 703 return str.str(); 704 } 705 706 TEST_F(AssemblerX86_64Test, ShrqReg) { 707 DriverFn(&shrq_fn, "shrq"); 708 } 709 710 TEST_F(AssemblerX86_64Test, ShrqImm) { 711 DriverStr(RepeatRI(&x86_64::X86_64Assembler::shrq, /*imm_bytes*/ 1U, "shrq ${imm}, %{reg}"), "shrqi"); 712 } 713 714 // Sarl only allows CL as the shift count. 715 std::string sarl_fn(AssemblerX86_64Test::Base* assembler_test, x86_64::X86_64Assembler* assembler) { 716 std::ostringstream str; 717 std::vector<x86_64::CpuRegister*> registers = assembler_test->GetRegisters(); 718 x86_64::CpuRegister shifter(x86_64::RCX); 719 for (auto reg : registers) { 720 assembler->sarl(*reg, shifter); 721 str << "sarl %cl, %" << assembler_test->GetSecondaryRegisterName(*reg) << "\n"; 722 } 723 return str.str(); 724 } 725 726 TEST_F(AssemblerX86_64Test, SarlReg) { 727 DriverFn(&sarl_fn, "sarl"); 728 } 729 730 TEST_F(AssemblerX86_64Test, SarlImm) { 731 DriverStr(RepeatrI(&x86_64::X86_64Assembler::sarl, /*imm_bytes*/ 1U, "sarl ${imm}, %{reg}"), "sarli"); 732 } 733 734 // Sarq only allows CL as the shift count. 735 std::string sarq_fn(AssemblerX86_64Test::Base* assembler_test, x86_64::X86_64Assembler* assembler) { 736 std::ostringstream str; 737 std::vector<x86_64::CpuRegister*> registers = assembler_test->GetRegisters(); 738 x86_64::CpuRegister shifter(x86_64::RCX); 739 for (auto reg : registers) { 740 assembler->sarq(*reg, shifter); 741 str << "sarq %cl, %" << assembler_test->GetRegisterName(*reg) << "\n"; 742 } 743 return str.str(); 744 } 745 746 TEST_F(AssemblerX86_64Test, SarqReg) { 747 DriverFn(&sarq_fn, "sarq"); 748 } 749 750 TEST_F(AssemblerX86_64Test, SarqImm) { 751 DriverStr(RepeatRI(&x86_64::X86_64Assembler::sarq, /*imm_bytes*/ 1U, "sarq ${imm}, %{reg}"), "sarqi"); 752 } 753 754 // Rorl only allows CL as the shift count. 755 std::string rorl_fn(AssemblerX86_64Test::Base* assembler_test, x86_64::X86_64Assembler* assembler) { 756 std::ostringstream str; 757 std::vector<x86_64::CpuRegister*> registers = assembler_test->GetRegisters(); 758 x86_64::CpuRegister shifter(x86_64::RCX); 759 for (auto reg : registers) { 760 assembler->rorl(*reg, shifter); 761 str << "rorl %cl, %" << assembler_test->GetSecondaryRegisterName(*reg) << "\n"; 762 } 763 return str.str(); 764 } 765 766 TEST_F(AssemblerX86_64Test, RorlReg) { 767 DriverFn(&rorl_fn, "rorl"); 768 } 769 770 TEST_F(AssemblerX86_64Test, RorlImm) { 771 DriverStr(RepeatrI(&x86_64::X86_64Assembler::rorl, /*imm_bytes*/ 1U, "rorl ${imm}, %{reg}"), "rorli"); 772 } 773 774 // Roll only allows CL as the shift count. 775 std::string roll_fn(AssemblerX86_64Test::Base* assembler_test, x86_64::X86_64Assembler* assembler) { 776 std::ostringstream str; 777 std::vector<x86_64::CpuRegister*> registers = assembler_test->GetRegisters(); 778 x86_64::CpuRegister shifter(x86_64::RCX); 779 for (auto reg : registers) { 780 assembler->roll(*reg, shifter); 781 str << "roll %cl, %" << assembler_test->GetSecondaryRegisterName(*reg) << "\n"; 782 } 783 return str.str(); 784 } 785 786 TEST_F(AssemblerX86_64Test, RollReg) { 787 DriverFn(&roll_fn, "roll"); 788 } 789 790 TEST_F(AssemblerX86_64Test, RollImm) { 791 DriverStr(RepeatrI(&x86_64::X86_64Assembler::roll, /*imm_bytes*/ 1U, "roll ${imm}, %{reg}"), "rolli"); 792 } 793 794 // Rorq only allows CL as the shift count. 795 std::string rorq_fn(AssemblerX86_64Test::Base* assembler_test, x86_64::X86_64Assembler* assembler) { 796 std::ostringstream str; 797 std::vector<x86_64::CpuRegister*> registers = assembler_test->GetRegisters(); 798 x86_64::CpuRegister shifter(x86_64::RCX); 799 for (auto reg : registers) { 800 assembler->rorq(*reg, shifter); 801 str << "rorq %cl, %" << assembler_test->GetRegisterName(*reg) << "\n"; 802 } 803 return str.str(); 804 } 805 806 TEST_F(AssemblerX86_64Test, RorqReg) { 807 DriverFn(&rorq_fn, "rorq"); 808 } 809 810 TEST_F(AssemblerX86_64Test, RorqImm) { 811 DriverStr(RepeatRI(&x86_64::X86_64Assembler::rorq, /*imm_bytes*/ 1U, "rorq ${imm}, %{reg}"), "rorqi"); 812 } 813 814 // Rolq only allows CL as the shift count. 815 std::string rolq_fn(AssemblerX86_64Test::Base* assembler_test, x86_64::X86_64Assembler* assembler) { 816 std::ostringstream str; 817 std::vector<x86_64::CpuRegister*> registers = assembler_test->GetRegisters(); 818 x86_64::CpuRegister shifter(x86_64::RCX); 819 for (auto reg : registers) { 820 assembler->rolq(*reg, shifter); 821 str << "rolq %cl, %" << assembler_test->GetRegisterName(*reg) << "\n"; 822 } 823 return str.str(); 824 } 825 826 TEST_F(AssemblerX86_64Test, RolqReg) { 827 DriverFn(&rolq_fn, "rolq"); 828 } 829 830 TEST_F(AssemblerX86_64Test, RolqImm) { 831 DriverStr(RepeatRI(&x86_64::X86_64Assembler::rolq, /*imm_bytes*/ 1U, "rolq ${imm}, %{reg}"), "rolqi"); 832 } 833 834 TEST_F(AssemblerX86_64Test, CmpqRegs) { 835 DriverStr(RepeatRR(&x86_64::X86_64Assembler::cmpq, "cmpq %{reg2}, %{reg1}"), "cmpq"); 836 } 837 838 TEST_F(AssemblerX86_64Test, CmpqImm) { 839 DriverStr(RepeatRI(&x86_64::X86_64Assembler::cmpq, 840 /*imm_bytes*/ 4U, 841 "cmpq ${imm}, %{reg}"), "cmpqi"); // only imm32 842 } 843 844 TEST_F(AssemblerX86_64Test, CmplRegs) { 845 DriverStr(Repeatrr(&x86_64::X86_64Assembler::cmpl, "cmp %{reg2}, %{reg1}"), "cmpl"); 846 } 847 848 TEST_F(AssemblerX86_64Test, CmplImm) { 849 DriverStr(RepeatrI(&x86_64::X86_64Assembler::cmpl, /*imm_bytes*/ 4U, "cmpl ${imm}, %{reg}"), "cmpli"); 850 } 851 852 TEST_F(AssemblerX86_64Test, Testl) { 853 // Note: uses different order for GCC than usual. This makes GCC happy, and doesn't have an 854 // impact on functional correctness. 855 DriverStr(Repeatrr(&x86_64::X86_64Assembler::testl, "testl %{reg1}, %{reg2}"), "testl"); 856 } 857 858 TEST_F(AssemblerX86_64Test, Negq) { 859 DriverStr(RepeatR(&x86_64::X86_64Assembler::negq, "negq %{reg}"), "negq"); 860 } 861 862 TEST_F(AssemblerX86_64Test, Negl) { 863 DriverStr(Repeatr(&x86_64::X86_64Assembler::negl, "negl %{reg}"), "negl"); 864 } 865 866 TEST_F(AssemblerX86_64Test, Notq) { 867 DriverStr(RepeatR(&x86_64::X86_64Assembler::notq, "notq %{reg}"), "notq"); 868 } 869 870 TEST_F(AssemblerX86_64Test, Notl) { 871 DriverStr(Repeatr(&x86_64::X86_64Assembler::notl, "notl %{reg}"), "notl"); 872 } 873 874 TEST_F(AssemblerX86_64Test, AndqRegs) { 875 DriverStr(RepeatRR(&x86_64::X86_64Assembler::andq, "andq %{reg2}, %{reg1}"), "andq"); 876 } 877 878 TEST_F(AssemblerX86_64Test, AndqImm) { 879 DriverStr(RepeatRI(&x86_64::X86_64Assembler::andq, 880 /*imm_bytes*/ 4U, 881 "andq ${imm}, %{reg}"), "andqi"); // only imm32 882 } 883 884 TEST_F(AssemblerX86_64Test, AndlRegs) { 885 DriverStr(Repeatrr(&x86_64::X86_64Assembler::andl, "andl %{reg2}, %{reg1}"), "andl"); 886 } 887 888 TEST_F(AssemblerX86_64Test, AndlImm) { 889 DriverStr(RepeatrI(&x86_64::X86_64Assembler::andl, 890 /*imm_bytes*/ 4U, 891 "andl ${imm}, %{reg}"), "andli"); 892 } 893 894 TEST_F(AssemblerX86_64Test, OrqRegs) { 895 DriverStr(RepeatRR(&x86_64::X86_64Assembler::orq, "orq %{reg2}, %{reg1}"), "orq"); 896 } 897 898 TEST_F(AssemblerX86_64Test, OrlRegs) { 899 DriverStr(Repeatrr(&x86_64::X86_64Assembler::orl, "orl %{reg2}, %{reg1}"), "orl"); 900 } 901 902 TEST_F(AssemblerX86_64Test, OrlImm) { 903 DriverStr(RepeatrI(&x86_64::X86_64Assembler::orl, 904 /*imm_bytes*/ 4U, "orl ${imm}, %{reg}"), "orli"); 905 } 906 907 TEST_F(AssemblerX86_64Test, XorqRegs) { 908 DriverStr(RepeatRR(&x86_64::X86_64Assembler::xorq, "xorq %{reg2}, %{reg1}"), "xorq"); 909 } 910 911 TEST_F(AssemblerX86_64Test, XorqImm) { 912 DriverStr(RepeatRI(&x86_64::X86_64Assembler::xorq, 913 /*imm_bytes*/ 4U, "xorq ${imm}, %{reg}"), "xorqi"); 914 } 915 916 TEST_F(AssemblerX86_64Test, XorlRegs) { 917 DriverStr(Repeatrr(&x86_64::X86_64Assembler::xorl, "xor %{reg2}, %{reg1}"), "xorl"); 918 } 919 920 TEST_F(AssemblerX86_64Test, XorlImm) { 921 DriverStr(RepeatrI(&x86_64::X86_64Assembler::xorl, 922 /*imm_bytes*/ 4U, "xor ${imm}, %{reg}"), "xorli"); 923 } 924 925 TEST_F(AssemblerX86_64Test, Xchgq) { 926 DriverStr(RepeatRR(&x86_64::X86_64Assembler::xchgq, "xchgq %{reg2}, %{reg1}"), "xchgq"); 927 } 928 929 TEST_F(AssemblerX86_64Test, Xchgl) { 930 // TODO: Test is disabled because GCC generates 0x87 0xC0 for xchgl eax, eax. All other cases 931 // are the same. Anyone know why it doesn't emit a simple 0x90? It does so for xchgq rax, rax... 932 // DriverStr(Repeatrr(&x86_64::X86_64Assembler::xchgl, "xchgl %{reg2}, %{reg1}"), "xchgl"); 933 } 934 935 TEST_F(AssemblerX86_64Test, LockCmpxchgl) { 936 DriverStr(RepeatAr(&x86_64::X86_64Assembler::LockCmpxchgl, 937 "lock cmpxchgl %{reg}, {mem}"), "lock_cmpxchgl"); 938 } 939 940 TEST_F(AssemblerX86_64Test, LockCmpxchgq) { 941 DriverStr(RepeatAR(&x86_64::X86_64Assembler::LockCmpxchgq, 942 "lock cmpxchg %{reg}, {mem}"), "lock_cmpxchg"); 943 } 944 945 TEST_F(AssemblerX86_64Test, MovqStore) { 946 DriverStr(RepeatAR(&x86_64::X86_64Assembler::movq, "movq %{reg}, {mem}"), "movq_s"); 947 } 948 949 TEST_F(AssemblerX86_64Test, MovqLoad) { 950 DriverStr(RepeatRA(&x86_64::X86_64Assembler::movq, "movq {mem}, %{reg}"), "movq_l"); 951 } 952 953 TEST_F(AssemblerX86_64Test, MovlStore) { 954 DriverStr(RepeatAr(&x86_64::X86_64Assembler::movl, "movl %{reg}, {mem}"), "movl_s"); 955 } 956 957 TEST_F(AssemblerX86_64Test, MovlLoad) { 958 DriverStr(RepeatrA(&x86_64::X86_64Assembler::movl, "movl {mem}, %{reg}"), "movl_l"); 959 } 960 961 TEST_F(AssemblerX86_64Test, MovwStore) { 962 DriverStr(RepeatAw(&x86_64::X86_64Assembler::movw, "movw %{reg}, {mem}"), "movw_s"); 963 } 964 965 TEST_F(AssemblerX86_64Test, MovbStore) { 966 DriverStr(RepeatAb(&x86_64::X86_64Assembler::movb, "movb %{reg}, {mem}"), "movb_s"); 967 } 968 969 TEST_F(AssemblerX86_64Test, Cmpw) { 970 DriverStr( 971 RepeatAI(&x86_64::X86_64Assembler::cmpw, /*imm_bytes*/ 2U, "cmpw ${imm}, {mem}"), "cmpw"); 972 } 973 974 TEST_F(AssemblerX86_64Test, MovqAddrImm) { 975 DriverStr(RepeatAI(&x86_64::X86_64Assembler::movq, 976 /*imm_bytes*/ 4U, 977 "movq ${imm}, {mem}"), "movq"); // only imm32 978 } 979 980 TEST_F(AssemblerX86_64Test, MovlAddrImm) { 981 DriverStr(RepeatAI(&x86_64::X86_64Assembler::movl, 982 /*imm_bytes*/ 4U, "movl ${imm}, {mem}"), "movl"); 983 } 984 985 TEST_F(AssemblerX86_64Test, MovwAddrImm) { 986 DriverStr(RepeatAI(&x86_64::X86_64Assembler::movw, 987 /*imm_bytes*/ 2U, "movw ${imm}, {mem}"), "movw"); 988 } 989 990 TEST_F(AssemblerX86_64Test, MovbAddrImm) { 991 DriverStr(RepeatAI(&x86_64::X86_64Assembler::movb, 992 /*imm_bytes*/ 1U, "movb ${imm}, {mem}"), "movb"); 993 } 994 995 TEST_F(AssemblerX86_64Test, Movntl) { 996 DriverStr(RepeatAr(&x86_64::X86_64Assembler::movntl, "movntil %{reg}, {mem}"), "movntl"); 997 } 998 999 TEST_F(AssemblerX86_64Test, Movntq) { 1000 DriverStr(RepeatAR(&x86_64::X86_64Assembler::movntq, "movntiq %{reg}, {mem}"), "movntq"); 1001 } 1002 1003 TEST_F(AssemblerX86_64Test, Cvtsi2ssAddr) { 1004 GetAssembler()->cvtsi2ss(x86_64::XmmRegister(x86_64::XMM0), 1005 x86_64::Address(x86_64::CpuRegister(x86_64::RAX), 0), 1006 /*is64bit*/ false); 1007 GetAssembler()->cvtsi2ss(x86_64::XmmRegister(x86_64::XMM0), 1008 x86_64::Address(x86_64::CpuRegister(x86_64::RAX), 0), 1009 /*is64bit*/ true); 1010 const char* expected = "cvtsi2ss 0(%RAX), %xmm0\n" 1011 "cvtsi2ssq 0(%RAX), %xmm0\n"; 1012 DriverStr(expected, "cvtsi2ss"); 1013 } 1014 1015 TEST_F(AssemblerX86_64Test, Cvtsi2sdAddr) { 1016 GetAssembler()->cvtsi2sd(x86_64::XmmRegister(x86_64::XMM0), 1017 x86_64::Address(x86_64::CpuRegister(x86_64::RAX), 0), 1018 /*is64bit*/ false); 1019 GetAssembler()->cvtsi2sd(x86_64::XmmRegister(x86_64::XMM0), 1020 x86_64::Address(x86_64::CpuRegister(x86_64::RAX), 0), 1021 /*is64bit*/ true); 1022 const char* expected = "cvtsi2sd 0(%RAX), %xmm0\n" 1023 "cvtsi2sdq 0(%RAX), %xmm0\n"; 1024 DriverStr(expected, "cvtsi2sd"); 1025 } 1026 1027 TEST_F(AssemblerX86_64Test, CmpqAddr) { 1028 DriverStr(RepeatRA(&x86_64::X86_64Assembler::cmpq, "cmpq {mem}, %{reg}"), "cmpq"); 1029 } 1030 1031 TEST_F(AssemblerX86_64Test, MovsxdAddr) { 1032 DriverStr(RepeatRA(&x86_64::X86_64Assembler::movsxd, "movslq {mem}, %{reg}"), "movsxd"); 1033 } 1034 1035 TEST_F(AssemblerX86_64Test, TestqAddr) { 1036 DriverStr(RepeatRA(&x86_64::X86_64Assembler::testq, "testq {mem}, %{reg}"), "testq"); 1037 } 1038 1039 TEST_F(AssemblerX86_64Test, AddqAddr) { 1040 DriverStr(RepeatRA(&x86_64::X86_64Assembler::addq, "addq {mem}, %{reg}"), "addq"); 1041 } 1042 1043 TEST_F(AssemblerX86_64Test, SubqAddr) { 1044 DriverStr(RepeatRA(&x86_64::X86_64Assembler::subq, "subq {mem}, %{reg}"), "subq"); 1045 } 1046 1047 TEST_F(AssemblerX86_64Test, Cvtss2sdAddr) { 1048 DriverStr(RepeatFA(&x86_64::X86_64Assembler::cvtss2sd, "cvtss2sd {mem}, %{reg}"), "cvtss2sd"); 1049 } 1050 1051 TEST_F(AssemblerX86_64Test, Cvtsd2ssAddr) { 1052 DriverStr(RepeatFA(&x86_64::X86_64Assembler::cvtsd2ss, "cvtsd2ss {mem}, %{reg}"), "cvtsd2ss"); 1053 } 1054 1055 TEST_F(AssemblerX86_64Test, ComissAddr) { 1056 DriverStr(RepeatFA(&x86_64::X86_64Assembler::comiss, "comiss {mem}, %{reg}"), "comiss"); 1057 } 1058 1059 TEST_F(AssemblerX86_64Test, ComisdAddr) { 1060 DriverStr(RepeatFA(&x86_64::X86_64Assembler::comisd, "comisd {mem}, %{reg}"), "comisd"); 1061 } 1062 1063 TEST_F(AssemblerX86_64Test, UComissAddr) { 1064 DriverStr(RepeatFA(&x86_64::X86_64Assembler::ucomiss, "ucomiss {mem}, %{reg}"), "ucomiss"); 1065 } 1066 1067 TEST_F(AssemblerX86_64Test, UComisdAddr) { 1068 DriverStr(RepeatFA(&x86_64::X86_64Assembler::ucomisd, "ucomisd {mem}, %{reg}"), "ucomisd"); 1069 } 1070 1071 TEST_F(AssemblerX86_64Test, Andq) { 1072 DriverStr(RepeatRA(&x86_64::X86_64Assembler::andq, "andq {mem}, %{reg}"), "andq"); 1073 } 1074 1075 TEST_F(AssemblerX86_64Test, Orq) { 1076 DriverStr(RepeatRA(&x86_64::X86_64Assembler::orq, "orq {mem}, %{reg}"), "orq"); 1077 } 1078 1079 TEST_F(AssemblerX86_64Test, Xorq) { 1080 DriverStr(RepeatRA(&x86_64::X86_64Assembler::xorq, "xorq {mem}, %{reg}"), "xorq"); 1081 } 1082 1083 TEST_F(AssemblerX86_64Test, RepneScasb) { 1084 GetAssembler()->repne_scasb(); 1085 const char* expected = "repne scasb\n"; 1086 DriverStr(expected, "repne_scasb"); 1087 } 1088 1089 TEST_F(AssemblerX86_64Test, RepneScasw) { 1090 GetAssembler()->repne_scasw(); 1091 const char* expected = "repne scasw\n"; 1092 DriverStr(expected, "repne_scasw"); 1093 } 1094 1095 TEST_F(AssemblerX86_64Test, RepMovsw) { 1096 GetAssembler()->rep_movsw(); 1097 const char* expected = "rep movsw\n"; 1098 DriverStr(expected, "rep_movsw"); 1099 } 1100 1101 TEST_F(AssemblerX86_64Test, Movsxd) { 1102 DriverStr(RepeatRr(&x86_64::X86_64Assembler::movsxd, "movsxd %{reg2}, %{reg1}"), "movsxd"); 1103 } 1104 1105 TEST_F(AssemblerX86_64Test, Movaps) { 1106 DriverStr(RepeatFF(&x86_64::X86_64Assembler::movaps, "movaps %{reg2}, %{reg1}"), "movaps"); 1107 } 1108 1109 TEST_F(AssemblerX86_64Test, MovapsStore) { 1110 DriverStr(RepeatAF(&x86_64::X86_64Assembler::movaps, "movaps %{reg}, {mem}"), "movaps_s"); 1111 } 1112 1113 TEST_F(AssemblerX86_64Test, MovapsLoad) { 1114 DriverStr(RepeatFA(&x86_64::X86_64Assembler::movaps, "movaps {mem}, %{reg}"), "movaps_l"); 1115 } 1116 1117 TEST_F(AssemblerX86_64Test, MovupsStore) { 1118 DriverStr(RepeatAF(&x86_64::X86_64Assembler::movups, "movups %{reg}, {mem}"), "movups_s"); 1119 } 1120 1121 TEST_F(AssemblerX86_64Test, MovupsLoad) { 1122 DriverStr(RepeatFA(&x86_64::X86_64Assembler::movups, "movups {mem}, %{reg}"), "movups_l"); 1123 } 1124 1125 TEST_F(AssemblerX86_64Test, Movss) { 1126 DriverStr(RepeatFF(&x86_64::X86_64Assembler::movss, "movss %{reg2}, %{reg1}"), "movss"); 1127 } 1128 1129 TEST_F(AssemblerX86_64Test, Movapd) { 1130 DriverStr(RepeatFF(&x86_64::X86_64Assembler::movapd, "movapd %{reg2}, %{reg1}"), "movapd"); 1131 } 1132 1133 TEST_F(AssemblerX86_64Test, MovapdStore) { 1134 DriverStr(RepeatAF(&x86_64::X86_64Assembler::movapd, "movapd %{reg}, {mem}"), "movapd_s"); 1135 } 1136 1137 TEST_F(AssemblerX86_64Test, MovapdLoad) { 1138 DriverStr(RepeatFA(&x86_64::X86_64Assembler::movapd, "movapd {mem}, %{reg}"), "movapd_l"); 1139 } 1140 1141 TEST_F(AssemblerX86_64Test, MovupdStore) { 1142 DriverStr(RepeatAF(&x86_64::X86_64Assembler::movupd, "movupd %{reg}, {mem}"), "movupd_s"); 1143 } 1144 1145 TEST_F(AssemblerX86_64Test, MovupdLoad) { 1146 DriverStr(RepeatFA(&x86_64::X86_64Assembler::movupd, "movupd {mem}, %{reg}"), "movupd_l"); 1147 } 1148 1149 TEST_F(AssemblerX86_64Test, Movsd) { 1150 DriverStr(RepeatFF(&x86_64::X86_64Assembler::movsd, "movsd %{reg2}, %{reg1}"), "movsd"); 1151 } 1152 1153 TEST_F(AssemblerX86_64Test, Movdqa) { 1154 DriverStr(RepeatFF(&x86_64::X86_64Assembler::movdqa, "movdqa %{reg2}, %{reg1}"), "movdqa"); 1155 } 1156 1157 TEST_F(AssemblerX86_64Test, MovdqaStore) { 1158 DriverStr(RepeatAF(&x86_64::X86_64Assembler::movdqa, "movdqa %{reg}, {mem}"), "movdqa_s"); 1159 } 1160 1161 TEST_F(AssemblerX86_64Test, MovdqaLoad) { 1162 DriverStr(RepeatFA(&x86_64::X86_64Assembler::movdqa, "movdqa {mem}, %{reg}"), "movdqa_l"); 1163 } 1164 1165 TEST_F(AssemblerX86_64Test, MovdquStore) { 1166 DriverStr(RepeatAF(&x86_64::X86_64Assembler::movdqu, "movdqu %{reg}, {mem}"), "movdqu_s"); 1167 } 1168 1169 TEST_F(AssemblerX86_64Test, MovdquLoad) { 1170 DriverStr(RepeatFA(&x86_64::X86_64Assembler::movdqu, "movdqu {mem}, %{reg}"), "movdqu_l"); 1171 } 1172 1173 TEST_F(AssemblerX86_64Test, Movd1) { 1174 DriverStr(RepeatFR(&x86_64::X86_64Assembler::movd, "movd %{reg2}, %{reg1}"), "movd.1"); 1175 } 1176 1177 TEST_F(AssemblerX86_64Test, Movd2) { 1178 DriverStr(RepeatRF(&x86_64::X86_64Assembler::movd, "movd %{reg2}, %{reg1}"), "movd.2"); 1179 } 1180 1181 TEST_F(AssemblerX86_64Test, Addss) { 1182 DriverStr(RepeatFF(&x86_64::X86_64Assembler::addss, "addss %{reg2}, %{reg1}"), "addss"); 1183 } 1184 1185 TEST_F(AssemblerX86_64Test, Addsd) { 1186 DriverStr(RepeatFF(&x86_64::X86_64Assembler::addsd, "addsd %{reg2}, %{reg1}"), "addsd"); 1187 } 1188 1189 TEST_F(AssemblerX86_64Test, Addps) { 1190 DriverStr(RepeatFF(&x86_64::X86_64Assembler::addps, "addps %{reg2}, %{reg1}"), "addps"); 1191 } 1192 1193 TEST_F(AssemblerX86_64Test, Addpd) { 1194 DriverStr(RepeatFF(&x86_64::X86_64Assembler::addpd, "addpd %{reg2}, %{reg1}"), "addpd"); 1195 } 1196 1197 TEST_F(AssemblerX86_64Test, Subss) { 1198 DriverStr(RepeatFF(&x86_64::X86_64Assembler::subss, "subss %{reg2}, %{reg1}"), "subss"); 1199 } 1200 1201 TEST_F(AssemblerX86_64Test, Subsd) { 1202 DriverStr(RepeatFF(&x86_64::X86_64Assembler::subsd, "subsd %{reg2}, %{reg1}"), "subsd"); 1203 } 1204 1205 TEST_F(AssemblerX86_64Test, Subps) { 1206 DriverStr(RepeatFF(&x86_64::X86_64Assembler::subps, "subps %{reg2}, %{reg1}"), "subps"); 1207 } 1208 1209 TEST_F(AssemblerX86_64Test, Subpd) { 1210 DriverStr(RepeatFF(&x86_64::X86_64Assembler::subpd, "subpd %{reg2}, %{reg1}"), "subpd"); 1211 } 1212 1213 TEST_F(AssemblerX86_64Test, Mulss) { 1214 DriverStr(RepeatFF(&x86_64::X86_64Assembler::mulss, "mulss %{reg2}, %{reg1}"), "mulss"); 1215 } 1216 1217 TEST_F(AssemblerX86_64Test, Mulsd) { 1218 DriverStr(RepeatFF(&x86_64::X86_64Assembler::mulsd, "mulsd %{reg2}, %{reg1}"), "mulsd"); 1219 } 1220 1221 TEST_F(AssemblerX86_64Test, Mulps) { 1222 DriverStr(RepeatFF(&x86_64::X86_64Assembler::mulps, "mulps %{reg2}, %{reg1}"), "mulps"); 1223 } 1224 1225 TEST_F(AssemblerX86_64Test, Mulpd) { 1226 DriverStr(RepeatFF(&x86_64::X86_64Assembler::mulpd, "mulpd %{reg2}, %{reg1}"), "mulpd"); 1227 } 1228 1229 TEST_F(AssemblerX86_64Test, Divss) { 1230 DriverStr(RepeatFF(&x86_64::X86_64Assembler::divss, "divss %{reg2}, %{reg1}"), "divss"); 1231 } 1232 1233 TEST_F(AssemblerX86_64Test, Divsd) { 1234 DriverStr(RepeatFF(&x86_64::X86_64Assembler::divsd, "divsd %{reg2}, %{reg1}"), "divsd"); 1235 } 1236 1237 TEST_F(AssemblerX86_64Test, Divps) { 1238 DriverStr(RepeatFF(&x86_64::X86_64Assembler::divps, "divps %{reg2}, %{reg1}"), "divps"); 1239 } 1240 1241 TEST_F(AssemblerX86_64Test, Divpd) { 1242 DriverStr(RepeatFF(&x86_64::X86_64Assembler::divpd, "divpd %{reg2}, %{reg1}"), "divpd"); 1243 } 1244 1245 TEST_F(AssemblerX86_64Test, Paddb) { 1246 DriverStr(RepeatFF(&x86_64::X86_64Assembler::paddb, "paddb %{reg2}, %{reg1}"), "paddb"); 1247 } 1248 1249 TEST_F(AssemblerX86_64Test, Psubb) { 1250 DriverStr(RepeatFF(&x86_64::X86_64Assembler::psubb, "psubb %{reg2}, %{reg1}"), "psubb"); 1251 } 1252 1253 TEST_F(AssemblerX86_64Test, Paddw) { 1254 DriverStr(RepeatFF(&x86_64::X86_64Assembler::paddw, "paddw %{reg2}, %{reg1}"), "paddw"); 1255 } 1256 1257 TEST_F(AssemblerX86_64Test, Psubw) { 1258 DriverStr(RepeatFF(&x86_64::X86_64Assembler::psubw, "psubw %{reg2}, %{reg1}"), "psubw"); 1259 } 1260 1261 TEST_F(AssemblerX86_64Test, Pmullw) { 1262 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pmullw, "pmullw %{reg2}, %{reg1}"), "pmullw"); 1263 } 1264 1265 TEST_F(AssemblerX86_64Test, Paddd) { 1266 DriverStr(RepeatFF(&x86_64::X86_64Assembler::paddd, "paddd %{reg2}, %{reg1}"), "paddd"); 1267 } 1268 1269 TEST_F(AssemblerX86_64Test, Psubd) { 1270 DriverStr(RepeatFF(&x86_64::X86_64Assembler::psubd, "psubd %{reg2}, %{reg1}"), "psubd"); 1271 } 1272 1273 TEST_F(AssemblerX86_64Test, Pmulld) { 1274 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pmulld, "pmulld %{reg2}, %{reg1}"), "pmulld"); 1275 } 1276 1277 TEST_F(AssemblerX86_64Test, Paddq) { 1278 DriverStr(RepeatFF(&x86_64::X86_64Assembler::paddq, "paddq %{reg2}, %{reg1}"), "paddq"); 1279 } 1280 1281 TEST_F(AssemblerX86_64Test, Psubq) { 1282 DriverStr(RepeatFF(&x86_64::X86_64Assembler::psubq, "psubq %{reg2}, %{reg1}"), "psubq"); 1283 } 1284 1285 TEST_F(AssemblerX86_64Test, Cvtsi2ss) { 1286 DriverStr(RepeatFr(&x86_64::X86_64Assembler::cvtsi2ss, "cvtsi2ss %{reg2}, %{reg1}"), "cvtsi2ss"); 1287 } 1288 1289 TEST_F(AssemblerX86_64Test, Cvtsi2sd) { 1290 DriverStr(RepeatFr(&x86_64::X86_64Assembler::cvtsi2sd, "cvtsi2sd %{reg2}, %{reg1}"), "cvtsi2sd"); 1291 } 1292 1293 TEST_F(AssemblerX86_64Test, Cvtss2si) { 1294 DriverStr(RepeatrF(&x86_64::X86_64Assembler::cvtss2si, "cvtss2si %{reg2}, %{reg1}"), "cvtss2si"); 1295 } 1296 1297 TEST_F(AssemblerX86_64Test, Cvtss2sd) { 1298 DriverStr(RepeatFF(&x86_64::X86_64Assembler::cvtss2sd, "cvtss2sd %{reg2}, %{reg1}"), "cvtss2sd"); 1299 } 1300 1301 TEST_F(AssemblerX86_64Test, Cvtsd2si) { 1302 DriverStr(RepeatrF(&x86_64::X86_64Assembler::cvtsd2si, "cvtsd2si %{reg2}, %{reg1}"), "cvtsd2si"); 1303 } 1304 1305 TEST_F(AssemblerX86_64Test, Cvttss2si) { 1306 DriverStr(RepeatrF(&x86_64::X86_64Assembler::cvttss2si, "cvttss2si %{reg2}, %{reg1}"), 1307 "cvttss2si"); 1308 } 1309 1310 TEST_F(AssemblerX86_64Test, Cvttsd2si) { 1311 DriverStr(RepeatrF(&x86_64::X86_64Assembler::cvttsd2si, "cvttsd2si %{reg2}, %{reg1}"), 1312 "cvttsd2si"); 1313 } 1314 1315 TEST_F(AssemblerX86_64Test, Cvtsd2ss) { 1316 DriverStr(RepeatFF(&x86_64::X86_64Assembler::cvtsd2ss, "cvtsd2ss %{reg2}, %{reg1}"), "cvtsd2ss"); 1317 } 1318 1319 TEST_F(AssemblerX86_64Test, Cvtdq2ps) { 1320 DriverStr(RepeatFF(&x86_64::X86_64Assembler::cvtdq2ps, "cvtdq2ps %{reg2}, %{reg1}"), "cvtdq2ps"); 1321 } 1322 1323 TEST_F(AssemblerX86_64Test, Cvtdq2pd) { 1324 DriverStr(RepeatFF(&x86_64::X86_64Assembler::cvtdq2pd, "cvtdq2pd %{reg2}, %{reg1}"), "cvtdq2pd"); 1325 } 1326 1327 TEST_F(AssemblerX86_64Test, Comiss) { 1328 DriverStr(RepeatFF(&x86_64::X86_64Assembler::comiss, "comiss %{reg2}, %{reg1}"), "comiss"); 1329 } 1330 1331 TEST_F(AssemblerX86_64Test, Comisd) { 1332 DriverStr(RepeatFF(&x86_64::X86_64Assembler::comisd, "comisd %{reg2}, %{reg1}"), "comisd"); 1333 } 1334 1335 TEST_F(AssemblerX86_64Test, Ucomiss) { 1336 DriverStr(RepeatFF(&x86_64::X86_64Assembler::ucomiss, "ucomiss %{reg2}, %{reg1}"), "ucomiss"); 1337 } 1338 1339 TEST_F(AssemblerX86_64Test, Ucomisd) { 1340 DriverStr(RepeatFF(&x86_64::X86_64Assembler::ucomisd, "ucomisd %{reg2}, %{reg1}"), "ucomisd"); 1341 } 1342 1343 TEST_F(AssemblerX86_64Test, Sqrtss) { 1344 DriverStr(RepeatFF(&x86_64::X86_64Assembler::sqrtss, "sqrtss %{reg2}, %{reg1}"), "sqrtss"); 1345 } 1346 1347 TEST_F(AssemblerX86_64Test, Sqrtsd) { 1348 DriverStr(RepeatFF(&x86_64::X86_64Assembler::sqrtsd, "sqrtsd %{reg2}, %{reg1}"), "sqrtsd"); 1349 } 1350 1351 TEST_F(AssemblerX86_64Test, Roundss) { 1352 DriverStr(RepeatFFI(&x86_64::X86_64Assembler::roundss, /*imm_bytes*/ 1U, 1353 "roundss ${imm}, %{reg2}, %{reg1}"), "roundss"); 1354 } 1355 1356 TEST_F(AssemblerX86_64Test, Roundsd) { 1357 DriverStr(RepeatFFI(&x86_64::X86_64Assembler::roundsd, /*imm_bytes*/ 1U, 1358 "roundsd ${imm}, %{reg2}, %{reg1}"), "roundsd"); 1359 } 1360 1361 TEST_F(AssemblerX86_64Test, Xorps) { 1362 DriverStr(RepeatFF(&x86_64::X86_64Assembler::xorps, "xorps %{reg2}, %{reg1}"), "xorps"); 1363 } 1364 1365 TEST_F(AssemblerX86_64Test, Xorpd) { 1366 DriverStr(RepeatFF(&x86_64::X86_64Assembler::xorpd, "xorpd %{reg2}, %{reg1}"), "xorpd"); 1367 } 1368 1369 TEST_F(AssemblerX86_64Test, Pxor) { 1370 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pxor, "pxor %{reg2}, %{reg1}"), "pxor"); 1371 } 1372 1373 TEST_F(AssemblerX86_64Test, Andps) { 1374 DriverStr(RepeatFF(&x86_64::X86_64Assembler::andps, "andps %{reg2}, %{reg1}"), "andps"); 1375 } 1376 1377 TEST_F(AssemblerX86_64Test, Andpd) { 1378 DriverStr(RepeatFF(&x86_64::X86_64Assembler::andpd, "andpd %{reg2}, %{reg1}"), "andpd"); 1379 } 1380 1381 TEST_F(AssemblerX86_64Test, Pand) { 1382 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pand, "pand %{reg2}, %{reg1}"), "pand"); 1383 } 1384 1385 TEST_F(AssemblerX86_64Test, andnpd) { 1386 DriverStr(RepeatFF(&x86_64::X86_64Assembler::andnpd, "andnpd %{reg2}, %{reg1}"), "andnpd"); 1387 } 1388 1389 TEST_F(AssemblerX86_64Test, andnps) { 1390 DriverStr(RepeatFF(&x86_64::X86_64Assembler::andnps, "andnps %{reg2}, %{reg1}"), "andnps"); 1391 } 1392 1393 TEST_F(AssemblerX86_64Test, Pandn) { 1394 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pandn, "pandn %{reg2}, %{reg1}"), "pandn"); 1395 } 1396 1397 TEST_F(AssemblerX86_64Test, Orps) { 1398 DriverStr(RepeatFF(&x86_64::X86_64Assembler::orps, "orps %{reg2}, %{reg1}"), "orps"); 1399 } 1400 1401 TEST_F(AssemblerX86_64Test, Orpd) { 1402 DriverStr(RepeatFF(&x86_64::X86_64Assembler::orpd, "orpd %{reg2}, %{reg1}"), "orpd"); 1403 } 1404 1405 TEST_F(AssemblerX86_64Test, Por) { 1406 DriverStr(RepeatFF(&x86_64::X86_64Assembler::por, "por %{reg2}, %{reg1}"), "por"); 1407 } 1408 1409 TEST_F(AssemblerX86_64Test, Pavgb) { 1410 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pavgb, "pavgb %{reg2}, %{reg1}"), "pavgb"); 1411 } 1412 1413 TEST_F(AssemblerX86_64Test, Pavgw) { 1414 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pavgw, "pavgw %{reg2}, %{reg1}"), "pavgw"); 1415 } 1416 1417 TEST_F(AssemblerX86_64Test, Psadbw) { 1418 DriverStr(RepeatFF(&x86_64::X86_64Assembler::psadbw, "psadbw %{reg2}, %{reg1}"), "psadbw"); 1419 } 1420 1421 TEST_F(AssemblerX86_64Test, Pmaddwd) { 1422 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pmaddwd, "pmaddwd %{reg2}, %{reg1}"), "pmadwd"); 1423 } 1424 1425 TEST_F(AssemblerX86_64Test, Phaddw) { 1426 DriverStr(RepeatFF(&x86_64::X86_64Assembler::phaddw, "phaddw %{reg2}, %{reg1}"), "phaddw"); 1427 } 1428 1429 TEST_F(AssemblerX86_64Test, Phaddd) { 1430 DriverStr(RepeatFF(&x86_64::X86_64Assembler::phaddd, "phaddd %{reg2}, %{reg1}"), "phaddd"); 1431 } 1432 1433 TEST_F(AssemblerX86_64Test, Haddps) { 1434 DriverStr(RepeatFF(&x86_64::X86_64Assembler::haddps, "haddps %{reg2}, %{reg1}"), "haddps"); 1435 } 1436 1437 TEST_F(AssemblerX86_64Test, Haddpd) { 1438 DriverStr(RepeatFF(&x86_64::X86_64Assembler::haddpd, "haddpd %{reg2}, %{reg1}"), "haddpd"); 1439 } 1440 1441 TEST_F(AssemblerX86_64Test, Phsubw) { 1442 DriverStr(RepeatFF(&x86_64::X86_64Assembler::phsubw, "phsubw %{reg2}, %{reg1}"), "phsubw"); 1443 } 1444 1445 TEST_F(AssemblerX86_64Test, Phsubd) { 1446 DriverStr(RepeatFF(&x86_64::X86_64Assembler::phsubd, "phsubd %{reg2}, %{reg1}"), "phsubd"); 1447 } 1448 1449 TEST_F(AssemblerX86_64Test, Hsubps) { 1450 DriverStr(RepeatFF(&x86_64::X86_64Assembler::hsubps, "hsubps %{reg2}, %{reg1}"), "hsubps"); 1451 } 1452 1453 TEST_F(AssemblerX86_64Test, Hsubpd) { 1454 DriverStr(RepeatFF(&x86_64::X86_64Assembler::hsubpd, "hsubpd %{reg2}, %{reg1}"), "hsubpd"); 1455 } 1456 1457 TEST_F(AssemblerX86_64Test, Pminsb) { 1458 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pminsb, "pminsb %{reg2}, %{reg1}"), "pminsb"); 1459 } 1460 1461 TEST_F(AssemblerX86_64Test, Pmaxsb) { 1462 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pmaxsb, "pmaxsb %{reg2}, %{reg1}"), "pmaxsb"); 1463 } 1464 1465 TEST_F(AssemblerX86_64Test, Pminsw) { 1466 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pminsw, "pminsw %{reg2}, %{reg1}"), "pminsw"); 1467 } 1468 1469 TEST_F(AssemblerX86_64Test, Pmaxsw) { 1470 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pmaxsw, "pmaxsw %{reg2}, %{reg1}"), "pmaxsw"); 1471 } 1472 1473 TEST_F(AssemblerX86_64Test, Pminsd) { 1474 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pminsd, "pminsd %{reg2}, %{reg1}"), "pminsd"); 1475 } 1476 1477 TEST_F(AssemblerX86_64Test, Pmaxsd) { 1478 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pmaxsd, "pmaxsd %{reg2}, %{reg1}"), "pmaxsd"); 1479 } 1480 1481 TEST_F(AssemblerX86_64Test, Pminub) { 1482 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pminub, "pminub %{reg2}, %{reg1}"), "pminub"); 1483 } 1484 1485 TEST_F(AssemblerX86_64Test, Pmaxub) { 1486 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pmaxub, "pmaxub %{reg2}, %{reg1}"), "pmaxub"); 1487 } 1488 1489 TEST_F(AssemblerX86_64Test, Pminuw) { 1490 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pminuw, "pminuw %{reg2}, %{reg1}"), "pminuw"); 1491 } 1492 1493 TEST_F(AssemblerX86_64Test, Pmaxuw) { 1494 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pmaxuw, "pmaxuw %{reg2}, %{reg1}"), "pmaxuw"); 1495 } 1496 1497 TEST_F(AssemblerX86_64Test, Pminud) { 1498 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pminud, "pminud %{reg2}, %{reg1}"), "pminud"); 1499 } 1500 1501 TEST_F(AssemblerX86_64Test, Pmaxud) { 1502 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pmaxud, "pmaxud %{reg2}, %{reg1}"), "pmaxud"); 1503 } 1504 1505 TEST_F(AssemblerX86_64Test, Minps) { 1506 DriverStr(RepeatFF(&x86_64::X86_64Assembler::minps, "minps %{reg2}, %{reg1}"), "minps"); 1507 } 1508 1509 TEST_F(AssemblerX86_64Test, Maxps) { 1510 DriverStr(RepeatFF(&x86_64::X86_64Assembler::maxps, "maxps %{reg2}, %{reg1}"), "maxps"); 1511 } 1512 1513 TEST_F(AssemblerX86_64Test, Minpd) { 1514 DriverStr(RepeatFF(&x86_64::X86_64Assembler::minpd, "minpd %{reg2}, %{reg1}"), "minpd"); 1515 } 1516 1517 TEST_F(AssemblerX86_64Test, Maxpd) { 1518 DriverStr(RepeatFF(&x86_64::X86_64Assembler::maxpd, "maxpd %{reg2}, %{reg1}"), "maxpd"); 1519 } 1520 1521 TEST_F(AssemblerX86_64Test, PCmpeqb) { 1522 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pcmpeqb, "pcmpeqb %{reg2}, %{reg1}"), "pcmpeqb"); 1523 } 1524 1525 TEST_F(AssemblerX86_64Test, PCmpeqw) { 1526 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pcmpeqw, "pcmpeqw %{reg2}, %{reg1}"), "pcmpeqw"); 1527 } 1528 1529 TEST_F(AssemblerX86_64Test, PCmpeqd) { 1530 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pcmpeqd, "pcmpeqd %{reg2}, %{reg1}"), "pcmpeqd"); 1531 } 1532 1533 TEST_F(AssemblerX86_64Test, PCmpeqq) { 1534 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pcmpeqq, "pcmpeqq %{reg2}, %{reg1}"), "pcmpeqq"); 1535 } 1536 1537 TEST_F(AssemblerX86_64Test, PCmpgtb) { 1538 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pcmpgtb, "pcmpgtb %{reg2}, %{reg1}"), "pcmpgtb"); 1539 } 1540 1541 TEST_F(AssemblerX86_64Test, PCmpgtw) { 1542 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pcmpgtw, "pcmpgtw %{reg2}, %{reg1}"), "pcmpgtw"); 1543 } 1544 1545 TEST_F(AssemblerX86_64Test, PCmpgtd) { 1546 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pcmpgtd, "pcmpgtd %{reg2}, %{reg1}"), "pcmpgtd"); 1547 } 1548 1549 TEST_F(AssemblerX86_64Test, PCmpgtq) { 1550 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pcmpgtq, "pcmpgtq %{reg2}, %{reg1}"), "pcmpgtq"); 1551 } 1552 1553 TEST_F(AssemblerX86_64Test, Shufps) { 1554 DriverStr(RepeatFFI(&x86_64::X86_64Assembler::shufps, /*imm_bytes*/ 1U, 1555 "shufps ${imm}, %{reg2}, %{reg1}"), "shufps"); 1556 } 1557 1558 TEST_F(AssemblerX86_64Test, Shufpd) { 1559 DriverStr(RepeatFFI(&x86_64::X86_64Assembler::shufpd, /*imm_bytes*/ 1U, 1560 "shufpd ${imm}, %{reg2}, %{reg1}"), "shufpd"); 1561 } 1562 1563 TEST_F(AssemblerX86_64Test, PShufd) { 1564 DriverStr(RepeatFFI(&x86_64::X86_64Assembler::pshufd, /*imm_bytes*/ 1U, 1565 "pshufd ${imm}, %{reg2}, %{reg1}"), "pshufd"); 1566 } 1567 1568 TEST_F(AssemblerX86_64Test, Punpcklbw) { 1569 DriverStr(RepeatFF(&x86_64::X86_64Assembler::punpcklbw, 1570 "punpcklbw %{reg2}, %{reg1}"), "punpcklbw"); 1571 } 1572 1573 TEST_F(AssemblerX86_64Test, Punpcklwd) { 1574 DriverStr(RepeatFF(&x86_64::X86_64Assembler::punpcklwd, 1575 "punpcklwd %{reg2}, %{reg1}"), "punpcklwd"); 1576 } 1577 1578 TEST_F(AssemblerX86_64Test, Punpckldq) { 1579 DriverStr(RepeatFF(&x86_64::X86_64Assembler::punpckldq, 1580 "punpckldq %{reg2}, %{reg1}"), "punpckldq"); 1581 } 1582 1583 TEST_F(AssemblerX86_64Test, Punpcklqdq) { 1584 DriverStr(RepeatFF(&x86_64::X86_64Assembler::punpcklqdq, 1585 "punpcklqdq %{reg2}, %{reg1}"), "punpcklqdq"); 1586 } 1587 1588 TEST_F(AssemblerX86_64Test, Punpckhbw) { 1589 DriverStr(RepeatFF(&x86_64::X86_64Assembler::punpckhbw, 1590 "punpckhbw %{reg2}, %{reg1}"), "punpckhbw"); 1591 } 1592 1593 TEST_F(AssemblerX86_64Test, Punpckhwd) { 1594 DriverStr(RepeatFF(&x86_64::X86_64Assembler::punpckhwd, 1595 "punpckhwd %{reg2}, %{reg1}"), "punpckhwd"); 1596 } 1597 1598 TEST_F(AssemblerX86_64Test, Punpckhdq) { 1599 DriverStr(RepeatFF(&x86_64::X86_64Assembler::punpckhdq, 1600 "punpckhdq %{reg2}, %{reg1}"), "punpckhdq"); 1601 } 1602 1603 TEST_F(AssemblerX86_64Test, Punpckhqdq) { 1604 DriverStr(RepeatFF(&x86_64::X86_64Assembler::punpckhqdq, 1605 "punpckhqdq %{reg2}, %{reg1}"), "punpckhqdq"); 1606 } 1607 1608 TEST_F(AssemblerX86_64Test, Psllw) { 1609 GetAssembler()->psllw(x86_64::XmmRegister(x86_64::XMM0), x86_64::Immediate(1)); 1610 GetAssembler()->psllw(x86_64::XmmRegister(x86_64::XMM15), x86_64::Immediate(2)); 1611 DriverStr("psllw $1, %xmm0\n" 1612 "psllw $2, %xmm15\n", "psllwi"); 1613 } 1614 1615 TEST_F(AssemblerX86_64Test, Pslld) { 1616 GetAssembler()->pslld(x86_64::XmmRegister(x86_64::XMM0), x86_64::Immediate(1)); 1617 GetAssembler()->pslld(x86_64::XmmRegister(x86_64::XMM15), x86_64::Immediate(2)); 1618 DriverStr("pslld $1, %xmm0\n" 1619 "pslld $2, %xmm15\n", "pslldi"); 1620 } 1621 1622 TEST_F(AssemblerX86_64Test, Psllq) { 1623 GetAssembler()->psllq(x86_64::XmmRegister(x86_64::XMM0), x86_64::Immediate(1)); 1624 GetAssembler()->psllq(x86_64::XmmRegister(x86_64::XMM15), x86_64::Immediate(2)); 1625 DriverStr("psllq $1, %xmm0\n" 1626 "psllq $2, %xmm15\n", "psllqi"); 1627 } 1628 1629 TEST_F(AssemblerX86_64Test, Psraw) { 1630 GetAssembler()->psraw(x86_64::XmmRegister(x86_64::XMM0), x86_64::Immediate(1)); 1631 GetAssembler()->psraw(x86_64::XmmRegister(x86_64::XMM15), x86_64::Immediate(2)); 1632 DriverStr("psraw $1, %xmm0\n" 1633 "psraw $2, %xmm15\n", "psrawi"); 1634 } 1635 1636 TEST_F(AssemblerX86_64Test, Psrad) { 1637 GetAssembler()->psrad(x86_64::XmmRegister(x86_64::XMM0), x86_64::Immediate(1)); 1638 GetAssembler()->psrad(x86_64::XmmRegister(x86_64::XMM15), x86_64::Immediate(2)); 1639 DriverStr("psrad $1, %xmm0\n" 1640 "psrad $2, %xmm15\n", "psradi"); 1641 } 1642 1643 TEST_F(AssemblerX86_64Test, Psrlw) { 1644 GetAssembler()->psrlw(x86_64::XmmRegister(x86_64::XMM0), x86_64::Immediate(1)); 1645 GetAssembler()->psrlw(x86_64::XmmRegister(x86_64::XMM15), x86_64::Immediate(2)); 1646 DriverStr("psrlw $1, %xmm0\n" 1647 "psrlw $2, %xmm15\n", "psrlwi"); 1648 } 1649 1650 TEST_F(AssemblerX86_64Test, Psrld) { 1651 GetAssembler()->psrld(x86_64::XmmRegister(x86_64::XMM0), x86_64::Immediate(1)); 1652 GetAssembler()->psrld(x86_64::XmmRegister(x86_64::XMM15), x86_64::Immediate(2)); 1653 DriverStr("psrld $1, %xmm0\n" 1654 "psrld $2, %xmm15\n", "psrldi"); 1655 } 1656 1657 TEST_F(AssemblerX86_64Test, Psrlq) { 1658 GetAssembler()->psrlq(x86_64::XmmRegister(x86_64::XMM0), x86_64::Immediate(1)); 1659 GetAssembler()->psrlq(x86_64::XmmRegister(x86_64::XMM15), x86_64::Immediate(2)); 1660 DriverStr("psrlq $1, %xmm0\n" 1661 "psrlq $2, %xmm15\n", "psrlqi"); 1662 } 1663 1664 TEST_F(AssemblerX86_64Test, Psrldq) { 1665 GetAssembler()->psrldq(x86_64::XmmRegister(x86_64::XMM0), x86_64::Immediate(1)); 1666 GetAssembler()->psrldq(x86_64::XmmRegister(x86_64::XMM15), x86_64::Immediate(2)); 1667 DriverStr("psrldq $1, %xmm0\n" 1668 "psrldq $2, %xmm15\n", "psrldqi"); 1669 } 1670 1671 std::string x87_fn(AssemblerX86_64Test::Base* assembler_test ATTRIBUTE_UNUSED, 1672 x86_64::X86_64Assembler* assembler) { 1673 std::ostringstream str; 1674 1675 assembler->fincstp(); 1676 str << "fincstp\n"; 1677 1678 assembler->fsin(); 1679 str << "fsin\n"; 1680 1681 assembler->fcos(); 1682 str << "fcos\n"; 1683 1684 assembler->fptan(); 1685 str << "fptan\n"; 1686 1687 return str.str(); 1688 } 1689 1690 TEST_F(AssemblerX86_64Test, X87) { 1691 DriverFn(&x87_fn, "x87"); 1692 } 1693 1694 TEST_F(AssemblerX86_64Test, FPUIntegerLoads) { 1695 DriverStr(RepeatA(&x86_64::X86_64Assembler::filds, 1696 addresses_singleton_, // no ext addressing 1697 "fildl {mem}"), "filds"); 1698 } 1699 1700 TEST_F(AssemblerX86_64Test, FPUIntegerLoadl) { 1701 DriverStr(RepeatA(&x86_64::X86_64Assembler::fildl, 1702 addresses_singleton_, // no ext addressing 1703 "fildll {mem}"), "fildl"); 1704 } 1705 1706 TEST_F(AssemblerX86_64Test, FPUIntegerStores) { 1707 DriverStr(RepeatA(&x86_64::X86_64Assembler::fistps, 1708 addresses_singleton_, // no ext addressing 1709 "fistpl {mem}"), "fistps"); 1710 } 1711 1712 TEST_F(AssemblerX86_64Test, FPUIntegerStorel) { 1713 DriverStr(RepeatA(&x86_64::X86_64Assembler::fistpl, 1714 addresses_singleton_, // no ext addressing 1715 "fistpll {mem}"), "fistpl"); 1716 } 1717 1718 TEST_F(AssemblerX86_64Test, Call) { 1719 DriverStr(RepeatR(&x86_64::X86_64Assembler::call, "call *%{reg}"), "call"); 1720 } 1721 1722 TEST_F(AssemblerX86_64Test, Jmp) { 1723 DriverStr(RepeatR(&x86_64::X86_64Assembler::jmp, "jmp *%{reg}"), "jmp"); 1724 } 1725 1726 TEST_F(AssemblerX86_64Test, Enter) { 1727 DriverStr(RepeatI(&x86_64::X86_64Assembler::enter, 1728 /*imm_bytes*/ 2U, 1729 "enter ${imm}, $0", /*non-negative*/ true), "enter"); 1730 } 1731 1732 TEST_F(AssemblerX86_64Test, RetImm) { 1733 DriverStr(RepeatI(&x86_64::X86_64Assembler::ret, 1734 /*imm_bytes*/ 2U, 1735 "ret ${imm}", /*non-negative*/ true), "ret"); 1736 } 1737 1738 std::string ret_and_leave_fn(AssemblerX86_64Test::Base* assembler_test ATTRIBUTE_UNUSED, 1739 x86_64::X86_64Assembler* assembler) { 1740 std::ostringstream str; 1741 1742 assembler->ret(); 1743 str << "ret\n"; 1744 1745 assembler->leave(); 1746 str << "leave\n"; 1747 1748 return str.str(); 1749 } 1750 1751 TEST_F(AssemblerX86_64Test, RetAndLeave) { 1752 DriverFn(&ret_and_leave_fn, "retleave"); 1753 } 1754 1755 TEST_F(AssemblerX86_64Test, Bswapl) { 1756 DriverStr(Repeatr(&x86_64::X86_64Assembler::bswapl, "bswap %{reg}"), "bswapl"); 1757 } 1758 1759 TEST_F(AssemblerX86_64Test, Bswapq) { 1760 DriverStr(RepeatR(&x86_64::X86_64Assembler::bswapq, "bswap %{reg}"), "bswapq"); 1761 } 1762 1763 TEST_F(AssemblerX86_64Test, Bsfl) { 1764 DriverStr(Repeatrr(&x86_64::X86_64Assembler::bsfl, "bsfl %{reg2}, %{reg1}"), "bsfl"); 1765 } 1766 1767 TEST_F(AssemblerX86_64Test, BsflAddress) { 1768 DriverStr(RepeatrA(&x86_64::X86_64Assembler::bsfl, "bsfl {mem}, %{reg}"), "bsfl_address"); 1769 } 1770 1771 TEST_F(AssemblerX86_64Test, Bsfq) { 1772 DriverStr(RepeatRR(&x86_64::X86_64Assembler::bsfq, "bsfq %{reg2}, %{reg1}"), "bsfq"); 1773 } 1774 1775 TEST_F(AssemblerX86_64Test, BsfqAddress) { 1776 DriverStr(RepeatRA(&x86_64::X86_64Assembler::bsfq, "bsfq {mem}, %{reg}"), "bsfq_address"); 1777 } 1778 1779 TEST_F(AssemblerX86_64Test, Bsrl) { 1780 DriverStr(Repeatrr(&x86_64::X86_64Assembler::bsrl, "bsrl %{reg2}, %{reg1}"), "bsrl"); 1781 } 1782 1783 TEST_F(AssemblerX86_64Test, BsrlAddress) { 1784 DriverStr(RepeatrA(&x86_64::X86_64Assembler::bsrl, "bsrl {mem}, %{reg}"), "bsrl_address"); 1785 } 1786 1787 TEST_F(AssemblerX86_64Test, Bsrq) { 1788 DriverStr(RepeatRR(&x86_64::X86_64Assembler::bsrq, "bsrq %{reg2}, %{reg1}"), "bsrq"); 1789 } 1790 1791 TEST_F(AssemblerX86_64Test, BsrqAddress) { 1792 DriverStr(RepeatRA(&x86_64::X86_64Assembler::bsrq, "bsrq {mem}, %{reg}"), "bsrq_address"); 1793 } 1794 1795 TEST_F(AssemblerX86_64Test, Popcntl) { 1796 DriverStr(Repeatrr(&x86_64::X86_64Assembler::popcntl, "popcntl %{reg2}, %{reg1}"), "popcntl"); 1797 } 1798 1799 TEST_F(AssemblerX86_64Test, PopcntlAddress) { 1800 DriverStr(RepeatrA(&x86_64::X86_64Assembler::popcntl, "popcntl {mem}, %{reg}"), "popcntl_address"); 1801 } 1802 1803 TEST_F(AssemblerX86_64Test, Popcntq) { 1804 DriverStr(RepeatRR(&x86_64::X86_64Assembler::popcntq, "popcntq %{reg2}, %{reg1}"), "popcntq"); 1805 } 1806 1807 TEST_F(AssemblerX86_64Test, PopcntqAddress) { 1808 DriverStr(RepeatRA(&x86_64::X86_64Assembler::popcntq, "popcntq {mem}, %{reg}"), "popcntq_address"); 1809 } 1810 1811 TEST_F(AssemblerX86_64Test, CmovlAddress) { 1812 GetAssembler()->cmov(x86_64::kEqual, x86_64::CpuRegister(x86_64::R10), x86_64::Address( 1813 x86_64::CpuRegister(x86_64::RDI), x86_64::CpuRegister(x86_64::RBX), x86_64::TIMES_4, 12), false); 1814 GetAssembler()->cmov(x86_64::kNotEqual, x86_64::CpuRegister(x86_64::RDI), x86_64::Address( 1815 x86_64::CpuRegister(x86_64::R10), x86_64::CpuRegister(x86_64::RBX), x86_64::TIMES_4, 12), false); 1816 GetAssembler()->cmov(x86_64::kEqual, x86_64::CpuRegister(x86_64::RDI), x86_64::Address( 1817 x86_64::CpuRegister(x86_64::RDI), x86_64::CpuRegister(x86_64::R9), x86_64::TIMES_4, 12), false); 1818 const char* expected = 1819 "cmovzl 0xc(%RDI,%RBX,4), %R10d\n" 1820 "cmovnzl 0xc(%R10,%RBX,4), %edi\n" 1821 "cmovzl 0xc(%RDI,%R9,4), %edi\n"; 1822 DriverStr(expected, "cmovl_address"); 1823 } 1824 1825 TEST_F(AssemblerX86_64Test, CmovqAddress) { 1826 GetAssembler()->cmov(x86_64::kEqual, x86_64::CpuRegister(x86_64::R10), x86_64::Address( 1827 x86_64::CpuRegister(x86_64::RDI), x86_64::CpuRegister(x86_64::RBX), x86_64::TIMES_4, 12), true); 1828 GetAssembler()->cmov(x86_64::kNotEqual, x86_64::CpuRegister(x86_64::RDI), x86_64::Address( 1829 x86_64::CpuRegister(x86_64::R10), x86_64::CpuRegister(x86_64::RBX), x86_64::TIMES_4, 12), true); 1830 GetAssembler()->cmov(x86_64::kEqual, x86_64::CpuRegister(x86_64::RDI), x86_64::Address( 1831 x86_64::CpuRegister(x86_64::RDI), x86_64::CpuRegister(x86_64::R9), x86_64::TIMES_4, 12), true); 1832 const char* expected = 1833 "cmovzq 0xc(%RDI,%RBX,4), %R10\n" 1834 "cmovnzq 0xc(%R10,%RBX,4), %rdi\n" 1835 "cmovzq 0xc(%RDI,%R9,4), %rdi\n"; 1836 DriverStr(expected, "cmovq_address"); 1837 } 1838 1839 TEST_F(AssemblerX86_64Test, Jrcxz) { 1840 x86_64::NearLabel target; 1841 GetAssembler()->jrcxz(&target); 1842 GetAssembler()->addl(x86_64::CpuRegister(x86_64::RDI), 1843 x86_64::Address(x86_64::CpuRegister(x86_64::RSP), 4)); 1844 GetAssembler()->Bind(&target); 1845 const char* expected = 1846 "jrcxz 1f\n" 1847 "addl 4(%RSP),%EDI\n" 1848 "1:\n"; 1849 1850 DriverStr(expected, "jrcxz"); 1851 } 1852 1853 TEST_F(AssemblerX86_64Test, NearLabel) { 1854 // Test both forward and backward branches. 1855 x86_64::NearLabel start, target; 1856 GetAssembler()->Bind(&start); 1857 GetAssembler()->j(x86_64::kEqual, &target); 1858 GetAssembler()->jmp(&target); 1859 GetAssembler()->jrcxz(&target); 1860 GetAssembler()->addl(x86_64::CpuRegister(x86_64::RDI), 1861 x86_64::Address(x86_64::CpuRegister(x86_64::RSP), 4)); 1862 GetAssembler()->Bind(&target); 1863 GetAssembler()->j(x86_64::kNotEqual, &start); 1864 GetAssembler()->jmp(&start); 1865 const char* expected = 1866 "1: je 2f\n" 1867 "jmp 2f\n" 1868 "jrcxz 2f\n" 1869 "addl 4(%RSP),%EDI\n" 1870 "2: jne 1b\n" 1871 "jmp 1b\n"; 1872 1873 DriverStr(expected, "near_label"); 1874 } 1875 1876 std::string setcc_test_fn(AssemblerX86_64Test::Base* assembler_test, 1877 x86_64::X86_64Assembler* assembler) { 1878 // From Condition 1879 /* 1880 kOverflow = 0, 1881 kNoOverflow = 1, 1882 kBelow = 2, 1883 kAboveEqual = 3, 1884 kEqual = 4, 1885 kNotEqual = 5, 1886 kBelowEqual = 6, 1887 kAbove = 7, 1888 kSign = 8, 1889 kNotSign = 9, 1890 kParityEven = 10, 1891 kParityOdd = 11, 1892 kLess = 12, 1893 kGreaterEqual = 13, 1894 kLessEqual = 14, 1895 */ 1896 std::string suffixes[15] = { "o", "no", "b", "ae", "e", "ne", "be", "a", "s", "ns", "pe", "po", 1897 "l", "ge", "le" }; 1898 1899 std::vector<x86_64::CpuRegister*> registers = assembler_test->GetRegisters(); 1900 std::ostringstream str; 1901 1902 for (auto reg : registers) { 1903 for (size_t i = 0; i < 15; ++i) { 1904 assembler->setcc(static_cast<x86_64::Condition>(i), *reg); 1905 str << "set" << suffixes[i] << " %" << assembler_test->GetQuaternaryRegisterName(*reg) << "\n"; 1906 } 1907 } 1908 1909 return str.str(); 1910 } 1911 1912 TEST_F(AssemblerX86_64Test, SetCC) { 1913 DriverFn(&setcc_test_fn, "setcc"); 1914 } 1915 1916 TEST_F(AssemblerX86_64Test, MovzxbRegs) { 1917 DriverStr(Repeatrb(&x86_64::X86_64Assembler::movzxb, "movzbl %{reg2}, %{reg1}"), "movzxb"); 1918 } 1919 1920 TEST_F(AssemblerX86_64Test, MovsxbRegs) { 1921 DriverStr(Repeatrb(&x86_64::X86_64Assembler::movsxb, "movsbl %{reg2}, %{reg1}"), "movsxb"); 1922 } 1923 1924 TEST_F(AssemblerX86_64Test, Repnescasw) { 1925 GetAssembler()->repne_scasw(); 1926 const char* expected = "repne scasw\n"; 1927 DriverStr(expected, "Repnescasw"); 1928 } 1929 1930 TEST_F(AssemblerX86_64Test, Repecmpsw) { 1931 GetAssembler()->repe_cmpsw(); 1932 const char* expected = "repe cmpsw\n"; 1933 DriverStr(expected, "Repecmpsw"); 1934 } 1935 1936 TEST_F(AssemblerX86_64Test, Repecmpsl) { 1937 GetAssembler()->repe_cmpsl(); 1938 const char* expected = "repe cmpsl\n"; 1939 DriverStr(expected, "Repecmpsl"); 1940 } 1941 1942 TEST_F(AssemblerX86_64Test, Repecmpsq) { 1943 GetAssembler()->repe_cmpsq(); 1944 const char* expected = "repe cmpsq\n"; 1945 DriverStr(expected, "Repecmpsq"); 1946 } 1947 1948 TEST_F(AssemblerX86_64Test, Cmpb) { 1949 DriverStr(RepeatAI(&x86_64::X86_64Assembler::cmpb, 1950 /*imm_bytes*/ 1U, 1951 "cmpb ${imm}, {mem}"), "cmpb"); 1952 } 1953 1954 TEST_F(AssemblerX86_64Test, TestbAddressImmediate) { 1955 DriverStr(RepeatAI(&x86_64::X86_64Assembler::testb, 1956 /*imm_bytes*/ 1U, 1957 "testb ${imm}, {mem}"), "testbi"); 1958 } 1959 1960 TEST_F(AssemblerX86_64Test, TestlAddressImmediate) { 1961 DriverStr(RepeatAI(&x86_64::X86_64Assembler::testl, 1962 /*imm_bytes*/ 4U, 1963 "testl ${imm}, {mem}"), "testli"); 1964 } 1965 1966 class JNIMacroAssemblerX86_64Test : public JNIMacroAssemblerTest<x86_64::X86_64JNIMacroAssembler> { 1967 public: 1968 using Base = JNIMacroAssemblerTest<x86_64::X86_64JNIMacroAssembler>; 1969 1970 protected: 1971 // Get the typically used name for this architecture, e.g., aarch64, x86-64, ... 1972 std::string GetArchitectureString() OVERRIDE { 1973 return "x86_64"; 1974 } 1975 1976 std::string GetDisassembleParameters() OVERRIDE { 1977 return " -D -bbinary -mi386:x86-64 -Mx86-64,addr64,data32 --no-show-raw-insn"; 1978 } 1979 1980 private: 1981 }; 1982 1983 static x86_64::X86_64ManagedRegister ManagedFromCpu(x86_64::Register r) { 1984 return x86_64::X86_64ManagedRegister::FromCpuRegister(r); 1985 } 1986 1987 static x86_64::X86_64ManagedRegister ManagedFromFpu(x86_64::FloatRegister r) { 1988 return x86_64::X86_64ManagedRegister::FromXmmRegister(r); 1989 } 1990 1991 std::string buildframe_test_fn(JNIMacroAssemblerX86_64Test::Base* assembler_test ATTRIBUTE_UNUSED, 1992 x86_64::X86_64JNIMacroAssembler* assembler) { 1993 // TODO: more interesting spill registers / entry spills. 1994 1995 // Two random spill regs. 1996 const ManagedRegister raw_spill_regs[] = { 1997 ManagedFromCpu(x86_64::R10), 1998 ManagedFromCpu(x86_64::RSI) 1999 }; 2000 ArrayRef<const ManagedRegister> spill_regs(raw_spill_regs); 2001 2002 // Three random entry spills. 2003 ManagedRegisterEntrySpills entry_spills; 2004 ManagedRegisterSpill spill(ManagedFromCpu(x86_64::RAX), 8, 0); 2005 entry_spills.push_back(spill); 2006 ManagedRegisterSpill spill2(ManagedFromCpu(x86_64::RBX), 8, 8); 2007 entry_spills.push_back(spill2); 2008 ManagedRegisterSpill spill3(ManagedFromFpu(x86_64::XMM1), 8, 16); 2009 entry_spills.push_back(spill3); 2010 2011 x86_64::X86_64ManagedRegister method_reg = ManagedFromCpu(x86_64::RDI); 2012 2013 size_t frame_size = 10 * kStackAlignment; 2014 assembler->BuildFrame(frame_size, method_reg, spill_regs, entry_spills); 2015 2016 // Construct assembly text counterpart. 2017 std::ostringstream str; 2018 // (1) Push the spill_regs. 2019 str << "pushq %rsi\n"; 2020 str << "pushq %r10\n"; 2021 // (2) Move down the stack pointer. 2022 ssize_t displacement = static_cast<ssize_t>(frame_size) - (spill_regs.size() * 8 + 8); 2023 str << "subq $" << displacement << ", %rsp\n"; 2024 // (3) Store method reference. 2025 str << "movq %rdi, (%rsp)\n"; 2026 // (4) Entry spills. 2027 str << "movq %rax, " << frame_size + 0 << "(%rsp)\n"; 2028 str << "movq %rbx, " << frame_size + 8 << "(%rsp)\n"; 2029 str << "movsd %xmm1, " << frame_size + 16 << "(%rsp)\n"; 2030 2031 return str.str(); 2032 } 2033 2034 TEST_F(JNIMacroAssemblerX86_64Test, BuildFrame) { 2035 DriverFn(&buildframe_test_fn, "BuildFrame"); 2036 } 2037 2038 std::string removeframe_test_fn(JNIMacroAssemblerX86_64Test::Base* assembler_test ATTRIBUTE_UNUSED, 2039 x86_64::X86_64JNIMacroAssembler* assembler) { 2040 // TODO: more interesting spill registers / entry spills. 2041 2042 // Two random spill regs. 2043 const ManagedRegister raw_spill_regs[] = { 2044 ManagedFromCpu(x86_64::R10), 2045 ManagedFromCpu(x86_64::RSI) 2046 }; 2047 ArrayRef<const ManagedRegister> spill_regs(raw_spill_regs); 2048 2049 size_t frame_size = 10 * kStackAlignment; 2050 assembler->RemoveFrame(frame_size, spill_regs, /* may_suspend */ true); 2051 2052 // Construct assembly text counterpart. 2053 std::ostringstream str; 2054 // (1) Move up the stack pointer. 2055 ssize_t displacement = static_cast<ssize_t>(frame_size) - spill_regs.size() * 8 - 8; 2056 str << "addq $" << displacement << ", %rsp\n"; 2057 // (2) Pop spill regs. 2058 str << "popq %r10\n"; 2059 str << "popq %rsi\n"; 2060 str << "ret\n"; 2061 2062 return str.str(); 2063 } 2064 2065 TEST_F(JNIMacroAssemblerX86_64Test, RemoveFrame) { 2066 DriverFn(&removeframe_test_fn, "RemoveFrame"); 2067 } 2068 2069 std::string increaseframe_test_fn( 2070 JNIMacroAssemblerX86_64Test::Base* assembler_test ATTRIBUTE_UNUSED, 2071 x86_64::X86_64JNIMacroAssembler* assembler) { 2072 assembler->IncreaseFrameSize(0U); 2073 assembler->IncreaseFrameSize(kStackAlignment); 2074 assembler->IncreaseFrameSize(10 * kStackAlignment); 2075 2076 // Construct assembly text counterpart. 2077 std::ostringstream str; 2078 str << "addq $0, %rsp\n"; 2079 str << "addq $-" << kStackAlignment << ", %rsp\n"; 2080 str << "addq $-" << 10 * kStackAlignment << ", %rsp\n"; 2081 2082 return str.str(); 2083 } 2084 2085 TEST_F(JNIMacroAssemblerX86_64Test, IncreaseFrame) { 2086 DriverFn(&increaseframe_test_fn, "IncreaseFrame"); 2087 } 2088 2089 std::string decreaseframe_test_fn( 2090 JNIMacroAssemblerX86_64Test::Base* assembler_test ATTRIBUTE_UNUSED, 2091 x86_64::X86_64JNIMacroAssembler* assembler) { 2092 assembler->DecreaseFrameSize(0U); 2093 assembler->DecreaseFrameSize(kStackAlignment); 2094 assembler->DecreaseFrameSize(10 * kStackAlignment); 2095 2096 // Construct assembly text counterpart. 2097 std::ostringstream str; 2098 str << "addq $0, %rsp\n"; 2099 str << "addq $" << kStackAlignment << ", %rsp\n"; 2100 str << "addq $" << 10 * kStackAlignment << ", %rsp\n"; 2101 2102 return str.str(); 2103 } 2104 2105 TEST_F(JNIMacroAssemblerX86_64Test, DecreaseFrame) { 2106 DriverFn(&decreaseframe_test_fn, "DecreaseFrame"); 2107 } 2108 2109 } // namespace art 2110
