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/macros.h"
25 #include "base/malloc_arena_pool.h"
26 #include "base/stl_util.h"
27 #include "jni_macro_assembler_x86_64.h"
28 #include "utils/assembler_test.h"
29 #include "utils/jni_macro_assembler_test.h"
30
31 namespace art HIDDEN {
32
TEST(AssemblerX86_64,CreateBuffer)33 TEST(AssemblerX86_64, CreateBuffer) {
34 MallocArenaPool pool;
35 ArenaAllocator allocator(&pool);
36 AssemblerBuffer buffer(&allocator);
37 AssemblerBuffer::EnsureCapacity ensured(&buffer);
38 buffer.Emit<uint8_t>(0x42);
39 ASSERT_EQ(static_cast<size_t>(1), buffer.Size());
40 buffer.Emit<int32_t>(42);
41 ASSERT_EQ(static_cast<size_t>(5), buffer.Size());
42 }
43
44 #ifdef ART_TARGET_ANDROID
45 static constexpr size_t kRandomIterations = 1000; // Devices might be puny, don't stress them...
46 #else
47 static constexpr size_t kRandomIterations = 100000; // Hosts are pretty powerful.
48 #endif
49
TEST(AssemblerX86_64,SignExtension)50 TEST(AssemblerX86_64, SignExtension) {
51 // 32bit.
52 for (int32_t i = 0; i < 128; i++) {
53 EXPECT_TRUE(IsInt<8>(i)) << i;
54 }
55 for (int32_t i = 128; i < 255; i++) {
56 EXPECT_FALSE(IsInt<8>(i)) << i;
57 }
58 // Do some higher ones randomly.
59 std::random_device rd;
60 std::default_random_engine e1(rd());
61 std::uniform_int_distribution<int32_t> uniform_dist(256, INT32_MAX);
62 for (size_t i = 0; i < kRandomIterations; i++) {
63 int32_t value = uniform_dist(e1);
64 EXPECT_FALSE(IsInt<8>(value)) << value;
65 }
66
67 // Negative ones.
68 for (int32_t i = -1; i >= -128; i--) {
69 EXPECT_TRUE(IsInt<8>(i)) << i;
70 }
71
72 for (int32_t i = -129; i > -256; i--) {
73 EXPECT_FALSE(IsInt<8>(i)) << i;
74 }
75
76 // Do some lower ones randomly.
77 std::uniform_int_distribution<int32_t> uniform_dist2(INT32_MIN, -256);
78 for (size_t i = 0; i < 100; i++) {
79 int32_t value = uniform_dist2(e1);
80 EXPECT_FALSE(IsInt<8>(value)) << value;
81 }
82
83 // 64bit.
84 for (int64_t i = 0; i < 128; i++) {
85 EXPECT_TRUE(IsInt<8>(i)) << i;
86 }
87 for (int32_t i = 128; i < 255; i++) {
88 EXPECT_FALSE(IsInt<8>(i)) << i;
89 }
90 // Do some higher ones randomly.
91 std::uniform_int_distribution<int64_t> uniform_dist3(256, INT64_MAX);
92 for (size_t i = 0; i < 100; i++) {
93 int64_t value = uniform_dist3(e1);
94 EXPECT_FALSE(IsInt<8>(value)) << value;
95 }
96
97 // Negative ones.
98 for (int64_t i = -1; i >= -128; i--) {
99 EXPECT_TRUE(IsInt<8>(i)) << i;
100 }
101
102 for (int64_t i = -129; i > -256; i--) {
103 EXPECT_FALSE(IsInt<8>(i)) << i;
104 }
105
106 // Do some lower ones randomly.
107 std::uniform_int_distribution<int64_t> uniform_dist4(INT64_MIN, -256);
108 for (size_t i = 0; i < kRandomIterations; i++) {
109 int64_t value = uniform_dist4(e1);
110 EXPECT_FALSE(IsInt<8>(value)) << value;
111 }
112
113 int64_t value = INT64_C(0x1200000010);
114 x86_64::Immediate imm(value);
115 EXPECT_FALSE(imm.is_int8());
116 EXPECT_FALSE(imm.is_int16());
117 EXPECT_FALSE(imm.is_int32());
118 value = INT64_C(0x8000000000000001);
119 x86_64::Immediate imm2(value);
120 EXPECT_FALSE(imm2.is_int8());
121 EXPECT_FALSE(imm2.is_int16());
122 EXPECT_FALSE(imm2.is_int32());
123 }
124
125 struct X86_64CpuRegisterCompare {
operator ()art::X86_64CpuRegisterCompare126 bool operator()(const x86_64::CpuRegister& a, const x86_64::CpuRegister& b) const {
127 return a.AsRegister() < b.AsRegister();
128 }
129 };
130
131 //
132 // Test fixture.
133 //
134
135 class AssemblerX86_64Test : public AssemblerTest<x86_64::X86_64Assembler,
136 x86_64::Address,
137 x86_64::CpuRegister,
138 x86_64::XmmRegister,
139 x86_64::Immediate> {
140 public:
141 using Base = AssemblerTest<x86_64::X86_64Assembler,
142 x86_64::Address,
143 x86_64::CpuRegister,
144 x86_64::XmmRegister,
145 x86_64::Immediate>;
146
147 protected:
AssemblerX86_64Test()148 AssemblerX86_64Test() : Base() {
149 require_same_encoding_ = false; // Allow different encoding with the same size and disassembly.
150 }
151
GetIsa()152 InstructionSet GetIsa() override {
153 return InstructionSet::kX86_64;
154 }
155
SetUpHelpers()156 void SetUpHelpers() override {
157 if (addresses_singleton_.size() == 0) {
158 // One addressing mode to test the repeat drivers.
159 addresses_singleton_.push_back(
160 x86_64::Address(x86_64::CpuRegister(x86_64::RAX),
161 x86_64::CpuRegister(x86_64::RBX), TIMES_1, -1));
162 }
163
164 if (addresses_.size() == 0) {
165 // Several addressing modes.
166 addresses_.push_back(
167 x86_64::Address(x86_64::CpuRegister(x86_64::RDI),
168 x86_64::CpuRegister(x86_64::RAX), TIMES_1, 15));
169 addresses_.push_back(
170 x86_64::Address(x86_64::CpuRegister(x86_64::RDI),
171 x86_64::CpuRegister(x86_64::RBX), TIMES_2, 16));
172 addresses_.push_back(
173 x86_64::Address(x86_64::CpuRegister(x86_64::RDI),
174 x86_64::CpuRegister(x86_64::RCX), TIMES_4, 17));
175 addresses_.push_back(
176 x86_64::Address(x86_64::CpuRegister(x86_64::RDI),
177 x86_64::CpuRegister(x86_64::RDX), TIMES_8, 18));
178 addresses_.push_back(x86_64::Address(x86_64::CpuRegister(x86_64::RAX), -1));
179 addresses_.push_back(x86_64::Address(x86_64::CpuRegister(x86_64::RBX), 0));
180 addresses_.push_back(x86_64::Address(x86_64::CpuRegister(x86_64::RSI), 1));
181 addresses_.push_back(x86_64::Address(x86_64::CpuRegister(x86_64::RDI), 987654321));
182 // Several addressing modes with the special ESP.
183 addresses_.push_back(
184 x86_64::Address(x86_64::CpuRegister(x86_64::RSP),
185 x86_64::CpuRegister(x86_64::RAX), TIMES_1, 15));
186 addresses_.push_back(
187 x86_64::Address(x86_64::CpuRegister(x86_64::RSP),
188 x86_64::CpuRegister(x86_64::RBX), TIMES_2, 16));
189 addresses_.push_back(
190 x86_64::Address(x86_64::CpuRegister(x86_64::RSP),
191 x86_64::CpuRegister(x86_64::RCX), TIMES_4, 17));
192 addresses_.push_back(
193 x86_64::Address(x86_64::CpuRegister(x86_64::RSP),
194 x86_64::CpuRegister(x86_64::RDX), TIMES_8, 18));
195 addresses_.push_back(x86_64::Address(x86_64::CpuRegister(x86_64::RSP), -1));
196 addresses_.push_back(x86_64::Address(x86_64::CpuRegister(x86_64::RSP), 0));
197 addresses_.push_back(x86_64::Address(x86_64::CpuRegister(x86_64::RSP), 1));
198 addresses_.push_back(x86_64::Address(x86_64::CpuRegister(x86_64::RSP), 987654321));
199 // Several addressing modes with the higher registers.
200 addresses_.push_back(
201 x86_64::Address(x86_64::CpuRegister(x86_64::R8),
202 x86_64::CpuRegister(x86_64::R15), TIMES_2, -1));
203 addresses_.push_back(x86_64::Address(x86_64::CpuRegister(x86_64::R15), 123456789));
204 }
205
206 if (secondary_register_names_.empty()) {
207 secondary_register_names_.emplace(x86_64::CpuRegister(x86_64::RAX), "eax");
208 secondary_register_names_.emplace(x86_64::CpuRegister(x86_64::RBX), "ebx");
209 secondary_register_names_.emplace(x86_64::CpuRegister(x86_64::RCX), "ecx");
210 secondary_register_names_.emplace(x86_64::CpuRegister(x86_64::RDX), "edx");
211 secondary_register_names_.emplace(x86_64::CpuRegister(x86_64::RBP), "ebp");
212 secondary_register_names_.emplace(x86_64::CpuRegister(x86_64::RSP), "esp");
213 secondary_register_names_.emplace(x86_64::CpuRegister(x86_64::RSI), "esi");
214 secondary_register_names_.emplace(x86_64::CpuRegister(x86_64::RDI), "edi");
215 secondary_register_names_.emplace(x86_64::CpuRegister(x86_64::R8), "r8d");
216 secondary_register_names_.emplace(x86_64::CpuRegister(x86_64::R9), "r9d");
217 secondary_register_names_.emplace(x86_64::CpuRegister(x86_64::R10), "r10d");
218 secondary_register_names_.emplace(x86_64::CpuRegister(x86_64::R11), "r11d");
219 secondary_register_names_.emplace(x86_64::CpuRegister(x86_64::R12), "r12d");
220 secondary_register_names_.emplace(x86_64::CpuRegister(x86_64::R13), "r13d");
221 secondary_register_names_.emplace(x86_64::CpuRegister(x86_64::R14), "r14d");
222 secondary_register_names_.emplace(x86_64::CpuRegister(x86_64::R15), "r15d");
223
224 tertiary_register_names_.emplace(x86_64::CpuRegister(x86_64::RAX), "ax");
225 tertiary_register_names_.emplace(x86_64::CpuRegister(x86_64::RBX), "bx");
226 tertiary_register_names_.emplace(x86_64::CpuRegister(x86_64::RCX), "cx");
227 tertiary_register_names_.emplace(x86_64::CpuRegister(x86_64::RDX), "dx");
228 tertiary_register_names_.emplace(x86_64::CpuRegister(x86_64::RBP), "bp");
229 tertiary_register_names_.emplace(x86_64::CpuRegister(x86_64::RSP), "sp");
230 tertiary_register_names_.emplace(x86_64::CpuRegister(x86_64::RSI), "si");
231 tertiary_register_names_.emplace(x86_64::CpuRegister(x86_64::RDI), "di");
232 tertiary_register_names_.emplace(x86_64::CpuRegister(x86_64::R8), "r8w");
233 tertiary_register_names_.emplace(x86_64::CpuRegister(x86_64::R9), "r9w");
234 tertiary_register_names_.emplace(x86_64::CpuRegister(x86_64::R10), "r10w");
235 tertiary_register_names_.emplace(x86_64::CpuRegister(x86_64::R11), "r11w");
236 tertiary_register_names_.emplace(x86_64::CpuRegister(x86_64::R12), "r12w");
237 tertiary_register_names_.emplace(x86_64::CpuRegister(x86_64::R13), "r13w");
238 tertiary_register_names_.emplace(x86_64::CpuRegister(x86_64::R14), "r14w");
239 tertiary_register_names_.emplace(x86_64::CpuRegister(x86_64::R15), "r15w");
240
241 quaternary_register_names_.emplace(x86_64::CpuRegister(x86_64::RAX), "al");
242 quaternary_register_names_.emplace(x86_64::CpuRegister(x86_64::RBX), "bl");
243 quaternary_register_names_.emplace(x86_64::CpuRegister(x86_64::RCX), "cl");
244 quaternary_register_names_.emplace(x86_64::CpuRegister(x86_64::RDX), "dl");
245 quaternary_register_names_.emplace(x86_64::CpuRegister(x86_64::RBP), "bpl");
246 quaternary_register_names_.emplace(x86_64::CpuRegister(x86_64::RSP), "spl");
247 quaternary_register_names_.emplace(x86_64::CpuRegister(x86_64::RSI), "sil");
248 quaternary_register_names_.emplace(x86_64::CpuRegister(x86_64::RDI), "dil");
249 quaternary_register_names_.emplace(x86_64::CpuRegister(x86_64::R8), "r8b");
250 quaternary_register_names_.emplace(x86_64::CpuRegister(x86_64::R9), "r9b");
251 quaternary_register_names_.emplace(x86_64::CpuRegister(x86_64::R10), "r10b");
252 quaternary_register_names_.emplace(x86_64::CpuRegister(x86_64::R11), "r11b");
253 quaternary_register_names_.emplace(x86_64::CpuRegister(x86_64::R12), "r12b");
254 quaternary_register_names_.emplace(x86_64::CpuRegister(x86_64::R13), "r13b");
255 quaternary_register_names_.emplace(x86_64::CpuRegister(x86_64::R14), "r14b");
256 quaternary_register_names_.emplace(x86_64::CpuRegister(x86_64::R15), "r15b");
257 }
258 }
259
TearDown()260 void TearDown() override {
261 AssemblerTest::TearDown();
262 }
263
GetAddresses()264 std::vector<x86_64::Address> GetAddresses() override {
265 return addresses_;
266 }
267
GetRegisters()268 ArrayRef<const x86_64::CpuRegister> GetRegisters() override {
269 static constexpr x86_64::CpuRegister kRegisters[] = {
270 x86_64::CpuRegister(x86_64::RAX),
271 x86_64::CpuRegister(x86_64::RBX),
272 x86_64::CpuRegister(x86_64::RCX),
273 x86_64::CpuRegister(x86_64::RDX),
274 x86_64::CpuRegister(x86_64::RBP),
275 x86_64::CpuRegister(x86_64::RSP),
276 x86_64::CpuRegister(x86_64::RSI),
277 x86_64::CpuRegister(x86_64::RDI),
278 x86_64::CpuRegister(x86_64::R8),
279 x86_64::CpuRegister(x86_64::R9),
280 x86_64::CpuRegister(x86_64::R10),
281 x86_64::CpuRegister(x86_64::R11),
282 x86_64::CpuRegister(x86_64::R12),
283 x86_64::CpuRegister(x86_64::R13),
284 x86_64::CpuRegister(x86_64::R14),
285 x86_64::CpuRegister(x86_64::R15),
286 };
287 return ArrayRef<const x86_64::CpuRegister>(kRegisters);
288 }
289
GetFPRegisters()290 ArrayRef<const x86_64::XmmRegister> GetFPRegisters() override {
291 static constexpr x86_64::XmmRegister kFPRegisters[] = {
292 x86_64::XmmRegister(x86_64::XMM0),
293 x86_64::XmmRegister(x86_64::XMM1),
294 x86_64::XmmRegister(x86_64::XMM2),
295 x86_64::XmmRegister(x86_64::XMM3),
296 x86_64::XmmRegister(x86_64::XMM4),
297 x86_64::XmmRegister(x86_64::XMM5),
298 x86_64::XmmRegister(x86_64::XMM6),
299 x86_64::XmmRegister(x86_64::XMM7),
300 x86_64::XmmRegister(x86_64::XMM8),
301 x86_64::XmmRegister(x86_64::XMM9),
302 x86_64::XmmRegister(x86_64::XMM10),
303 x86_64::XmmRegister(x86_64::XMM11),
304 x86_64::XmmRegister(x86_64::XMM12),
305 x86_64::XmmRegister(x86_64::XMM13),
306 x86_64::XmmRegister(x86_64::XMM14),
307 x86_64::XmmRegister(x86_64::XMM15),
308 };
309 return ArrayRef<const x86_64::XmmRegister>(kFPRegisters);
310 }
311
CreateImmediate(int64_t imm_value)312 x86_64::Immediate CreateImmediate(int64_t imm_value) override {
313 return x86_64::Immediate(imm_value);
314 }
315
GetSecondaryRegisterName(const x86_64::CpuRegister & reg)316 std::string GetSecondaryRegisterName(const x86_64::CpuRegister& reg) override {
317 CHECK(secondary_register_names_.find(reg) != secondary_register_names_.end());
318 return secondary_register_names_[reg];
319 }
320
GetTertiaryRegisterName(const x86_64::CpuRegister & reg)321 std::string GetTertiaryRegisterName(const x86_64::CpuRegister& reg) override {
322 CHECK(tertiary_register_names_.find(reg) != tertiary_register_names_.end());
323 return tertiary_register_names_[reg];
324 }
325
GetQuaternaryRegisterName(const x86_64::CpuRegister & reg)326 std::string GetQuaternaryRegisterName(const x86_64::CpuRegister& reg) override {
327 CHECK(quaternary_register_names_.find(reg) != quaternary_register_names_.end());
328 return quaternary_register_names_[reg];
329 }
330
331 std::vector<x86_64::Address> addresses_singleton_;
332
333 private:
334 std::vector<x86_64::Address> addresses_;
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 };
339
340 class AssemblerX86_64AVXTest : public AssemblerX86_64Test {
341 public:
AssemblerX86_64AVXTest()342 AssemblerX86_64AVXTest()
343 : instruction_set_features_(X86_64InstructionSetFeatures::FromVariant("kabylake", nullptr)) {}
344 protected:
CreateAssembler(ArenaAllocator * allocator)345 x86_64::X86_64Assembler* CreateAssembler(ArenaAllocator* allocator) override {
346 return new (allocator) x86_64::X86_64Assembler(allocator, instruction_set_features_.get());
347 }
348 private:
349 std::unique_ptr<const X86_64InstructionSetFeatures> instruction_set_features_;
350 };
351
352 //
353 // Test some repeat drivers used in the tests.
354 //
355
TEST_F(AssemblerX86_64Test,RepeatI4)356 TEST_F(AssemblerX86_64Test, RepeatI4) {
357 EXPECT_EQ("$0\n$-1\n$18\n$4660\n$-4660\n$305419896\n$-305419896\n",
358 RepeatI(/*f*/ nullptr, /*imm_bytes*/ 4U, "${imm}"));
359 }
360
TEST_F(AssemblerX86_64Test,RepeatI8)361 TEST_F(AssemblerX86_64Test, RepeatI8) {
362 EXPECT_EQ("$0\n$-1\n$18\n$4660\n$-4660\n$305419896\n$-305419896\n"
363 "$20015998343868\n$-20015998343868\n$1311768467463790320\n"
364 "$-1311768467463790320\n",
365 RepeatI(/*f*/ nullptr, /*imm_bytes*/ 8U, "${imm}"));
366 }
367
TEST_F(AssemblerX86_64Test,Repeatr)368 TEST_F(AssemblerX86_64Test, Repeatr) {
369 EXPECT_EQ("%eax\n%ebx\n%ecx\n%edx\n%ebp\n%esp\n%esi\n%edi\n"
370 "%r8d\n%r9d\n%r10d\n%r11d\n%r12d\n%r13d\n%r14d\n%r15d\n",
371 Repeatr(/*f*/ nullptr, "%{reg}"));
372 }
373
TEST_F(AssemblerX86_64Test,RepeatrI)374 TEST_F(AssemblerX86_64Test, RepeatrI) {
375 EXPECT_NE(RepeatrI(/*f*/ nullptr, /*imm_bytes*/ 1U, "%{reg} ${imm}").
376 find("%eax $0\n%eax $-1\n%eax $18\n%ebx $0\n%ebx $-1\n%ebx $18\n"
377 "%ecx $0\n%ecx $-1\n%ecx $18\n%edx $0\n%edx $-1\n%edx $18\n"),
378 std::string::npos);
379 }
380
TEST_F(AssemblerX86_64Test,Repeatrr)381 TEST_F(AssemblerX86_64Test, Repeatrr) {
382 EXPECT_NE(Repeatrr(/*f*/ nullptr, "%{reg1} %{reg2}")
383 .find("%eax %eax\n%eax %ebx\n%eax %ecx\n%eax %edx\n"
384 "%eax %ebp\n%eax %esp\n%eax %esi\n%eax %edi\n"),
385 std::string::npos);
386 }
387
TEST_F(AssemblerX86_64Test,Repeatrb)388 TEST_F(AssemblerX86_64Test, Repeatrb) {
389 EXPECT_NE(Repeatrb(/*f*/ nullptr, "%{reg1} %{reg2}").
390 find("%eax %al\n%eax %bl\n%eax %cl\n%eax %dl\n%eax %bpl\n"
391 "%eax %spl\n%eax %sil\n%eax %dil\n%eax %r8b\n%eax %r9b\n"),
392 std::string::npos);
393 }
394
TEST_F(AssemblerX86_64Test,RepeatrF)395 TEST_F(AssemblerX86_64Test, RepeatrF) {
396 EXPECT_NE(RepeatrF(/*f*/ nullptr, "%{reg1} %{reg2}")
397 .find("%eax %xmm0\n%eax %xmm1\n%eax %xmm2\n%eax %xmm3\n"
398 "%eax %xmm4\n%eax %xmm5\n%eax %xmm6\n%eax %xmm7\n"),
399 std::string::npos);
400 }
401
TEST_F(AssemblerX86_64Test,RepeatR)402 TEST_F(AssemblerX86_64Test, RepeatR) {
403 EXPECT_EQ("%rax\n%rbx\n%rcx\n%rdx\n%rbp\n%rsp\n%rsi\n%rdi\n"
404 "%r8\n%r9\n%r10\n%r11\n%r12\n%r13\n%r14\n%r15\n",
405 RepeatR(/*f*/ nullptr, "%{reg}"));
406 }
407
TEST_F(AssemblerX86_64Test,RepeatRI)408 TEST_F(AssemblerX86_64Test, RepeatRI) {
409 EXPECT_NE(RepeatRI(/*f*/ nullptr, /*imm_bytes*/ 1U, "%{reg} ${imm}")
410 .find("%rax $0\n%rax $-1\n%rax $18\n%rbx $0\n%rbx $-1\n%rbx $18\n"
411 "%rcx $0\n%rcx $-1\n%rcx $18\n%rdx $0\n%rdx $-1\n%rdx $18\n"),
412 std::string::npos);
413 }
414
TEST_F(AssemblerX86_64Test,RepeatRr)415 TEST_F(AssemblerX86_64Test, RepeatRr) {
416 EXPECT_NE(RepeatRr(/*f*/ nullptr, "%{reg1} %{reg2}")
417 .find("%rax %eax\n%rax %ebx\n%rax %ecx\n%rax %edx\n%rax %ebp\n"
418 "%rax %esp\n%rax %esi\n%rax %edi\n%rax %r8d\n%rax %r9d\n"),
419 std::string::npos);
420 }
421
TEST_F(AssemblerX86_64Test,RepeatRR)422 TEST_F(AssemblerX86_64Test, RepeatRR) {
423 EXPECT_NE(RepeatRR(/*f*/ nullptr, "%{reg1} %{reg2}")
424 .find("%rax %rax\n%rax %rbx\n%rax %rcx\n%rax %rdx\n%rax %rbp\n"
425 "%rax %rsp\n%rax %rsi\n%rax %rdi\n%rax %r8\n%rax %r9\n"),
426 std::string::npos);
427 }
428
TEST_F(AssemblerX86_64Test,RepeatRF)429 TEST_F(AssemblerX86_64Test, RepeatRF) {
430 EXPECT_NE(RepeatRF(/*f*/ nullptr, "%{reg1} %{reg2}")
431 .find("%rax %xmm0\n%rax %xmm1\n%rax %xmm2\n%rax %xmm3\n%rax %xmm4\n"
432 "%rax %xmm5\n%rax %xmm6\n%rax %xmm7\n%rax %xmm8\n%rax %xmm9\n"),
433 std::string::npos);
434 }
435
TEST_F(AssemblerX86_64Test,RepeatFF)436 TEST_F(AssemblerX86_64Test, RepeatFF) {
437 EXPECT_NE(RepeatFF(/*f*/ nullptr, "%{reg1} %{reg2}")
438 .find("%xmm0 %xmm0\n%xmm0 %xmm1\n%xmm0 %xmm2\n%xmm0 %xmm3\n%xmm0 %xmm4\n"
439 "%xmm0 %xmm5\n%xmm0 %xmm6\n%xmm0 %xmm7\n%xmm0 %xmm8\n%xmm0 %xmm9\n"),
440 std::string::npos);
441 }
442
TEST_F(AssemblerX86_64Test,RepeatFFI)443 TEST_F(AssemblerX86_64Test, RepeatFFI) {
444 EXPECT_NE(RepeatFFI(/*f*/ nullptr, /*imm_bytes*/ 1U, "%{reg1} %{reg2} ${imm}")
445 .find("%xmm0 %xmm0 $0\n%xmm0 %xmm0 $-1\n%xmm0 %xmm0 $18\n"
446 "%xmm0 %xmm1 $0\n%xmm0 %xmm1 $-1\n%xmm0 %xmm1 $18\n"),
447 std::string::npos);
448 }
449
TEST_F(AssemblerX86_64Test,RepeatA)450 TEST_F(AssemblerX86_64Test, RepeatA) {
451 EXPECT_EQ("-1(%rax,%rbx,1)\n", RepeatA(/*f*/ nullptr, addresses_singleton_, "{mem}"));
452 }
453
TEST_F(AssemblerX86_64Test,RepeatAFull)454 TEST_F(AssemblerX86_64Test, RepeatAFull) {
455 EXPECT_EQ("15(%rdi,%rax,1)\n16(%rdi,%rbx,2)\n17(%rdi,%rcx,4)\n18(%rdi,%rdx,8)\n"
456 "-1(%rax)\n(%rbx)\n1(%rsi)\n987654321(%rdi)\n15(%rsp,%rax,1)\n"
457 "16(%rsp,%rbx,2)\n17(%rsp,%rcx,4)\n18(%rsp,%rdx,8)\n-1(%rsp)\n"
458 "(%rsp)\n1(%rsp)\n987654321(%rsp)\n-1(%r8,%r15,2)\n123456789(%r15)\n",
459 RepeatA(/*f*/ nullptr, "{mem}"));
460 }
461
TEST_F(AssemblerX86_64Test,RepeatAI)462 TEST_F(AssemblerX86_64Test, RepeatAI) {
463 EXPECT_EQ("-1(%rax,%rbx,1) $0\n-1(%rax,%rbx,1) $-1\n-1(%rax,%rbx,1) $18\n",
464 RepeatAI(/*f*/ nullptr, /*imm_bytes*/ 1U, addresses_singleton_, "{mem} ${imm}"));
465 }
466
TEST_F(AssemblerX86_64Test,RepeatRA)467 TEST_F(AssemblerX86_64Test, RepeatRA) {
468 EXPECT_NE(RepeatRA(/*f*/ nullptr, addresses_singleton_, "%{reg} {mem}")
469 .find("%rax -1(%rax,%rbx,1)\n%rbx -1(%rax,%rbx,1)\n%rcx -1(%rax,%rbx,1)\n"
470 "%rdx -1(%rax,%rbx,1)\n%rbp -1(%rax,%rbx,1)\n%rsp -1(%rax,%rbx,1)\n"),
471 std::string::npos);
472 }
473
TEST_F(AssemblerX86_64Test,RepeatrA)474 TEST_F(AssemblerX86_64Test, RepeatrA) {
475 EXPECT_NE(RepeatrA(/*f*/ nullptr, addresses_singleton_, "%{reg} {mem}")
476 .find("%eax -1(%rax,%rbx,1)\n%ebx -1(%rax,%rbx,1)\n%ecx -1(%rax,%rbx,1)\n"
477 "%edx -1(%rax,%rbx,1)\n%ebp -1(%rax,%rbx,1)\n%esp -1(%rax,%rbx,1)\n"),
478 std::string::npos);
479 }
480
TEST_F(AssemblerX86_64Test,RepeatAR)481 TEST_F(AssemblerX86_64Test, RepeatAR) {
482 EXPECT_NE(RepeatAR(/*f*/ nullptr, addresses_singleton_, "{mem} %{reg}")
483 .find("-1(%rax,%rbx,1) %rax\n-1(%rax,%rbx,1) %rbx\n-1(%rax,%rbx,1) %rcx\n"
484 "-1(%rax,%rbx,1) %rdx\n-1(%rax,%rbx,1) %rbp\n-1(%rax,%rbx,1) %rsp\n"),
485 std::string::npos);
486 }
487
TEST_F(AssemblerX86_64Test,RepeatAr)488 TEST_F(AssemblerX86_64Test, RepeatAr) {
489 EXPECT_NE(RepeatAr(/*f*/ nullptr, addresses_singleton_, "{mem} %{reg}")
490 .find("-1(%rax,%rbx,1) %eax\n-1(%rax,%rbx,1) %ebx\n-1(%rax,%rbx,1) %ecx\n"
491 "-1(%rax,%rbx,1) %edx\n-1(%rax,%rbx,1) %ebp\n-1(%rax,%rbx,1) %esp\n"),
492 std::string::npos);
493 }
494
TEST_F(AssemblerX86_64Test,RepeatFA)495 TEST_F(AssemblerX86_64Test, RepeatFA) {
496 EXPECT_NE(RepeatFA(/*f*/ nullptr, addresses_singleton_, "%{reg} {mem}").
497 find("%xmm0 -1(%rax,%rbx,1)\n%xmm1 -1(%rax,%rbx,1)\n%xmm2 -1(%rax,%rbx,1)\n"
498 "%xmm3 -1(%rax,%rbx,1)\n%xmm4 -1(%rax,%rbx,1)\n%xmm5 -1(%rax,%rbx,1)\n"),
499 std::string::npos);
500 }
501
TEST_F(AssemblerX86_64Test,RepeatAF)502 TEST_F(AssemblerX86_64Test, RepeatAF) {
503 EXPECT_NE(RepeatAF(/*f*/ nullptr, addresses_singleton_, "{mem} %{reg}")
504 .find("-1(%rax,%rbx,1) %xmm0\n-1(%rax,%rbx,1) %xmm1\n-1(%rax,%rbx,1) %xmm2\n"
505 "-1(%rax,%rbx,1) %xmm3\n-1(%rax,%rbx,1) %xmm4\n-1(%rax,%rbx,1) %xmm5\n"),
506 std::string::npos);
507 }
508
509 //
510 // Actual x86-64 instruction assembler tests.
511 //
512
TEST_F(AssemblerX86_64Test,Toolchain)513 TEST_F(AssemblerX86_64Test, Toolchain) {
514 EXPECT_TRUE(CheckTools());
515 }
516
TEST_F(AssemblerX86_64Test,PopqAllAddresses)517 TEST_F(AssemblerX86_64Test, PopqAllAddresses) {
518 // Make sure all addressing modes combinations are tested at least once.
519 std::vector<x86_64::Address> all_addresses;
520 for (const x86_64::CpuRegister& base : GetRegisters()) {
521 // Base only.
522 all_addresses.push_back(x86_64::Address(base, -1));
523 all_addresses.push_back(x86_64::Address(base, 0));
524 all_addresses.push_back(x86_64::Address(base, 1));
525 all_addresses.push_back(x86_64::Address(base, 123456789));
526 for (const x86_64::CpuRegister& index : GetRegisters()) {
527 if (index.AsRegister() == x86_64::RSP) {
528 // Index cannot be RSP.
529 continue;
530 } else if (base.AsRegister() == index.AsRegister()) {
531 // Index only.
532 all_addresses.push_back(x86_64::Address(index, TIMES_1, -1));
533 all_addresses.push_back(x86_64::Address(index, TIMES_2, 0));
534 all_addresses.push_back(x86_64::Address(index, TIMES_4, 1));
535 all_addresses.push_back(x86_64::Address(index, TIMES_8, 123456789));
536 }
537 // Base and index.
538 all_addresses.push_back(x86_64::Address(base, index, TIMES_1, -1));
539 all_addresses.push_back(x86_64::Address(base, index, TIMES_2, 0));
540 all_addresses.push_back(x86_64::Address(base, index, TIMES_4, 1));
541 all_addresses.push_back(x86_64::Address(base, index, TIMES_8, 123456789));
542 }
543 }
544 DriverStr(RepeatA(&x86_64::X86_64Assembler::popq, all_addresses, "popq {mem}"), "popq");
545 }
546
TEST_F(AssemblerX86_64Test,PushqRegs)547 TEST_F(AssemblerX86_64Test, PushqRegs) {
548 DriverStr(RepeatR(&x86_64::X86_64Assembler::pushq, "pushq %{reg}"), "pushq");
549 }
550
TEST_F(AssemblerX86_64Test,PushqImm)551 TEST_F(AssemblerX86_64Test, PushqImm) {
552 DriverStr(RepeatI(&x86_64::X86_64Assembler::pushq, /*imm_bytes*/ 4U,
553 "pushq ${imm}"), "pushqi");
554 }
555
TEST_F(AssemblerX86_64Test,MovqRegs)556 TEST_F(AssemblerX86_64Test, MovqRegs) {
557 DriverStr(RepeatRR(&x86_64::X86_64Assembler::movq, "movq %{reg2}, %{reg1}"), "movq");
558 }
559
TEST_F(AssemblerX86_64Test,MovqImm)560 TEST_F(AssemblerX86_64Test, MovqImm) {
561 DriverStr(RepeatRI(&x86_64::X86_64Assembler::movq, /*imm_bytes*/ 8U,
562 "movq ${imm}, %{reg}"), "movqi");
563 }
564
TEST_F(AssemblerX86_64Test,MovlRegs)565 TEST_F(AssemblerX86_64Test, MovlRegs) {
566 DriverStr(Repeatrr(&x86_64::X86_64Assembler::movl, "mov %{reg2}, %{reg1}"), "movl");
567 }
568
TEST_F(AssemblerX86_64Test,MovlImm)569 TEST_F(AssemblerX86_64Test, MovlImm) {
570 DriverStr(RepeatrI(&x86_64::X86_64Assembler::movl, /*imm_bytes*/ 4U,
571 "mov ${imm}, %{reg}"), "movli");
572 }
573
TEST_F(AssemblerX86_64Test,AddqRegs)574 TEST_F(AssemblerX86_64Test, AddqRegs) {
575 DriverStr(RepeatRR(&x86_64::X86_64Assembler::addq, "addq %{reg2}, %{reg1}"), "addq");
576 }
577
TEST_F(AssemblerX86_64Test,AddqImm)578 TEST_F(AssemblerX86_64Test, AddqImm) {
579 DriverStr(RepeatRI(&x86_64::X86_64Assembler::addq, /*imm_bytes*/ 4U,
580 "addq ${imm}, %{reg}"), "addqi");
581 }
582
TEST_F(AssemblerX86_64Test,AddlRegs)583 TEST_F(AssemblerX86_64Test, AddlRegs) {
584 DriverStr(Repeatrr(&x86_64::X86_64Assembler::addl, "add %{reg2}, %{reg1}"), "addl");
585 }
586
TEST_F(AssemblerX86_64Test,AddlImm)587 TEST_F(AssemblerX86_64Test, AddlImm) {
588 DriverStr(RepeatrI(&x86_64::X86_64Assembler::addl, /*imm_bytes*/ 4U,
589 "add ${imm}, %{reg}"), "addli");
590 }
591
TEST_F(AssemblerX86_64Test,AddwMem)592 TEST_F(AssemblerX86_64Test, AddwMem) {
593 DriverStr(
594 RepeatAI(&x86_64::X86_64Assembler::addw, /*imm_bytes*/2U, "addw ${imm}, {mem}"), "addw");
595 }
596
TEST_F(AssemblerX86_64Test,AddwImm)597 TEST_F(AssemblerX86_64Test, AddwImm) {
598 DriverStr(
599 RepeatwI(&x86_64::X86_64Assembler::addw, /*imm_bytes*/2U, "addw ${imm}, %{reg}"), "addw");
600 }
601
TEST_F(AssemblerX86_64Test,AddwMemReg)602 TEST_F(AssemblerX86_64Test, AddwMemReg) {
603 DriverStr(
604 RepeatAw(&x86_64::X86_64Assembler::addw, "addw %{reg}, {mem}"), "addw");
605 }
606
TEST_F(AssemblerX86_64Test,ImulqReg1)607 TEST_F(AssemblerX86_64Test, ImulqReg1) {
608 DriverStr(RepeatR(&x86_64::X86_64Assembler::imulq, "imulq %{reg}"), "imulq");
609 }
610
TEST_F(AssemblerX86_64Test,ImulqRegs)611 TEST_F(AssemblerX86_64Test, ImulqRegs) {
612 DriverStr(RepeatRR(&x86_64::X86_64Assembler::imulq, "imulq %{reg2}, %{reg1}"), "imulq");
613 }
614
TEST_F(AssemblerX86_64Test,ImulqImm)615 TEST_F(AssemblerX86_64Test, ImulqImm) {
616 DriverStr(RepeatRI(&x86_64::X86_64Assembler::imulq, /*imm_bytes*/ 4U,
617 "imulq ${imm}, %{reg}, %{reg}"),
618 "imulqi");
619 }
620
TEST_F(AssemblerX86_64Test,ImullRegs)621 TEST_F(AssemblerX86_64Test, ImullRegs) {
622 DriverStr(Repeatrr(&x86_64::X86_64Assembler::imull, "imul %{reg2}, %{reg1}"), "imull");
623 }
624
TEST_F(AssemblerX86_64Test,ImullImm)625 TEST_F(AssemblerX86_64Test, ImullImm) {
626 DriverStr(RepeatrI(&x86_64::X86_64Assembler::imull, /*imm_bytes*/ 4U,
627 "imull ${imm}, %{reg}, %{reg}"),
628 "imulli");
629 }
630
TEST_F(AssemblerX86_64Test,Mull)631 TEST_F(AssemblerX86_64Test, Mull) {
632 DriverStr(Repeatr(&x86_64::X86_64Assembler::mull, "mull %{reg}"), "mull");
633 }
634
TEST_F(AssemblerX86_64Test,SubqRegs)635 TEST_F(AssemblerX86_64Test, SubqRegs) {
636 DriverStr(RepeatRR(&x86_64::X86_64Assembler::subq, "subq %{reg2}, %{reg1}"), "subq");
637 }
638
TEST_F(AssemblerX86_64Test,SubqImm)639 TEST_F(AssemblerX86_64Test, SubqImm) {
640 DriverStr(RepeatRI(&x86_64::X86_64Assembler::subq, /*imm_bytes*/ 4U,
641 "subq ${imm}, %{reg}"), "subqi");
642 }
643
TEST_F(AssemblerX86_64Test,SublRegs)644 TEST_F(AssemblerX86_64Test, SublRegs) {
645 DriverStr(Repeatrr(&x86_64::X86_64Assembler::subl, "sub %{reg2}, %{reg1}"), "subl");
646 }
647
TEST_F(AssemblerX86_64Test,SublImm)648 TEST_F(AssemblerX86_64Test, SublImm) {
649 DriverStr(RepeatrI(&x86_64::X86_64Assembler::subl, /*imm_bytes*/ 4U,
650 "sub ${imm}, %{reg}"), "subli");
651 }
652
653 // Shll only allows CL as the shift count.
shll_fn(AssemblerX86_64Test::Base * assembler_test,x86_64::X86_64Assembler * assembler)654 std::string shll_fn(AssemblerX86_64Test::Base* assembler_test, x86_64::X86_64Assembler* assembler) {
655 std::ostringstream str;
656 ArrayRef<const x86_64::CpuRegister> registers = assembler_test->GetRegisters();
657 x86_64::CpuRegister shifter(x86_64::RCX);
658 for (auto&& reg : registers) {
659 assembler->shll(reg, shifter);
660 str << "shll %cl, %" << assembler_test->GetSecondaryRegisterName(reg) << "\n";
661 }
662 return str.str();
663 }
664
TEST_F(AssemblerX86_64Test,ShllReg)665 TEST_F(AssemblerX86_64Test, ShllReg) {
666 DriverFn(&shll_fn, "shll");
667 }
668
TEST_F(AssemblerX86_64Test,ShllImm)669 TEST_F(AssemblerX86_64Test, ShllImm) {
670 DriverStr(RepeatrI(&x86_64::X86_64Assembler::shll, /*imm_bytes*/ 1U,
671 "shll ${imm}, %{reg}"), "shlli");
672 }
673
674 // Shlq only allows CL as the shift count.
shlq_fn(AssemblerX86_64Test::Base * assembler_test,x86_64::X86_64Assembler * assembler)675 std::string shlq_fn(AssemblerX86_64Test::Base* assembler_test, x86_64::X86_64Assembler* assembler) {
676 std::ostringstream str;
677 ArrayRef<const x86_64::CpuRegister> registers = assembler_test->GetRegisters();
678 x86_64::CpuRegister shifter(x86_64::RCX);
679 for (auto&& reg : registers) {
680 assembler->shlq(reg, shifter);
681 str << "shlq %cl, %" << assembler_test->GetRegisterName(reg) << "\n";
682 }
683 return str.str();
684 }
685
TEST_F(AssemblerX86_64Test,ShlqReg)686 TEST_F(AssemblerX86_64Test, ShlqReg) {
687 DriverFn(&shlq_fn, "shlq");
688 }
689
TEST_F(AssemblerX86_64Test,ShlqImm)690 TEST_F(AssemblerX86_64Test, ShlqImm) {
691 DriverStr(RepeatRI(&x86_64::X86_64Assembler::shlq, /*imm_bytes*/ 1U,
692 "shlq ${imm}, %{reg}"), "shlqi");
693 }
694
695 // Shrl only allows CL as the shift count.
shrl_fn(AssemblerX86_64Test::Base * assembler_test,x86_64::X86_64Assembler * assembler)696 std::string shrl_fn(AssemblerX86_64Test::Base* assembler_test, x86_64::X86_64Assembler* assembler) {
697 std::ostringstream str;
698 ArrayRef<const x86_64::CpuRegister> registers = assembler_test->GetRegisters();
699 x86_64::CpuRegister shifter(x86_64::RCX);
700 for (auto&& reg : registers) {
701 assembler->shrl(reg, shifter);
702 str << "shrl %cl, %" << assembler_test->GetSecondaryRegisterName(reg) << "\n";
703 }
704 return str.str();
705 }
706
TEST_F(AssemblerX86_64Test,ShrlReg)707 TEST_F(AssemblerX86_64Test, ShrlReg) {
708 DriverFn(&shrl_fn, "shrl");
709 }
710
TEST_F(AssemblerX86_64Test,ShrlImm)711 TEST_F(AssemblerX86_64Test, ShrlImm) {
712 DriverStr(RepeatrI(&x86_64::X86_64Assembler::shrl, /*imm_bytes*/ 1U, "shrl ${imm}, %{reg}"), "shrli");
713 }
714
715 // Shrq only allows CL as the shift count.
shrq_fn(AssemblerX86_64Test::Base * assembler_test,x86_64::X86_64Assembler * assembler)716 std::string shrq_fn(AssemblerX86_64Test::Base* assembler_test, x86_64::X86_64Assembler* assembler) {
717 std::ostringstream str;
718 ArrayRef<const x86_64::CpuRegister> registers = assembler_test->GetRegisters();
719 x86_64::CpuRegister shifter(x86_64::RCX);
720 for (auto&& reg : registers) {
721 assembler->shrq(reg, shifter);
722 str << "shrq %cl, %" << assembler_test->GetRegisterName(reg) << "\n";
723 }
724 return str.str();
725 }
726
TEST_F(AssemblerX86_64Test,ShrqReg)727 TEST_F(AssemblerX86_64Test, ShrqReg) {
728 DriverFn(&shrq_fn, "shrq");
729 }
730
TEST_F(AssemblerX86_64Test,ShrqImm)731 TEST_F(AssemblerX86_64Test, ShrqImm) {
732 DriverStr(RepeatRI(&x86_64::X86_64Assembler::shrq, /*imm_bytes*/ 1U, "shrq ${imm}, %{reg}"), "shrqi");
733 }
734
735 // Sarl only allows CL as the shift count.
sarl_fn(AssemblerX86_64Test::Base * assembler_test,x86_64::X86_64Assembler * assembler)736 std::string sarl_fn(AssemblerX86_64Test::Base* assembler_test, x86_64::X86_64Assembler* assembler) {
737 std::ostringstream str;
738 ArrayRef<const x86_64::CpuRegister> registers = assembler_test->GetRegisters();
739 x86_64::CpuRegister shifter(x86_64::RCX);
740 for (auto&& reg : registers) {
741 assembler->sarl(reg, shifter);
742 str << "sarl %cl, %" << assembler_test->GetSecondaryRegisterName(reg) << "\n";
743 }
744 return str.str();
745 }
746
TEST_F(AssemblerX86_64Test,SarlReg)747 TEST_F(AssemblerX86_64Test, SarlReg) {
748 DriverFn(&sarl_fn, "sarl");
749 }
750
TEST_F(AssemblerX86_64Test,SarlImm)751 TEST_F(AssemblerX86_64Test, SarlImm) {
752 DriverStr(RepeatrI(&x86_64::X86_64Assembler::sarl, /*imm_bytes*/ 1U, "sarl ${imm}, %{reg}"), "sarli");
753 }
754
755 // Sarq only allows CL as the shift count.
sarq_fn(AssemblerX86_64Test::Base * assembler_test,x86_64::X86_64Assembler * assembler)756 std::string sarq_fn(AssemblerX86_64Test::Base* assembler_test, x86_64::X86_64Assembler* assembler) {
757 std::ostringstream str;
758 ArrayRef<const x86_64::CpuRegister> registers = assembler_test->GetRegisters();
759 x86_64::CpuRegister shifter(x86_64::RCX);
760 for (auto&& reg : registers) {
761 assembler->sarq(reg, shifter);
762 str << "sarq %cl, %" << assembler_test->GetRegisterName(reg) << "\n";
763 }
764 return str.str();
765 }
766
TEST_F(AssemblerX86_64Test,SarqReg)767 TEST_F(AssemblerX86_64Test, SarqReg) {
768 DriverFn(&sarq_fn, "sarq");
769 }
770
TEST_F(AssemblerX86_64Test,SarqImm)771 TEST_F(AssemblerX86_64Test, SarqImm) {
772 DriverStr(RepeatRI(&x86_64::X86_64Assembler::sarq, /*imm_bytes*/ 1U, "sarq ${imm}, %{reg}"), "sarqi");
773 }
774
775 // Rorl only allows CL as the shift count.
rorl_fn(AssemblerX86_64Test::Base * assembler_test,x86_64::X86_64Assembler * assembler)776 std::string rorl_fn(AssemblerX86_64Test::Base* assembler_test, x86_64::X86_64Assembler* assembler) {
777 std::ostringstream str;
778 ArrayRef<const x86_64::CpuRegister> registers = assembler_test->GetRegisters();
779 x86_64::CpuRegister shifter(x86_64::RCX);
780 for (auto&& reg : registers) {
781 assembler->rorl(reg, shifter);
782 str << "rorl %cl, %" << assembler_test->GetSecondaryRegisterName(reg) << "\n";
783 }
784 return str.str();
785 }
786
TEST_F(AssemblerX86_64Test,RorlReg)787 TEST_F(AssemblerX86_64Test, RorlReg) {
788 DriverFn(&rorl_fn, "rorl");
789 }
790
TEST_F(AssemblerX86_64Test,RorlImm)791 TEST_F(AssemblerX86_64Test, RorlImm) {
792 DriverStr(RepeatrI(&x86_64::X86_64Assembler::rorl, /*imm_bytes*/ 1U, "rorl ${imm}, %{reg}"), "rorli");
793 }
794
795 // Roll only allows CL as the shift count.
roll_fn(AssemblerX86_64Test::Base * assembler_test,x86_64::X86_64Assembler * assembler)796 std::string roll_fn(AssemblerX86_64Test::Base* assembler_test, x86_64::X86_64Assembler* assembler) {
797 std::ostringstream str;
798 ArrayRef<const x86_64::CpuRegister> registers = assembler_test->GetRegisters();
799 x86_64::CpuRegister shifter(x86_64::RCX);
800 for (auto&& reg : registers) {
801 assembler->roll(reg, shifter);
802 str << "roll %cl, %" << assembler_test->GetSecondaryRegisterName(reg) << "\n";
803 }
804 return str.str();
805 }
806
TEST_F(AssemblerX86_64Test,RollReg)807 TEST_F(AssemblerX86_64Test, RollReg) {
808 DriverFn(&roll_fn, "roll");
809 }
810
TEST_F(AssemblerX86_64Test,RollImm)811 TEST_F(AssemblerX86_64Test, RollImm) {
812 DriverStr(RepeatrI(&x86_64::X86_64Assembler::roll, /*imm_bytes*/ 1U, "roll ${imm}, %{reg}"), "rolli");
813 }
814
815 // Rorq only allows CL as the shift count.
rorq_fn(AssemblerX86_64Test::Base * assembler_test,x86_64::X86_64Assembler * assembler)816 std::string rorq_fn(AssemblerX86_64Test::Base* assembler_test, x86_64::X86_64Assembler* assembler) {
817 std::ostringstream str;
818 ArrayRef<const x86_64::CpuRegister> registers = assembler_test->GetRegisters();
819 x86_64::CpuRegister shifter(x86_64::RCX);
820 for (auto&& reg : registers) {
821 assembler->rorq(reg, shifter);
822 str << "rorq %cl, %" << assembler_test->GetRegisterName(reg) << "\n";
823 }
824 return str.str();
825 }
826
TEST_F(AssemblerX86_64Test,RorqReg)827 TEST_F(AssemblerX86_64Test, RorqReg) {
828 DriverFn(&rorq_fn, "rorq");
829 }
830
TEST_F(AssemblerX86_64Test,RorqImm)831 TEST_F(AssemblerX86_64Test, RorqImm) {
832 DriverStr(RepeatRI(&x86_64::X86_64Assembler::rorq, /*imm_bytes*/ 1U, "rorq ${imm}, %{reg}"), "rorqi");
833 }
834
835 // Rolq only allows CL as the shift count.
rolq_fn(AssemblerX86_64Test::Base * assembler_test,x86_64::X86_64Assembler * assembler)836 std::string rolq_fn(AssemblerX86_64Test::Base* assembler_test, x86_64::X86_64Assembler* assembler) {
837 std::ostringstream str;
838 ArrayRef<const x86_64::CpuRegister> registers = assembler_test->GetRegisters();
839 x86_64::CpuRegister shifter(x86_64::RCX);
840 for (auto&& reg : registers) {
841 assembler->rolq(reg, shifter);
842 str << "rolq %cl, %" << assembler_test->GetRegisterName(reg) << "\n";
843 }
844 return str.str();
845 }
846
TEST_F(AssemblerX86_64Test,RolqReg)847 TEST_F(AssemblerX86_64Test, RolqReg) {
848 DriverFn(&rolq_fn, "rolq");
849 }
850
TEST_F(AssemblerX86_64Test,RolqImm)851 TEST_F(AssemblerX86_64Test, RolqImm) {
852 DriverStr(RepeatRI(&x86_64::X86_64Assembler::rolq, /*imm_bytes*/ 1U, "rolq ${imm}, %{reg}"), "rolqi");
853 }
854
TEST_F(AssemblerX86_64Test,CmpqRegs)855 TEST_F(AssemblerX86_64Test, CmpqRegs) {
856 DriverStr(RepeatRR(&x86_64::X86_64Assembler::cmpq, "cmpq %{reg2}, %{reg1}"), "cmpq");
857 }
858
TEST_F(AssemblerX86_64Test,CmpqImm)859 TEST_F(AssemblerX86_64Test, CmpqImm) {
860 DriverStr(RepeatRI(&x86_64::X86_64Assembler::cmpq,
861 /*imm_bytes*/ 4U,
862 "cmpq ${imm}, %{reg}"), "cmpqi"); // only imm32
863 }
864
TEST_F(AssemblerX86_64Test,CmplRegs)865 TEST_F(AssemblerX86_64Test, CmplRegs) {
866 DriverStr(Repeatrr(&x86_64::X86_64Assembler::cmpl, "cmp %{reg2}, %{reg1}"), "cmpl");
867 }
868
TEST_F(AssemblerX86_64Test,CmplImm)869 TEST_F(AssemblerX86_64Test, CmplImm) {
870 DriverStr(RepeatrI(&x86_64::X86_64Assembler::cmpl, /*imm_bytes*/ 4U, "cmpl ${imm}, %{reg}"), "cmpli");
871 }
872
TEST_F(AssemblerX86_64Test,Testl)873 TEST_F(AssemblerX86_64Test, Testl) {
874 // Note: uses different order for GCC than usual. This makes GCC happy, and doesn't have an
875 // impact on functional correctness.
876 DriverStr(Repeatrr(&x86_64::X86_64Assembler::testl, "testl %{reg1}, %{reg2}"), "testl");
877 }
878
TEST_F(AssemblerX86_64Test,Idivq)879 TEST_F(AssemblerX86_64Test, Idivq) {
880 DriverStr(RepeatR(&x86_64::X86_64Assembler::idivq, "idivq %{reg}"), "idivq");
881 }
882
TEST_F(AssemblerX86_64Test,Idivl)883 TEST_F(AssemblerX86_64Test, Idivl) {
884 DriverStr(Repeatr(&x86_64::X86_64Assembler::idivl, "idivl %{reg}"), "idivl");
885 }
886
TEST_F(AssemblerX86_64Test,Divq)887 TEST_F(AssemblerX86_64Test, Divq) {
888 DriverStr(RepeatR(&x86_64::X86_64Assembler::divq, "divq %{reg}"), "divq");
889 }
890
TEST_F(AssemblerX86_64Test,Divl)891 TEST_F(AssemblerX86_64Test, Divl) {
892 DriverStr(Repeatr(&x86_64::X86_64Assembler::divl, "divl %{reg}"), "divl");
893 }
894
TEST_F(AssemblerX86_64Test,Negq)895 TEST_F(AssemblerX86_64Test, Negq) {
896 DriverStr(RepeatR(&x86_64::X86_64Assembler::negq, "negq %{reg}"), "negq");
897 }
898
TEST_F(AssemblerX86_64Test,Negl)899 TEST_F(AssemblerX86_64Test, Negl) {
900 DriverStr(Repeatr(&x86_64::X86_64Assembler::negl, "negl %{reg}"), "negl");
901 }
902
TEST_F(AssemblerX86_64Test,Notq)903 TEST_F(AssemblerX86_64Test, Notq) {
904 DriverStr(RepeatR(&x86_64::X86_64Assembler::notq, "notq %{reg}"), "notq");
905 }
906
TEST_F(AssemblerX86_64Test,Notl)907 TEST_F(AssemblerX86_64Test, Notl) {
908 DriverStr(Repeatr(&x86_64::X86_64Assembler::notl, "notl %{reg}"), "notl");
909 }
910
TEST_F(AssemblerX86_64Test,AndqRegs)911 TEST_F(AssemblerX86_64Test, AndqRegs) {
912 DriverStr(RepeatRR(&x86_64::X86_64Assembler::andq, "andq %{reg2}, %{reg1}"), "andq");
913 }
914
TEST_F(AssemblerX86_64Test,AndqImm)915 TEST_F(AssemblerX86_64Test, AndqImm) {
916 DriverStr(RepeatRI(&x86_64::X86_64Assembler::andq,
917 /*imm_bytes*/ 4U,
918 "andq ${imm}, %{reg}"), "andqi"); // only imm32
919 }
920
TEST_F(AssemblerX86_64Test,AndlRegs)921 TEST_F(AssemblerX86_64Test, AndlRegs) {
922 DriverStr(Repeatrr(&x86_64::X86_64Assembler::andl, "andl %{reg2}, %{reg1}"), "andl");
923 }
924
TEST_F(AssemblerX86_64Test,AndlImm)925 TEST_F(AssemblerX86_64Test, AndlImm) {
926 DriverStr(RepeatrI(&x86_64::X86_64Assembler::andl,
927 /*imm_bytes*/ 4U,
928 "andl ${imm}, %{reg}"), "andli");
929 }
930
TEST_F(AssemblerX86_64Test,Andw)931 TEST_F(AssemblerX86_64Test, Andw) {
932 DriverStr(
933 RepeatAI(&x86_64::X86_64Assembler::andw, /*imm_bytes*/2U, "andw ${imm}, {mem}"), "andw");
934 }
935
TEST_F(AssemblerX86_64Test,OrqRegs)936 TEST_F(AssemblerX86_64Test, OrqRegs) {
937 DriverStr(RepeatRR(&x86_64::X86_64Assembler::orq, "orq %{reg2}, %{reg1}"), "orq");
938 }
939
TEST_F(AssemblerX86_64Test,OrlRegs)940 TEST_F(AssemblerX86_64Test, OrlRegs) {
941 DriverStr(Repeatrr(&x86_64::X86_64Assembler::orl, "orl %{reg2}, %{reg1}"), "orl");
942 }
943
TEST_F(AssemblerX86_64Test,OrlImm)944 TEST_F(AssemblerX86_64Test, OrlImm) {
945 DriverStr(RepeatrI(&x86_64::X86_64Assembler::orl,
946 /*imm_bytes*/ 4U, "orl ${imm}, %{reg}"), "orli");
947 }
948
TEST_F(AssemblerX86_64Test,XorqRegs)949 TEST_F(AssemblerX86_64Test, XorqRegs) {
950 DriverStr(RepeatRR(&x86_64::X86_64Assembler::xorq, "xorq %{reg2}, %{reg1}"), "xorq");
951 }
952
TEST_F(AssemblerX86_64Test,XorqImm)953 TEST_F(AssemblerX86_64Test, XorqImm) {
954 DriverStr(RepeatRI(&x86_64::X86_64Assembler::xorq,
955 /*imm_bytes*/ 4U, "xorq ${imm}, %{reg}"), "xorqi");
956 }
957
TEST_F(AssemblerX86_64Test,XorlRegs)958 TEST_F(AssemblerX86_64Test, XorlRegs) {
959 DriverStr(Repeatrr(&x86_64::X86_64Assembler::xorl, "xor %{reg2}, %{reg1}"), "xorl");
960 }
961
TEST_F(AssemblerX86_64Test,XorlImm)962 TEST_F(AssemblerX86_64Test, XorlImm) {
963 DriverStr(RepeatrI(&x86_64::X86_64Assembler::xorl,
964 /*imm_bytes*/ 4U, "xor ${imm}, %{reg}"), "xorli");
965 }
966
TEST_F(AssemblerX86_64Test,XchgqReg)967 TEST_F(AssemblerX86_64Test, XchgqReg) {
968 DriverStr(RepeatRR(&x86_64::X86_64Assembler::xchgq, "xchgq %{reg2}, %{reg1}"), "xchgq");
969 }
970
TEST_F(AssemblerX86_64Test,XchgqMem)971 TEST_F(AssemblerX86_64Test, XchgqMem) {
972 DriverStr(RepeatRA(&x86_64::X86_64Assembler::xchgq, "xchgq %{reg}, {mem}"), "xchgq");
973 }
974
TEST_F(AssemblerX86_64Test,XchglReg)975 TEST_F(AssemblerX86_64Test, XchglReg) {
976 // Exclude `xcghl eax, eax` because the reference implementation generates 0x87 0xC0 (contrary to
977 // the intel manual saying that this should be a `nop` 0x90). All other cases are the same.
978 static const std::vector<std::pair<x86_64::CpuRegister, x86_64::CpuRegister>> except = {
979 std::make_pair(x86_64::CpuRegister(x86_64::RAX), x86_64::CpuRegister(x86_64::RAX))
980 };
981 DriverStr(Repeatrr(&x86_64::X86_64Assembler::xchgl, "xchgl %{reg2}, %{reg1}", &except), "xchgl");
982 }
983
TEST_F(AssemblerX86_64Test,XchglMem)984 TEST_F(AssemblerX86_64Test, XchglMem) {
985 DriverStr(RepeatrA(&x86_64::X86_64Assembler::xchgl, "xchgl %{reg}, {mem}"), "xchgl");
986 }
987
TEST_F(AssemblerX86_64Test,XchgwReg)988 TEST_F(AssemblerX86_64Test, XchgwReg) {
989 DriverStr(Repeatww(&x86_64::X86_64Assembler::xchgw, "xchgw %{reg2}, %{reg1}"), "xchgw");
990 }
991
TEST_F(AssemblerX86_64Test,XchgwMem)992 TEST_F(AssemblerX86_64Test, XchgwMem) {
993 DriverStr(RepeatwA(&x86_64::X86_64Assembler::xchgw, "xchgw %{reg}, {mem}"), "xchgw");
994 }
995
TEST_F(AssemblerX86_64Test,XchgbReg)996 TEST_F(AssemblerX86_64Test, XchgbReg) {
997 DriverStr(Repeatbb(&x86_64::X86_64Assembler::xchgb, "xchgb %{reg2}, %{reg1}"), "xchgb");
998 }
999
TEST_F(AssemblerX86_64Test,XchgbMem)1000 TEST_F(AssemblerX86_64Test, XchgbMem) {
1001 DriverStr(RepeatbA(&x86_64::X86_64Assembler::xchgb, "xchgb %{reg}, {mem}"), "xchgb");
1002 }
1003
TEST_F(AssemblerX86_64Test,XaddqReg)1004 TEST_F(AssemblerX86_64Test, XaddqReg) {
1005 DriverStr(RepeatRR(&x86_64::X86_64Assembler::xaddq, "xaddq %{reg2}, %{reg1}"), "xaddq");
1006 }
1007
TEST_F(AssemblerX86_64Test,XaddqMem)1008 TEST_F(AssemblerX86_64Test, XaddqMem) {
1009 DriverStr(RepeatAR(&x86_64::X86_64Assembler::xaddq, "xaddq %{reg}, {mem}"), "xaddq");
1010 }
1011
TEST_F(AssemblerX86_64Test,XaddlReg)1012 TEST_F(AssemblerX86_64Test, XaddlReg) {
1013 DriverStr(Repeatrr(&x86_64::X86_64Assembler::xaddl, "xaddl %{reg2}, %{reg1}"), "xaddl");
1014 }
1015
TEST_F(AssemblerX86_64Test,XaddlMem)1016 TEST_F(AssemblerX86_64Test, XaddlMem) {
1017 DriverStr(RepeatAr(&x86_64::X86_64Assembler::xaddl, "xaddl %{reg}, {mem}"), "xaddl");
1018 }
1019
TEST_F(AssemblerX86_64Test,XaddwReg)1020 TEST_F(AssemblerX86_64Test, XaddwReg) {
1021 DriverStr(Repeatww(&x86_64::X86_64Assembler::xaddw, "xaddw %{reg2}, %{reg1}"), "xaddw");
1022 }
1023
TEST_F(AssemblerX86_64Test,XaddwMem)1024 TEST_F(AssemblerX86_64Test, XaddwMem) {
1025 DriverStr(RepeatAw(&x86_64::X86_64Assembler::xaddw, "xaddw %{reg}, {mem}"), "xaddw");
1026 }
1027
TEST_F(AssemblerX86_64Test,XaddbReg)1028 TEST_F(AssemblerX86_64Test, XaddbReg) {
1029 DriverStr(Repeatbb(&x86_64::X86_64Assembler::xaddb, "xaddb %{reg2}, %{reg1}"), "xaddb");
1030 }
1031
TEST_F(AssemblerX86_64Test,XaddbMem)1032 TEST_F(AssemblerX86_64Test, XaddbMem) {
1033 DriverStr(RepeatAb(&x86_64::X86_64Assembler::xaddb, "xaddb %{reg}, {mem}"), "xaddb");
1034 }
1035
TEST_F(AssemblerX86_64Test,LockXaddq)1036 TEST_F(AssemblerX86_64Test, LockXaddq) {
1037 DriverStr(
1038 RepeatAR(&x86_64::X86_64Assembler::LockXaddq, "lock xaddq %{reg}, {mem}"), "lock_xaddq");
1039 }
1040
TEST_F(AssemblerX86_64Test,LockXaddl)1041 TEST_F(AssemblerX86_64Test, LockXaddl) {
1042 DriverStr(
1043 RepeatAr(&x86_64::X86_64Assembler::LockXaddl, "lock xaddl %{reg}, {mem}"), "lock_xaddl");
1044 }
1045
TEST_F(AssemblerX86_64Test,LockXaddw)1046 TEST_F(AssemblerX86_64Test, LockXaddw) {
1047 DriverStr(
1048 RepeatAw(&x86_64::X86_64Assembler::LockXaddw, "lock xaddw %{reg}, {mem}"), "lock_xaddw");
1049 }
1050
TEST_F(AssemblerX86_64Test,LockXaddb)1051 TEST_F(AssemblerX86_64Test, LockXaddb) {
1052 DriverStr(
1053 RepeatAb(&x86_64::X86_64Assembler::LockXaddb, "lock xaddb %{reg}, {mem}"), "lock_xaddb");
1054 }
1055
TEST_F(AssemblerX86_64Test,Cmpxchgb)1056 TEST_F(AssemblerX86_64Test, Cmpxchgb) {
1057 DriverStr(RepeatAb(&x86_64::X86_64Assembler::cmpxchgb, "cmpxchgb %{reg}, {mem}"), "cmpxchgb");
1058 }
1059
TEST_F(AssemblerX86_64Test,Cmpxchgw)1060 TEST_F(AssemblerX86_64Test, Cmpxchgw) {
1061 DriverStr(RepeatAw(&x86_64::X86_64Assembler::cmpxchgw, "cmpxchgw %{reg}, {mem}"), "cmpxchgw");
1062 }
1063
TEST_F(AssemblerX86_64Test,Cmpxchgl)1064 TEST_F(AssemblerX86_64Test, Cmpxchgl) {
1065 DriverStr(RepeatAr(&x86_64::X86_64Assembler::cmpxchgl, "cmpxchgl %{reg}, {mem}"), "cmpxchgl");
1066 }
1067
TEST_F(AssemblerX86_64Test,Cmpxchgq)1068 TEST_F(AssemblerX86_64Test, Cmpxchgq) {
1069 DriverStr(RepeatAR(&x86_64::X86_64Assembler::cmpxchgq, "cmpxchg %{reg}, {mem}"), "cmpxchg");
1070 }
1071
TEST_F(AssemblerX86_64Test,LockCmpxchgb)1072 TEST_F(AssemblerX86_64Test, LockCmpxchgb) {
1073 DriverStr(RepeatAb(&x86_64::X86_64Assembler::LockCmpxchgb,
1074 "lock cmpxchgb %{reg}, {mem}"), "lock_cmpxchgb");
1075 }
1076
TEST_F(AssemblerX86_64Test,LockCmpxchgw)1077 TEST_F(AssemblerX86_64Test, LockCmpxchgw) {
1078 DriverStr(RepeatAw(&x86_64::X86_64Assembler::LockCmpxchgw,
1079 "lock cmpxchgw %{reg}, {mem}"), "lock_cmpxchgw");
1080 }
1081
TEST_F(AssemblerX86_64Test,LockCmpxchgl)1082 TEST_F(AssemblerX86_64Test, LockCmpxchgl) {
1083 DriverStr(RepeatAr(&x86_64::X86_64Assembler::LockCmpxchgl,
1084 "lock cmpxchgl %{reg}, {mem}"), "lock_cmpxchgl");
1085 }
1086
TEST_F(AssemblerX86_64Test,LockCmpxchgq)1087 TEST_F(AssemblerX86_64Test, LockCmpxchgq) {
1088 DriverStr(RepeatAR(&x86_64::X86_64Assembler::LockCmpxchgq,
1089 "lock cmpxchg %{reg}, {mem}"), "lock_cmpxchg");
1090 }
1091
TEST_F(AssemblerX86_64Test,MovqStore)1092 TEST_F(AssemblerX86_64Test, MovqStore) {
1093 DriverStr(RepeatAR(&x86_64::X86_64Assembler::movq, "movq %{reg}, {mem}"), "movq_s");
1094 }
1095
TEST_F(AssemblerX86_64Test,MovqLoad)1096 TEST_F(AssemblerX86_64Test, MovqLoad) {
1097 DriverStr(RepeatRA(&x86_64::X86_64Assembler::movq, "movq {mem}, %{reg}"), "movq_l");
1098 }
1099
TEST_F(AssemblerX86_64Test,MovlStore)1100 TEST_F(AssemblerX86_64Test, MovlStore) {
1101 DriverStr(RepeatAr(&x86_64::X86_64Assembler::movl, "movl %{reg}, {mem}"), "movl_s");
1102 }
1103
TEST_F(AssemblerX86_64Test,MovlLoad)1104 TEST_F(AssemblerX86_64Test, MovlLoad) {
1105 DriverStr(RepeatrA(&x86_64::X86_64Assembler::movl, "movl {mem}, %{reg}"), "movl_l");
1106 }
1107
TEST_F(AssemblerX86_64Test,MovwStore)1108 TEST_F(AssemblerX86_64Test, MovwStore) {
1109 DriverStr(RepeatAw(&x86_64::X86_64Assembler::movw, "movw %{reg}, {mem}"), "movw_s");
1110 }
1111
TEST_F(AssemblerX86_64Test,MovbStore)1112 TEST_F(AssemblerX86_64Test, MovbStore) {
1113 DriverStr(RepeatAb(&x86_64::X86_64Assembler::movb, "movb %{reg}, {mem}"), "movb_s");
1114 }
1115
TEST_F(AssemblerX86_64Test,Cmpw)1116 TEST_F(AssemblerX86_64Test, Cmpw) {
1117 DriverStr(
1118 RepeatAI(&x86_64::X86_64Assembler::cmpw, /*imm_bytes*/ 2U, "cmpw ${imm}, {mem}"), "cmpw");
1119 }
1120
TEST_F(AssemblerX86_64Test,MovqAddrImm)1121 TEST_F(AssemblerX86_64Test, MovqAddrImm) {
1122 DriverStr(RepeatAI(&x86_64::X86_64Assembler::movq,
1123 /*imm_bytes*/ 4U,
1124 "movq ${imm}, {mem}"), "movq"); // only imm32
1125 }
1126
TEST_F(AssemblerX86_64Test,MovlAddrImm)1127 TEST_F(AssemblerX86_64Test, MovlAddrImm) {
1128 DriverStr(RepeatAI(&x86_64::X86_64Assembler::movl,
1129 /*imm_bytes*/ 4U, "movl ${imm}, {mem}"), "movl");
1130 }
1131
TEST_F(AssemblerX86_64Test,MovwAddrImm)1132 TEST_F(AssemblerX86_64Test, MovwAddrImm) {
1133 DriverStr(RepeatAI(&x86_64::X86_64Assembler::movw,
1134 /*imm_bytes*/ 2U, "movw ${imm}, {mem}"), "movw");
1135 }
1136
TEST_F(AssemblerX86_64Test,MovbAddrImm)1137 TEST_F(AssemblerX86_64Test, MovbAddrImm) {
1138 DriverStr(RepeatAI(&x86_64::X86_64Assembler::movb,
1139 /*imm_bytes*/ 1U, "movb ${imm}, {mem}"), "movb");
1140 }
1141
TEST_F(AssemblerX86_64Test,Movntl)1142 TEST_F(AssemblerX86_64Test, Movntl) {
1143 DriverStr(RepeatAr(&x86_64::X86_64Assembler::movntl, "movntil %{reg}, {mem}"), "movntl");
1144 }
1145
TEST_F(AssemblerX86_64Test,Movntq)1146 TEST_F(AssemblerX86_64Test, Movntq) {
1147 DriverStr(RepeatAR(&x86_64::X86_64Assembler::movntq, "movntiq %{reg}, {mem}"), "movntq");
1148 }
1149
TEST_F(AssemblerX86_64Test,Cvtsi2ssAddr)1150 TEST_F(AssemblerX86_64Test, Cvtsi2ssAddr) {
1151 GetAssembler()->cvtsi2ss(x86_64::XmmRegister(x86_64::XMM0),
1152 x86_64::Address(x86_64::CpuRegister(x86_64::RAX), 0),
1153 /*is64bit*/ false);
1154 GetAssembler()->cvtsi2ss(x86_64::XmmRegister(x86_64::XMM0),
1155 x86_64::Address(x86_64::CpuRegister(x86_64::RAX), 0),
1156 /*is64bit*/ true);
1157 const char* expected = "cvtsi2ss 0(%RAX), %xmm0\n"
1158 "cvtsi2ssq 0(%RAX), %xmm0\n";
1159 DriverStr(expected, "cvtsi2ss");
1160 }
1161
TEST_F(AssemblerX86_64Test,Cvtsi2sdAddr)1162 TEST_F(AssemblerX86_64Test, Cvtsi2sdAddr) {
1163 GetAssembler()->cvtsi2sd(x86_64::XmmRegister(x86_64::XMM0),
1164 x86_64::Address(x86_64::CpuRegister(x86_64::RAX), 0),
1165 /*is64bit*/ false);
1166 GetAssembler()->cvtsi2sd(x86_64::XmmRegister(x86_64::XMM0),
1167 x86_64::Address(x86_64::CpuRegister(x86_64::RAX), 0),
1168 /*is64bit*/ true);
1169 const char* expected = "cvtsi2sd 0(%RAX), %xmm0\n"
1170 "cvtsi2sdq 0(%RAX), %xmm0\n";
1171 DriverStr(expected, "cvtsi2sd");
1172 }
1173
TEST_F(AssemblerX86_64Test,CmpqAddr)1174 TEST_F(AssemblerX86_64Test, CmpqAddr) {
1175 DriverStr(RepeatRA(&x86_64::X86_64Assembler::cmpq, "cmpq {mem}, %{reg}"), "cmpq");
1176 }
1177
TEST_F(AssemblerX86_64Test,MovsxdAddr)1178 TEST_F(AssemblerX86_64Test, MovsxdAddr) {
1179 DriverStr(RepeatRA(&x86_64::X86_64Assembler::movsxd, "movslq {mem}, %{reg}"), "movsxd");
1180 }
1181
TEST_F(AssemblerX86_64Test,TestqAddr)1182 TEST_F(AssemblerX86_64Test, TestqAddr) {
1183 DriverStr(RepeatRA(&x86_64::X86_64Assembler::testq, "testq {mem}, %{reg}"), "testq");
1184 }
1185
TEST_F(AssemblerX86_64Test,AddqAddr)1186 TEST_F(AssemblerX86_64Test, AddqAddr) {
1187 DriverStr(RepeatRA(&x86_64::X86_64Assembler::addq, "addq {mem}, %{reg}"), "addq");
1188 }
1189
TEST_F(AssemblerX86_64Test,SubqAddr)1190 TEST_F(AssemblerX86_64Test, SubqAddr) {
1191 DriverStr(RepeatRA(&x86_64::X86_64Assembler::subq, "subq {mem}, %{reg}"), "subq");
1192 }
1193
TEST_F(AssemblerX86_64Test,Cvtss2sdAddr)1194 TEST_F(AssemblerX86_64Test, Cvtss2sdAddr) {
1195 DriverStr(RepeatFA(&x86_64::X86_64Assembler::cvtss2sd, "cvtss2sd {mem}, %{reg}"), "cvtss2sd");
1196 }
1197
TEST_F(AssemblerX86_64Test,Cvtsd2ssAddr)1198 TEST_F(AssemblerX86_64Test, Cvtsd2ssAddr) {
1199 DriverStr(RepeatFA(&x86_64::X86_64Assembler::cvtsd2ss, "cvtsd2ss {mem}, %{reg}"), "cvtsd2ss");
1200 }
1201
TEST_F(AssemblerX86_64Test,ComissAddr)1202 TEST_F(AssemblerX86_64Test, ComissAddr) {
1203 DriverStr(RepeatFA(&x86_64::X86_64Assembler::comiss, "comiss {mem}, %{reg}"), "comiss");
1204 }
1205
TEST_F(AssemblerX86_64Test,ComisdAddr)1206 TEST_F(AssemblerX86_64Test, ComisdAddr) {
1207 DriverStr(RepeatFA(&x86_64::X86_64Assembler::comisd, "comisd {mem}, %{reg}"), "comisd");
1208 }
1209
TEST_F(AssemblerX86_64Test,UComissAddr)1210 TEST_F(AssemblerX86_64Test, UComissAddr) {
1211 DriverStr(RepeatFA(&x86_64::X86_64Assembler::ucomiss, "ucomiss {mem}, %{reg}"), "ucomiss");
1212 }
1213
TEST_F(AssemblerX86_64Test,UComisdAddr)1214 TEST_F(AssemblerX86_64Test, UComisdAddr) {
1215 DriverStr(RepeatFA(&x86_64::X86_64Assembler::ucomisd, "ucomisd {mem}, %{reg}"), "ucomisd");
1216 }
1217
TEST_F(AssemblerX86_64Test,Andq)1218 TEST_F(AssemblerX86_64Test, Andq) {
1219 DriverStr(RepeatRA(&x86_64::X86_64Assembler::andq, "andq {mem}, %{reg}"), "andq");
1220 }
1221
TEST_F(AssemblerX86_64Test,Orq)1222 TEST_F(AssemblerX86_64Test, Orq) {
1223 DriverStr(RepeatRA(&x86_64::X86_64Assembler::orq, "orq {mem}, %{reg}"), "orq");
1224 }
1225
TEST_F(AssemblerX86_64Test,Xorq)1226 TEST_F(AssemblerX86_64Test, Xorq) {
1227 DriverStr(RepeatRA(&x86_64::X86_64Assembler::xorq, "xorq {mem}, %{reg}"), "xorq");
1228 }
1229
TEST_F(AssemblerX86_64Test,RepneScasb)1230 TEST_F(AssemblerX86_64Test, RepneScasb) {
1231 GetAssembler()->repne_scasb();
1232 const char* expected = "repne scasb\n";
1233 DriverStr(expected, "repne_scasb");
1234 }
1235
TEST_F(AssemblerX86_64Test,RepneScasw)1236 TEST_F(AssemblerX86_64Test, RepneScasw) {
1237 GetAssembler()->repne_scasw();
1238 const char* expected = "repne scasw\n";
1239 DriverStr(expected, "repne_scasw");
1240 }
1241
TEST_F(AssemblerX86_64Test,RepMovsb)1242 TEST_F(AssemblerX86_64Test, RepMovsb) {
1243 GetAssembler()->rep_movsb();
1244 const char* expected = "rep movsb\n";
1245 DriverStr(expected, "rep_movsb");
1246 }
1247
TEST_F(AssemblerX86_64Test,RepMovsw)1248 TEST_F(AssemblerX86_64Test, RepMovsw) {
1249 GetAssembler()->rep_movsw();
1250 const char* expected = "rep movsw\n";
1251 DriverStr(expected, "rep_movsw");
1252 }
1253
TEST_F(AssemblerX86_64Test,RepMovsl)1254 TEST_F(AssemblerX86_64Test, RepMovsl) {
1255 GetAssembler()->rep_movsl();
1256 const char* expected = "rep movsl\n";
1257 DriverStr(expected, "rep_movsl");
1258 }
1259
TEST_F(AssemblerX86_64Test,Movsxd)1260 TEST_F(AssemblerX86_64Test, Movsxd) {
1261 DriverStr(RepeatRr(&x86_64::X86_64Assembler::movsxd, "movslq %{reg2}, %{reg1}"), "movsxd");
1262 }
1263
TEST_F(AssemblerX86_64Test,Movaps)1264 TEST_F(AssemblerX86_64Test, Movaps) {
1265 DriverStr(RepeatFF(&x86_64::X86_64Assembler::movaps, "movaps %{reg2}, %{reg1}"), "movaps");
1266 }
1267
TEST_F(AssemblerX86_64AVXTest,VMovaps)1268 TEST_F(AssemblerX86_64AVXTest, VMovaps) {
1269 DriverStr(RepeatFF(&x86_64::X86_64Assembler::vmovaps, "vmovaps %{reg2}, %{reg1}"), "vmovaps");
1270 }
1271
TEST_F(AssemblerX86_64AVXTest,Movaps)1272 TEST_F(AssemblerX86_64AVXTest, Movaps) {
1273 DriverStr(RepeatFF(&x86_64::X86_64Assembler::movaps, "vmovaps %{reg2}, %{reg1}"), "avx_movaps");
1274 }
1275
TEST_F(AssemblerX86_64Test,MovapsStore)1276 TEST_F(AssemblerX86_64Test, MovapsStore) {
1277 DriverStr(RepeatAF(&x86_64::X86_64Assembler::movaps, "movaps %{reg}, {mem}"), "movaps_s");
1278 }
1279
TEST_F(AssemblerX86_64AVXTest,VMovapsStore)1280 TEST_F(AssemblerX86_64AVXTest, VMovapsStore) {
1281 DriverStr(RepeatAF(&x86_64::X86_64Assembler::vmovaps, "vmovaps %{reg}, {mem}"), "vmovaps_s");
1282 }
1283
TEST_F(AssemblerX86_64AVXTest,MovapsStore)1284 TEST_F(AssemblerX86_64AVXTest, MovapsStore) {
1285 DriverStr(RepeatAF(&x86_64::X86_64Assembler::movaps, "vmovaps %{reg}, {mem}"), "avx_movaps_s");
1286 }
1287
TEST_F(AssemblerX86_64Test,MovapsLoad)1288 TEST_F(AssemblerX86_64Test, MovapsLoad) {
1289 DriverStr(RepeatFA(&x86_64::X86_64Assembler::movaps, "movaps {mem}, %{reg}"), "movaps_l");
1290 }
1291
TEST_F(AssemblerX86_64AVXTest,VMovapsLoad)1292 TEST_F(AssemblerX86_64AVXTest, VMovapsLoad) {
1293 DriverStr(RepeatFA(&x86_64::X86_64Assembler::vmovaps, "vmovaps {mem}, %{reg}"), "vmovaps_l");
1294 }
1295
TEST_F(AssemblerX86_64AVXTest,MovapsLoad)1296 TEST_F(AssemblerX86_64AVXTest, MovapsLoad) {
1297 DriverStr(RepeatFA(&x86_64::X86_64Assembler::movaps, "vmovaps {mem}, %{reg}"), "avx_movaps_l");
1298 }
1299
TEST_F(AssemblerX86_64Test,MovupsStore)1300 TEST_F(AssemblerX86_64Test, MovupsStore) {
1301 DriverStr(RepeatAF(&x86_64::X86_64Assembler::movups, "movups %{reg}, {mem}"), "movups_s");
1302 }
1303
TEST_F(AssemblerX86_64AVXTest,VMovupsStore)1304 TEST_F(AssemblerX86_64AVXTest, VMovupsStore) {
1305 DriverStr(RepeatAF(&x86_64::X86_64Assembler::vmovups, "vmovups %{reg}, {mem}"), "vmovups_s");
1306 }
1307
TEST_F(AssemblerX86_64AVXTest,MovupsStore)1308 TEST_F(AssemblerX86_64AVXTest, MovupsStore) {
1309 DriverStr(RepeatAF(&x86_64::X86_64Assembler::movups, "vmovups %{reg}, {mem}"), "avx_movups_s");
1310 }
1311
TEST_F(AssemblerX86_64Test,MovupsLoad)1312 TEST_F(AssemblerX86_64Test, MovupsLoad) {
1313 DriverStr(RepeatFA(&x86_64::X86_64Assembler::movups, "movups {mem}, %{reg}"), "movups_l");
1314 }
1315
TEST_F(AssemblerX86_64AVXTest,VMovupsLoad)1316 TEST_F(AssemblerX86_64AVXTest, VMovupsLoad) {
1317 DriverStr(RepeatFA(&x86_64::X86_64Assembler::vmovups, "vmovups {mem}, %{reg}"), "vmovups_l");
1318 }
1319
TEST_F(AssemblerX86_64AVXTest,MovupsLoad)1320 TEST_F(AssemblerX86_64AVXTest, MovupsLoad) {
1321 DriverStr(RepeatFA(&x86_64::X86_64Assembler::movups, "vmovups {mem}, %{reg}"), "avx_movups_l");
1322 }
1323
TEST_F(AssemblerX86_64Test,Movss)1324 TEST_F(AssemblerX86_64Test, Movss) {
1325 DriverStr(RepeatFF(&x86_64::X86_64Assembler::movss, "movss %{reg2}, %{reg1}"), "movss");
1326 }
1327
TEST_F(AssemblerX86_64Test,Movapd)1328 TEST_F(AssemblerX86_64Test, Movapd) {
1329 DriverStr(RepeatFF(&x86_64::X86_64Assembler::movapd, "movapd %{reg2}, %{reg1}"), "movapd");
1330 }
1331
TEST_F(AssemblerX86_64AVXTest,VMovapd)1332 TEST_F(AssemblerX86_64AVXTest, VMovapd) {
1333 DriverStr(RepeatFF(&x86_64::X86_64Assembler::vmovapd, "vmovapd %{reg2}, %{reg1}"), "vmovapd");
1334 }
1335
TEST_F(AssemblerX86_64AVXTest,Movapd)1336 TEST_F(AssemblerX86_64AVXTest, Movapd) {
1337 DriverStr(RepeatFF(&x86_64::X86_64Assembler::movapd, "vmovapd %{reg2}, %{reg1}"), "avx_movapd");
1338 }
1339
TEST_F(AssemblerX86_64Test,MovapdStore)1340 TEST_F(AssemblerX86_64Test, MovapdStore) {
1341 DriverStr(RepeatAF(&x86_64::X86_64Assembler::movapd, "movapd %{reg}, {mem}"), "movapd_s");
1342 }
1343
TEST_F(AssemblerX86_64AVXTest,VMovapdStore)1344 TEST_F(AssemblerX86_64AVXTest, VMovapdStore) {
1345 DriverStr(RepeatAF(&x86_64::X86_64Assembler::vmovapd, "vmovapd %{reg}, {mem}"), "vmovapd_s");
1346 }
1347
TEST_F(AssemblerX86_64AVXTest,MovapdStore)1348 TEST_F(AssemblerX86_64AVXTest, MovapdStore) {
1349 DriverStr(RepeatAF(&x86_64::X86_64Assembler::movapd, "vmovapd %{reg}, {mem}"), "avx_movapd_s");
1350 }
1351
TEST_F(AssemblerX86_64Test,MovapdLoad)1352 TEST_F(AssemblerX86_64Test, MovapdLoad) {
1353 DriverStr(RepeatFA(&x86_64::X86_64Assembler::movapd, "movapd {mem}, %{reg}"), "movapd_l");
1354 }
1355
TEST_F(AssemblerX86_64AVXTest,VMovapdLoad)1356 TEST_F(AssemblerX86_64AVXTest, VMovapdLoad) {
1357 DriverStr(RepeatFA(&x86_64::X86_64Assembler::vmovapd, "vmovapd {mem}, %{reg}"), "vmovapd_l");
1358 }
1359
TEST_F(AssemblerX86_64AVXTest,MovapdLoad)1360 TEST_F(AssemblerX86_64AVXTest, MovapdLoad) {
1361 DriverStr(RepeatFA(&x86_64::X86_64Assembler::movapd, "vmovapd {mem}, %{reg}"), "avx_movapd_l");
1362 }
1363
TEST_F(AssemblerX86_64Test,MovupdStore)1364 TEST_F(AssemblerX86_64Test, MovupdStore) {
1365 DriverStr(RepeatAF(&x86_64::X86_64Assembler::movupd, "movupd %{reg}, {mem}"), "movupd_s");
1366 }
1367
TEST_F(AssemblerX86_64AVXTest,VMovupdStore)1368 TEST_F(AssemblerX86_64AVXTest, VMovupdStore) {
1369 DriverStr(RepeatAF(&x86_64::X86_64Assembler::vmovupd, "vmovupd %{reg}, {mem}"), "vmovupd_s");
1370 }
1371
TEST_F(AssemblerX86_64AVXTest,MovupdStore)1372 TEST_F(AssemblerX86_64AVXTest, MovupdStore) {
1373 DriverStr(RepeatAF(&x86_64::X86_64Assembler::movupd, "vmovupd %{reg}, {mem}"), "avx_movupd_s");
1374 }
1375
TEST_F(AssemblerX86_64Test,MovupdLoad)1376 TEST_F(AssemblerX86_64Test, MovupdLoad) {
1377 DriverStr(RepeatFA(&x86_64::X86_64Assembler::movupd, "movupd {mem}, %{reg}"), "movupd_l");
1378 }
1379
TEST_F(AssemblerX86_64AVXTest,VMovupdLoad)1380 TEST_F(AssemblerX86_64AVXTest, VMovupdLoad) {
1381 DriverStr(RepeatFA(&x86_64::X86_64Assembler::vmovupd, "vmovupd {mem}, %{reg}"), "vmovupd_l");
1382 }
1383
TEST_F(AssemblerX86_64AVXTest,MovupdLoad)1384 TEST_F(AssemblerX86_64AVXTest, MovupdLoad) {
1385 DriverStr(RepeatFA(&x86_64::X86_64Assembler::movupd, "vmovupd {mem}, %{reg}"), "avx_movupd_l");
1386 }
1387
TEST_F(AssemblerX86_64Test,Movsd)1388 TEST_F(AssemblerX86_64Test, Movsd) {
1389 DriverStr(RepeatFF(&x86_64::X86_64Assembler::movsd, "movsd %{reg2}, %{reg1}"), "movsd");
1390 }
1391
TEST_F(AssemblerX86_64Test,Movdqa)1392 TEST_F(AssemblerX86_64Test, Movdqa) {
1393 DriverStr(RepeatFF(&x86_64::X86_64Assembler::movdqa, "movdqa %{reg2}, %{reg1}"), "movdqa");
1394 }
1395
TEST_F(AssemblerX86_64AVXTest,VMovdqa)1396 TEST_F(AssemblerX86_64AVXTest, VMovdqa) {
1397 DriverStr(RepeatFF(&x86_64::X86_64Assembler::vmovdqa, "vmovdqa %{reg2}, %{reg1}"), "vmovdqa");
1398 }
1399
TEST_F(AssemblerX86_64AVXTest,Movdqa)1400 TEST_F(AssemblerX86_64AVXTest, Movdqa) {
1401 DriverStr(RepeatFF(&x86_64::X86_64Assembler::movdqa, "vmovdqa %{reg2}, %{reg1}"), "avx_movdqa");
1402 }
1403
TEST_F(AssemblerX86_64Test,MovdqaStore)1404 TEST_F(AssemblerX86_64Test, MovdqaStore) {
1405 DriverStr(RepeatAF(&x86_64::X86_64Assembler::movdqa, "movdqa %{reg}, {mem}"), "movdqa_s");
1406 }
1407
TEST_F(AssemblerX86_64AVXTest,VMovdqaStore)1408 TEST_F(AssemblerX86_64AVXTest, VMovdqaStore) {
1409 DriverStr(RepeatAF(&x86_64::X86_64Assembler::vmovdqa, "vmovdqa %{reg}, {mem}"), "vmovdqa_s");
1410 }
1411
TEST_F(AssemblerX86_64AVXTest,MovdqaStore)1412 TEST_F(AssemblerX86_64AVXTest, MovdqaStore) {
1413 DriverStr(RepeatAF(&x86_64::X86_64Assembler::movdqa, "vmovdqa %{reg}, {mem}"), "avx_movdqa_s");
1414 }
1415
TEST_F(AssemblerX86_64Test,MovdqaLoad)1416 TEST_F(AssemblerX86_64Test, MovdqaLoad) {
1417 DriverStr(RepeatFA(&x86_64::X86_64Assembler::movdqa, "movdqa {mem}, %{reg}"), "movdqa_l");
1418 }
1419
TEST_F(AssemblerX86_64AVXTest,VMovdqaLoad)1420 TEST_F(AssemblerX86_64AVXTest, VMovdqaLoad) {
1421 DriverStr(RepeatFA(&x86_64::X86_64Assembler::vmovdqa, "vmovdqa {mem}, %{reg}"), "vmovdqa_l");
1422 }
1423
TEST_F(AssemblerX86_64AVXTest,MovdqaLoad)1424 TEST_F(AssemblerX86_64AVXTest, MovdqaLoad) {
1425 DriverStr(RepeatFA(&x86_64::X86_64Assembler::movdqa, "vmovdqa {mem}, %{reg}"), "avx_movdqa_l");
1426 }
1427
TEST_F(AssemblerX86_64Test,MovdquStore)1428 TEST_F(AssemblerX86_64Test, MovdquStore) {
1429 DriverStr(RepeatAF(&x86_64::X86_64Assembler::movdqu, "movdqu %{reg}, {mem}"), "movdqu_s");
1430 }
1431
TEST_F(AssemblerX86_64AVXTest,VMovdquStore)1432 TEST_F(AssemblerX86_64AVXTest, VMovdquStore) {
1433 DriverStr(RepeatAF(&x86_64::X86_64Assembler::vmovdqu, "vmovdqu %{reg}, {mem}"), "vmovdqu_s");
1434 }
1435
TEST_F(AssemblerX86_64AVXTest,MovdquStore)1436 TEST_F(AssemblerX86_64AVXTest, MovdquStore) {
1437 DriverStr(RepeatAF(&x86_64::X86_64Assembler::movdqu, "vmovdqu %{reg}, {mem}"), "avx_movdqu_s");
1438 }
1439
TEST_F(AssemblerX86_64Test,MovdquLoad)1440 TEST_F(AssemblerX86_64Test, MovdquLoad) {
1441 DriverStr(RepeatFA(&x86_64::X86_64Assembler::movdqu, "movdqu {mem}, %{reg}"), "movdqu_l");
1442 }
1443
TEST_F(AssemblerX86_64AVXTest,VMovdquLoad)1444 TEST_F(AssemblerX86_64AVXTest, VMovdquLoad) {
1445 DriverStr(RepeatFA(&x86_64::X86_64Assembler::vmovdqu, "vmovdqu {mem}, %{reg}"), "vmovdqu_l");
1446 }
1447
TEST_F(AssemblerX86_64AVXTest,MovdquLoad)1448 TEST_F(AssemblerX86_64AVXTest, MovdquLoad) {
1449 DriverStr(RepeatFA(&x86_64::X86_64Assembler::movdqu, "vmovdqu {mem}, %{reg}"), "avx_movdqu_l");
1450 }
1451
TEST_F(AssemblerX86_64Test,Movd1)1452 TEST_F(AssemblerX86_64Test, Movd1) {
1453 DriverStr(RepeatFR(&x86_64::X86_64Assembler::movd, "movd %{reg2}, %{reg1}"), "movd.1");
1454 }
1455
TEST_F(AssemblerX86_64Test,Movd2)1456 TEST_F(AssemblerX86_64Test, Movd2) {
1457 DriverStr(RepeatRF(&x86_64::X86_64Assembler::movd, "movd %{reg2}, %{reg1}"), "movd.2");
1458 }
1459
TEST_F(AssemblerX86_64Test,Addss)1460 TEST_F(AssemblerX86_64Test, Addss) {
1461 DriverStr(RepeatFF(&x86_64::X86_64Assembler::addss, "addss %{reg2}, %{reg1}"), "addss");
1462 }
1463
TEST_F(AssemblerX86_64Test,Addsd)1464 TEST_F(AssemblerX86_64Test, Addsd) {
1465 DriverStr(RepeatFF(&x86_64::X86_64Assembler::addsd, "addsd %{reg2}, %{reg1}"), "addsd");
1466 }
1467
TEST_F(AssemblerX86_64Test,Addps)1468 TEST_F(AssemblerX86_64Test, Addps) {
1469 DriverStr(RepeatFF(&x86_64::X86_64Assembler::addps, "addps %{reg2}, %{reg1}"), "addps");
1470 }
1471
TEST_F(AssemblerX86_64AVXTest,VAddps)1472 TEST_F(AssemblerX86_64AVXTest, VAddps) {
1473 DriverStr(
1474 RepeatFFF(&x86_64::X86_64Assembler::vaddps, "vaddps %{reg3}, %{reg2}, %{reg1}"), "vaddps");
1475 }
1476
TEST_F(AssemblerX86_64Test,Addpd)1477 TEST_F(AssemblerX86_64Test, Addpd) {
1478 DriverStr(RepeatFF(&x86_64::X86_64Assembler::addpd, "addpd %{reg2}, %{reg1}"), "addpd");
1479 }
1480
TEST_F(AssemblerX86_64AVXTest,VAddpd)1481 TEST_F(AssemblerX86_64AVXTest, VAddpd) {
1482 DriverStr(
1483 RepeatFFF(&x86_64::X86_64Assembler::vaddpd, "vaddpd %{reg3}, %{reg2}, %{reg1}"), "vaddpd");
1484 }
1485
TEST_F(AssemblerX86_64Test,Subss)1486 TEST_F(AssemblerX86_64Test, Subss) {
1487 DriverStr(RepeatFF(&x86_64::X86_64Assembler::subss, "subss %{reg2}, %{reg1}"), "subss");
1488 }
1489
TEST_F(AssemblerX86_64Test,Subsd)1490 TEST_F(AssemblerX86_64Test, Subsd) {
1491 DriverStr(RepeatFF(&x86_64::X86_64Assembler::subsd, "subsd %{reg2}, %{reg1}"), "subsd");
1492 }
1493
TEST_F(AssemblerX86_64Test,Subps)1494 TEST_F(AssemblerX86_64Test, Subps) {
1495 DriverStr(RepeatFF(&x86_64::X86_64Assembler::subps, "subps %{reg2}, %{reg1}"), "subps");
1496 }
1497
TEST_F(AssemblerX86_64AVXTest,VSubps)1498 TEST_F(AssemblerX86_64AVXTest, VSubps) {
1499 DriverStr(
1500 RepeatFFF(&x86_64::X86_64Assembler::vsubps, "vsubps %{reg3},%{reg2}, %{reg1}"), "vsubps");
1501 }
1502
TEST_F(AssemblerX86_64Test,Subpd)1503 TEST_F(AssemblerX86_64Test, Subpd) {
1504 DriverStr(RepeatFF(&x86_64::X86_64Assembler::subpd, "subpd %{reg2}, %{reg1}"), "subpd");
1505 }
1506
TEST_F(AssemblerX86_64AVXTest,VSubpd)1507 TEST_F(AssemblerX86_64AVXTest, VSubpd) {
1508 DriverStr(
1509 RepeatFFF(&x86_64::X86_64Assembler::vsubpd, "vsubpd %{reg3}, %{reg2}, %{reg1}"), "vsubpd");
1510 }
1511
TEST_F(AssemblerX86_64Test,Mulss)1512 TEST_F(AssemblerX86_64Test, Mulss) {
1513 DriverStr(RepeatFF(&x86_64::X86_64Assembler::mulss, "mulss %{reg2}, %{reg1}"), "mulss");
1514 }
1515
TEST_F(AssemblerX86_64Test,Mulsd)1516 TEST_F(AssemblerX86_64Test, Mulsd) {
1517 DriverStr(RepeatFF(&x86_64::X86_64Assembler::mulsd, "mulsd %{reg2}, %{reg1}"), "mulsd");
1518 }
1519
TEST_F(AssemblerX86_64Test,Mulps)1520 TEST_F(AssemblerX86_64Test, Mulps) {
1521 DriverStr(RepeatFF(&x86_64::X86_64Assembler::mulps, "mulps %{reg2}, %{reg1}"), "mulps");
1522 }
1523
TEST_F(AssemblerX86_64AVXTest,VMulps)1524 TEST_F(AssemblerX86_64AVXTest, VMulps) {
1525 DriverStr(
1526 RepeatFFF(&x86_64::X86_64Assembler::vmulps, "vmulps %{reg3}, %{reg2}, %{reg1}"), "vmulps");
1527 }
1528
TEST_F(AssemblerX86_64Test,Mulpd)1529 TEST_F(AssemblerX86_64Test, Mulpd) {
1530 DriverStr(RepeatFF(&x86_64::X86_64Assembler::mulpd, "mulpd %{reg2}, %{reg1}"), "mulpd");
1531 }
1532
TEST_F(AssemblerX86_64AVXTest,VMulpd)1533 TEST_F(AssemblerX86_64AVXTest, VMulpd) {
1534 DriverStr(
1535 RepeatFFF(&x86_64::X86_64Assembler::vmulpd, "vmulpd %{reg3}, %{reg2}, %{reg1}"), "vmulpd");
1536 }
1537
TEST_F(AssemblerX86_64Test,Divss)1538 TEST_F(AssemblerX86_64Test, Divss) {
1539 DriverStr(RepeatFF(&x86_64::X86_64Assembler::divss, "divss %{reg2}, %{reg1}"), "divss");
1540 }
1541
TEST_F(AssemblerX86_64Test,Divsd)1542 TEST_F(AssemblerX86_64Test, Divsd) {
1543 DriverStr(RepeatFF(&x86_64::X86_64Assembler::divsd, "divsd %{reg2}, %{reg1}"), "divsd");
1544 }
1545
TEST_F(AssemblerX86_64Test,Divps)1546 TEST_F(AssemblerX86_64Test, Divps) {
1547 DriverStr(RepeatFF(&x86_64::X86_64Assembler::divps, "divps %{reg2}, %{reg1}"), "divps");
1548 }
1549
TEST_F(AssemblerX86_64AVXTest,VDivps)1550 TEST_F(AssemblerX86_64AVXTest, VDivps) {
1551 DriverStr(
1552 RepeatFFF(&x86_64::X86_64Assembler::vdivps, "vdivps %{reg3}, %{reg2}, %{reg1}"), "vdivps");
1553 }
1554
TEST_F(AssemblerX86_64Test,Divpd)1555 TEST_F(AssemblerX86_64Test, Divpd) {
1556 DriverStr(RepeatFF(&x86_64::X86_64Assembler::divpd, "divpd %{reg2}, %{reg1}"), "divpd");
1557 }
1558
TEST_F(AssemblerX86_64AVXTest,VDivpd)1559 TEST_F(AssemblerX86_64AVXTest, VDivpd) {
1560 DriverStr(
1561 RepeatFFF(&x86_64::X86_64Assembler::vdivpd, "vdivpd %{reg3}, %{reg2}, %{reg1}"), "vdivpd");
1562 }
1563
TEST_F(AssemblerX86_64Test,Paddb)1564 TEST_F(AssemblerX86_64Test, Paddb) {
1565 DriverStr(RepeatFF(&x86_64::X86_64Assembler::paddb, "paddb %{reg2}, %{reg1}"), "paddb");
1566 }
1567
TEST_F(AssemblerX86_64AVXTest,VPaddb)1568 TEST_F(AssemblerX86_64AVXTest, VPaddb) {
1569 DriverStr(
1570 RepeatFFF(&x86_64::X86_64Assembler::vpaddb, "vpaddb %{reg3}, %{reg2}, %{reg1}"), "vpaddb");
1571 }
1572
TEST_F(AssemblerX86_64Test,Psubb)1573 TEST_F(AssemblerX86_64Test, Psubb) {
1574 DriverStr(RepeatFF(&x86_64::X86_64Assembler::psubb, "psubb %{reg2}, %{reg1}"), "psubb");
1575 }
1576
TEST_F(AssemblerX86_64AVXTest,VPsubb)1577 TEST_F(AssemblerX86_64AVXTest, VPsubb) {
1578 DriverStr(
1579 RepeatFFF(&x86_64::X86_64Assembler::vpsubb, "vpsubb %{reg3},%{reg2}, %{reg1}"), "vpsubb");
1580 }
1581
TEST_F(AssemblerX86_64Test,Paddw)1582 TEST_F(AssemblerX86_64Test, Paddw) {
1583 DriverStr(RepeatFF(&x86_64::X86_64Assembler::paddw, "paddw %{reg2}, %{reg1}"), "paddw");
1584 }
1585
TEST_F(AssemblerX86_64AVXTest,VPsubw)1586 TEST_F(AssemblerX86_64AVXTest, VPsubw) {
1587 DriverStr(
1588 RepeatFFF(&x86_64::X86_64Assembler::vpsubw, "vpsubw %{reg3}, %{reg2}, %{reg1}"), "vpsubw");
1589 }
1590
TEST_F(AssemblerX86_64AVXTest,VPaddw)1591 TEST_F(AssemblerX86_64AVXTest, VPaddw) {
1592 DriverStr(
1593 RepeatFFF(&x86_64::X86_64Assembler::vpaddw, "vpaddw %{reg3}, %{reg2}, %{reg1}"), "vpaddw");
1594 }
1595
TEST_F(AssemblerX86_64Test,Psubw)1596 TEST_F(AssemblerX86_64Test, Psubw) {
1597 DriverStr(RepeatFF(&x86_64::X86_64Assembler::psubw, "psubw %{reg2}, %{reg1}"), "psubw");
1598 }
1599
TEST_F(AssemblerX86_64Test,Pmullw)1600 TEST_F(AssemblerX86_64Test, Pmullw) {
1601 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pmullw, "pmullw %{reg2}, %{reg1}"), "pmullw");
1602 }
1603
TEST_F(AssemblerX86_64AVXTest,VPmullw)1604 TEST_F(AssemblerX86_64AVXTest, VPmullw) {
1605 DriverStr(
1606 RepeatFFF(&x86_64::X86_64Assembler::vpmullw, "vpmullw %{reg3}, %{reg2}, %{reg1}"), "vpmullw");
1607 }
1608
TEST_F(AssemblerX86_64Test,Paddd)1609 TEST_F(AssemblerX86_64Test, Paddd) {
1610 DriverStr(RepeatFF(&x86_64::X86_64Assembler::paddd, "paddd %{reg2}, %{reg1}"), "paddd");
1611 }
1612
TEST_F(AssemblerX86_64AVXTest,VPaddd)1613 TEST_F(AssemblerX86_64AVXTest, VPaddd) {
1614 DriverStr(
1615 RepeatFFF(&x86_64::X86_64Assembler::vpaddd, "vpaddd %{reg3}, %{reg2}, %{reg1}"), "vpaddd");
1616 }
1617
TEST_F(AssemblerX86_64Test,Psubd)1618 TEST_F(AssemblerX86_64Test, Psubd) {
1619 DriverStr(RepeatFF(&x86_64::X86_64Assembler::psubd, "psubd %{reg2}, %{reg1}"), "psubd");
1620 }
1621
TEST_F(AssemblerX86_64AVXTest,VPsubd)1622 TEST_F(AssemblerX86_64AVXTest, VPsubd) {
1623 DriverStr(
1624 RepeatFFF(&x86_64::X86_64Assembler::vpsubd, "vpsubd %{reg3}, %{reg2}, %{reg1}"), "vpsubd");
1625 }
1626
TEST_F(AssemblerX86_64Test,Pmulld)1627 TEST_F(AssemblerX86_64Test, Pmulld) {
1628 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pmulld, "pmulld %{reg2}, %{reg1}"), "pmulld");
1629 }
1630
TEST_F(AssemblerX86_64AVXTest,VPmulld)1631 TEST_F(AssemblerX86_64AVXTest, VPmulld) {
1632 DriverStr(
1633 RepeatFFF(&x86_64::X86_64Assembler::vpmulld, "vpmulld %{reg3}, %{reg2}, %{reg1}"), "vpmulld");
1634 }
1635
TEST_F(AssemblerX86_64Test,Paddq)1636 TEST_F(AssemblerX86_64Test, Paddq) {
1637 DriverStr(RepeatFF(&x86_64::X86_64Assembler::paddq, "paddq %{reg2}, %{reg1}"), "paddq");
1638 }
1639
TEST_F(AssemblerX86_64AVXTest,VPaddq)1640 TEST_F(AssemblerX86_64AVXTest, VPaddq) {
1641 DriverStr(
1642 RepeatFFF(&x86_64::X86_64Assembler::vpaddq, "vpaddq %{reg3}, %{reg2}, %{reg1}"), "vpaddq");
1643 }
1644
TEST_F(AssemblerX86_64Test,Psubq)1645 TEST_F(AssemblerX86_64Test, Psubq) {
1646 DriverStr(RepeatFF(&x86_64::X86_64Assembler::psubq, "psubq %{reg2}, %{reg1}"), "psubq");
1647 }
1648
TEST_F(AssemblerX86_64AVXTest,VPsubq)1649 TEST_F(AssemblerX86_64AVXTest, VPsubq) {
1650 DriverStr(
1651 RepeatFFF(&x86_64::X86_64Assembler::vpsubq, "vpsubq %{reg3}, %{reg2}, %{reg1}"), "vpsubq");
1652 }
1653
TEST_F(AssemblerX86_64Test,Paddusb)1654 TEST_F(AssemblerX86_64Test, Paddusb) {
1655 DriverStr(RepeatFF(&x86_64::X86_64Assembler::paddusb, "paddusb %{reg2}, %{reg1}"), "paddusb");
1656 }
1657
TEST_F(AssemblerX86_64Test,Paddsb)1658 TEST_F(AssemblerX86_64Test, Paddsb) {
1659 DriverStr(RepeatFF(&x86_64::X86_64Assembler::paddsb, "paddsb %{reg2}, %{reg1}"), "paddsb");
1660 }
1661
TEST_F(AssemblerX86_64Test,Paddusw)1662 TEST_F(AssemblerX86_64Test, Paddusw) {
1663 DriverStr(RepeatFF(&x86_64::X86_64Assembler::paddusw, "paddusw %{reg2}, %{reg1}"), "paddusw");
1664 }
1665
TEST_F(AssemblerX86_64Test,Paddsw)1666 TEST_F(AssemblerX86_64Test, Paddsw) {
1667 DriverStr(RepeatFF(&x86_64::X86_64Assembler::paddsw, "paddsw %{reg2}, %{reg1}"), "paddsw");
1668 }
1669
TEST_F(AssemblerX86_64Test,Psubusb)1670 TEST_F(AssemblerX86_64Test, Psubusb) {
1671 DriverStr(RepeatFF(&x86_64::X86_64Assembler::psubusb, "psubusb %{reg2}, %{reg1}"), "psubusb");
1672 }
1673
TEST_F(AssemblerX86_64Test,Psubsb)1674 TEST_F(AssemblerX86_64Test, Psubsb) {
1675 DriverStr(RepeatFF(&x86_64::X86_64Assembler::psubsb, "psubsb %{reg2}, %{reg1}"), "psubsb");
1676 }
1677
TEST_F(AssemblerX86_64Test,Psubusw)1678 TEST_F(AssemblerX86_64Test, Psubusw) {
1679 DriverStr(RepeatFF(&x86_64::X86_64Assembler::psubusw, "psubusw %{reg2}, %{reg1}"), "psubusw");
1680 }
1681
TEST_F(AssemblerX86_64Test,Psubsw)1682 TEST_F(AssemblerX86_64Test, Psubsw) {
1683 DriverStr(RepeatFF(&x86_64::X86_64Assembler::psubsw, "psubsw %{reg2}, %{reg1}"), "psubsw");
1684 }
1685
TEST_F(AssemblerX86_64Test,Cvtsi2ss)1686 TEST_F(AssemblerX86_64Test, Cvtsi2ss) {
1687 DriverStr(RepeatFr(&x86_64::X86_64Assembler::cvtsi2ss, "cvtsi2ss %{reg2}, %{reg1}"), "cvtsi2ss");
1688 }
1689
TEST_F(AssemblerX86_64Test,Cvtsi2sd)1690 TEST_F(AssemblerX86_64Test, Cvtsi2sd) {
1691 DriverStr(RepeatFr(&x86_64::X86_64Assembler::cvtsi2sd, "cvtsi2sd %{reg2}, %{reg1}"), "cvtsi2sd");
1692 }
1693
TEST_F(AssemblerX86_64Test,Cvtss2si)1694 TEST_F(AssemblerX86_64Test, Cvtss2si) {
1695 DriverStr(RepeatrF(&x86_64::X86_64Assembler::cvtss2si, "cvtss2si %{reg2}, %{reg1}"), "cvtss2si");
1696 }
1697
TEST_F(AssemblerX86_64Test,Cvtss2sd)1698 TEST_F(AssemblerX86_64Test, Cvtss2sd) {
1699 DriverStr(RepeatFF(&x86_64::X86_64Assembler::cvtss2sd, "cvtss2sd %{reg2}, %{reg1}"), "cvtss2sd");
1700 }
1701
TEST_F(AssemblerX86_64Test,Cvtsd2si)1702 TEST_F(AssemblerX86_64Test, Cvtsd2si) {
1703 DriverStr(RepeatrF(&x86_64::X86_64Assembler::cvtsd2si, "cvtsd2si %{reg2}, %{reg1}"), "cvtsd2si");
1704 }
1705
TEST_F(AssemblerX86_64Test,Cvttss2si)1706 TEST_F(AssemblerX86_64Test, Cvttss2si) {
1707 DriverStr(RepeatrF(&x86_64::X86_64Assembler::cvttss2si, "cvttss2si %{reg2}, %{reg1}"),
1708 "cvttss2si");
1709 }
1710
TEST_F(AssemblerX86_64Test,Cvttsd2si)1711 TEST_F(AssemblerX86_64Test, Cvttsd2si) {
1712 DriverStr(RepeatrF(&x86_64::X86_64Assembler::cvttsd2si, "cvttsd2si %{reg2}, %{reg1}"),
1713 "cvttsd2si");
1714 }
1715
TEST_F(AssemblerX86_64Test,Cvtsd2ss)1716 TEST_F(AssemblerX86_64Test, Cvtsd2ss) {
1717 DriverStr(RepeatFF(&x86_64::X86_64Assembler::cvtsd2ss, "cvtsd2ss %{reg2}, %{reg1}"), "cvtsd2ss");
1718 }
1719
TEST_F(AssemblerX86_64Test,Cvtdq2ps)1720 TEST_F(AssemblerX86_64Test, Cvtdq2ps) {
1721 DriverStr(RepeatFF(&x86_64::X86_64Assembler::cvtdq2ps, "cvtdq2ps %{reg2}, %{reg1}"), "cvtdq2ps");
1722 }
1723
TEST_F(AssemblerX86_64Test,Cvtdq2pd)1724 TEST_F(AssemblerX86_64Test, Cvtdq2pd) {
1725 DriverStr(RepeatFF(&x86_64::X86_64Assembler::cvtdq2pd, "cvtdq2pd %{reg2}, %{reg1}"), "cvtdq2pd");
1726 }
1727
TEST_F(AssemblerX86_64Test,Comiss)1728 TEST_F(AssemblerX86_64Test, Comiss) {
1729 DriverStr(RepeatFF(&x86_64::X86_64Assembler::comiss, "comiss %{reg2}, %{reg1}"), "comiss");
1730 }
1731
TEST_F(AssemblerX86_64Test,Comisd)1732 TEST_F(AssemblerX86_64Test, Comisd) {
1733 DriverStr(RepeatFF(&x86_64::X86_64Assembler::comisd, "comisd %{reg2}, %{reg1}"), "comisd");
1734 }
1735
TEST_F(AssemblerX86_64Test,Ucomiss)1736 TEST_F(AssemblerX86_64Test, Ucomiss) {
1737 DriverStr(RepeatFF(&x86_64::X86_64Assembler::ucomiss, "ucomiss %{reg2}, %{reg1}"), "ucomiss");
1738 }
1739
TEST_F(AssemblerX86_64Test,Ucomisd)1740 TEST_F(AssemblerX86_64Test, Ucomisd) {
1741 DriverStr(RepeatFF(&x86_64::X86_64Assembler::ucomisd, "ucomisd %{reg2}, %{reg1}"), "ucomisd");
1742 }
1743
TEST_F(AssemblerX86_64Test,Sqrtss)1744 TEST_F(AssemblerX86_64Test, Sqrtss) {
1745 DriverStr(RepeatFF(&x86_64::X86_64Assembler::sqrtss, "sqrtss %{reg2}, %{reg1}"), "sqrtss");
1746 }
1747
TEST_F(AssemblerX86_64Test,Sqrtsd)1748 TEST_F(AssemblerX86_64Test, Sqrtsd) {
1749 DriverStr(RepeatFF(&x86_64::X86_64Assembler::sqrtsd, "sqrtsd %{reg2}, %{reg1}"), "sqrtsd");
1750 }
1751
TEST_F(AssemblerX86_64Test,Roundss)1752 TEST_F(AssemblerX86_64Test, Roundss) {
1753 DriverStr(RepeatFFI(&x86_64::X86_64Assembler::roundss, /*imm_bytes*/ 1U,
1754 "roundss ${imm}, %{reg2}, %{reg1}"), "roundss");
1755 }
1756
TEST_F(AssemblerX86_64Test,Roundsd)1757 TEST_F(AssemblerX86_64Test, Roundsd) {
1758 DriverStr(RepeatFFI(&x86_64::X86_64Assembler::roundsd, /*imm_bytes*/ 1U,
1759 "roundsd ${imm}, %{reg2}, %{reg1}"), "roundsd");
1760 }
1761
TEST_F(AssemblerX86_64Test,Xorps)1762 TEST_F(AssemblerX86_64Test, Xorps) {
1763 DriverStr(RepeatFF(&x86_64::X86_64Assembler::xorps, "xorps %{reg2}, %{reg1}"), "xorps");
1764 }
1765
TEST_F(AssemblerX86_64Test,Xorpd)1766 TEST_F(AssemblerX86_64Test, Xorpd) {
1767 DriverStr(RepeatFF(&x86_64::X86_64Assembler::xorpd, "xorpd %{reg2}, %{reg1}"), "xorpd");
1768 }
1769
TEST_F(AssemblerX86_64Test,Pxor)1770 TEST_F(AssemblerX86_64Test, Pxor) {
1771 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pxor, "pxor %{reg2}, %{reg1}"), "pxor");
1772 }
1773
TEST_F(AssemblerX86_64AVXTest,VPXor)1774 TEST_F(AssemblerX86_64AVXTest, VPXor) {
1775 DriverStr(RepeatFFF(&x86_64::X86_64Assembler::vpxor,
1776 "vpxor %{reg3}, %{reg2}, %{reg1}"), "vpxor");
1777 }
1778
TEST_F(AssemblerX86_64AVXTest,VXorps)1779 TEST_F(AssemblerX86_64AVXTest, VXorps) {
1780 DriverStr(RepeatFFF(&x86_64::X86_64Assembler::vxorps,
1781 "vxorps %{reg3}, %{reg2}, %{reg1}"), "vxorps");
1782 }
1783
TEST_F(AssemblerX86_64AVXTest,VXorpd)1784 TEST_F(AssemblerX86_64AVXTest, VXorpd) {
1785 DriverStr(RepeatFFF(&x86_64::X86_64Assembler::vxorpd,
1786 "vxorpd %{reg3}, %{reg2}, %{reg1}"), "vxorpd");
1787 }
1788
TEST_F(AssemblerX86_64Test,Andps)1789 TEST_F(AssemblerX86_64Test, Andps) {
1790 DriverStr(RepeatFF(&x86_64::X86_64Assembler::andps, "andps %{reg2}, %{reg1}"), "andps");
1791 }
1792
TEST_F(AssemblerX86_64Test,Andpd)1793 TEST_F(AssemblerX86_64Test, Andpd) {
1794 DriverStr(RepeatFF(&x86_64::X86_64Assembler::andpd, "andpd %{reg2}, %{reg1}"), "andpd");
1795 }
1796
TEST_F(AssemblerX86_64Test,Pand)1797 TEST_F(AssemblerX86_64Test, Pand) {
1798 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pand, "pand %{reg2}, %{reg1}"), "pand");
1799 }
1800
TEST_F(AssemblerX86_64AVXTest,VPAnd)1801 TEST_F(AssemblerX86_64AVXTest, VPAnd) {
1802 DriverStr(RepeatFFF(&x86_64::X86_64Assembler::vpand,
1803 "vpand %{reg3}, %{reg2}, %{reg1}"), "vpand");
1804 }
1805
TEST_F(AssemblerX86_64AVXTest,VAndps)1806 TEST_F(AssemblerX86_64AVXTest, VAndps) {
1807 DriverStr(RepeatFFF(&x86_64::X86_64Assembler::vandps,
1808 "vandps %{reg3}, %{reg2}, %{reg1}"), "vandps");
1809 }
1810
TEST_F(AssemblerX86_64AVXTest,VAndpd)1811 TEST_F(AssemblerX86_64AVXTest, VAndpd) {
1812 DriverStr(RepeatFFF(&x86_64::X86_64Assembler::vandpd,
1813 "vandpd %{reg3}, %{reg2}, %{reg1}"), "vandpd");
1814 }
1815
TEST_F(AssemblerX86_64Test,Andn)1816 TEST_F(AssemblerX86_64Test, Andn) {
1817 DriverStr(RepeatRRR(&x86_64::X86_64Assembler::andn, "andn %{reg3}, %{reg2}, %{reg1}"), "andn");
1818 }
TEST_F(AssemblerX86_64Test,andnpd)1819 TEST_F(AssemblerX86_64Test, andnpd) {
1820 DriverStr(RepeatFF(&x86_64::X86_64Assembler::andnpd, "andnpd %{reg2}, %{reg1}"), "andnpd");
1821 }
1822
TEST_F(AssemblerX86_64Test,andnps)1823 TEST_F(AssemblerX86_64Test, andnps) {
1824 DriverStr(RepeatFF(&x86_64::X86_64Assembler::andnps, "andnps %{reg2}, %{reg1}"), "andnps");
1825 }
1826
TEST_F(AssemblerX86_64Test,Pandn)1827 TEST_F(AssemblerX86_64Test, Pandn) {
1828 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pandn, "pandn %{reg2}, %{reg1}"), "pandn");
1829 }
1830
TEST_F(AssemblerX86_64AVXTest,VPAndn)1831 TEST_F(AssemblerX86_64AVXTest, VPAndn) {
1832 DriverStr(RepeatFFF(&x86_64::X86_64Assembler::vpandn,
1833 "vpandn %{reg3}, %{reg2}, %{reg1}"), "vpandn");
1834 }
1835
TEST_F(AssemblerX86_64AVXTest,VAndnps)1836 TEST_F(AssemblerX86_64AVXTest, VAndnps) {
1837 DriverStr(RepeatFFF(&x86_64::X86_64Assembler::vandnps,
1838 "vandnps %{reg3}, %{reg2}, %{reg1}"), "vandnps");
1839 }
1840
TEST_F(AssemblerX86_64AVXTest,VAndnpd)1841 TEST_F(AssemblerX86_64AVXTest, VAndnpd) {
1842 DriverStr(RepeatFFF(&x86_64::X86_64Assembler::vandnpd,
1843 "vandnpd %{reg3}, %{reg2}, %{reg1}"), "vandnpd");
1844 }
1845
TEST_F(AssemblerX86_64Test,Orps)1846 TEST_F(AssemblerX86_64Test, Orps) {
1847 DriverStr(RepeatFF(&x86_64::X86_64Assembler::orps, "orps %{reg2}, %{reg1}"), "orps");
1848 }
1849
TEST_F(AssemblerX86_64Test,Orpd)1850 TEST_F(AssemblerX86_64Test, Orpd) {
1851 DriverStr(RepeatFF(&x86_64::X86_64Assembler::orpd, "orpd %{reg2}, %{reg1}"), "orpd");
1852 }
1853
TEST_F(AssemblerX86_64Test,Por)1854 TEST_F(AssemblerX86_64Test, Por) {
1855 DriverStr(RepeatFF(&x86_64::X86_64Assembler::por, "por %{reg2}, %{reg1}"), "por");
1856 }
1857
TEST_F(AssemblerX86_64AVXTest,VPor)1858 TEST_F(AssemblerX86_64AVXTest, VPor) {
1859 DriverStr(RepeatFFF(&x86_64::X86_64Assembler::vpor,
1860 "vpor %{reg3}, %{reg2}, %{reg1}"), "vpor");
1861 }
1862
TEST_F(AssemblerX86_64AVXTest,Vorps)1863 TEST_F(AssemblerX86_64AVXTest, Vorps) {
1864 DriverStr(RepeatFFF(&x86_64::X86_64Assembler::vorps,
1865 "vorps %{reg3}, %{reg2}, %{reg1}"), "vorps");
1866 }
1867
TEST_F(AssemblerX86_64AVXTest,Vorpd)1868 TEST_F(AssemblerX86_64AVXTest, Vorpd) {
1869 DriverStr(RepeatFFF(&x86_64::X86_64Assembler::vorpd,
1870 "vorpd %{reg3}, %{reg2}, %{reg1}"), "vorpd");
1871 }
1872
TEST_F(AssemblerX86_64Test,Pavgb)1873 TEST_F(AssemblerX86_64Test, Pavgb) {
1874 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pavgb, "pavgb %{reg2}, %{reg1}"), "pavgb");
1875 }
1876
TEST_F(AssemblerX86_64Test,Pavgw)1877 TEST_F(AssemblerX86_64Test, Pavgw) {
1878 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pavgw, "pavgw %{reg2}, %{reg1}"), "pavgw");
1879 }
1880
TEST_F(AssemblerX86_64Test,Psadbw)1881 TEST_F(AssemblerX86_64Test, Psadbw) {
1882 DriverStr(RepeatFF(&x86_64::X86_64Assembler::psadbw, "psadbw %{reg2}, %{reg1}"), "psadbw");
1883 }
1884
TEST_F(AssemblerX86_64Test,Pmaddwd)1885 TEST_F(AssemblerX86_64Test, Pmaddwd) {
1886 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pmaddwd, "pmaddwd %{reg2}, %{reg1}"), "pmadwd");
1887 }
1888
TEST_F(AssemblerX86_64AVXTest,VPmaddwd)1889 TEST_F(AssemblerX86_64AVXTest, VPmaddwd) {
1890 DriverStr(RepeatFFF(&x86_64::X86_64Assembler::vpmaddwd,
1891 "vpmaddwd %{reg3}, %{reg2}, %{reg1}"), "vpmaddwd");
1892 }
1893
TEST_F(AssemblerX86_64AVXTest,VFmadd213ss)1894 TEST_F(AssemblerX86_64AVXTest, VFmadd213ss) {
1895 DriverStr(RepeatFFF(&x86_64::X86_64Assembler::vfmadd213ss,
1896 "vfmadd213ss %{reg3}, %{reg2}, %{reg1}"), "vfmadd213ss");
1897 }
1898
TEST_F(AssemblerX86_64AVXTest,VFmadd213sd)1899 TEST_F(AssemblerX86_64AVXTest, VFmadd213sd) {
1900 DriverStr(RepeatFFF(&x86_64::X86_64Assembler::vfmadd213sd,
1901 "vfmadd213sd %{reg3}, %{reg2}, %{reg1}"), "vfmadd213sd");
1902 }
1903
TEST_F(AssemblerX86_64Test,Phaddw)1904 TEST_F(AssemblerX86_64Test, Phaddw) {
1905 DriverStr(RepeatFF(&x86_64::X86_64Assembler::phaddw, "phaddw %{reg2}, %{reg1}"), "phaddw");
1906 }
1907
TEST_F(AssemblerX86_64Test,Phaddd)1908 TEST_F(AssemblerX86_64Test, Phaddd) {
1909 DriverStr(RepeatFF(&x86_64::X86_64Assembler::phaddd, "phaddd %{reg2}, %{reg1}"), "phaddd");
1910 }
1911
TEST_F(AssemblerX86_64Test,Haddps)1912 TEST_F(AssemblerX86_64Test, Haddps) {
1913 DriverStr(RepeatFF(&x86_64::X86_64Assembler::haddps, "haddps %{reg2}, %{reg1}"), "haddps");
1914 }
1915
TEST_F(AssemblerX86_64Test,Haddpd)1916 TEST_F(AssemblerX86_64Test, Haddpd) {
1917 DriverStr(RepeatFF(&x86_64::X86_64Assembler::haddpd, "haddpd %{reg2}, %{reg1}"), "haddpd");
1918 }
1919
TEST_F(AssemblerX86_64Test,Phsubw)1920 TEST_F(AssemblerX86_64Test, Phsubw) {
1921 DriverStr(RepeatFF(&x86_64::X86_64Assembler::phsubw, "phsubw %{reg2}, %{reg1}"), "phsubw");
1922 }
1923
TEST_F(AssemblerX86_64Test,Phsubd)1924 TEST_F(AssemblerX86_64Test, Phsubd) {
1925 DriverStr(RepeatFF(&x86_64::X86_64Assembler::phsubd, "phsubd %{reg2}, %{reg1}"), "phsubd");
1926 }
1927
TEST_F(AssemblerX86_64Test,Hsubps)1928 TEST_F(AssemblerX86_64Test, Hsubps) {
1929 DriverStr(RepeatFF(&x86_64::X86_64Assembler::hsubps, "hsubps %{reg2}, %{reg1}"), "hsubps");
1930 }
1931
TEST_F(AssemblerX86_64Test,Hsubpd)1932 TEST_F(AssemblerX86_64Test, Hsubpd) {
1933 DriverStr(RepeatFF(&x86_64::X86_64Assembler::hsubpd, "hsubpd %{reg2}, %{reg1}"), "hsubpd");
1934 }
1935
TEST_F(AssemblerX86_64Test,Pminsb)1936 TEST_F(AssemblerX86_64Test, Pminsb) {
1937 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pminsb, "pminsb %{reg2}, %{reg1}"), "pminsb");
1938 }
1939
TEST_F(AssemblerX86_64Test,Pmaxsb)1940 TEST_F(AssemblerX86_64Test, Pmaxsb) {
1941 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pmaxsb, "pmaxsb %{reg2}, %{reg1}"), "pmaxsb");
1942 }
1943
TEST_F(AssemblerX86_64Test,Pminsw)1944 TEST_F(AssemblerX86_64Test, Pminsw) {
1945 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pminsw, "pminsw %{reg2}, %{reg1}"), "pminsw");
1946 }
1947
TEST_F(AssemblerX86_64Test,Pmaxsw)1948 TEST_F(AssemblerX86_64Test, Pmaxsw) {
1949 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pmaxsw, "pmaxsw %{reg2}, %{reg1}"), "pmaxsw");
1950 }
1951
TEST_F(AssemblerX86_64Test,Pminsd)1952 TEST_F(AssemblerX86_64Test, Pminsd) {
1953 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pminsd, "pminsd %{reg2}, %{reg1}"), "pminsd");
1954 }
1955
TEST_F(AssemblerX86_64Test,Pmaxsd)1956 TEST_F(AssemblerX86_64Test, Pmaxsd) {
1957 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pmaxsd, "pmaxsd %{reg2}, %{reg1}"), "pmaxsd");
1958 }
1959
TEST_F(AssemblerX86_64Test,Pminub)1960 TEST_F(AssemblerX86_64Test, Pminub) {
1961 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pminub, "pminub %{reg2}, %{reg1}"), "pminub");
1962 }
1963
TEST_F(AssemblerX86_64Test,Pmaxub)1964 TEST_F(AssemblerX86_64Test, Pmaxub) {
1965 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pmaxub, "pmaxub %{reg2}, %{reg1}"), "pmaxub");
1966 }
1967
TEST_F(AssemblerX86_64Test,Pminuw)1968 TEST_F(AssemblerX86_64Test, Pminuw) {
1969 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pminuw, "pminuw %{reg2}, %{reg1}"), "pminuw");
1970 }
1971
TEST_F(AssemblerX86_64Test,Pmaxuw)1972 TEST_F(AssemblerX86_64Test, Pmaxuw) {
1973 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pmaxuw, "pmaxuw %{reg2}, %{reg1}"), "pmaxuw");
1974 }
1975
TEST_F(AssemblerX86_64Test,Pminud)1976 TEST_F(AssemblerX86_64Test, Pminud) {
1977 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pminud, "pminud %{reg2}, %{reg1}"), "pminud");
1978 }
1979
TEST_F(AssemblerX86_64Test,Pmaxud)1980 TEST_F(AssemblerX86_64Test, Pmaxud) {
1981 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pmaxud, "pmaxud %{reg2}, %{reg1}"), "pmaxud");
1982 }
1983
TEST_F(AssemblerX86_64Test,Minps)1984 TEST_F(AssemblerX86_64Test, Minps) {
1985 DriverStr(RepeatFF(&x86_64::X86_64Assembler::minps, "minps %{reg2}, %{reg1}"), "minps");
1986 }
1987
TEST_F(AssemblerX86_64Test,Maxps)1988 TEST_F(AssemblerX86_64Test, Maxps) {
1989 DriverStr(RepeatFF(&x86_64::X86_64Assembler::maxps, "maxps %{reg2}, %{reg1}"), "maxps");
1990 }
1991
TEST_F(AssemblerX86_64Test,Minpd)1992 TEST_F(AssemblerX86_64Test, Minpd) {
1993 DriverStr(RepeatFF(&x86_64::X86_64Assembler::minpd, "minpd %{reg2}, %{reg1}"), "minpd");
1994 }
1995
TEST_F(AssemblerX86_64Test,Maxpd)1996 TEST_F(AssemblerX86_64Test, Maxpd) {
1997 DriverStr(RepeatFF(&x86_64::X86_64Assembler::maxpd, "maxpd %{reg2}, %{reg1}"), "maxpd");
1998 }
1999
TEST_F(AssemblerX86_64Test,PCmpeqb)2000 TEST_F(AssemblerX86_64Test, PCmpeqb) {
2001 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pcmpeqb, "pcmpeqb %{reg2}, %{reg1}"), "pcmpeqb");
2002 }
2003
TEST_F(AssemblerX86_64Test,PCmpeqw)2004 TEST_F(AssemblerX86_64Test, PCmpeqw) {
2005 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pcmpeqw, "pcmpeqw %{reg2}, %{reg1}"), "pcmpeqw");
2006 }
2007
TEST_F(AssemblerX86_64Test,PCmpeqd)2008 TEST_F(AssemblerX86_64Test, PCmpeqd) {
2009 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pcmpeqd, "pcmpeqd %{reg2}, %{reg1}"), "pcmpeqd");
2010 }
2011
TEST_F(AssemblerX86_64Test,PCmpeqq)2012 TEST_F(AssemblerX86_64Test, PCmpeqq) {
2013 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pcmpeqq, "pcmpeqq %{reg2}, %{reg1}"), "pcmpeqq");
2014 }
2015
TEST_F(AssemblerX86_64Test,PCmpgtb)2016 TEST_F(AssemblerX86_64Test, PCmpgtb) {
2017 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pcmpgtb, "pcmpgtb %{reg2}, %{reg1}"), "pcmpgtb");
2018 }
2019
TEST_F(AssemblerX86_64Test,PCmpgtw)2020 TEST_F(AssemblerX86_64Test, PCmpgtw) {
2021 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pcmpgtw, "pcmpgtw %{reg2}, %{reg1}"), "pcmpgtw");
2022 }
2023
TEST_F(AssemblerX86_64Test,PCmpgtd)2024 TEST_F(AssemblerX86_64Test, PCmpgtd) {
2025 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pcmpgtd, "pcmpgtd %{reg2}, %{reg1}"), "pcmpgtd");
2026 }
2027
TEST_F(AssemblerX86_64Test,PCmpgtq)2028 TEST_F(AssemblerX86_64Test, PCmpgtq) {
2029 DriverStr(RepeatFF(&x86_64::X86_64Assembler::pcmpgtq, "pcmpgtq %{reg2}, %{reg1}"), "pcmpgtq");
2030 }
2031
TEST_F(AssemblerX86_64Test,Shufps)2032 TEST_F(AssemblerX86_64Test, Shufps) {
2033 DriverStr(RepeatFFI(&x86_64::X86_64Assembler::shufps, /*imm_bytes*/ 1U,
2034 "shufps ${imm}, %{reg2}, %{reg1}"), "shufps");
2035 }
2036
TEST_F(AssemblerX86_64Test,Shufpd)2037 TEST_F(AssemblerX86_64Test, Shufpd) {
2038 DriverStr(RepeatFFI(&x86_64::X86_64Assembler::shufpd, /*imm_bytes*/ 1U,
2039 "shufpd ${imm}, %{reg2}, %{reg1}"), "shufpd");
2040 }
2041
TEST_F(AssemblerX86_64Test,PShufd)2042 TEST_F(AssemblerX86_64Test, PShufd) {
2043 DriverStr(RepeatFFI(&x86_64::X86_64Assembler::pshufd, /*imm_bytes*/ 1U,
2044 "pshufd ${imm}, %{reg2}, %{reg1}"), "pshufd");
2045 }
2046
TEST_F(AssemblerX86_64Test,Punpcklbw)2047 TEST_F(AssemblerX86_64Test, Punpcklbw) {
2048 DriverStr(RepeatFF(&x86_64::X86_64Assembler::punpcklbw,
2049 "punpcklbw %{reg2}, %{reg1}"), "punpcklbw");
2050 }
2051
TEST_F(AssemblerX86_64Test,Punpcklwd)2052 TEST_F(AssemblerX86_64Test, Punpcklwd) {
2053 DriverStr(RepeatFF(&x86_64::X86_64Assembler::punpcklwd,
2054 "punpcklwd %{reg2}, %{reg1}"), "punpcklwd");
2055 }
2056
TEST_F(AssemblerX86_64Test,Punpckldq)2057 TEST_F(AssemblerX86_64Test, Punpckldq) {
2058 DriverStr(RepeatFF(&x86_64::X86_64Assembler::punpckldq,
2059 "punpckldq %{reg2}, %{reg1}"), "punpckldq");
2060 }
2061
TEST_F(AssemblerX86_64Test,Punpcklqdq)2062 TEST_F(AssemblerX86_64Test, Punpcklqdq) {
2063 DriverStr(RepeatFF(&x86_64::X86_64Assembler::punpcklqdq,
2064 "punpcklqdq %{reg2}, %{reg1}"), "punpcklqdq");
2065 }
2066
TEST_F(AssemblerX86_64Test,Punpckhbw)2067 TEST_F(AssemblerX86_64Test, Punpckhbw) {
2068 DriverStr(RepeatFF(&x86_64::X86_64Assembler::punpckhbw,
2069 "punpckhbw %{reg2}, %{reg1}"), "punpckhbw");
2070 }
2071
TEST_F(AssemblerX86_64Test,Punpckhwd)2072 TEST_F(AssemblerX86_64Test, Punpckhwd) {
2073 DriverStr(RepeatFF(&x86_64::X86_64Assembler::punpckhwd,
2074 "punpckhwd %{reg2}, %{reg1}"), "punpckhwd");
2075 }
2076
TEST_F(AssemblerX86_64Test,Punpckhdq)2077 TEST_F(AssemblerX86_64Test, Punpckhdq) {
2078 DriverStr(RepeatFF(&x86_64::X86_64Assembler::punpckhdq,
2079 "punpckhdq %{reg2}, %{reg1}"), "punpckhdq");
2080 }
2081
TEST_F(AssemblerX86_64Test,Punpckhqdq)2082 TEST_F(AssemblerX86_64Test, Punpckhqdq) {
2083 DriverStr(RepeatFF(&x86_64::X86_64Assembler::punpckhqdq,
2084 "punpckhqdq %{reg2}, %{reg1}"), "punpckhqdq");
2085 }
2086
TEST_F(AssemblerX86_64Test,Psllw)2087 TEST_F(AssemblerX86_64Test, Psllw) {
2088 GetAssembler()->psllw(x86_64::XmmRegister(x86_64::XMM0), x86_64::Immediate(1));
2089 GetAssembler()->psllw(x86_64::XmmRegister(x86_64::XMM15), x86_64::Immediate(2));
2090 DriverStr("psllw $1, %xmm0\n"
2091 "psllw $2, %xmm15\n", "psllwi");
2092 }
2093
TEST_F(AssemblerX86_64Test,Pslld)2094 TEST_F(AssemblerX86_64Test, Pslld) {
2095 GetAssembler()->pslld(x86_64::XmmRegister(x86_64::XMM0), x86_64::Immediate(1));
2096 GetAssembler()->pslld(x86_64::XmmRegister(x86_64::XMM15), x86_64::Immediate(2));
2097 DriverStr("pslld $1, %xmm0\n"
2098 "pslld $2, %xmm15\n", "pslldi");
2099 }
2100
TEST_F(AssemblerX86_64Test,Psllq)2101 TEST_F(AssemblerX86_64Test, Psllq) {
2102 GetAssembler()->psllq(x86_64::XmmRegister(x86_64::XMM0), x86_64::Immediate(1));
2103 GetAssembler()->psllq(x86_64::XmmRegister(x86_64::XMM15), x86_64::Immediate(2));
2104 DriverStr("psllq $1, %xmm0\n"
2105 "psllq $2, %xmm15\n", "psllqi");
2106 }
2107
TEST_F(AssemblerX86_64Test,Psraw)2108 TEST_F(AssemblerX86_64Test, Psraw) {
2109 GetAssembler()->psraw(x86_64::XmmRegister(x86_64::XMM0), x86_64::Immediate(1));
2110 GetAssembler()->psraw(x86_64::XmmRegister(x86_64::XMM15), x86_64::Immediate(2));
2111 DriverStr("psraw $1, %xmm0\n"
2112 "psraw $2, %xmm15\n", "psrawi");
2113 }
2114
TEST_F(AssemblerX86_64Test,Psrad)2115 TEST_F(AssemblerX86_64Test, Psrad) {
2116 GetAssembler()->psrad(x86_64::XmmRegister(x86_64::XMM0), x86_64::Immediate(1));
2117 GetAssembler()->psrad(x86_64::XmmRegister(x86_64::XMM15), x86_64::Immediate(2));
2118 DriverStr("psrad $1, %xmm0\n"
2119 "psrad $2, %xmm15\n", "psradi");
2120 }
2121
TEST_F(AssemblerX86_64Test,Psrlw)2122 TEST_F(AssemblerX86_64Test, Psrlw) {
2123 GetAssembler()->psrlw(x86_64::XmmRegister(x86_64::XMM0), x86_64::Immediate(1));
2124 GetAssembler()->psrlw(x86_64::XmmRegister(x86_64::XMM15), x86_64::Immediate(2));
2125 DriverStr("psrlw $1, %xmm0\n"
2126 "psrlw $2, %xmm15\n", "psrlwi");
2127 }
2128
TEST_F(AssemblerX86_64Test,Psrld)2129 TEST_F(AssemblerX86_64Test, Psrld) {
2130 GetAssembler()->psrld(x86_64::XmmRegister(x86_64::XMM0), x86_64::Immediate(1));
2131 GetAssembler()->psrld(x86_64::XmmRegister(x86_64::XMM15), x86_64::Immediate(2));
2132 DriverStr("psrld $1, %xmm0\n"
2133 "psrld $2, %xmm15\n", "psrldi");
2134 }
2135
TEST_F(AssemblerX86_64Test,Psrlq)2136 TEST_F(AssemblerX86_64Test, Psrlq) {
2137 GetAssembler()->psrlq(x86_64::XmmRegister(x86_64::XMM0), x86_64::Immediate(1));
2138 GetAssembler()->psrlq(x86_64::XmmRegister(x86_64::XMM15), x86_64::Immediate(2));
2139 DriverStr("psrlq $1, %xmm0\n"
2140 "psrlq $2, %xmm15\n", "psrlqi");
2141 }
2142
TEST_F(AssemblerX86_64Test,Psrldq)2143 TEST_F(AssemblerX86_64Test, Psrldq) {
2144 GetAssembler()->psrldq(x86_64::XmmRegister(x86_64::XMM0), x86_64::Immediate(1));
2145 GetAssembler()->psrldq(x86_64::XmmRegister(x86_64::XMM15), x86_64::Immediate(2));
2146 DriverStr("psrldq $1, %xmm0\n"
2147 "psrldq $2, %xmm15\n", "psrldqi");
2148 }
2149
x87_fn(AssemblerX86_64Test::Base * assembler_test,x86_64::X86_64Assembler * assembler)2150 std::string x87_fn([[maybe_unused]] AssemblerX86_64Test::Base* assembler_test,
2151 x86_64::X86_64Assembler* assembler) {
2152 std::ostringstream str;
2153
2154 assembler->fincstp();
2155 str << "fincstp\n";
2156
2157 assembler->fsin();
2158 str << "fsin\n";
2159
2160 assembler->fcos();
2161 str << "fcos\n";
2162
2163 assembler->fptan();
2164 str << "fptan\n";
2165
2166 return str.str();
2167 }
2168
TEST_F(AssemblerX86_64Test,X87)2169 TEST_F(AssemblerX86_64Test, X87) {
2170 DriverFn(&x87_fn, "x87");
2171 }
2172
TEST_F(AssemblerX86_64Test,FPUIntegerLoads)2173 TEST_F(AssemblerX86_64Test, FPUIntegerLoads) {
2174 DriverStr(RepeatA(&x86_64::X86_64Assembler::filds,
2175 addresses_singleton_, // no ext addressing
2176 "fildl {mem}"), "filds");
2177 }
2178
TEST_F(AssemblerX86_64Test,FPUIntegerLoadl)2179 TEST_F(AssemblerX86_64Test, FPUIntegerLoadl) {
2180 DriverStr(RepeatA(&x86_64::X86_64Assembler::fildl,
2181 addresses_singleton_, // no ext addressing
2182 "fildll {mem}"), "fildl");
2183 }
2184
TEST_F(AssemblerX86_64Test,FPUIntegerStores)2185 TEST_F(AssemblerX86_64Test, FPUIntegerStores) {
2186 DriverStr(RepeatA(&x86_64::X86_64Assembler::fistps,
2187 addresses_singleton_, // no ext addressing
2188 "fistpl {mem}"), "fistps");
2189 }
2190
TEST_F(AssemblerX86_64Test,FPUIntegerStorel)2191 TEST_F(AssemblerX86_64Test, FPUIntegerStorel) {
2192 DriverStr(RepeatA(&x86_64::X86_64Assembler::fistpl,
2193 addresses_singleton_, // no ext addressing
2194 "fistpll {mem}"), "fistpl");
2195 }
2196
TEST_F(AssemblerX86_64Test,Call)2197 TEST_F(AssemblerX86_64Test, Call) {
2198 DriverStr(RepeatR(&x86_64::X86_64Assembler::call, "call *%{reg}"), "call");
2199 }
2200
TEST_F(AssemblerX86_64Test,Jmp)2201 TEST_F(AssemblerX86_64Test, Jmp) {
2202 DriverStr(RepeatR(&x86_64::X86_64Assembler::jmp, "jmp *%{reg}"), "jmp");
2203 }
2204
TEST_F(AssemblerX86_64Test,Enter)2205 TEST_F(AssemblerX86_64Test, Enter) {
2206 DriverStr(RepeatI(&x86_64::X86_64Assembler::enter,
2207 /*imm_bytes*/ 2U,
2208 "enter ${imm}, $0", /*non-negative*/ true), "enter");
2209 }
2210
TEST_F(AssemblerX86_64Test,RetImm)2211 TEST_F(AssemblerX86_64Test, RetImm) {
2212 DriverStr(RepeatI(&x86_64::X86_64Assembler::ret,
2213 /*imm_bytes*/ 2U,
2214 "ret ${imm}", /*non-negative*/ true), "ret");
2215 }
2216
ret_and_leave_fn(AssemblerX86_64Test::Base * assembler_test,x86_64::X86_64Assembler * assembler)2217 std::string ret_and_leave_fn([[maybe_unused]] AssemblerX86_64Test::Base* assembler_test,
2218 x86_64::X86_64Assembler* assembler) {
2219 std::ostringstream str;
2220
2221 assembler->ret();
2222 str << "ret\n";
2223
2224 assembler->leave();
2225 str << "leave\n";
2226
2227 return str.str();
2228 }
2229
TEST_F(AssemblerX86_64Test,RetAndLeave)2230 TEST_F(AssemblerX86_64Test, RetAndLeave) {
2231 DriverFn(&ret_and_leave_fn, "retleave");
2232 }
2233
TEST_F(AssemblerX86_64Test,Blsmask)2234 TEST_F(AssemblerX86_64Test, Blsmask) {
2235 DriverStr(RepeatRR(&x86_64::X86_64Assembler::blsmsk, "blsmsk %{reg2}, %{reg1}"), "blsmsk");
2236 }
2237
TEST_F(AssemblerX86_64Test,Blsi)2238 TEST_F(AssemblerX86_64Test, Blsi) {
2239 DriverStr(RepeatRR(&x86_64::X86_64Assembler::blsi, "blsi %{reg2}, %{reg1}"), "blsi");
2240 }
2241
TEST_F(AssemblerX86_64Test,Blsr)2242 TEST_F(AssemblerX86_64Test, Blsr) {
2243 DriverStr(RepeatRR(&x86_64::X86_64Assembler::blsr, "blsr %{reg2}, %{reg1}"), "blsr");
2244 }
2245
TEST_F(AssemblerX86_64Test,Bswapl)2246 TEST_F(AssemblerX86_64Test, Bswapl) {
2247 DriverStr(Repeatr(&x86_64::X86_64Assembler::bswapl, "bswap %{reg}"), "bswapl");
2248 }
2249
TEST_F(AssemblerX86_64Test,Bswapq)2250 TEST_F(AssemblerX86_64Test, Bswapq) {
2251 DriverStr(RepeatR(&x86_64::X86_64Assembler::bswapq, "bswap %{reg}"), "bswapq");
2252 }
2253
TEST_F(AssemblerX86_64Test,Bsfl)2254 TEST_F(AssemblerX86_64Test, Bsfl) {
2255 DriverStr(Repeatrr(&x86_64::X86_64Assembler::bsfl, "bsfl %{reg2}, %{reg1}"), "bsfl");
2256 }
2257
TEST_F(AssemblerX86_64Test,BsflAddress)2258 TEST_F(AssemblerX86_64Test, BsflAddress) {
2259 DriverStr(RepeatrA(&x86_64::X86_64Assembler::bsfl, "bsfl {mem}, %{reg}"), "bsfl_address");
2260 }
2261
TEST_F(AssemblerX86_64Test,Bsfq)2262 TEST_F(AssemblerX86_64Test, Bsfq) {
2263 DriverStr(RepeatRR(&x86_64::X86_64Assembler::bsfq, "bsfq %{reg2}, %{reg1}"), "bsfq");
2264 }
2265
TEST_F(AssemblerX86_64Test,BsfqAddress)2266 TEST_F(AssemblerX86_64Test, BsfqAddress) {
2267 DriverStr(RepeatRA(&x86_64::X86_64Assembler::bsfq, "bsfq {mem}, %{reg}"), "bsfq_address");
2268 }
2269
TEST_F(AssemblerX86_64Test,Bsrl)2270 TEST_F(AssemblerX86_64Test, Bsrl) {
2271 DriverStr(Repeatrr(&x86_64::X86_64Assembler::bsrl, "bsrl %{reg2}, %{reg1}"), "bsrl");
2272 }
2273
TEST_F(AssemblerX86_64Test,BsrlAddress)2274 TEST_F(AssemblerX86_64Test, BsrlAddress) {
2275 DriverStr(RepeatrA(&x86_64::X86_64Assembler::bsrl, "bsrl {mem}, %{reg}"), "bsrl_address");
2276 }
2277
TEST_F(AssemblerX86_64Test,Bsrq)2278 TEST_F(AssemblerX86_64Test, Bsrq) {
2279 DriverStr(RepeatRR(&x86_64::X86_64Assembler::bsrq, "bsrq %{reg2}, %{reg1}"), "bsrq");
2280 }
2281
TEST_F(AssemblerX86_64Test,BsrqAddress)2282 TEST_F(AssemblerX86_64Test, BsrqAddress) {
2283 DriverStr(RepeatRA(&x86_64::X86_64Assembler::bsrq, "bsrq {mem}, %{reg}"), "bsrq_address");
2284 }
2285
TEST_F(AssemblerX86_64Test,Popcntl)2286 TEST_F(AssemblerX86_64Test, Popcntl) {
2287 DriverStr(Repeatrr(&x86_64::X86_64Assembler::popcntl, "popcntl %{reg2}, %{reg1}"), "popcntl");
2288 }
2289
TEST_F(AssemblerX86_64Test,PopcntlAddress)2290 TEST_F(AssemblerX86_64Test, PopcntlAddress) {
2291 DriverStr(RepeatrA(&x86_64::X86_64Assembler::popcntl, "popcntl {mem}, %{reg}"), "popcntl_address");
2292 }
2293
TEST_F(AssemblerX86_64Test,Popcntq)2294 TEST_F(AssemblerX86_64Test, Popcntq) {
2295 DriverStr(RepeatRR(&x86_64::X86_64Assembler::popcntq, "popcntq %{reg2}, %{reg1}"), "popcntq");
2296 }
2297
TEST_F(AssemblerX86_64Test,PopcntqAddress)2298 TEST_F(AssemblerX86_64Test, PopcntqAddress) {
2299 DriverStr(RepeatRA(&x86_64::X86_64Assembler::popcntq, "popcntq {mem}, %{reg}"), "popcntq_address");
2300 }
2301
TEST_F(AssemblerX86_64Test,CmovlAddress)2302 TEST_F(AssemblerX86_64Test, CmovlAddress) {
2303 GetAssembler()->cmov(x86_64::kEqual, x86_64::CpuRegister(x86_64::R10), x86_64::Address(
2304 x86_64::CpuRegister(x86_64::RDI), x86_64::CpuRegister(x86_64::RBX), TIMES_4, 12), false);
2305 GetAssembler()->cmov(x86_64::kNotEqual, x86_64::CpuRegister(x86_64::RDI), x86_64::Address(
2306 x86_64::CpuRegister(x86_64::R10), x86_64::CpuRegister(x86_64::RBX), TIMES_4, 12), false);
2307 GetAssembler()->cmov(x86_64::kEqual, x86_64::CpuRegister(x86_64::RDI), x86_64::Address(
2308 x86_64::CpuRegister(x86_64::RDI), x86_64::CpuRegister(x86_64::R9), TIMES_4, 12), false);
2309 const char* expected =
2310 "cmovzl 0xc(%RDI,%RBX,4), %R10d\n"
2311 "cmovnzl 0xc(%R10,%RBX,4), %edi\n"
2312 "cmovzl 0xc(%RDI,%R9,4), %edi\n";
2313 DriverStr(expected, "cmovl_address");
2314 }
2315
TEST_F(AssemblerX86_64Test,CmovqAddress)2316 TEST_F(AssemblerX86_64Test, CmovqAddress) {
2317 GetAssembler()->cmov(x86_64::kEqual, x86_64::CpuRegister(x86_64::R10), x86_64::Address(
2318 x86_64::CpuRegister(x86_64::RDI), x86_64::CpuRegister(x86_64::RBX), TIMES_4, 12), true);
2319 GetAssembler()->cmov(x86_64::kNotEqual, x86_64::CpuRegister(x86_64::RDI), x86_64::Address(
2320 x86_64::CpuRegister(x86_64::R10), x86_64::CpuRegister(x86_64::RBX), TIMES_4, 12), true);
2321 GetAssembler()->cmov(x86_64::kEqual, x86_64::CpuRegister(x86_64::RDI), x86_64::Address(
2322 x86_64::CpuRegister(x86_64::RDI), x86_64::CpuRegister(x86_64::R9), TIMES_4, 12), true);
2323 const char* expected =
2324 "cmovzq 0xc(%RDI,%RBX,4), %R10\n"
2325 "cmovnzq 0xc(%R10,%RBX,4), %rdi\n"
2326 "cmovzq 0xc(%RDI,%R9,4), %rdi\n";
2327 DriverStr(expected, "cmovq_address");
2328 }
2329
TEST_F(AssemblerX86_64Test,Jrcxz)2330 TEST_F(AssemblerX86_64Test, Jrcxz) {
2331 x86_64::NearLabel target;
2332 GetAssembler()->jrcxz(&target);
2333 GetAssembler()->addl(x86_64::CpuRegister(x86_64::RDI),
2334 x86_64::Address(x86_64::CpuRegister(x86_64::RSP), 4));
2335 GetAssembler()->Bind(&target);
2336 const char* expected =
2337 "jrcxz 1f\n"
2338 "addl 4(%RSP),%EDI\n"
2339 "1:\n";
2340
2341 DriverStr(expected, "jrcxz");
2342 }
2343
TEST_F(AssemblerX86_64Test,NearLabel)2344 TEST_F(AssemblerX86_64Test, NearLabel) {
2345 // Test both forward and backward branches.
2346 x86_64::NearLabel start, target;
2347 GetAssembler()->Bind(&start);
2348 GetAssembler()->j(x86_64::kEqual, &target);
2349 GetAssembler()->jmp(&target);
2350 GetAssembler()->jrcxz(&target);
2351 GetAssembler()->addl(x86_64::CpuRegister(x86_64::RDI),
2352 x86_64::Address(x86_64::CpuRegister(x86_64::RSP), 4));
2353 GetAssembler()->Bind(&target);
2354 GetAssembler()->j(x86_64::kNotEqual, &start);
2355 GetAssembler()->jmp(&start);
2356 const char* expected =
2357 "1: je 2f\n"
2358 "jmp 2f\n"
2359 "jrcxz 2f\n"
2360 "addl 4(%RSP),%EDI\n"
2361 "2: jne 1b\n"
2362 "jmp 1b\n";
2363
2364 DriverStr(expected, "near_label");
2365 }
2366
setcc_test_fn(AssemblerX86_64Test::Base * assembler_test,x86_64::X86_64Assembler * assembler)2367 std::string setcc_test_fn(AssemblerX86_64Test::Base* assembler_test,
2368 x86_64::X86_64Assembler* assembler) {
2369 // From Condition
2370 /*
2371 kOverflow = 0,
2372 kNoOverflow = 1,
2373 kBelow = 2,
2374 kAboveEqual = 3,
2375 kEqual = 4,
2376 kNotEqual = 5,
2377 kBelowEqual = 6,
2378 kAbove = 7,
2379 kSign = 8,
2380 kNotSign = 9,
2381 kParityEven = 10,
2382 kParityOdd = 11,
2383 kLess = 12,
2384 kGreaterEqual = 13,
2385 kLessEqual = 14,
2386 */
2387 std::string suffixes[15] = { "o", "no", "b", "ae", "e", "ne", "be", "a", "s", "ns", "pe", "po",
2388 "l", "ge", "le" };
2389
2390 ArrayRef<const x86_64::CpuRegister> registers = assembler_test->GetRegisters();
2391 std::ostringstream str;
2392
2393 for (auto&& reg : registers) {
2394 for (size_t i = 0; i < 15; ++i) {
2395 assembler->setcc(static_cast<x86_64::Condition>(i), reg);
2396 str << "set" << suffixes[i] << " %" << assembler_test->GetQuaternaryRegisterName(reg) << "\n";
2397 }
2398 }
2399
2400 return str.str();
2401 }
2402
TEST_F(AssemblerX86_64Test,SetCC)2403 TEST_F(AssemblerX86_64Test, SetCC) {
2404 DriverFn(&setcc_test_fn, "setcc");
2405 }
2406
TEST_F(AssemblerX86_64Test,MovzxbRegs)2407 TEST_F(AssemblerX86_64Test, MovzxbRegs) {
2408 DriverStr(Repeatrb(&x86_64::X86_64Assembler::movzxb, "movzbl %{reg2}, %{reg1}"), "movzxb");
2409 }
2410
TEST_F(AssemblerX86_64Test,MovsxbRegs)2411 TEST_F(AssemblerX86_64Test, MovsxbRegs) {
2412 DriverStr(Repeatrb(&x86_64::X86_64Assembler::movsxb, "movsbl %{reg2}, %{reg1}"), "movsxb");
2413 }
2414
TEST_F(AssemblerX86_64Test,Repnescasw)2415 TEST_F(AssemblerX86_64Test, Repnescasw) {
2416 GetAssembler()->repne_scasw();
2417 const char* expected = "repne scasw\n";
2418 DriverStr(expected, "Repnescasw");
2419 }
2420
TEST_F(AssemblerX86_64Test,Repecmpsw)2421 TEST_F(AssemblerX86_64Test, Repecmpsw) {
2422 GetAssembler()->repe_cmpsw();
2423 const char* expected = "repe cmpsw\n";
2424 DriverStr(expected, "Repecmpsw");
2425 }
2426
TEST_F(AssemblerX86_64Test,Repecmpsl)2427 TEST_F(AssemblerX86_64Test, Repecmpsl) {
2428 GetAssembler()->repe_cmpsl();
2429 const char* expected = "repe cmpsl\n";
2430 DriverStr(expected, "Repecmpsl");
2431 }
2432
TEST_F(AssemblerX86_64Test,Repecmpsq)2433 TEST_F(AssemblerX86_64Test, Repecmpsq) {
2434 GetAssembler()->repe_cmpsq();
2435 const char* expected = "repe cmpsq\n";
2436 DriverStr(expected, "Repecmpsq");
2437 }
2438
TEST_F(AssemblerX86_64Test,Ud2)2439 TEST_F(AssemblerX86_64Test, Ud2) {
2440 GetAssembler()->ud2();
2441 const char* expected = "ud2\n";
2442 DriverStr(expected, "Ud2");
2443 }
2444
TEST_F(AssemblerX86_64Test,Cmpb)2445 TEST_F(AssemblerX86_64Test, Cmpb) {
2446 DriverStr(RepeatAI(&x86_64::X86_64Assembler::cmpb,
2447 /*imm_bytes*/ 1U,
2448 "cmpb ${imm}, {mem}"), "cmpb");
2449 }
2450
TEST_F(AssemblerX86_64Test,TestbAddressImmediate)2451 TEST_F(AssemblerX86_64Test, TestbAddressImmediate) {
2452 DriverStr(RepeatAI(&x86_64::X86_64Assembler::testb,
2453 /*imm_bytes*/ 1U,
2454 "testb ${imm}, {mem}"), "testbi");
2455 }
2456
TEST_F(AssemblerX86_64Test,TestlAddressImmediate)2457 TEST_F(AssemblerX86_64Test, TestlAddressImmediate) {
2458 DriverStr(RepeatAI(&x86_64::X86_64Assembler::testl,
2459 /*imm_bytes*/ 4U,
2460 "testl ${imm}, {mem}"), "testli");
2461 }
2462
2463 // Test that displacing an existing address is the same as constructing a new one with the same
2464 // initial displacement.
TEST_F(AssemblerX86_64Test,AddressDisplaceBy)2465 TEST_F(AssemblerX86_64Test, AddressDisplaceBy) {
2466 // Test different displacements, including some 8-bit and 32-bit ones, so that changing
2467 // displacement may require a different addressing mode.
2468 static const std::vector<int32_t> displacements = {0, 42, -42, 140, -140};
2469 // Test with all scale factors.
2470 static const std::vector<ScaleFactor> scales = {TIMES_1, TIMES_2, TIMES_4, TIMES_8};
2471
2472 for (int32_t disp0 : displacements) { // initial displacement
2473 for (int32_t disp : displacements) { // extra displacement
2474 for (const x86_64::CpuRegister reg : GetRegisters()) {
2475 // Test non-SIB addressing.
2476 EXPECT_EQ(x86_64::Address::displace(x86_64::Address(reg, disp0), disp),
2477 x86_64::Address(reg, disp0 + disp));
2478
2479 // Test SIB addressing with RBP base.
2480 if (reg.AsRegister() != x86_64::RSP) {
2481 for (ScaleFactor scale : scales) {
2482 EXPECT_EQ(x86_64::Address::displace(x86_64::Address(reg, scale, disp0), disp),
2483 x86_64::Address(reg, scale, disp0 + disp));
2484 }
2485 }
2486
2487 // Test SIB addressing with different base.
2488 for (const x86_64::CpuRegister& index : GetRegisters()) {
2489 if (index.AsRegister() == x86_64::RSP) {
2490 continue; // Skip RSP as it cannot be used with this address constructor.
2491 }
2492 for (ScaleFactor scale : scales) {
2493 EXPECT_EQ(x86_64::Address::displace(x86_64::Address(reg, index, scale, disp0), disp),
2494 x86_64::Address(reg, index, scale, disp0 + disp));
2495 }
2496 }
2497
2498 // Test absolute and RIP-relative addressing.
2499 EXPECT_EQ(x86_64::Address::displace(x86_64::Address::Absolute(disp0, false), disp),
2500 x86_64::Address::Absolute(disp0 + disp, false));
2501 EXPECT_EQ(x86_64::Address::displace(x86_64::Address::Absolute(disp0, true), disp),
2502 x86_64::Address::Absolute(disp0 + disp, true));
2503 }
2504 }
2505 }
2506 }
2507
2508 class JNIMacroAssemblerX86_64Test : public JNIMacroAssemblerTest<x86_64::X86_64JNIMacroAssembler> {
2509 public:
2510 using Base = JNIMacroAssemblerTest<x86_64::X86_64JNIMacroAssembler>;
2511
2512 protected:
GetIsa()2513 InstructionSet GetIsa() override {
2514 return InstructionSet::kX86_64;
2515 }
2516
2517 private:
2518 };
2519
ManagedFromCpu(x86_64::Register r)2520 static x86_64::X86_64ManagedRegister ManagedFromCpu(x86_64::Register r) {
2521 return x86_64::X86_64ManagedRegister::FromCpuRegister(r);
2522 }
2523
ManagedFromFpu(x86_64::FloatRegister r)2524 static x86_64::X86_64ManagedRegister ManagedFromFpu(x86_64::FloatRegister r) {
2525 return x86_64::X86_64ManagedRegister::FromXmmRegister(r);
2526 }
2527
buildframe_test_fn(JNIMacroAssemblerX86_64Test::Base * assembler_test,x86_64::X86_64JNIMacroAssembler * assembler)2528 std::string buildframe_test_fn([[maybe_unused]] JNIMacroAssemblerX86_64Test::Base* assembler_test,
2529 x86_64::X86_64JNIMacroAssembler* assembler) {
2530 // TODO: more interesting spill registers / entry spills.
2531
2532 // Two random spill regs.
2533 const ManagedRegister raw_spill_regs[] = {
2534 ManagedFromCpu(x86_64::R10),
2535 ManagedFromCpu(x86_64::RSI)
2536 };
2537 ArrayRef<const ManagedRegister> spill_regs(raw_spill_regs);
2538
2539 x86_64::X86_64ManagedRegister method_reg = ManagedFromCpu(x86_64::RDI);
2540
2541 size_t frame_size = 10 * kStackAlignment;
2542 assembler->BuildFrame(frame_size, method_reg, spill_regs);
2543
2544 // Three random entry spills.
2545 assembler->Store(FrameOffset(frame_size + 0u), ManagedFromCpu(x86_64::RAX), /* size= */ 8u);
2546 assembler->Store(FrameOffset(frame_size + 8u), ManagedFromCpu(x86_64::RBX), /* size= */ 8u);
2547 assembler->Store(FrameOffset(frame_size + 16u), ManagedFromFpu(x86_64::XMM1), /* size= */ 8u);
2548
2549 // Construct assembly text counterpart.
2550 std::ostringstream str;
2551 // (1) Push the spill_regs.
2552 str << "pushq %rsi\n";
2553 str << "pushq %r10\n";
2554 // (2) Move down the stack pointer.
2555 ssize_t displacement = static_cast<ssize_t>(frame_size) - (spill_regs.size() * 8 + 8);
2556 str << "subq $" << displacement << ", %rsp\n";
2557 // (3) Store method reference.
2558 str << "movq %rdi, (%rsp)\n";
2559 // (4) Entry spills.
2560 str << "movq %rax, " << frame_size + 0 << "(%rsp)\n";
2561 str << "movq %rbx, " << frame_size + 8 << "(%rsp)\n";
2562 str << "movsd %xmm1, " << frame_size + 16 << "(%rsp)\n";
2563
2564 return str.str();
2565 }
2566
TEST_F(JNIMacroAssemblerX86_64Test,BuildFrame)2567 TEST_F(JNIMacroAssemblerX86_64Test, BuildFrame) {
2568 DriverFn(&buildframe_test_fn, "BuildFrame");
2569 }
2570
removeframe_test_fn(JNIMacroAssemblerX86_64Test::Base * assembler_test,x86_64::X86_64JNIMacroAssembler * assembler)2571 std::string removeframe_test_fn([[maybe_unused]] JNIMacroAssemblerX86_64Test::Base* assembler_test,
2572 x86_64::X86_64JNIMacroAssembler* assembler) {
2573 // TODO: more interesting spill registers / entry spills.
2574
2575 // Two random spill regs.
2576 const ManagedRegister raw_spill_regs[] = {
2577 ManagedFromCpu(x86_64::R10),
2578 ManagedFromCpu(x86_64::RSI)
2579 };
2580 ArrayRef<const ManagedRegister> spill_regs(raw_spill_regs);
2581
2582 size_t frame_size = 10 * kStackAlignment;
2583 assembler->RemoveFrame(frame_size, spill_regs, /* may_suspend= */ true);
2584
2585 // Construct assembly text counterpart.
2586 std::ostringstream str;
2587 // (1) Move up the stack pointer.
2588 ssize_t displacement = static_cast<ssize_t>(frame_size) - spill_regs.size() * 8 - 8;
2589 str << "addq $" << displacement << ", %rsp\n";
2590 // (2) Pop spill regs.
2591 str << "popq %r10\n";
2592 str << "popq %rsi\n";
2593 str << "ret\n";
2594
2595 return str.str();
2596 }
2597
TEST_F(JNIMacroAssemblerX86_64Test,RemoveFrame)2598 TEST_F(JNIMacroAssemblerX86_64Test, RemoveFrame) {
2599 DriverFn(&removeframe_test_fn, "RemoveFrame");
2600 }
2601
increaseframe_test_fn(JNIMacroAssemblerX86_64Test::Base * assembler_test,x86_64::X86_64JNIMacroAssembler * assembler)2602 std::string increaseframe_test_fn(
2603 [[maybe_unused]] JNIMacroAssemblerX86_64Test::Base* assembler_test,
2604 x86_64::X86_64JNIMacroAssembler* assembler) {
2605 assembler->IncreaseFrameSize(0U);
2606 assembler->IncreaseFrameSize(kStackAlignment);
2607 assembler->IncreaseFrameSize(10 * kStackAlignment);
2608
2609 // Construct assembly text counterpart.
2610 std::ostringstream str;
2611 // Increase by 0 is a NO-OP and ignored by the assembler.
2612 str << "addq $-" << kStackAlignment << ", %rsp\n";
2613 str << "addq $-" << 10 * kStackAlignment << ", %rsp\n";
2614
2615 return str.str();
2616 }
2617
TEST_F(JNIMacroAssemblerX86_64Test,IncreaseFrame)2618 TEST_F(JNIMacroAssemblerX86_64Test, IncreaseFrame) {
2619 DriverFn(&increaseframe_test_fn, "IncreaseFrame");
2620 }
2621
decreaseframe_test_fn(JNIMacroAssemblerX86_64Test::Base * assembler_test,x86_64::X86_64JNIMacroAssembler * assembler)2622 std::string decreaseframe_test_fn(
2623 [[maybe_unused]] JNIMacroAssemblerX86_64Test::Base* assembler_test,
2624 x86_64::X86_64JNIMacroAssembler* assembler) {
2625 assembler->DecreaseFrameSize(0U);
2626 assembler->DecreaseFrameSize(kStackAlignment);
2627 assembler->DecreaseFrameSize(10 * kStackAlignment);
2628
2629 // Construct assembly text counterpart.
2630 std::ostringstream str;
2631 // Decrease by 0 is a NO-OP and ignored by the assembler.
2632 str << "addq $" << kStackAlignment << ", %rsp\n";
2633 str << "addq $" << 10 * kStackAlignment << ", %rsp\n";
2634
2635 return str.str();
2636 }
2637
TEST_F(JNIMacroAssemblerX86_64Test,DecreaseFrame)2638 TEST_F(JNIMacroAssemblerX86_64Test, DecreaseFrame) {
2639 DriverFn(&decreaseframe_test_fn, "DecreaseFrame");
2640 }
2641
2642 } // namespace art
2643