blob: ad75174d236b2ad8bffc73c843ef1e37adac344d [file] [log] [blame]
Elliott Hughes2faa5f12012-01-30 14:42:07 -08001/*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
Ian Rogersb033c752011-07-20 12:22:35 -070016
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070017#include "assembler_x86.h"
Jesse Wilsonc981ace2011-06-22 14:17:14 -070018
Vladimir Marko93205e32016-04-13 11:59:46 +010019#include "base/arena_allocator.h"
David Sehr3215fff2018-04-03 17:10:12 -070020#include "base/malloc_arena_pool.h"
Roland Levillain647b9ed2014-11-27 12:06:00 +000021#include "base/stl_util.h"
22#include "utils/assembler_test.h"
Jesse Wilsonc981ace2011-06-22 14:17:14 -070023
Ian Rogersb033c752011-07-20 12:22:35 -070024namespace art {
25
26TEST(AssemblerX86, CreateBuffer) {
David Sehr3215fff2018-04-03 17:10:12 -070027 MallocArenaPool pool;
Vladimir Marko69d310e2017-10-09 14:12:23 +010028 ArenaAllocator allocator(&pool);
29 AssemblerBuffer buffer(&allocator);
Ian Rogersb033c752011-07-20 12:22:35 -070030 AssemblerBuffer::EnsureCapacity ensured(&buffer);
31 buffer.Emit<uint8_t>(0x42);
32 ASSERT_EQ(static_cast<size_t>(1), buffer.Size());
33 buffer.Emit<int32_t>(42);
34 ASSERT_EQ(static_cast<size_t>(5), buffer.Size());
Jesse Wilsonc981ace2011-06-22 14:17:14 -070035}
Ian Rogersb033c752011-07-20 12:22:35 -070036
Aart Bik5dafb3c2017-09-13 13:10:12 -070037//
38// Test fixture.
39//
40
Aart Bikcaa31e72017-09-14 17:08:50 -070041class AssemblerX86Test : public AssemblerTest<x86::X86Assembler,
42 x86::Address,
43 x86::Register,
44 x86::XmmRegister,
45 x86::Immediate> {
Mark Mendellbcee0922015-09-15 21:45:01 -040046 public:
Andreas Gampec55bb392018-09-21 00:02:02 +000047 using Base = AssemblerTest<x86::X86Assembler,
48 x86::Address,
49 x86::Register,
50 x86::XmmRegister,
51 x86::Immediate>;
Mark Mendellbcee0922015-09-15 21:45:01 -040052
Roland Levillain647b9ed2014-11-27 12:06:00 +000053 protected:
Roland Levillainbbc6e7e2018-08-24 16:58:47 +010054 std::string GetArchitectureString() override {
Roland Levillain647b9ed2014-11-27 12:06:00 +000055 return "x86";
56 }
57
Roland Levillainbbc6e7e2018-08-24 16:58:47 +010058 std::string GetAssemblerParameters() override {
Roland Levillain647b9ed2014-11-27 12:06:00 +000059 return " --32";
60 }
61
Roland Levillainbbc6e7e2018-08-24 16:58:47 +010062 std::string GetDisassembleParameters() override {
Roland Levillain647b9ed2014-11-27 12:06:00 +000063 return " -D -bbinary -mi386 --no-show-raw-insn";
64 }
65
Roland Levillainbbc6e7e2018-08-24 16:58:47 +010066 void SetUpHelpers() override {
Aart Bikcaa31e72017-09-14 17:08:50 -070067 if (addresses_singleton_.size() == 0) {
68 // One addressing mode to test the repeat drivers.
69 addresses_singleton_.push_back(x86::Address(x86::EAX, x86::EBX, x86::TIMES_1, 2));
70 }
71
72 if (addresses_.size() == 0) {
73 // Several addressing modes.
74 addresses_.push_back(x86::Address(x86::EDI, x86::EAX, x86::TIMES_1, 15));
75 addresses_.push_back(x86::Address(x86::EDI, x86::EBX, x86::TIMES_2, 16));
76 addresses_.push_back(x86::Address(x86::EDI, x86::ECX, x86::TIMES_4, 17));
77 addresses_.push_back(x86::Address(x86::EDI, x86::EDX, x86::TIMES_8, 18));
78 addresses_.push_back(x86::Address(x86::EAX, -1));
79 addresses_.push_back(x86::Address(x86::EBX, 0));
80 addresses_.push_back(x86::Address(x86::ESI, 1));
81 addresses_.push_back(x86::Address(x86::EDI, 987654321));
82 // Several addressing modes with the special ESP.
83 addresses_.push_back(x86::Address(x86::ESP, x86::EAX, x86::TIMES_1, 15));
84 addresses_.push_back(x86::Address(x86::ESP, x86::EBX, x86::TIMES_2, 16));
85 addresses_.push_back(x86::Address(x86::ESP, x86::ECX, x86::TIMES_4, 17));
86 addresses_.push_back(x86::Address(x86::ESP, x86::EDX, x86::TIMES_8, 18));
87 addresses_.push_back(x86::Address(x86::ESP, -1));
88 addresses_.push_back(x86::Address(x86::ESP, 0));
89 addresses_.push_back(x86::Address(x86::ESP, 1));
90 addresses_.push_back(x86::Address(x86::ESP, 987654321));
91 }
Roland Levillain647b9ed2014-11-27 12:06:00 +000092 if (registers_.size() == 0) {
93 registers_.insert(end(registers_),
Igor Murashkin5573c372017-11-16 13:34:30 -080094 {
Roland Levillain647b9ed2014-11-27 12:06:00 +000095 new x86::Register(x86::EAX),
96 new x86::Register(x86::EBX),
97 new x86::Register(x86::ECX),
98 new x86::Register(x86::EDX),
99 new x86::Register(x86::EBP),
100 new x86::Register(x86::ESP),
101 new x86::Register(x86::ESI),
102 new x86::Register(x86::EDI)
103 });
104 }
105
106 if (fp_registers_.size() == 0) {
107 fp_registers_.insert(end(fp_registers_),
Igor Murashkin5573c372017-11-16 13:34:30 -0800108 {
Roland Levillain647b9ed2014-11-27 12:06:00 +0000109 new x86::XmmRegister(x86::XMM0),
110 new x86::XmmRegister(x86::XMM1),
111 new x86::XmmRegister(x86::XMM2),
112 new x86::XmmRegister(x86::XMM3),
113 new x86::XmmRegister(x86::XMM4),
114 new x86::XmmRegister(x86::XMM5),
115 new x86::XmmRegister(x86::XMM6),
116 new x86::XmmRegister(x86::XMM7)
117 });
118 }
119 }
120
Roland Levillainbbc6e7e2018-08-24 16:58:47 +0100121 void TearDown() override {
Roland Levillain647b9ed2014-11-27 12:06:00 +0000122 AssemblerTest::TearDown();
123 STLDeleteElements(&registers_);
124 STLDeleteElements(&fp_registers_);
125 }
126
Roland Levillainbbc6e7e2018-08-24 16:58:47 +0100127 std::vector<x86::Address> GetAddresses() override {
Aart Bikcaa31e72017-09-14 17:08:50 -0700128 return addresses_;
129 }
130
Roland Levillainbbc6e7e2018-08-24 16:58:47 +0100131 std::vector<x86::Register*> GetRegisters() override {
Roland Levillain647b9ed2014-11-27 12:06:00 +0000132 return registers_;
133 }
134
Roland Levillainbbc6e7e2018-08-24 16:58:47 +0100135 std::vector<x86::XmmRegister*> GetFPRegisters() override {
Roland Levillain647b9ed2014-11-27 12:06:00 +0000136 return fp_registers_;
137 }
138
Roland Levillainbbc6e7e2018-08-24 16:58:47 +0100139 x86::Immediate CreateImmediate(int64_t imm_value) override {
Roland Levillain647b9ed2014-11-27 12:06:00 +0000140 return x86::Immediate(imm_value);
141 }
142
Aart Bikcaa31e72017-09-14 17:08:50 -0700143 std::vector<x86::Address> addresses_singleton_;
144
Roland Levillain647b9ed2014-11-27 12:06:00 +0000145 private:
Aart Bikcaa31e72017-09-14 17:08:50 -0700146 std::vector<x86::Address> addresses_;
Roland Levillain647b9ed2014-11-27 12:06:00 +0000147 std::vector<x86::Register*> registers_;
148 std::vector<x86::XmmRegister*> fp_registers_;
149};
150
Aart Bik5dafb3c2017-09-13 13:10:12 -0700151//
Aart Bikf7754e82017-09-20 10:33:06 -0700152// Test some repeat drivers used in the tests.
Aart Bik5dafb3c2017-09-13 13:10:12 -0700153//
154
155TEST_F(AssemblerX86Test, RepeatRR) {
Aart Bikf7754e82017-09-20 10:33:06 -0700156 EXPECT_NE(RepeatRR(/*f*/ nullptr, "%{reg1} %{reg2}")
157 .find("%eax %eax\n%eax %ebx\n%eax %ecx\n%eax %edx\n%eax %ebp\n%eax %esp\n%eax %esi\n"
158 "%eax %edi\n%ebx %eax\n%ebx %ebx\n%ebx %ecx\n%ebx %edx\n%ebx %ebp\n%ebx %esp\n"),
159 std::string::npos);
Aart Bik5dafb3c2017-09-13 13:10:12 -0700160}
161
162TEST_F(AssemblerX86Test, RepeatRI) {
Aart Bikcaa31e72017-09-14 17:08:50 -0700163 EXPECT_EQ("%eax $0\n%eax $-1\n%eax $18\n%ebx $0\n%ebx $-1\n%ebx $18\n%ecx $0\n%ecx $-1\n"
164 "%ecx $18\n%edx $0\n%edx $-1\n%edx $18\n%ebp $0\n%ebp $-1\n%ebp $18\n%esp $0\n"
165 "%esp $-1\n%esp $18\n%esi $0\n%esi $-1\n%esi $18\n%edi $0\n%edi $-1\n%edi $18\n",
166 RepeatRI(/*f*/ nullptr, /*imm_bytes*/ 1U, "%{reg} ${imm}"));
Aart Bik5dafb3c2017-09-13 13:10:12 -0700167}
168
169TEST_F(AssemblerX86Test, RepeatFF) {
Aart Bikf7754e82017-09-20 10:33:06 -0700170 EXPECT_NE(RepeatFF(/*f*/ nullptr, "%{reg1} %{reg2}")
171 .find("%XMM0 %XMM0\n%XMM0 %XMM1\n%XMM0 %XMM2\n%XMM0 %XMM3\n%XMM0 %XMM4\n%XMM0 %XMM5\n"
172 "%XMM0 %XMM6\n%XMM0 %XMM7\n%XMM1 %XMM0\n%XMM1 %XMM1\n%XMM1 %XMM2\n%XMM1 %XMM3\n"),
173 std::string::npos);
Aart Bik5dafb3c2017-09-13 13:10:12 -0700174}
175
176TEST_F(AssemblerX86Test, RepeatFFI) {
Aart Bikcaa31e72017-09-14 17:08:50 -0700177 EXPECT_NE(RepeatFFI(/*f*/ nullptr, /*imm_bytes*/ 1U, "%{reg1} %{reg2} ${imm}")
178 .find("%XMM0 %XMM0 $0\n%XMM0 %XMM0 $-1\n%XMM0 %XMM0 $18\n"
179 "%XMM0 %XMM1 $0\n%XMM0 %XMM1 $-1\n%XMM0 %XMM1 $18\n"),
Aart Bik5dafb3c2017-09-13 13:10:12 -0700180 std::string::npos);
181}
182
Aart Bikcaa31e72017-09-14 17:08:50 -0700183TEST_F(AssemblerX86Test, RepeatA) {
184 EXPECT_EQ("2(%eax,%ebx,1)\n", RepeatA(/*f*/ nullptr, addresses_singleton_, "{mem}"));
185}
186
187TEST_F(AssemblerX86Test, RepeatAI) {
188 EXPECT_EQ("2(%eax,%ebx,1) $0\n2(%eax,%ebx,1) $-1\n2(%eax,%ebx,1) $18\n",
189 RepeatAI(/*f*/ nullptr, /*imm_bytes*/ 1U, addresses_singleton_, "{mem} ${imm}"));
190}
191
192TEST_F(AssemblerX86Test, RepeatRA) {
193 EXPECT_EQ("%eax 2(%eax,%ebx,1)\n%ebx 2(%eax,%ebx,1)\n%ecx 2(%eax,%ebx,1)\n"
194 "%edx 2(%eax,%ebx,1)\n%ebp 2(%eax,%ebx,1)\n%esp 2(%eax,%ebx,1)\n"
195 "%esi 2(%eax,%ebx,1)\n%edi 2(%eax,%ebx,1)\n",
196 RepeatRA(/*f*/ nullptr, addresses_singleton_, "%{reg} {mem}"));
197}
198
199TEST_F(AssemblerX86Test, RepeatAR) {
200 EXPECT_EQ("2(%eax,%ebx,1) %eax\n2(%eax,%ebx,1) %ebx\n2(%eax,%ebx,1) %ecx\n"
201 "2(%eax,%ebx,1) %edx\n2(%eax,%ebx,1) %ebp\n2(%eax,%ebx,1) %esp\n"
202 "2(%eax,%ebx,1) %esi\n2(%eax,%ebx,1) %edi\n",
203 RepeatAR(/*f*/ nullptr, addresses_singleton_, "{mem} %{reg}"));
204}
205
206TEST_F(AssemblerX86Test, RepeatFA) {
207 EXPECT_EQ("%XMM0 2(%eax,%ebx,1)\n%XMM1 2(%eax,%ebx,1)\n%XMM2 2(%eax,%ebx,1)\n"
208 "%XMM3 2(%eax,%ebx,1)\n%XMM4 2(%eax,%ebx,1)\n%XMM5 2(%eax,%ebx,1)\n"
209 "%XMM6 2(%eax,%ebx,1)\n%XMM7 2(%eax,%ebx,1)\n",
210 RepeatFA(/*f*/ nullptr, addresses_singleton_, "%{reg} {mem}"));
211}
212
213TEST_F(AssemblerX86Test, RepeatAF) {
214 EXPECT_EQ("2(%eax,%ebx,1) %XMM0\n2(%eax,%ebx,1) %XMM1\n2(%eax,%ebx,1) %XMM2\n"
215 "2(%eax,%ebx,1) %XMM3\n2(%eax,%ebx,1) %XMM4\n2(%eax,%ebx,1) %XMM5\n"
216 "2(%eax,%ebx,1) %XMM6\n2(%eax,%ebx,1) %XMM7\n",
217 RepeatAF(/*f*/ nullptr, addresses_singleton_, "{mem} %{reg}"));
218}
219
Aart Bik5dafb3c2017-09-13 13:10:12 -0700220//
221// Actual x86 instruction assembler tests.
222//
Roland Levillain647b9ed2014-11-27 12:06:00 +0000223
Aart Bikf7754e82017-09-20 10:33:06 -0700224TEST_F(AssemblerX86Test, PoplAllAddresses) {
225 // Make sure all addressing modes combinations are tested at least once.
226 std::vector<x86::Address> all_addresses;
227 for (x86::Register* base : GetRegisters()) {
228 // Base only.
229 all_addresses.push_back(x86::Address(*base, -1));
230 all_addresses.push_back(x86::Address(*base, 0));
231 all_addresses.push_back(x86::Address(*base, 1));
232 all_addresses.push_back(x86::Address(*base, 123456789));
233 for (x86::Register* index : GetRegisters()) {
234 if (*index == x86::ESP) {
235 // Index cannot be ESP.
236 continue;
237 } else if (*base == *index) {
238 // Index only.
239 all_addresses.push_back(x86::Address(*index, x86::TIMES_1, -1));
240 all_addresses.push_back(x86::Address(*index, x86::TIMES_2, 0));
241 all_addresses.push_back(x86::Address(*index, x86::TIMES_4, 1));
242 all_addresses.push_back(x86::Address(*index, x86::TIMES_8, 123456789));
243 }
244 // Base and index.
245 all_addresses.push_back(x86::Address(*base, *index, x86::TIMES_1, -1));
246 all_addresses.push_back(x86::Address(*base, *index, x86::TIMES_2, 0));
247 all_addresses.push_back(x86::Address(*base, *index, x86::TIMES_4, 1));
248 all_addresses.push_back(x86::Address(*base, *index, x86::TIMES_8, 123456789));
249 }
250 }
251 DriverStr(RepeatA(&x86::X86Assembler::popl, all_addresses, "popl {mem}"), "popq");
252}
253
Roland Levillain647b9ed2014-11-27 12:06:00 +0000254TEST_F(AssemblerX86Test, Movl) {
Aart Bikcaa31e72017-09-14 17:08:50 -0700255 DriverStr(RepeatRR(&x86::X86Assembler::movl, "movl %{reg2}, %{reg1}"), "movl");
256}
257
258TEST_F(AssemblerX86Test, MovlLoad) {
259 DriverStr(RepeatRA(&x86::X86Assembler::movl, "movl {mem}, %{reg}"), "movl-load");
260}
261
Nicolas Geoffrayded55942018-01-26 16:33:41 +0000262TEST_F(AssemblerX86Test, Addw) {
263 DriverStr(RepeatAI(&x86::X86Assembler::addw, /*imm_bytes*/ 2U, "addw ${imm}, {mem}"), "addw");
264}
265
Aart Bikcaa31e72017-09-14 17:08:50 -0700266TEST_F(AssemblerX86Test, MovlStore) {
267 DriverStr(RepeatAR(&x86::X86Assembler::movl, "movl %{reg}, {mem}"), "movl-store");
Roland Levillain647b9ed2014-11-27 12:06:00 +0000268}
269
Mark Mendell7a08fb52015-07-15 14:09:35 -0400270TEST_F(AssemblerX86Test, Movntl) {
Aart Bikcaa31e72017-09-14 17:08:50 -0700271 DriverStr(RepeatAR(&x86::X86Assembler::movntl, "movntil %{reg}, {mem}"), "movntl");
Mark Mendell7a08fb52015-07-15 14:09:35 -0400272}
273
Roland Levillain647b9ed2014-11-27 12:06:00 +0000274TEST_F(AssemblerX86Test, LoadLongConstant) {
275 GetAssembler()->LoadLongConstant(x86::XMM0, 51);
276 const char* expected =
277 "push $0x0\n"
278 "push $0x33\n"
279 "movsd 0(%esp), %xmm0\n"
280 "add $8, %esp\n";
281 DriverStr(expected, "LoadLongConstant");
282}
283
Mark Mendell58d25fd2015-04-03 14:52:31 -0400284TEST_F(AssemblerX86Test, LockCmpxchgl) {
Aart Bikcaa31e72017-09-14 17:08:50 -0700285 DriverStr(RepeatAR(&x86::X86Assembler::LockCmpxchgl,
286 "lock cmpxchgl %{reg}, {mem}"), "lock_cmpxchgl");
Mark Mendell58d25fd2015-04-03 14:52:31 -0400287}
288
289TEST_F(AssemblerX86Test, LockCmpxchg8b) {
Aart Bikcaa31e72017-09-14 17:08:50 -0700290 DriverStr(RepeatA(&x86::X86Assembler::LockCmpxchg8b,
291 "lock cmpxchg8b {mem}"), "lock_cmpxchg8b");
Mark Mendell58d25fd2015-04-03 14:52:31 -0400292}
293
Aart Bikcaa31e72017-09-14 17:08:50 -0700294TEST_F(AssemblerX86Test, FPUIntegerLoadS) {
295 DriverStr(RepeatA(&x86::X86Assembler::filds, "fildl {mem}"), "fildd");
Roland Levillain0a186012015-04-13 17:00:20 +0100296}
297
Aart Bikcaa31e72017-09-14 17:08:50 -0700298TEST_F(AssemblerX86Test, FPUIntegerLoadL) {
299 DriverStr(RepeatA(&x86::X86Assembler::fildl, "fildll {mem}"), "fildl");
300}
301
302TEST_F(AssemblerX86Test, FPUIntegerStoreS) {
303 DriverStr(RepeatA(&x86::X86Assembler::fistps, "fistpl {mem}"), "fistps");
304}
305
306TEST_F(AssemblerX86Test, FPUIntegerStoreL) {
307 DriverStr(RepeatA(&x86::X86Assembler::fistpl, "fistpll {mem}"), "fistpl");
Roland Levillain0a186012015-04-13 17:00:20 +0100308}
309
jessicahandojob03d6402016-09-07 12:16:53 -0700310TEST_F(AssemblerX86Test, Repnescasb) {
311 GetAssembler()->repne_scasb();
312 const char* expected = "repne scasb\n";
313 DriverStr(expected, "Repnescasb");
314}
315
Andreas Gampe21030dd2015-05-07 14:46:15 -0700316TEST_F(AssemblerX86Test, Repnescasw) {
317 GetAssembler()->repne_scasw();
318 const char* expected = "repne scasw\n";
319 DriverStr(expected, "Repnescasw");
320}
321
jessicahandojob03d6402016-09-07 12:16:53 -0700322TEST_F(AssemblerX86Test, Repecmpsb) {
323 GetAssembler()->repe_cmpsb();
324 const char* expected = "repe cmpsb\n";
325 DriverStr(expected, "Repecmpsb");
326}
327
agicsaki71311f82015-07-27 11:34:13 -0700328TEST_F(AssemblerX86Test, Repecmpsw) {
329 GetAssembler()->repe_cmpsw();
330 const char* expected = "repe cmpsw\n";
331 DriverStr(expected, "Repecmpsw");
332}
333
agicsaki970abfb2015-07-31 10:31:14 -0700334TEST_F(AssemblerX86Test, Repecmpsl) {
335 GetAssembler()->repe_cmpsl();
336 const char* expected = "repe cmpsl\n";
337 DriverStr(expected, "Repecmpsl");
338}
339
jessicahandojob03d6402016-09-07 12:16:53 -0700340TEST_F(AssemblerX86Test, RepMovsb) {
341 GetAssembler()->rep_movsb();
342 const char* expected = "rep movsb\n";
343 DriverStr(expected, "rep_movsb");
Mark Mendellb9c4bbe2015-07-01 14:26:52 -0400344}
345
346TEST_F(AssemblerX86Test, RepMovsw) {
347 GetAssembler()->rep_movsw();
348 const char* expected = "rep movsw\n";
349 DriverStr(expected, "rep_movsw");
350}
351
Mark Mendellbcee0922015-09-15 21:45:01 -0400352TEST_F(AssemblerX86Test, Bsfl) {
353 DriverStr(RepeatRR(&x86::X86Assembler::bsfl, "bsfl %{reg2}, %{reg1}"), "bsfl");
354}
355
356TEST_F(AssemblerX86Test, BsflAddress) {
Aart Bikcaa31e72017-09-14 17:08:50 -0700357 DriverStr(RepeatRA(&x86::X86Assembler::bsfl, "bsfl {mem}, %{reg}"), "bsfl_address");
Mark Mendellbcee0922015-09-15 21:45:01 -0400358}
359
Mark Mendell8ae3ffb2015-08-12 21:16:41 -0400360TEST_F(AssemblerX86Test, Bsrl) {
361 DriverStr(RepeatRR(&x86::X86Assembler::bsrl, "bsrl %{reg2}, %{reg1}"), "bsrl");
362}
363
364TEST_F(AssemblerX86Test, BsrlAddress) {
Aart Bikcaa31e72017-09-14 17:08:50 -0700365 DriverStr(RepeatRA(&x86::X86Assembler::bsrl, "bsrl {mem}, %{reg}"), "bsrl_address");
Mark Mendell8ae3ffb2015-08-12 21:16:41 -0400366}
367
Aart Bikc39dac12016-01-21 08:59:48 -0800368TEST_F(AssemblerX86Test, Popcntl) {
369 DriverStr(RepeatRR(&x86::X86Assembler::popcntl, "popcntl %{reg2}, %{reg1}"), "popcntl");
370}
371
372TEST_F(AssemblerX86Test, PopcntlAddress) {
Aart Bikcaa31e72017-09-14 17:08:50 -0700373 DriverStr(RepeatRA(&x86::X86Assembler::popcntl, "popcntl {mem}, %{reg}"), "popcntl_address");
Aart Bikc39dac12016-01-21 08:59:48 -0800374}
375
Mark Mendellbcee0922015-09-15 21:45:01 -0400376// Rorl only allows CL as the shift count.
377std::string rorl_fn(AssemblerX86Test::Base* assembler_test, x86::X86Assembler* assembler) {
378 std::ostringstream str;
Mark Mendellbcee0922015-09-15 21:45:01 -0400379 std::vector<x86::Register*> registers = assembler_test->GetRegisters();
Mark Mendellbcee0922015-09-15 21:45:01 -0400380 x86::Register shifter(x86::ECX);
381 for (auto reg : registers) {
382 assembler->rorl(*reg, shifter);
383 str << "rorl %cl, %" << assembler_test->GetRegisterName(*reg) << "\n";
384 }
Mark Mendellbcee0922015-09-15 21:45:01 -0400385 return str.str();
386}
387
388TEST_F(AssemblerX86Test, RorlReg) {
389 DriverFn(&rorl_fn, "rorl");
390}
391
392TEST_F(AssemblerX86Test, RorlImm) {
Aart Bikf7754e82017-09-20 10:33:06 -0700393 DriverStr(RepeatRI(&x86::X86Assembler::rorl, /*imm_bytes*/ 1U, "rorl ${imm}, %{reg}"), "rorli");
Mark Mendellbcee0922015-09-15 21:45:01 -0400394}
395
396// Roll only allows CL as the shift count.
397std::string roll_fn(AssemblerX86Test::Base* assembler_test, x86::X86Assembler* assembler) {
398 std::ostringstream str;
Mark Mendellbcee0922015-09-15 21:45:01 -0400399 std::vector<x86::Register*> registers = assembler_test->GetRegisters();
Mark Mendellbcee0922015-09-15 21:45:01 -0400400 x86::Register shifter(x86::ECX);
401 for (auto reg : registers) {
402 assembler->roll(*reg, shifter);
403 str << "roll %cl, %" << assembler_test->GetRegisterName(*reg) << "\n";
404 }
Mark Mendellbcee0922015-09-15 21:45:01 -0400405 return str.str();
406}
407
408TEST_F(AssemblerX86Test, RollReg) {
409 DriverFn(&roll_fn, "roll");
410}
411
412TEST_F(AssemblerX86Test, RollImm) {
Aart Bikf7754e82017-09-20 10:33:06 -0700413 DriverStr(RepeatRI(&x86::X86Assembler::roll, /*imm_bytes*/ 1U, "roll ${imm}, %{reg}"), "rolli");
Mark Mendellbcee0922015-09-15 21:45:01 -0400414}
415
Aart Bik3ae3b592017-02-24 14:09:15 -0800416TEST_F(AssemblerX86Test, Cvtdq2ps) {
417 DriverStr(RepeatFF(&x86::X86Assembler::cvtdq2ps, "cvtdq2ps %{reg2}, %{reg1}"), "cvtdq2ps");
418}
419
420TEST_F(AssemblerX86Test, Cvtdq2pd) {
421 DriverStr(RepeatFF(&x86::X86Assembler::cvtdq2pd, "cvtdq2pd %{reg2}, %{reg1}"), "cvtdq2pd");
422}
423
Aart Bik18ba1212016-08-01 14:11:20 -0700424TEST_F(AssemblerX86Test, ComissAddr) {
Aart Bikcaa31e72017-09-14 17:08:50 -0700425 DriverStr(RepeatFA(&x86::X86Assembler::comiss, "comiss {mem}, %{reg}"), "comiss");
Aart Bik18ba1212016-08-01 14:11:20 -0700426}
427
Mark Mendell9f51f262015-10-30 09:21:37 -0400428TEST_F(AssemblerX86Test, UComissAddr) {
Aart Bikcaa31e72017-09-14 17:08:50 -0700429 DriverStr(RepeatFA(&x86::X86Assembler::ucomiss, "ucomiss {mem}, %{reg}"), "ucomiss");
Mark Mendell9f51f262015-10-30 09:21:37 -0400430}
431
Aart Bik18ba1212016-08-01 14:11:20 -0700432TEST_F(AssemblerX86Test, ComisdAddr) {
Aart Bikcaa31e72017-09-14 17:08:50 -0700433 DriverStr(RepeatFA(&x86::X86Assembler::comisd, "comisd {mem}, %{reg}"), "comisd");
Aart Bik18ba1212016-08-01 14:11:20 -0700434}
435
Mark Mendell9f51f262015-10-30 09:21:37 -0400436TEST_F(AssemblerX86Test, UComisdAddr) {
Aart Bikcaa31e72017-09-14 17:08:50 -0700437 DriverStr(RepeatFA(&x86::X86Assembler::ucomisd, "ucomisd {mem}, %{reg}"), "ucomisd");
Mark Mendell9f51f262015-10-30 09:21:37 -0400438}
439
Aart Bik33dd9092016-08-01 15:55:36 -0700440TEST_F(AssemblerX86Test, RoundSS) {
Aart Bikf7754e82017-09-20 10:33:06 -0700441 DriverStr(RepeatFFI(&x86::X86Assembler::roundss, /*imm_bytes*/ 1U,
Aart Bikcaa31e72017-09-14 17:08:50 -0700442 "roundss ${imm}, %{reg2}, %{reg1}"), "roundss");
Aart Bik33dd9092016-08-01 15:55:36 -0700443}
444
445TEST_F(AssemblerX86Test, RoundSD) {
Aart Bikf7754e82017-09-20 10:33:06 -0700446 DriverStr(RepeatFFI(&x86::X86Assembler::roundsd, /*imm_bytes*/ 1U,
Aart Bikcaa31e72017-09-14 17:08:50 -0700447 "roundsd ${imm}, %{reg2}, %{reg1}"), "roundsd");
Aart Bik33dd9092016-08-01 15:55:36 -0700448}
Mark Mendell9f51f262015-10-30 09:21:37 -0400449
Mark Mendellabdac472016-02-12 13:49:03 -0500450TEST_F(AssemblerX86Test, CmovlAddress) {
451 GetAssembler()->cmovl(x86::kEqual, x86::Register(x86::EAX), x86::Address(
452 x86::Register(x86::EDI), x86::Register(x86::EBX), x86::TIMES_4, 12));
453 GetAssembler()->cmovl(x86::kNotEqual, x86::Register(x86::EDI), x86::Address(
454 x86::Register(x86::ESI), x86::Register(x86::EBX), x86::TIMES_4, 12));
455 GetAssembler()->cmovl(x86::kEqual, x86::Register(x86::EDI), x86::Address(
456 x86::Register(x86::EDI), x86::Register(x86::EAX), x86::TIMES_4, 12));
457 const char* expected =
458 "cmovzl 0xc(%EDI,%EBX,4), %eax\n"
459 "cmovnzl 0xc(%ESI,%EBX,4), %edi\n"
460 "cmovzl 0xc(%EDI,%EAX,4), %edi\n";
Mark Mendellabdac472016-02-12 13:49:03 -0500461 DriverStr(expected, "cmovl_address");
462}
463
Vladimir Marko953437b2016-08-24 08:30:46 +0000464TEST_F(AssemblerX86Test, TestbAddressImmediate) {
Aart Bikcaa31e72017-09-14 17:08:50 -0700465 DriverStr(RepeatAI(&x86::X86Assembler::testb, /*imm_bytes*/ 1U, "testb ${imm}, {mem}"), "testb");
Vladimir Marko953437b2016-08-24 08:30:46 +0000466}
467
468TEST_F(AssemblerX86Test, TestlAddressImmediate) {
Aart Bikcaa31e72017-09-14 17:08:50 -0700469 DriverStr(RepeatAI(&x86::X86Assembler::testl, /*imm_bytes*/ 4U, "testl ${imm}, {mem}"), "testl");
Vladimir Marko953437b2016-08-24 08:30:46 +0000470}
471
Aart Bikc7782262017-01-13 16:20:08 -0800472TEST_F(AssemblerX86Test, Movaps) {
473 DriverStr(RepeatFF(&x86::X86Assembler::movaps, "movaps %{reg2}, %{reg1}"), "movaps");
474}
475
Aart Bikcaa31e72017-09-14 17:08:50 -0700476TEST_F(AssemblerX86Test, MovapsLoad) {
477 DriverStr(RepeatFA(&x86::X86Assembler::movaps, "movaps {mem}, %{reg}"), "movaps_load");
Aart Bikc7782262017-01-13 16:20:08 -0800478}
479
Aart Bikcaa31e72017-09-14 17:08:50 -0700480TEST_F(AssemblerX86Test, MovapsStore) {
481 DriverStr(RepeatAF(&x86::X86Assembler::movaps, "movaps %{reg}, {mem}"), "movaps_store");
482}
483
484TEST_F(AssemblerX86Test, MovupsLoad) {
485 DriverStr(RepeatFA(&x86::X86Assembler::movups, "movups {mem}, %{reg}"), "movups_load");
486}
487
488TEST_F(AssemblerX86Test, MovupsStore) {
489 DriverStr(RepeatAF(&x86::X86Assembler::movups, "movups %{reg}, {mem}"), "movups_store");
Aart Bikc7782262017-01-13 16:20:08 -0800490}
491
492TEST_F(AssemblerX86Test, Movapd) {
493 DriverStr(RepeatFF(&x86::X86Assembler::movapd, "movapd %{reg2}, %{reg1}"), "movapd");
494}
495
Aart Bikcaa31e72017-09-14 17:08:50 -0700496TEST_F(AssemblerX86Test, MovapdLoad) {
497 DriverStr(RepeatFA(&x86::X86Assembler::movapd, "movapd {mem}, %{reg}"), "movapd_load");
Aart Bikc7782262017-01-13 16:20:08 -0800498}
499
Aart Bikcaa31e72017-09-14 17:08:50 -0700500TEST_F(AssemblerX86Test, MovapdStore) {
501 DriverStr(RepeatAF(&x86::X86Assembler::movapd, "movapd %{reg}, {mem}"), "movapd_store");
502}
503
504TEST_F(AssemblerX86Test, MovupdLoad) {
505 DriverStr(RepeatFA(&x86::X86Assembler::movupd, "movupd {mem}, %{reg}"), "movupd_load");
506}
507
508TEST_F(AssemblerX86Test, MovupdStore) {
509 DriverStr(RepeatAF(&x86::X86Assembler::movupd, "movupd %{reg}, {mem}"), "movupd_store");
Aart Bikc7782262017-01-13 16:20:08 -0800510}
511
Aart Bik68555e92017-02-13 14:28:45 -0800512TEST_F(AssemblerX86Test, Movdqa) {
513 DriverStr(RepeatFF(&x86::X86Assembler::movdqa, "movdqa %{reg2}, %{reg1}"), "movdqa");
514}
515
Aart Bikcaa31e72017-09-14 17:08:50 -0700516TEST_F(AssemblerX86Test, MovdqaLoad) {
517 DriverStr(RepeatFA(&x86::X86Assembler::movdqa, "movdqa {mem}, %{reg}"), "movdqa_load");
Aart Bik68555e92017-02-13 14:28:45 -0800518}
519
Aart Bikcaa31e72017-09-14 17:08:50 -0700520TEST_F(AssemblerX86Test, MovdqaStore) {
521 DriverStr(RepeatAF(&x86::X86Assembler::movdqa, "movdqa %{reg}, {mem}"), "movdqa_store");
522}
523
524TEST_F(AssemblerX86Test, MovdquLoad) {
525 DriverStr(RepeatFA(&x86::X86Assembler::movdqu, "movdqu {mem}, %{reg}"), "movdqu_load");
526}
527
528TEST_F(AssemblerX86Test, MovdquStore) {
529 DriverStr(RepeatAF(&x86::X86Assembler::movdqu, "movdqu %{reg}, {mem}"), "movdqu_store");
Aart Bik68555e92017-02-13 14:28:45 -0800530}
531
Aart Bikc7782262017-01-13 16:20:08 -0800532TEST_F(AssemblerX86Test, AddPS) {
Aart Bik12e06ed2017-01-31 16:11:24 -0800533 DriverStr(RepeatFF(&x86::X86Assembler::addps, "addps %{reg2}, %{reg1}"), "addps");
Aart Bikc7782262017-01-13 16:20:08 -0800534}
535
536TEST_F(AssemblerX86Test, AddPD) {
Aart Bik12e06ed2017-01-31 16:11:24 -0800537 DriverStr(RepeatFF(&x86::X86Assembler::addpd, "addpd %{reg2}, %{reg1}"), "addpd");
Aart Bikc7782262017-01-13 16:20:08 -0800538}
539
540TEST_F(AssemblerX86Test, SubPS) {
Aart Bik12e06ed2017-01-31 16:11:24 -0800541 DriverStr(RepeatFF(&x86::X86Assembler::subps, "subps %{reg2}, %{reg1}"), "subps");
Aart Bikc7782262017-01-13 16:20:08 -0800542}
543
544TEST_F(AssemblerX86Test, SubPD) {
Aart Bik12e06ed2017-01-31 16:11:24 -0800545 DriverStr(RepeatFF(&x86::X86Assembler::subpd, "subpd %{reg2}, %{reg1}"), "subpd");
Aart Bikc7782262017-01-13 16:20:08 -0800546}
547
548TEST_F(AssemblerX86Test, MulPS) {
Aart Bik12e06ed2017-01-31 16:11:24 -0800549 DriverStr(RepeatFF(&x86::X86Assembler::mulps, "mulps %{reg2}, %{reg1}"), "mulps");
Aart Bikc7782262017-01-13 16:20:08 -0800550}
551
552TEST_F(AssemblerX86Test, MulPD) {
Aart Bik12e06ed2017-01-31 16:11:24 -0800553 DriverStr(RepeatFF(&x86::X86Assembler::mulpd, "mulpd %{reg2}, %{reg1}"), "mulpd");
Aart Bikc7782262017-01-13 16:20:08 -0800554}
555
556TEST_F(AssemblerX86Test, DivPS) {
Aart Bik12e06ed2017-01-31 16:11:24 -0800557 DriverStr(RepeatFF(&x86::X86Assembler::divps, "divps %{reg2}, %{reg1}"), "divps");
Aart Bikc7782262017-01-13 16:20:08 -0800558}
559
560TEST_F(AssemblerX86Test, DivPD) {
Aart Bik12e06ed2017-01-31 16:11:24 -0800561 DriverStr(RepeatFF(&x86::X86Assembler::divpd, "divpd %{reg2}, %{reg1}"), "divpd");
562}
563
Aart Bike69d7a92017-02-17 11:48:23 -0800564TEST_F(AssemblerX86Test, PAddB) {
565 DriverStr(RepeatFF(&x86::X86Assembler::paddb, "paddb %{reg2}, %{reg1}"), "paddb");
566}
567
568TEST_F(AssemblerX86Test, PSubB) {
569 DriverStr(RepeatFF(&x86::X86Assembler::psubb, "psubb %{reg2}, %{reg1}"), "psubb");
570}
571
572TEST_F(AssemblerX86Test, PAddW) {
573 DriverStr(RepeatFF(&x86::X86Assembler::paddw, "paddw %{reg2}, %{reg1}"), "paddw");
574}
575
576TEST_F(AssemblerX86Test, PSubW) {
577 DriverStr(RepeatFF(&x86::X86Assembler::psubw, "psubw %{reg2}, %{reg1}"), "psubw");
578}
579
580TEST_F(AssemblerX86Test, PMullW) {
581 DriverStr(RepeatFF(&x86::X86Assembler::pmullw, "pmullw %{reg2}, %{reg1}"), "pmullw");
582}
583
Aart Bik68555e92017-02-13 14:28:45 -0800584TEST_F(AssemblerX86Test, PAddD) {
585 DriverStr(RepeatFF(&x86::X86Assembler::paddd, "paddd %{reg2}, %{reg1}"), "paddd");
586}
587
588TEST_F(AssemblerX86Test, PSubD) {
589 DriverStr(RepeatFF(&x86::X86Assembler::psubd, "psubd %{reg2}, %{reg1}"), "psubd");
590}
591
592TEST_F(AssemblerX86Test, PMullD) {
593 DriverStr(RepeatFF(&x86::X86Assembler::pmulld, "pmulld %{reg2}, %{reg1}"), "pmulld");
594}
595
Aart Bike69d7a92017-02-17 11:48:23 -0800596TEST_F(AssemblerX86Test, PAddQ) {
597 DriverStr(RepeatFF(&x86::X86Assembler::paddq, "paddq %{reg2}, %{reg1}"), "paddq");
598}
599
600TEST_F(AssemblerX86Test, PSubQ) {
601 DriverStr(RepeatFF(&x86::X86Assembler::psubq, "psubq %{reg2}, %{reg1}"), "psubq");
602}
603
Aart Bik4ca17352018-03-07 15:47:39 -0800604TEST_F(AssemblerX86Test, PAddUSB) {
605 DriverStr(RepeatFF(&x86::X86Assembler::paddusb, "paddusb %{reg2}, %{reg1}"), "paddusb");
606}
607
608TEST_F(AssemblerX86Test, PAddSB) {
609 DriverStr(RepeatFF(&x86::X86Assembler::paddsb, "paddsb %{reg2}, %{reg1}"), "paddsb");
610}
611
612TEST_F(AssemblerX86Test, PAddUSW) {
613 DriverStr(RepeatFF(&x86::X86Assembler::paddusw, "paddusw %{reg2}, %{reg1}"), "paddusw");
614}
615
616TEST_F(AssemblerX86Test, PAddSW) {
617 DriverStr(RepeatFF(&x86::X86Assembler::psubsw, "psubsw %{reg2}, %{reg1}"), "psubsw");
618}
619
620TEST_F(AssemblerX86Test, PSubUSB) {
621 DriverStr(RepeatFF(&x86::X86Assembler::psubusb, "psubusb %{reg2}, %{reg1}"), "psubusb");
622}
623
624TEST_F(AssemblerX86Test, PSubSB) {
625 DriverStr(RepeatFF(&x86::X86Assembler::psubsb, "psubsb %{reg2}, %{reg1}"), "psubsb");
626}
627
628TEST_F(AssemblerX86Test, PSubUSW) {
629 DriverStr(RepeatFF(&x86::X86Assembler::psubusw, "psubusw %{reg2}, %{reg1}"), "psubusw");
630}
631
632TEST_F(AssemblerX86Test, PSubSW) {
633 DriverStr(RepeatFF(&x86::X86Assembler::psubsw, "psubsw %{reg2}, %{reg1}"), "psubsw");
634}
635
Aart Bik68555e92017-02-13 14:28:45 -0800636TEST_F(AssemblerX86Test, XorPD) {
637 DriverStr(RepeatFF(&x86::X86Assembler::xorpd, "xorpd %{reg2}, %{reg1}"), "xorpd");
638}
639
640TEST_F(AssemblerX86Test, XorPS) {
641 DriverStr(RepeatFF(&x86::X86Assembler::xorps, "xorps %{reg2}, %{reg1}"), "xorps");
642}
643
644TEST_F(AssemblerX86Test, PXor) {
645 DriverStr(RepeatFF(&x86::X86Assembler::pxor, "pxor %{reg2}, %{reg1}"), "pxor");
646}
647
648TEST_F(AssemblerX86Test, AndPD) {
649 DriverStr(RepeatFF(&x86::X86Assembler::andpd, "andpd %{reg2}, %{reg1}"), "andpd");
650}
651
652TEST_F(AssemblerX86Test, AndPS) {
653 DriverStr(RepeatFF(&x86::X86Assembler::andps, "andps %{reg2}, %{reg1}"), "andps");
654}
655
656TEST_F(AssemblerX86Test, PAnd) {
657 DriverStr(RepeatFF(&x86::X86Assembler::pand, "pand %{reg2}, %{reg1}"), "pand");
658}
659
Aart Bik21c580b2017-03-13 11:52:07 -0700660TEST_F(AssemblerX86Test, AndnPD) {
661 DriverStr(RepeatFF(&x86::X86Assembler::andnpd, "andnpd %{reg2}, %{reg1}"), "andnpd");
662}
663
664TEST_F(AssemblerX86Test, AndnPS) {
665 DriverStr(RepeatFF(&x86::X86Assembler::andnps, "andnps %{reg2}, %{reg1}"), "andnps");
666}
667
668TEST_F(AssemblerX86Test, PAndn) {
669 DriverStr(RepeatFF(&x86::X86Assembler::pandn, "pandn %{reg2}, %{reg1}"), "pandn");
670}
671
Aart Bik68555e92017-02-13 14:28:45 -0800672TEST_F(AssemblerX86Test, OrPD) {
673 DriverStr(RepeatFF(&x86::X86Assembler::orpd, "orpd %{reg2}, %{reg1}"), "orpd");
674}
675
676TEST_F(AssemblerX86Test, OrPS) {
677 DriverStr(RepeatFF(&x86::X86Assembler::orps, "orps %{reg2}, %{reg1}"), "orps");
678}
679
680TEST_F(AssemblerX86Test, POr) {
681 DriverStr(RepeatFF(&x86::X86Assembler::por, "por %{reg2}, %{reg1}"), "por");
682}
683
Aart Bik67d3fd72017-03-31 15:11:53 -0700684TEST_F(AssemblerX86Test, PAvgB) {
685 DriverStr(RepeatFF(&x86::X86Assembler::pavgb, "pavgb %{reg2}, %{reg1}"), "pavgb");
686}
687
688TEST_F(AssemblerX86Test, PAvgW) {
689 DriverStr(RepeatFF(&x86::X86Assembler::pavgw, "pavgw %{reg2}, %{reg1}"), "pavgw");
690}
691
Aart Bik6005a872017-07-24 13:33:39 -0700692TEST_F(AssemblerX86Test, PSadBW) {
693 DriverStr(RepeatFF(&x86::X86Assembler::psadbw, "psadbw %{reg2}, %{reg1}"), "psadbw");
694}
695
696TEST_F(AssemblerX86Test, PMAddWD) {
697 DriverStr(RepeatFF(&x86::X86Assembler::pmaddwd, "pmaddwd %{reg2}, %{reg1}"), "pmaddwd");
698}
699
700TEST_F(AssemblerX86Test, PHAddW) {
701 DriverStr(RepeatFF(&x86::X86Assembler::phaddw, "phaddw %{reg2}, %{reg1}"), "phaddw");
702}
703
704TEST_F(AssemblerX86Test, PHAddD) {
705 DriverStr(RepeatFF(&x86::X86Assembler::phaddd, "phaddd %{reg2}, %{reg1}"), "phaddd");
706}
707
708TEST_F(AssemblerX86Test, HAddPS) {
709 DriverStr(RepeatFF(&x86::X86Assembler::haddps, "haddps %{reg2}, %{reg1}"), "haddps");
710}
711
712TEST_F(AssemblerX86Test, HAddPD) {
713 DriverStr(RepeatFF(&x86::X86Assembler::haddpd, "haddpd %{reg2}, %{reg1}"), "haddpd");
714}
715
716TEST_F(AssemblerX86Test, PHSubW) {
717 DriverStr(RepeatFF(&x86::X86Assembler::phsubw, "phsubw %{reg2}, %{reg1}"), "phsubw");
718}
719
720TEST_F(AssemblerX86Test, PHSubD) {
721 DriverStr(RepeatFF(&x86::X86Assembler::phsubd, "phsubd %{reg2}, %{reg1}"), "phsubd");
722}
723
724TEST_F(AssemblerX86Test, HSubPS) {
725 DriverStr(RepeatFF(&x86::X86Assembler::hsubps, "hsubps %{reg2}, %{reg1}"), "hsubps");
726}
727
728TEST_F(AssemblerX86Test, HSubPD) {
729 DriverStr(RepeatFF(&x86::X86Assembler::hsubpd, "hsubpd %{reg2}, %{reg1}"), "hsubpd");
730}
731
Aart Bikc8e93c72017-05-10 10:49:22 -0700732TEST_F(AssemblerX86Test, PMinSB) {
733 DriverStr(RepeatFF(&x86::X86Assembler::pminsb, "pminsb %{reg2}, %{reg1}"), "pminsb");
734}
735
736TEST_F(AssemblerX86Test, PMaxSB) {
737 DriverStr(RepeatFF(&x86::X86Assembler::pmaxsb, "pmaxsb %{reg2}, %{reg1}"), "pmaxsb");
738}
739
740TEST_F(AssemblerX86Test, PMinSW) {
741 DriverStr(RepeatFF(&x86::X86Assembler::pminsw, "pminsw %{reg2}, %{reg1}"), "pminsw");
742}
743
744TEST_F(AssemblerX86Test, PMaxSW) {
745 DriverStr(RepeatFF(&x86::X86Assembler::pmaxsw, "pmaxsw %{reg2}, %{reg1}"), "pmaxsw");
746}
747
748TEST_F(AssemblerX86Test, PMinSD) {
749 DriverStr(RepeatFF(&x86::X86Assembler::pminsd, "pminsd %{reg2}, %{reg1}"), "pminsd");
750}
751
752TEST_F(AssemblerX86Test, PMaxSD) {
753 DriverStr(RepeatFF(&x86::X86Assembler::pmaxsd, "pmaxsd %{reg2}, %{reg1}"), "pmaxsd");
754}
755
756TEST_F(AssemblerX86Test, PMinUB) {
757 DriverStr(RepeatFF(&x86::X86Assembler::pminub, "pminub %{reg2}, %{reg1}"), "pminub");
758}
759
760TEST_F(AssemblerX86Test, PMaxUB) {
761 DriverStr(RepeatFF(&x86::X86Assembler::pmaxub, "pmaxub %{reg2}, %{reg1}"), "pmaxub");
762}
763
764TEST_F(AssemblerX86Test, PMinUW) {
765 DriverStr(RepeatFF(&x86::X86Assembler::pminuw, "pminuw %{reg2}, %{reg1}"), "pminuw");
766}
767
768TEST_F(AssemblerX86Test, PMaxUW) {
769 DriverStr(RepeatFF(&x86::X86Assembler::pmaxuw, "pmaxuw %{reg2}, %{reg1}"), "pmaxuw");
770}
771
772TEST_F(AssemblerX86Test, PMinUD) {
773 DriverStr(RepeatFF(&x86::X86Assembler::pminud, "pminud %{reg2}, %{reg1}"), "pminud");
774}
775
776TEST_F(AssemblerX86Test, PMaxUD) {
777 DriverStr(RepeatFF(&x86::X86Assembler::pmaxud, "pmaxud %{reg2}, %{reg1}"), "pmaxud");
778}
779
780TEST_F(AssemblerX86Test, MinPS) {
781 DriverStr(RepeatFF(&x86::X86Assembler::minps, "minps %{reg2}, %{reg1}"), "minps");
782}
783
784TEST_F(AssemblerX86Test, MaxPS) {
785 DriverStr(RepeatFF(&x86::X86Assembler::maxps, "maxps %{reg2}, %{reg1}"), "maxps");
786}
787
788TEST_F(AssemblerX86Test, MinPD) {
789 DriverStr(RepeatFF(&x86::X86Assembler::minpd, "minpd %{reg2}, %{reg1}"), "minpd");
790}
791
792TEST_F(AssemblerX86Test, MaxPD) {
793 DriverStr(RepeatFF(&x86::X86Assembler::maxpd, "maxpd %{reg2}, %{reg1}"), "maxpd");
794}
795
Aart Bik4b455332017-03-15 11:19:35 -0700796TEST_F(AssemblerX86Test, PCmpeqB) {
797 DriverStr(RepeatFF(&x86::X86Assembler::pcmpeqb, "pcmpeqb %{reg2}, %{reg1}"), "cmpeqb");
798}
799
800TEST_F(AssemblerX86Test, PCmpeqW) {
801 DriverStr(RepeatFF(&x86::X86Assembler::pcmpeqw, "pcmpeqw %{reg2}, %{reg1}"), "cmpeqw");
802}
803
804TEST_F(AssemblerX86Test, PCmpeqD) {
805 DriverStr(RepeatFF(&x86::X86Assembler::pcmpeqd, "pcmpeqd %{reg2}, %{reg1}"), "cmpeqd");
806}
807
808TEST_F(AssemblerX86Test, PCmpeqQ) {
809 DriverStr(RepeatFF(&x86::X86Assembler::pcmpeqq, "pcmpeqq %{reg2}, %{reg1}"), "cmpeqq");
810}
811
Aart Bik8939c642017-04-03 14:09:01 -0700812TEST_F(AssemblerX86Test, PCmpgtB) {
813 DriverStr(RepeatFF(&x86::X86Assembler::pcmpgtb, "pcmpgtb %{reg2}, %{reg1}"), "cmpgtb");
814}
815
816TEST_F(AssemblerX86Test, PCmpgtW) {
817 DriverStr(RepeatFF(&x86::X86Assembler::pcmpgtw, "pcmpgtw %{reg2}, %{reg1}"), "cmpgtw");
818}
819
820TEST_F(AssemblerX86Test, PCmpgtD) {
821 DriverStr(RepeatFF(&x86::X86Assembler::pcmpgtd, "pcmpgtd %{reg2}, %{reg1}"), "cmpgtd");
822}
823
824TEST_F(AssemblerX86Test, PCmpgtQ) {
825 DriverStr(RepeatFF(&x86::X86Assembler::pcmpgtq, "pcmpgtq %{reg2}, %{reg1}"), "cmpgtq");
826}
827
Aart Bik12e06ed2017-01-31 16:11:24 -0800828TEST_F(AssemblerX86Test, ShufPS) {
829 DriverStr(RepeatFFI(&x86::X86Assembler::shufps, 1, "shufps ${imm}, %{reg2}, %{reg1}"), "shufps");
830}
831
832TEST_F(AssemblerX86Test, ShufPD) {
833 DriverStr(RepeatFFI(&x86::X86Assembler::shufpd, 1, "shufpd ${imm}, %{reg2}, %{reg1}"), "shufpd");
Aart Bikc7782262017-01-13 16:20:08 -0800834}
835
Aart Bik68555e92017-02-13 14:28:45 -0800836TEST_F(AssemblerX86Test, PShufD) {
837 DriverStr(RepeatFFI(&x86::X86Assembler::pshufd, 1, "pshufd ${imm}, %{reg2}, %{reg1}"), "pshufd");
838}
839
Aart Bike69d7a92017-02-17 11:48:23 -0800840TEST_F(AssemblerX86Test, Punpcklbw) {
841 DriverStr(RepeatFF(&x86::X86Assembler::punpcklbw, "punpcklbw %{reg2}, %{reg1}"), "punpcklbw");
842}
843
844TEST_F(AssemblerX86Test, Punpcklwd) {
845 DriverStr(RepeatFF(&x86::X86Assembler::punpcklwd, "punpcklwd %{reg2}, %{reg1}"), "punpcklwd");
846}
847
848TEST_F(AssemblerX86Test, Punpckldq) {
849 DriverStr(RepeatFF(&x86::X86Assembler::punpckldq, "punpckldq %{reg2}, %{reg1}"), "punpckldq");
850}
851
852TEST_F(AssemblerX86Test, Punpcklqdq) {
853 DriverStr(RepeatFF(&x86::X86Assembler::punpcklqdq, "punpcklqdq %{reg2}, %{reg1}"), "punpcklqdq");
854}
855
Aart Bik3332db82017-08-11 15:10:30 -0700856TEST_F(AssemblerX86Test, Punpckhbw) {
857 DriverStr(RepeatFF(&x86::X86Assembler::punpckhbw, "punpckhbw %{reg2}, %{reg1}"), "punpckhbw");
858}
859
860TEST_F(AssemblerX86Test, Punpckhwd) {
861 DriverStr(RepeatFF(&x86::X86Assembler::punpckhwd, "punpckhwd %{reg2}, %{reg1}"), "punpckhwd");
862}
863
864TEST_F(AssemblerX86Test, Punpckhdq) {
865 DriverStr(RepeatFF(&x86::X86Assembler::punpckhdq, "punpckhdq %{reg2}, %{reg1}"), "punpckhdq");
866}
867
868TEST_F(AssemblerX86Test, Punpckhqdq) {
869 DriverStr(RepeatFF(&x86::X86Assembler::punpckhqdq, "punpckhqdq %{reg2}, %{reg1}"), "punpckhqdq");
870}
871
Aart Bike69d7a92017-02-17 11:48:23 -0800872TEST_F(AssemblerX86Test, psllw) {
873 GetAssembler()->psllw(x86::XMM0, CreateImmediate(16));
874 DriverStr("psllw $0x10, %xmm0\n", "psllwi");
875}
876
877TEST_F(AssemblerX86Test, pslld) {
878 GetAssembler()->pslld(x86::XMM0, CreateImmediate(16));
879 DriverStr("pslld $0x10, %xmm0\n", "pslldi");
880}
881
882TEST_F(AssemblerX86Test, psllq) {
883 GetAssembler()->psllq(x86::XMM0, CreateImmediate(16));
884 DriverStr("psllq $0x10, %xmm0\n", "psllqi");
885}
886
887TEST_F(AssemblerX86Test, psraw) {
888 GetAssembler()->psraw(x86::XMM0, CreateImmediate(16));
889 DriverStr("psraw $0x10, %xmm0\n", "psrawi");
890}
891
892TEST_F(AssemblerX86Test, psrad) {
893 GetAssembler()->psrad(x86::XMM0, CreateImmediate(16));
894 DriverStr("psrad $0x10, %xmm0\n", "psradi");
895}
896
897TEST_F(AssemblerX86Test, psrlw) {
898 GetAssembler()->psrlw(x86::XMM0, CreateImmediate(16));
899 DriverStr("psrlw $0x10, %xmm0\n", "psrlwi");
900}
901
902TEST_F(AssemblerX86Test, psrld) {
903 GetAssembler()->psrld(x86::XMM0, CreateImmediate(16));
904 DriverStr("psrld $0x10, %xmm0\n", "psrldi");
905}
906
907TEST_F(AssemblerX86Test, psrlq) {
908 GetAssembler()->psrlq(x86::XMM0, CreateImmediate(16));
909 DriverStr("psrlq $0x10, %xmm0\n", "psrlqi");
910}
911
912TEST_F(AssemblerX86Test, psrldq) {
913 GetAssembler()->psrldq(x86::XMM0, CreateImmediate(16));
914 DriverStr("psrldq $0x10, %xmm0\n", "psrldqi");
915}
916
Mark Mendell73f455e2015-08-21 09:30:05 -0400917TEST_F(AssemblerX86Test, Jecxz) {
918 x86::NearLabel target;
919 GetAssembler()->jecxz(&target);
920 GetAssembler()->addl(x86::EDI, x86::Address(x86::ESP, 4));
921 GetAssembler()->Bind(&target);
922 const char* expected =
923 "jecxz 1f\n"
924 "addl 4(%ESP),%EDI\n"
925 "1:\n";
Mark Mendell73f455e2015-08-21 09:30:05 -0400926 DriverStr(expected, "jecxz");
927}
928
929TEST_F(AssemblerX86Test, NearLabel) {
930 // Test both forward and backward branches.
931 x86::NearLabel start, target;
932 GetAssembler()->Bind(&start);
933 GetAssembler()->j(x86::kEqual, &target);
934 GetAssembler()->jmp(&target);
935 GetAssembler()->jecxz(&target);
936 GetAssembler()->addl(x86::EDI, x86::Address(x86::ESP, 4));
937 GetAssembler()->Bind(&target);
938 GetAssembler()->j(x86::kNotEqual, &start);
939 GetAssembler()->jmp(&start);
940 const char* expected =
941 "1: je 2f\n"
942 "jmp 2f\n"
943 "jecxz 2f\n"
944 "addl 4(%ESP),%EDI\n"
945 "2: jne 1b\n"
946 "jmp 1b\n";
Mark Mendell73f455e2015-08-21 09:30:05 -0400947 DriverStr(expected, "near_label");
948}
949
Serguei Katkov3b625932016-05-06 10:24:17 +0600950TEST_F(AssemblerX86Test, Cmpb) {
Aart Bikf7754e82017-09-20 10:33:06 -0700951 DriverStr(RepeatAI(&x86::X86Assembler::cmpb,
952 /*imm_bytes*/ 1U,
953 "cmpb ${imm}, {mem}"), "cmpb");
954}
955
956TEST_F(AssemblerX86Test, Cmpw) {
Vladimir Marko29a8d842018-02-13 13:46:15 +0000957 DriverStr(RepeatAI(&x86::X86Assembler::cmpw, /*imm_bytes*/ 2U, "cmpw ${imm}, {mem}"), "cmpw");
Serguei Katkov3b625932016-05-06 10:24:17 +0600958}
959
Ian Rogersb033c752011-07-20 12:22:35 -0700960} // namespace art