Elliott Hughes | 2faa5f1 | 2012-01-30 14:42:07 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2011 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 16 | |
Brian Carlstrom | 578bbdc | 2011-07-21 14:07:47 -0700 | [diff] [blame] | 17 | #include "assembler_x86.h" |
Jesse Wilson | c981ace | 2011-06-22 14:17:14 -0700 | [diff] [blame] | 18 | |
Vladimir Marko | 93205e3 | 2016-04-13 11:59:46 +0100 | [diff] [blame] | 19 | #include "base/arena_allocator.h" |
David Sehr | 3215fff | 2018-04-03 17:10:12 -0700 | [diff] [blame] | 20 | #include "base/malloc_arena_pool.h" |
Roland Levillain | 647b9ed | 2014-11-27 12:06:00 +0000 | [diff] [blame] | 21 | #include "base/stl_util.h" |
| 22 | #include "utils/assembler_test.h" |
Jesse Wilson | c981ace | 2011-06-22 14:17:14 -0700 | [diff] [blame] | 23 | |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 24 | namespace art { |
| 25 | |
| 26 | TEST(AssemblerX86, CreateBuffer) { |
David Sehr | 3215fff | 2018-04-03 17:10:12 -0700 | [diff] [blame] | 27 | MallocArenaPool pool; |
Vladimir Marko | 69d310e | 2017-10-09 14:12:23 +0100 | [diff] [blame] | 28 | ArenaAllocator allocator(&pool); |
| 29 | AssemblerBuffer buffer(&allocator); |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 30 | 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 Wilson | c981ace | 2011-06-22 14:17:14 -0700 | [diff] [blame] | 35 | } |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 36 | |
Aart Bik | 5dafb3c | 2017-09-13 13:10:12 -0700 | [diff] [blame] | 37 | // |
| 38 | // Test fixture. |
| 39 | // |
| 40 | |
Aart Bik | caa31e7 | 2017-09-14 17:08:50 -0700 | [diff] [blame] | 41 | class AssemblerX86Test : public AssemblerTest<x86::X86Assembler, |
| 42 | x86::Address, |
| 43 | x86::Register, |
| 44 | x86::XmmRegister, |
| 45 | x86::Immediate> { |
Mark Mendell | bcee092 | 2015-09-15 21:45:01 -0400 | [diff] [blame] | 46 | public: |
Andreas Gampe | c55bb39 | 2018-09-21 00:02:02 +0000 | [diff] [blame] | 47 | using Base = AssemblerTest<x86::X86Assembler, |
| 48 | x86::Address, |
| 49 | x86::Register, |
| 50 | x86::XmmRegister, |
| 51 | x86::Immediate>; |
Mark Mendell | bcee092 | 2015-09-15 21:45:01 -0400 | [diff] [blame] | 52 | |
Roland Levillain | 647b9ed | 2014-11-27 12:06:00 +0000 | [diff] [blame] | 53 | protected: |
Roland Levillain | bbc6e7e | 2018-08-24 16:58:47 +0100 | [diff] [blame] | 54 | std::string GetArchitectureString() override { |
Roland Levillain | 647b9ed | 2014-11-27 12:06:00 +0000 | [diff] [blame] | 55 | return "x86"; |
| 56 | } |
| 57 | |
Roland Levillain | bbc6e7e | 2018-08-24 16:58:47 +0100 | [diff] [blame] | 58 | std::string GetAssemblerParameters() override { |
Roland Levillain | 647b9ed | 2014-11-27 12:06:00 +0000 | [diff] [blame] | 59 | return " --32"; |
| 60 | } |
| 61 | |
Roland Levillain | bbc6e7e | 2018-08-24 16:58:47 +0100 | [diff] [blame] | 62 | std::string GetDisassembleParameters() override { |
Roland Levillain | 647b9ed | 2014-11-27 12:06:00 +0000 | [diff] [blame] | 63 | return " -D -bbinary -mi386 --no-show-raw-insn"; |
| 64 | } |
| 65 | |
Roland Levillain | bbc6e7e | 2018-08-24 16:58:47 +0100 | [diff] [blame] | 66 | void SetUpHelpers() override { |
Aart Bik | caa31e7 | 2017-09-14 17:08:50 -0700 | [diff] [blame] | 67 | 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 Levillain | 647b9ed | 2014-11-27 12:06:00 +0000 | [diff] [blame] | 92 | if (registers_.size() == 0) { |
| 93 | registers_.insert(end(registers_), |
Igor Murashkin | 5573c37 | 2017-11-16 13:34:30 -0800 | [diff] [blame] | 94 | { |
Roland Levillain | 647b9ed | 2014-11-27 12:06:00 +0000 | [diff] [blame] | 95 | 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 Murashkin | 5573c37 | 2017-11-16 13:34:30 -0800 | [diff] [blame] | 108 | { |
Roland Levillain | 647b9ed | 2014-11-27 12:06:00 +0000 | [diff] [blame] | 109 | 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 Levillain | bbc6e7e | 2018-08-24 16:58:47 +0100 | [diff] [blame] | 121 | void TearDown() override { |
Roland Levillain | 647b9ed | 2014-11-27 12:06:00 +0000 | [diff] [blame] | 122 | AssemblerTest::TearDown(); |
| 123 | STLDeleteElements(®isters_); |
| 124 | STLDeleteElements(&fp_registers_); |
| 125 | } |
| 126 | |
Roland Levillain | bbc6e7e | 2018-08-24 16:58:47 +0100 | [diff] [blame] | 127 | std::vector<x86::Address> GetAddresses() override { |
Aart Bik | caa31e7 | 2017-09-14 17:08:50 -0700 | [diff] [blame] | 128 | return addresses_; |
| 129 | } |
| 130 | |
Roland Levillain | bbc6e7e | 2018-08-24 16:58:47 +0100 | [diff] [blame] | 131 | std::vector<x86::Register*> GetRegisters() override { |
Roland Levillain | 647b9ed | 2014-11-27 12:06:00 +0000 | [diff] [blame] | 132 | return registers_; |
| 133 | } |
| 134 | |
Roland Levillain | bbc6e7e | 2018-08-24 16:58:47 +0100 | [diff] [blame] | 135 | std::vector<x86::XmmRegister*> GetFPRegisters() override { |
Roland Levillain | 647b9ed | 2014-11-27 12:06:00 +0000 | [diff] [blame] | 136 | return fp_registers_; |
| 137 | } |
| 138 | |
Roland Levillain | bbc6e7e | 2018-08-24 16:58:47 +0100 | [diff] [blame] | 139 | x86::Immediate CreateImmediate(int64_t imm_value) override { |
Roland Levillain | 647b9ed | 2014-11-27 12:06:00 +0000 | [diff] [blame] | 140 | return x86::Immediate(imm_value); |
| 141 | } |
| 142 | |
Aart Bik | caa31e7 | 2017-09-14 17:08:50 -0700 | [diff] [blame] | 143 | std::vector<x86::Address> addresses_singleton_; |
| 144 | |
Roland Levillain | 647b9ed | 2014-11-27 12:06:00 +0000 | [diff] [blame] | 145 | private: |
Aart Bik | caa31e7 | 2017-09-14 17:08:50 -0700 | [diff] [blame] | 146 | std::vector<x86::Address> addresses_; |
Roland Levillain | 647b9ed | 2014-11-27 12:06:00 +0000 | [diff] [blame] | 147 | std::vector<x86::Register*> registers_; |
| 148 | std::vector<x86::XmmRegister*> fp_registers_; |
| 149 | }; |
| 150 | |
Aart Bik | 5dafb3c | 2017-09-13 13:10:12 -0700 | [diff] [blame] | 151 | // |
Aart Bik | f7754e8 | 2017-09-20 10:33:06 -0700 | [diff] [blame] | 152 | // Test some repeat drivers used in the tests. |
Aart Bik | 5dafb3c | 2017-09-13 13:10:12 -0700 | [diff] [blame] | 153 | // |
| 154 | |
| 155 | TEST_F(AssemblerX86Test, RepeatRR) { |
Aart Bik | f7754e8 | 2017-09-20 10:33:06 -0700 | [diff] [blame] | 156 | 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 Bik | 5dafb3c | 2017-09-13 13:10:12 -0700 | [diff] [blame] | 160 | } |
| 161 | |
| 162 | TEST_F(AssemblerX86Test, RepeatRI) { |
Aart Bik | caa31e7 | 2017-09-14 17:08:50 -0700 | [diff] [blame] | 163 | 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 Bik | 5dafb3c | 2017-09-13 13:10:12 -0700 | [diff] [blame] | 167 | } |
| 168 | |
| 169 | TEST_F(AssemblerX86Test, RepeatFF) { |
Aart Bik | f7754e8 | 2017-09-20 10:33:06 -0700 | [diff] [blame] | 170 | 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 Bik | 5dafb3c | 2017-09-13 13:10:12 -0700 | [diff] [blame] | 174 | } |
| 175 | |
| 176 | TEST_F(AssemblerX86Test, RepeatFFI) { |
Aart Bik | caa31e7 | 2017-09-14 17:08:50 -0700 | [diff] [blame] | 177 | 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 Bik | 5dafb3c | 2017-09-13 13:10:12 -0700 | [diff] [blame] | 180 | std::string::npos); |
| 181 | } |
| 182 | |
Aart Bik | caa31e7 | 2017-09-14 17:08:50 -0700 | [diff] [blame] | 183 | TEST_F(AssemblerX86Test, RepeatA) { |
| 184 | EXPECT_EQ("2(%eax,%ebx,1)\n", RepeatA(/*f*/ nullptr, addresses_singleton_, "{mem}")); |
| 185 | } |
| 186 | |
| 187 | TEST_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 | |
| 192 | TEST_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 | |
| 199 | TEST_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 | |
| 206 | TEST_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 | |
| 213 | TEST_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 Bik | 5dafb3c | 2017-09-13 13:10:12 -0700 | [diff] [blame] | 220 | // |
| 221 | // Actual x86 instruction assembler tests. |
| 222 | // |
Roland Levillain | 647b9ed | 2014-11-27 12:06:00 +0000 | [diff] [blame] | 223 | |
Aart Bik | f7754e8 | 2017-09-20 10:33:06 -0700 | [diff] [blame] | 224 | TEST_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 Levillain | 647b9ed | 2014-11-27 12:06:00 +0000 | [diff] [blame] | 254 | TEST_F(AssemblerX86Test, Movl) { |
Aart Bik | caa31e7 | 2017-09-14 17:08:50 -0700 | [diff] [blame] | 255 | DriverStr(RepeatRR(&x86::X86Assembler::movl, "movl %{reg2}, %{reg1}"), "movl"); |
| 256 | } |
| 257 | |
| 258 | TEST_F(AssemblerX86Test, MovlLoad) { |
| 259 | DriverStr(RepeatRA(&x86::X86Assembler::movl, "movl {mem}, %{reg}"), "movl-load"); |
| 260 | } |
| 261 | |
Nicolas Geoffray | ded5594 | 2018-01-26 16:33:41 +0000 | [diff] [blame] | 262 | TEST_F(AssemblerX86Test, Addw) { |
| 263 | DriverStr(RepeatAI(&x86::X86Assembler::addw, /*imm_bytes*/ 2U, "addw ${imm}, {mem}"), "addw"); |
| 264 | } |
| 265 | |
Aart Bik | caa31e7 | 2017-09-14 17:08:50 -0700 | [diff] [blame] | 266 | TEST_F(AssemblerX86Test, MovlStore) { |
| 267 | DriverStr(RepeatAR(&x86::X86Assembler::movl, "movl %{reg}, {mem}"), "movl-store"); |
Roland Levillain | 647b9ed | 2014-11-27 12:06:00 +0000 | [diff] [blame] | 268 | } |
| 269 | |
Mark Mendell | 7a08fb5 | 2015-07-15 14:09:35 -0400 | [diff] [blame] | 270 | TEST_F(AssemblerX86Test, Movntl) { |
Aart Bik | caa31e7 | 2017-09-14 17:08:50 -0700 | [diff] [blame] | 271 | DriverStr(RepeatAR(&x86::X86Assembler::movntl, "movntil %{reg}, {mem}"), "movntl"); |
Mark Mendell | 7a08fb5 | 2015-07-15 14:09:35 -0400 | [diff] [blame] | 272 | } |
| 273 | |
Roland Levillain | 647b9ed | 2014-11-27 12:06:00 +0000 | [diff] [blame] | 274 | TEST_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 Mendell | 58d25fd | 2015-04-03 14:52:31 -0400 | [diff] [blame] | 284 | TEST_F(AssemblerX86Test, LockCmpxchgl) { |
Aart Bik | caa31e7 | 2017-09-14 17:08:50 -0700 | [diff] [blame] | 285 | DriverStr(RepeatAR(&x86::X86Assembler::LockCmpxchgl, |
| 286 | "lock cmpxchgl %{reg}, {mem}"), "lock_cmpxchgl"); |
Mark Mendell | 58d25fd | 2015-04-03 14:52:31 -0400 | [diff] [blame] | 287 | } |
| 288 | |
| 289 | TEST_F(AssemblerX86Test, LockCmpxchg8b) { |
Aart Bik | caa31e7 | 2017-09-14 17:08:50 -0700 | [diff] [blame] | 290 | DriverStr(RepeatA(&x86::X86Assembler::LockCmpxchg8b, |
| 291 | "lock cmpxchg8b {mem}"), "lock_cmpxchg8b"); |
Mark Mendell | 58d25fd | 2015-04-03 14:52:31 -0400 | [diff] [blame] | 292 | } |
| 293 | |
Aart Bik | caa31e7 | 2017-09-14 17:08:50 -0700 | [diff] [blame] | 294 | TEST_F(AssemblerX86Test, FPUIntegerLoadS) { |
| 295 | DriverStr(RepeatA(&x86::X86Assembler::filds, "fildl {mem}"), "fildd"); |
Roland Levillain | 0a18601 | 2015-04-13 17:00:20 +0100 | [diff] [blame] | 296 | } |
| 297 | |
Aart Bik | caa31e7 | 2017-09-14 17:08:50 -0700 | [diff] [blame] | 298 | TEST_F(AssemblerX86Test, FPUIntegerLoadL) { |
| 299 | DriverStr(RepeatA(&x86::X86Assembler::fildl, "fildll {mem}"), "fildl"); |
| 300 | } |
| 301 | |
| 302 | TEST_F(AssemblerX86Test, FPUIntegerStoreS) { |
| 303 | DriverStr(RepeatA(&x86::X86Assembler::fistps, "fistpl {mem}"), "fistps"); |
| 304 | } |
| 305 | |
| 306 | TEST_F(AssemblerX86Test, FPUIntegerStoreL) { |
| 307 | DriverStr(RepeatA(&x86::X86Assembler::fistpl, "fistpll {mem}"), "fistpl"); |
Roland Levillain | 0a18601 | 2015-04-13 17:00:20 +0100 | [diff] [blame] | 308 | } |
| 309 | |
jessicahandojo | b03d640 | 2016-09-07 12:16:53 -0700 | [diff] [blame] | 310 | TEST_F(AssemblerX86Test, Repnescasb) { |
| 311 | GetAssembler()->repne_scasb(); |
| 312 | const char* expected = "repne scasb\n"; |
| 313 | DriverStr(expected, "Repnescasb"); |
| 314 | } |
| 315 | |
Andreas Gampe | 21030dd | 2015-05-07 14:46:15 -0700 | [diff] [blame] | 316 | TEST_F(AssemblerX86Test, Repnescasw) { |
| 317 | GetAssembler()->repne_scasw(); |
| 318 | const char* expected = "repne scasw\n"; |
| 319 | DriverStr(expected, "Repnescasw"); |
| 320 | } |
| 321 | |
jessicahandojo | b03d640 | 2016-09-07 12:16:53 -0700 | [diff] [blame] | 322 | TEST_F(AssemblerX86Test, Repecmpsb) { |
| 323 | GetAssembler()->repe_cmpsb(); |
| 324 | const char* expected = "repe cmpsb\n"; |
| 325 | DriverStr(expected, "Repecmpsb"); |
| 326 | } |
| 327 | |
agicsaki | 71311f8 | 2015-07-27 11:34:13 -0700 | [diff] [blame] | 328 | TEST_F(AssemblerX86Test, Repecmpsw) { |
| 329 | GetAssembler()->repe_cmpsw(); |
| 330 | const char* expected = "repe cmpsw\n"; |
| 331 | DriverStr(expected, "Repecmpsw"); |
| 332 | } |
| 333 | |
agicsaki | 970abfb | 2015-07-31 10:31:14 -0700 | [diff] [blame] | 334 | TEST_F(AssemblerX86Test, Repecmpsl) { |
| 335 | GetAssembler()->repe_cmpsl(); |
| 336 | const char* expected = "repe cmpsl\n"; |
| 337 | DriverStr(expected, "Repecmpsl"); |
| 338 | } |
| 339 | |
jessicahandojo | b03d640 | 2016-09-07 12:16:53 -0700 | [diff] [blame] | 340 | TEST_F(AssemblerX86Test, RepMovsb) { |
| 341 | GetAssembler()->rep_movsb(); |
| 342 | const char* expected = "rep movsb\n"; |
| 343 | DriverStr(expected, "rep_movsb"); |
Mark Mendell | b9c4bbe | 2015-07-01 14:26:52 -0400 | [diff] [blame] | 344 | } |
| 345 | |
| 346 | TEST_F(AssemblerX86Test, RepMovsw) { |
| 347 | GetAssembler()->rep_movsw(); |
| 348 | const char* expected = "rep movsw\n"; |
| 349 | DriverStr(expected, "rep_movsw"); |
| 350 | } |
| 351 | |
Mark Mendell | bcee092 | 2015-09-15 21:45:01 -0400 | [diff] [blame] | 352 | TEST_F(AssemblerX86Test, Bsfl) { |
| 353 | DriverStr(RepeatRR(&x86::X86Assembler::bsfl, "bsfl %{reg2}, %{reg1}"), "bsfl"); |
| 354 | } |
| 355 | |
| 356 | TEST_F(AssemblerX86Test, BsflAddress) { |
Aart Bik | caa31e7 | 2017-09-14 17:08:50 -0700 | [diff] [blame] | 357 | DriverStr(RepeatRA(&x86::X86Assembler::bsfl, "bsfl {mem}, %{reg}"), "bsfl_address"); |
Mark Mendell | bcee092 | 2015-09-15 21:45:01 -0400 | [diff] [blame] | 358 | } |
| 359 | |
Mark Mendell | 8ae3ffb | 2015-08-12 21:16:41 -0400 | [diff] [blame] | 360 | TEST_F(AssemblerX86Test, Bsrl) { |
| 361 | DriverStr(RepeatRR(&x86::X86Assembler::bsrl, "bsrl %{reg2}, %{reg1}"), "bsrl"); |
| 362 | } |
| 363 | |
| 364 | TEST_F(AssemblerX86Test, BsrlAddress) { |
Aart Bik | caa31e7 | 2017-09-14 17:08:50 -0700 | [diff] [blame] | 365 | DriverStr(RepeatRA(&x86::X86Assembler::bsrl, "bsrl {mem}, %{reg}"), "bsrl_address"); |
Mark Mendell | 8ae3ffb | 2015-08-12 21:16:41 -0400 | [diff] [blame] | 366 | } |
| 367 | |
Aart Bik | c39dac1 | 2016-01-21 08:59:48 -0800 | [diff] [blame] | 368 | TEST_F(AssemblerX86Test, Popcntl) { |
| 369 | DriverStr(RepeatRR(&x86::X86Assembler::popcntl, "popcntl %{reg2}, %{reg1}"), "popcntl"); |
| 370 | } |
| 371 | |
| 372 | TEST_F(AssemblerX86Test, PopcntlAddress) { |
Aart Bik | caa31e7 | 2017-09-14 17:08:50 -0700 | [diff] [blame] | 373 | DriverStr(RepeatRA(&x86::X86Assembler::popcntl, "popcntl {mem}, %{reg}"), "popcntl_address"); |
Aart Bik | c39dac1 | 2016-01-21 08:59:48 -0800 | [diff] [blame] | 374 | } |
| 375 | |
Mark Mendell | bcee092 | 2015-09-15 21:45:01 -0400 | [diff] [blame] | 376 | // Rorl only allows CL as the shift count. |
| 377 | std::string rorl_fn(AssemblerX86Test::Base* assembler_test, x86::X86Assembler* assembler) { |
| 378 | std::ostringstream str; |
Mark Mendell | bcee092 | 2015-09-15 21:45:01 -0400 | [diff] [blame] | 379 | std::vector<x86::Register*> registers = assembler_test->GetRegisters(); |
Mark Mendell | bcee092 | 2015-09-15 21:45:01 -0400 | [diff] [blame] | 380 | 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 Mendell | bcee092 | 2015-09-15 21:45:01 -0400 | [diff] [blame] | 385 | return str.str(); |
| 386 | } |
| 387 | |
| 388 | TEST_F(AssemblerX86Test, RorlReg) { |
| 389 | DriverFn(&rorl_fn, "rorl"); |
| 390 | } |
| 391 | |
| 392 | TEST_F(AssemblerX86Test, RorlImm) { |
Aart Bik | f7754e8 | 2017-09-20 10:33:06 -0700 | [diff] [blame] | 393 | DriverStr(RepeatRI(&x86::X86Assembler::rorl, /*imm_bytes*/ 1U, "rorl ${imm}, %{reg}"), "rorli"); |
Mark Mendell | bcee092 | 2015-09-15 21:45:01 -0400 | [diff] [blame] | 394 | } |
| 395 | |
| 396 | // Roll only allows CL as the shift count. |
| 397 | std::string roll_fn(AssemblerX86Test::Base* assembler_test, x86::X86Assembler* assembler) { |
| 398 | std::ostringstream str; |
Mark Mendell | bcee092 | 2015-09-15 21:45:01 -0400 | [diff] [blame] | 399 | std::vector<x86::Register*> registers = assembler_test->GetRegisters(); |
Mark Mendell | bcee092 | 2015-09-15 21:45:01 -0400 | [diff] [blame] | 400 | 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 Mendell | bcee092 | 2015-09-15 21:45:01 -0400 | [diff] [blame] | 405 | return str.str(); |
| 406 | } |
| 407 | |
| 408 | TEST_F(AssemblerX86Test, RollReg) { |
| 409 | DriverFn(&roll_fn, "roll"); |
| 410 | } |
| 411 | |
| 412 | TEST_F(AssemblerX86Test, RollImm) { |
Aart Bik | f7754e8 | 2017-09-20 10:33:06 -0700 | [diff] [blame] | 413 | DriverStr(RepeatRI(&x86::X86Assembler::roll, /*imm_bytes*/ 1U, "roll ${imm}, %{reg}"), "rolli"); |
Mark Mendell | bcee092 | 2015-09-15 21:45:01 -0400 | [diff] [blame] | 414 | } |
| 415 | |
Aart Bik | 3ae3b59 | 2017-02-24 14:09:15 -0800 | [diff] [blame] | 416 | TEST_F(AssemblerX86Test, Cvtdq2ps) { |
| 417 | DriverStr(RepeatFF(&x86::X86Assembler::cvtdq2ps, "cvtdq2ps %{reg2}, %{reg1}"), "cvtdq2ps"); |
| 418 | } |
| 419 | |
| 420 | TEST_F(AssemblerX86Test, Cvtdq2pd) { |
| 421 | DriverStr(RepeatFF(&x86::X86Assembler::cvtdq2pd, "cvtdq2pd %{reg2}, %{reg1}"), "cvtdq2pd"); |
| 422 | } |
| 423 | |
Aart Bik | 18ba121 | 2016-08-01 14:11:20 -0700 | [diff] [blame] | 424 | TEST_F(AssemblerX86Test, ComissAddr) { |
Aart Bik | caa31e7 | 2017-09-14 17:08:50 -0700 | [diff] [blame] | 425 | DriverStr(RepeatFA(&x86::X86Assembler::comiss, "comiss {mem}, %{reg}"), "comiss"); |
Aart Bik | 18ba121 | 2016-08-01 14:11:20 -0700 | [diff] [blame] | 426 | } |
| 427 | |
Mark Mendell | 9f51f26 | 2015-10-30 09:21:37 -0400 | [diff] [blame] | 428 | TEST_F(AssemblerX86Test, UComissAddr) { |
Aart Bik | caa31e7 | 2017-09-14 17:08:50 -0700 | [diff] [blame] | 429 | DriverStr(RepeatFA(&x86::X86Assembler::ucomiss, "ucomiss {mem}, %{reg}"), "ucomiss"); |
Mark Mendell | 9f51f26 | 2015-10-30 09:21:37 -0400 | [diff] [blame] | 430 | } |
| 431 | |
Aart Bik | 18ba121 | 2016-08-01 14:11:20 -0700 | [diff] [blame] | 432 | TEST_F(AssemblerX86Test, ComisdAddr) { |
Aart Bik | caa31e7 | 2017-09-14 17:08:50 -0700 | [diff] [blame] | 433 | DriverStr(RepeatFA(&x86::X86Assembler::comisd, "comisd {mem}, %{reg}"), "comisd"); |
Aart Bik | 18ba121 | 2016-08-01 14:11:20 -0700 | [diff] [blame] | 434 | } |
| 435 | |
Mark Mendell | 9f51f26 | 2015-10-30 09:21:37 -0400 | [diff] [blame] | 436 | TEST_F(AssemblerX86Test, UComisdAddr) { |
Aart Bik | caa31e7 | 2017-09-14 17:08:50 -0700 | [diff] [blame] | 437 | DriverStr(RepeatFA(&x86::X86Assembler::ucomisd, "ucomisd {mem}, %{reg}"), "ucomisd"); |
Mark Mendell | 9f51f26 | 2015-10-30 09:21:37 -0400 | [diff] [blame] | 438 | } |
| 439 | |
Aart Bik | 33dd909 | 2016-08-01 15:55:36 -0700 | [diff] [blame] | 440 | TEST_F(AssemblerX86Test, RoundSS) { |
Aart Bik | f7754e8 | 2017-09-20 10:33:06 -0700 | [diff] [blame] | 441 | DriverStr(RepeatFFI(&x86::X86Assembler::roundss, /*imm_bytes*/ 1U, |
Aart Bik | caa31e7 | 2017-09-14 17:08:50 -0700 | [diff] [blame] | 442 | "roundss ${imm}, %{reg2}, %{reg1}"), "roundss"); |
Aart Bik | 33dd909 | 2016-08-01 15:55:36 -0700 | [diff] [blame] | 443 | } |
| 444 | |
| 445 | TEST_F(AssemblerX86Test, RoundSD) { |
Aart Bik | f7754e8 | 2017-09-20 10:33:06 -0700 | [diff] [blame] | 446 | DriverStr(RepeatFFI(&x86::X86Assembler::roundsd, /*imm_bytes*/ 1U, |
Aart Bik | caa31e7 | 2017-09-14 17:08:50 -0700 | [diff] [blame] | 447 | "roundsd ${imm}, %{reg2}, %{reg1}"), "roundsd"); |
Aart Bik | 33dd909 | 2016-08-01 15:55:36 -0700 | [diff] [blame] | 448 | } |
Mark Mendell | 9f51f26 | 2015-10-30 09:21:37 -0400 | [diff] [blame] | 449 | |
Mark Mendell | abdac47 | 2016-02-12 13:49:03 -0500 | [diff] [blame] | 450 | TEST_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 Mendell | abdac47 | 2016-02-12 13:49:03 -0500 | [diff] [blame] | 461 | DriverStr(expected, "cmovl_address"); |
| 462 | } |
| 463 | |
Vladimir Marko | 953437b | 2016-08-24 08:30:46 +0000 | [diff] [blame] | 464 | TEST_F(AssemblerX86Test, TestbAddressImmediate) { |
Aart Bik | caa31e7 | 2017-09-14 17:08:50 -0700 | [diff] [blame] | 465 | DriverStr(RepeatAI(&x86::X86Assembler::testb, /*imm_bytes*/ 1U, "testb ${imm}, {mem}"), "testb"); |
Vladimir Marko | 953437b | 2016-08-24 08:30:46 +0000 | [diff] [blame] | 466 | } |
| 467 | |
| 468 | TEST_F(AssemblerX86Test, TestlAddressImmediate) { |
Aart Bik | caa31e7 | 2017-09-14 17:08:50 -0700 | [diff] [blame] | 469 | DriverStr(RepeatAI(&x86::X86Assembler::testl, /*imm_bytes*/ 4U, "testl ${imm}, {mem}"), "testl"); |
Vladimir Marko | 953437b | 2016-08-24 08:30:46 +0000 | [diff] [blame] | 470 | } |
| 471 | |
Aart Bik | c778226 | 2017-01-13 16:20:08 -0800 | [diff] [blame] | 472 | TEST_F(AssemblerX86Test, Movaps) { |
| 473 | DriverStr(RepeatFF(&x86::X86Assembler::movaps, "movaps %{reg2}, %{reg1}"), "movaps"); |
| 474 | } |
| 475 | |
Aart Bik | caa31e7 | 2017-09-14 17:08:50 -0700 | [diff] [blame] | 476 | TEST_F(AssemblerX86Test, MovapsLoad) { |
| 477 | DriverStr(RepeatFA(&x86::X86Assembler::movaps, "movaps {mem}, %{reg}"), "movaps_load"); |
Aart Bik | c778226 | 2017-01-13 16:20:08 -0800 | [diff] [blame] | 478 | } |
| 479 | |
Aart Bik | caa31e7 | 2017-09-14 17:08:50 -0700 | [diff] [blame] | 480 | TEST_F(AssemblerX86Test, MovapsStore) { |
| 481 | DriverStr(RepeatAF(&x86::X86Assembler::movaps, "movaps %{reg}, {mem}"), "movaps_store"); |
| 482 | } |
| 483 | |
| 484 | TEST_F(AssemblerX86Test, MovupsLoad) { |
| 485 | DriverStr(RepeatFA(&x86::X86Assembler::movups, "movups {mem}, %{reg}"), "movups_load"); |
| 486 | } |
| 487 | |
| 488 | TEST_F(AssemblerX86Test, MovupsStore) { |
| 489 | DriverStr(RepeatAF(&x86::X86Assembler::movups, "movups %{reg}, {mem}"), "movups_store"); |
Aart Bik | c778226 | 2017-01-13 16:20:08 -0800 | [diff] [blame] | 490 | } |
| 491 | |
| 492 | TEST_F(AssemblerX86Test, Movapd) { |
| 493 | DriverStr(RepeatFF(&x86::X86Assembler::movapd, "movapd %{reg2}, %{reg1}"), "movapd"); |
| 494 | } |
| 495 | |
Aart Bik | caa31e7 | 2017-09-14 17:08:50 -0700 | [diff] [blame] | 496 | TEST_F(AssemblerX86Test, MovapdLoad) { |
| 497 | DriverStr(RepeatFA(&x86::X86Assembler::movapd, "movapd {mem}, %{reg}"), "movapd_load"); |
Aart Bik | c778226 | 2017-01-13 16:20:08 -0800 | [diff] [blame] | 498 | } |
| 499 | |
Aart Bik | caa31e7 | 2017-09-14 17:08:50 -0700 | [diff] [blame] | 500 | TEST_F(AssemblerX86Test, MovapdStore) { |
| 501 | DriverStr(RepeatAF(&x86::X86Assembler::movapd, "movapd %{reg}, {mem}"), "movapd_store"); |
| 502 | } |
| 503 | |
| 504 | TEST_F(AssemblerX86Test, MovupdLoad) { |
| 505 | DriverStr(RepeatFA(&x86::X86Assembler::movupd, "movupd {mem}, %{reg}"), "movupd_load"); |
| 506 | } |
| 507 | |
| 508 | TEST_F(AssemblerX86Test, MovupdStore) { |
| 509 | DriverStr(RepeatAF(&x86::X86Assembler::movupd, "movupd %{reg}, {mem}"), "movupd_store"); |
Aart Bik | c778226 | 2017-01-13 16:20:08 -0800 | [diff] [blame] | 510 | } |
| 511 | |
Aart Bik | 68555e9 | 2017-02-13 14:28:45 -0800 | [diff] [blame] | 512 | TEST_F(AssemblerX86Test, Movdqa) { |
| 513 | DriverStr(RepeatFF(&x86::X86Assembler::movdqa, "movdqa %{reg2}, %{reg1}"), "movdqa"); |
| 514 | } |
| 515 | |
Aart Bik | caa31e7 | 2017-09-14 17:08:50 -0700 | [diff] [blame] | 516 | TEST_F(AssemblerX86Test, MovdqaLoad) { |
| 517 | DriverStr(RepeatFA(&x86::X86Assembler::movdqa, "movdqa {mem}, %{reg}"), "movdqa_load"); |
Aart Bik | 68555e9 | 2017-02-13 14:28:45 -0800 | [diff] [blame] | 518 | } |
| 519 | |
Aart Bik | caa31e7 | 2017-09-14 17:08:50 -0700 | [diff] [blame] | 520 | TEST_F(AssemblerX86Test, MovdqaStore) { |
| 521 | DriverStr(RepeatAF(&x86::X86Assembler::movdqa, "movdqa %{reg}, {mem}"), "movdqa_store"); |
| 522 | } |
| 523 | |
| 524 | TEST_F(AssemblerX86Test, MovdquLoad) { |
| 525 | DriverStr(RepeatFA(&x86::X86Assembler::movdqu, "movdqu {mem}, %{reg}"), "movdqu_load"); |
| 526 | } |
| 527 | |
| 528 | TEST_F(AssemblerX86Test, MovdquStore) { |
| 529 | DriverStr(RepeatAF(&x86::X86Assembler::movdqu, "movdqu %{reg}, {mem}"), "movdqu_store"); |
Aart Bik | 68555e9 | 2017-02-13 14:28:45 -0800 | [diff] [blame] | 530 | } |
| 531 | |
Aart Bik | c778226 | 2017-01-13 16:20:08 -0800 | [diff] [blame] | 532 | TEST_F(AssemblerX86Test, AddPS) { |
Aart Bik | 12e06ed | 2017-01-31 16:11:24 -0800 | [diff] [blame] | 533 | DriverStr(RepeatFF(&x86::X86Assembler::addps, "addps %{reg2}, %{reg1}"), "addps"); |
Aart Bik | c778226 | 2017-01-13 16:20:08 -0800 | [diff] [blame] | 534 | } |
| 535 | |
| 536 | TEST_F(AssemblerX86Test, AddPD) { |
Aart Bik | 12e06ed | 2017-01-31 16:11:24 -0800 | [diff] [blame] | 537 | DriverStr(RepeatFF(&x86::X86Assembler::addpd, "addpd %{reg2}, %{reg1}"), "addpd"); |
Aart Bik | c778226 | 2017-01-13 16:20:08 -0800 | [diff] [blame] | 538 | } |
| 539 | |
| 540 | TEST_F(AssemblerX86Test, SubPS) { |
Aart Bik | 12e06ed | 2017-01-31 16:11:24 -0800 | [diff] [blame] | 541 | DriverStr(RepeatFF(&x86::X86Assembler::subps, "subps %{reg2}, %{reg1}"), "subps"); |
Aart Bik | c778226 | 2017-01-13 16:20:08 -0800 | [diff] [blame] | 542 | } |
| 543 | |
| 544 | TEST_F(AssemblerX86Test, SubPD) { |
Aart Bik | 12e06ed | 2017-01-31 16:11:24 -0800 | [diff] [blame] | 545 | DriverStr(RepeatFF(&x86::X86Assembler::subpd, "subpd %{reg2}, %{reg1}"), "subpd"); |
Aart Bik | c778226 | 2017-01-13 16:20:08 -0800 | [diff] [blame] | 546 | } |
| 547 | |
| 548 | TEST_F(AssemblerX86Test, MulPS) { |
Aart Bik | 12e06ed | 2017-01-31 16:11:24 -0800 | [diff] [blame] | 549 | DriverStr(RepeatFF(&x86::X86Assembler::mulps, "mulps %{reg2}, %{reg1}"), "mulps"); |
Aart Bik | c778226 | 2017-01-13 16:20:08 -0800 | [diff] [blame] | 550 | } |
| 551 | |
| 552 | TEST_F(AssemblerX86Test, MulPD) { |
Aart Bik | 12e06ed | 2017-01-31 16:11:24 -0800 | [diff] [blame] | 553 | DriverStr(RepeatFF(&x86::X86Assembler::mulpd, "mulpd %{reg2}, %{reg1}"), "mulpd"); |
Aart Bik | c778226 | 2017-01-13 16:20:08 -0800 | [diff] [blame] | 554 | } |
| 555 | |
| 556 | TEST_F(AssemblerX86Test, DivPS) { |
Aart Bik | 12e06ed | 2017-01-31 16:11:24 -0800 | [diff] [blame] | 557 | DriverStr(RepeatFF(&x86::X86Assembler::divps, "divps %{reg2}, %{reg1}"), "divps"); |
Aart Bik | c778226 | 2017-01-13 16:20:08 -0800 | [diff] [blame] | 558 | } |
| 559 | |
| 560 | TEST_F(AssemblerX86Test, DivPD) { |
Aart Bik | 12e06ed | 2017-01-31 16:11:24 -0800 | [diff] [blame] | 561 | DriverStr(RepeatFF(&x86::X86Assembler::divpd, "divpd %{reg2}, %{reg1}"), "divpd"); |
| 562 | } |
| 563 | |
Aart Bik | e69d7a9 | 2017-02-17 11:48:23 -0800 | [diff] [blame] | 564 | TEST_F(AssemblerX86Test, PAddB) { |
| 565 | DriverStr(RepeatFF(&x86::X86Assembler::paddb, "paddb %{reg2}, %{reg1}"), "paddb"); |
| 566 | } |
| 567 | |
| 568 | TEST_F(AssemblerX86Test, PSubB) { |
| 569 | DriverStr(RepeatFF(&x86::X86Assembler::psubb, "psubb %{reg2}, %{reg1}"), "psubb"); |
| 570 | } |
| 571 | |
| 572 | TEST_F(AssemblerX86Test, PAddW) { |
| 573 | DriverStr(RepeatFF(&x86::X86Assembler::paddw, "paddw %{reg2}, %{reg1}"), "paddw"); |
| 574 | } |
| 575 | |
| 576 | TEST_F(AssemblerX86Test, PSubW) { |
| 577 | DriverStr(RepeatFF(&x86::X86Assembler::psubw, "psubw %{reg2}, %{reg1}"), "psubw"); |
| 578 | } |
| 579 | |
| 580 | TEST_F(AssemblerX86Test, PMullW) { |
| 581 | DriverStr(RepeatFF(&x86::X86Assembler::pmullw, "pmullw %{reg2}, %{reg1}"), "pmullw"); |
| 582 | } |
| 583 | |
Aart Bik | 68555e9 | 2017-02-13 14:28:45 -0800 | [diff] [blame] | 584 | TEST_F(AssemblerX86Test, PAddD) { |
| 585 | DriverStr(RepeatFF(&x86::X86Assembler::paddd, "paddd %{reg2}, %{reg1}"), "paddd"); |
| 586 | } |
| 587 | |
| 588 | TEST_F(AssemblerX86Test, PSubD) { |
| 589 | DriverStr(RepeatFF(&x86::X86Assembler::psubd, "psubd %{reg2}, %{reg1}"), "psubd"); |
| 590 | } |
| 591 | |
| 592 | TEST_F(AssemblerX86Test, PMullD) { |
| 593 | DriverStr(RepeatFF(&x86::X86Assembler::pmulld, "pmulld %{reg2}, %{reg1}"), "pmulld"); |
| 594 | } |
| 595 | |
Aart Bik | e69d7a9 | 2017-02-17 11:48:23 -0800 | [diff] [blame] | 596 | TEST_F(AssemblerX86Test, PAddQ) { |
| 597 | DriverStr(RepeatFF(&x86::X86Assembler::paddq, "paddq %{reg2}, %{reg1}"), "paddq"); |
| 598 | } |
| 599 | |
| 600 | TEST_F(AssemblerX86Test, PSubQ) { |
| 601 | DriverStr(RepeatFF(&x86::X86Assembler::psubq, "psubq %{reg2}, %{reg1}"), "psubq"); |
| 602 | } |
| 603 | |
Aart Bik | 4ca1735 | 2018-03-07 15:47:39 -0800 | [diff] [blame] | 604 | TEST_F(AssemblerX86Test, PAddUSB) { |
| 605 | DriverStr(RepeatFF(&x86::X86Assembler::paddusb, "paddusb %{reg2}, %{reg1}"), "paddusb"); |
| 606 | } |
| 607 | |
| 608 | TEST_F(AssemblerX86Test, PAddSB) { |
| 609 | DriverStr(RepeatFF(&x86::X86Assembler::paddsb, "paddsb %{reg2}, %{reg1}"), "paddsb"); |
| 610 | } |
| 611 | |
| 612 | TEST_F(AssemblerX86Test, PAddUSW) { |
| 613 | DriverStr(RepeatFF(&x86::X86Assembler::paddusw, "paddusw %{reg2}, %{reg1}"), "paddusw"); |
| 614 | } |
| 615 | |
| 616 | TEST_F(AssemblerX86Test, PAddSW) { |
| 617 | DriverStr(RepeatFF(&x86::X86Assembler::psubsw, "psubsw %{reg2}, %{reg1}"), "psubsw"); |
| 618 | } |
| 619 | |
| 620 | TEST_F(AssemblerX86Test, PSubUSB) { |
| 621 | DriverStr(RepeatFF(&x86::X86Assembler::psubusb, "psubusb %{reg2}, %{reg1}"), "psubusb"); |
| 622 | } |
| 623 | |
| 624 | TEST_F(AssemblerX86Test, PSubSB) { |
| 625 | DriverStr(RepeatFF(&x86::X86Assembler::psubsb, "psubsb %{reg2}, %{reg1}"), "psubsb"); |
| 626 | } |
| 627 | |
| 628 | TEST_F(AssemblerX86Test, PSubUSW) { |
| 629 | DriverStr(RepeatFF(&x86::X86Assembler::psubusw, "psubusw %{reg2}, %{reg1}"), "psubusw"); |
| 630 | } |
| 631 | |
| 632 | TEST_F(AssemblerX86Test, PSubSW) { |
| 633 | DriverStr(RepeatFF(&x86::X86Assembler::psubsw, "psubsw %{reg2}, %{reg1}"), "psubsw"); |
| 634 | } |
| 635 | |
Aart Bik | 68555e9 | 2017-02-13 14:28:45 -0800 | [diff] [blame] | 636 | TEST_F(AssemblerX86Test, XorPD) { |
| 637 | DriverStr(RepeatFF(&x86::X86Assembler::xorpd, "xorpd %{reg2}, %{reg1}"), "xorpd"); |
| 638 | } |
| 639 | |
| 640 | TEST_F(AssemblerX86Test, XorPS) { |
| 641 | DriverStr(RepeatFF(&x86::X86Assembler::xorps, "xorps %{reg2}, %{reg1}"), "xorps"); |
| 642 | } |
| 643 | |
| 644 | TEST_F(AssemblerX86Test, PXor) { |
| 645 | DriverStr(RepeatFF(&x86::X86Assembler::pxor, "pxor %{reg2}, %{reg1}"), "pxor"); |
| 646 | } |
| 647 | |
| 648 | TEST_F(AssemblerX86Test, AndPD) { |
| 649 | DriverStr(RepeatFF(&x86::X86Assembler::andpd, "andpd %{reg2}, %{reg1}"), "andpd"); |
| 650 | } |
| 651 | |
| 652 | TEST_F(AssemblerX86Test, AndPS) { |
| 653 | DriverStr(RepeatFF(&x86::X86Assembler::andps, "andps %{reg2}, %{reg1}"), "andps"); |
| 654 | } |
| 655 | |
| 656 | TEST_F(AssemblerX86Test, PAnd) { |
| 657 | DriverStr(RepeatFF(&x86::X86Assembler::pand, "pand %{reg2}, %{reg1}"), "pand"); |
| 658 | } |
| 659 | |
Aart Bik | 21c580b | 2017-03-13 11:52:07 -0700 | [diff] [blame] | 660 | TEST_F(AssemblerX86Test, AndnPD) { |
| 661 | DriverStr(RepeatFF(&x86::X86Assembler::andnpd, "andnpd %{reg2}, %{reg1}"), "andnpd"); |
| 662 | } |
| 663 | |
| 664 | TEST_F(AssemblerX86Test, AndnPS) { |
| 665 | DriverStr(RepeatFF(&x86::X86Assembler::andnps, "andnps %{reg2}, %{reg1}"), "andnps"); |
| 666 | } |
| 667 | |
| 668 | TEST_F(AssemblerX86Test, PAndn) { |
| 669 | DriverStr(RepeatFF(&x86::X86Assembler::pandn, "pandn %{reg2}, %{reg1}"), "pandn"); |
| 670 | } |
| 671 | |
Aart Bik | 68555e9 | 2017-02-13 14:28:45 -0800 | [diff] [blame] | 672 | TEST_F(AssemblerX86Test, OrPD) { |
| 673 | DriverStr(RepeatFF(&x86::X86Assembler::orpd, "orpd %{reg2}, %{reg1}"), "orpd"); |
| 674 | } |
| 675 | |
| 676 | TEST_F(AssemblerX86Test, OrPS) { |
| 677 | DriverStr(RepeatFF(&x86::X86Assembler::orps, "orps %{reg2}, %{reg1}"), "orps"); |
| 678 | } |
| 679 | |
| 680 | TEST_F(AssemblerX86Test, POr) { |
| 681 | DriverStr(RepeatFF(&x86::X86Assembler::por, "por %{reg2}, %{reg1}"), "por"); |
| 682 | } |
| 683 | |
Aart Bik | 67d3fd7 | 2017-03-31 15:11:53 -0700 | [diff] [blame] | 684 | TEST_F(AssemblerX86Test, PAvgB) { |
| 685 | DriverStr(RepeatFF(&x86::X86Assembler::pavgb, "pavgb %{reg2}, %{reg1}"), "pavgb"); |
| 686 | } |
| 687 | |
| 688 | TEST_F(AssemblerX86Test, PAvgW) { |
| 689 | DriverStr(RepeatFF(&x86::X86Assembler::pavgw, "pavgw %{reg2}, %{reg1}"), "pavgw"); |
| 690 | } |
| 691 | |
Aart Bik | 6005a87 | 2017-07-24 13:33:39 -0700 | [diff] [blame] | 692 | TEST_F(AssemblerX86Test, PSadBW) { |
| 693 | DriverStr(RepeatFF(&x86::X86Assembler::psadbw, "psadbw %{reg2}, %{reg1}"), "psadbw"); |
| 694 | } |
| 695 | |
| 696 | TEST_F(AssemblerX86Test, PMAddWD) { |
| 697 | DriverStr(RepeatFF(&x86::X86Assembler::pmaddwd, "pmaddwd %{reg2}, %{reg1}"), "pmaddwd"); |
| 698 | } |
| 699 | |
| 700 | TEST_F(AssemblerX86Test, PHAddW) { |
| 701 | DriverStr(RepeatFF(&x86::X86Assembler::phaddw, "phaddw %{reg2}, %{reg1}"), "phaddw"); |
| 702 | } |
| 703 | |
| 704 | TEST_F(AssemblerX86Test, PHAddD) { |
| 705 | DriverStr(RepeatFF(&x86::X86Assembler::phaddd, "phaddd %{reg2}, %{reg1}"), "phaddd"); |
| 706 | } |
| 707 | |
| 708 | TEST_F(AssemblerX86Test, HAddPS) { |
| 709 | DriverStr(RepeatFF(&x86::X86Assembler::haddps, "haddps %{reg2}, %{reg1}"), "haddps"); |
| 710 | } |
| 711 | |
| 712 | TEST_F(AssemblerX86Test, HAddPD) { |
| 713 | DriverStr(RepeatFF(&x86::X86Assembler::haddpd, "haddpd %{reg2}, %{reg1}"), "haddpd"); |
| 714 | } |
| 715 | |
| 716 | TEST_F(AssemblerX86Test, PHSubW) { |
| 717 | DriverStr(RepeatFF(&x86::X86Assembler::phsubw, "phsubw %{reg2}, %{reg1}"), "phsubw"); |
| 718 | } |
| 719 | |
| 720 | TEST_F(AssemblerX86Test, PHSubD) { |
| 721 | DriverStr(RepeatFF(&x86::X86Assembler::phsubd, "phsubd %{reg2}, %{reg1}"), "phsubd"); |
| 722 | } |
| 723 | |
| 724 | TEST_F(AssemblerX86Test, HSubPS) { |
| 725 | DriverStr(RepeatFF(&x86::X86Assembler::hsubps, "hsubps %{reg2}, %{reg1}"), "hsubps"); |
| 726 | } |
| 727 | |
| 728 | TEST_F(AssemblerX86Test, HSubPD) { |
| 729 | DriverStr(RepeatFF(&x86::X86Assembler::hsubpd, "hsubpd %{reg2}, %{reg1}"), "hsubpd"); |
| 730 | } |
| 731 | |
Aart Bik | c8e93c7 | 2017-05-10 10:49:22 -0700 | [diff] [blame] | 732 | TEST_F(AssemblerX86Test, PMinSB) { |
| 733 | DriverStr(RepeatFF(&x86::X86Assembler::pminsb, "pminsb %{reg2}, %{reg1}"), "pminsb"); |
| 734 | } |
| 735 | |
| 736 | TEST_F(AssemblerX86Test, PMaxSB) { |
| 737 | DriverStr(RepeatFF(&x86::X86Assembler::pmaxsb, "pmaxsb %{reg2}, %{reg1}"), "pmaxsb"); |
| 738 | } |
| 739 | |
| 740 | TEST_F(AssemblerX86Test, PMinSW) { |
| 741 | DriverStr(RepeatFF(&x86::X86Assembler::pminsw, "pminsw %{reg2}, %{reg1}"), "pminsw"); |
| 742 | } |
| 743 | |
| 744 | TEST_F(AssemblerX86Test, PMaxSW) { |
| 745 | DriverStr(RepeatFF(&x86::X86Assembler::pmaxsw, "pmaxsw %{reg2}, %{reg1}"), "pmaxsw"); |
| 746 | } |
| 747 | |
| 748 | TEST_F(AssemblerX86Test, PMinSD) { |
| 749 | DriverStr(RepeatFF(&x86::X86Assembler::pminsd, "pminsd %{reg2}, %{reg1}"), "pminsd"); |
| 750 | } |
| 751 | |
| 752 | TEST_F(AssemblerX86Test, PMaxSD) { |
| 753 | DriverStr(RepeatFF(&x86::X86Assembler::pmaxsd, "pmaxsd %{reg2}, %{reg1}"), "pmaxsd"); |
| 754 | } |
| 755 | |
| 756 | TEST_F(AssemblerX86Test, PMinUB) { |
| 757 | DriverStr(RepeatFF(&x86::X86Assembler::pminub, "pminub %{reg2}, %{reg1}"), "pminub"); |
| 758 | } |
| 759 | |
| 760 | TEST_F(AssemblerX86Test, PMaxUB) { |
| 761 | DriverStr(RepeatFF(&x86::X86Assembler::pmaxub, "pmaxub %{reg2}, %{reg1}"), "pmaxub"); |
| 762 | } |
| 763 | |
| 764 | TEST_F(AssemblerX86Test, PMinUW) { |
| 765 | DriverStr(RepeatFF(&x86::X86Assembler::pminuw, "pminuw %{reg2}, %{reg1}"), "pminuw"); |
| 766 | } |
| 767 | |
| 768 | TEST_F(AssemblerX86Test, PMaxUW) { |
| 769 | DriverStr(RepeatFF(&x86::X86Assembler::pmaxuw, "pmaxuw %{reg2}, %{reg1}"), "pmaxuw"); |
| 770 | } |
| 771 | |
| 772 | TEST_F(AssemblerX86Test, PMinUD) { |
| 773 | DriverStr(RepeatFF(&x86::X86Assembler::pminud, "pminud %{reg2}, %{reg1}"), "pminud"); |
| 774 | } |
| 775 | |
| 776 | TEST_F(AssemblerX86Test, PMaxUD) { |
| 777 | DriverStr(RepeatFF(&x86::X86Assembler::pmaxud, "pmaxud %{reg2}, %{reg1}"), "pmaxud"); |
| 778 | } |
| 779 | |
| 780 | TEST_F(AssemblerX86Test, MinPS) { |
| 781 | DriverStr(RepeatFF(&x86::X86Assembler::minps, "minps %{reg2}, %{reg1}"), "minps"); |
| 782 | } |
| 783 | |
| 784 | TEST_F(AssemblerX86Test, MaxPS) { |
| 785 | DriverStr(RepeatFF(&x86::X86Assembler::maxps, "maxps %{reg2}, %{reg1}"), "maxps"); |
| 786 | } |
| 787 | |
| 788 | TEST_F(AssemblerX86Test, MinPD) { |
| 789 | DriverStr(RepeatFF(&x86::X86Assembler::minpd, "minpd %{reg2}, %{reg1}"), "minpd"); |
| 790 | } |
| 791 | |
| 792 | TEST_F(AssemblerX86Test, MaxPD) { |
| 793 | DriverStr(RepeatFF(&x86::X86Assembler::maxpd, "maxpd %{reg2}, %{reg1}"), "maxpd"); |
| 794 | } |
| 795 | |
Aart Bik | 4b45533 | 2017-03-15 11:19:35 -0700 | [diff] [blame] | 796 | TEST_F(AssemblerX86Test, PCmpeqB) { |
| 797 | DriverStr(RepeatFF(&x86::X86Assembler::pcmpeqb, "pcmpeqb %{reg2}, %{reg1}"), "cmpeqb"); |
| 798 | } |
| 799 | |
| 800 | TEST_F(AssemblerX86Test, PCmpeqW) { |
| 801 | DriverStr(RepeatFF(&x86::X86Assembler::pcmpeqw, "pcmpeqw %{reg2}, %{reg1}"), "cmpeqw"); |
| 802 | } |
| 803 | |
| 804 | TEST_F(AssemblerX86Test, PCmpeqD) { |
| 805 | DriverStr(RepeatFF(&x86::X86Assembler::pcmpeqd, "pcmpeqd %{reg2}, %{reg1}"), "cmpeqd"); |
| 806 | } |
| 807 | |
| 808 | TEST_F(AssemblerX86Test, PCmpeqQ) { |
| 809 | DriverStr(RepeatFF(&x86::X86Assembler::pcmpeqq, "pcmpeqq %{reg2}, %{reg1}"), "cmpeqq"); |
| 810 | } |
| 811 | |
Aart Bik | 8939c64 | 2017-04-03 14:09:01 -0700 | [diff] [blame] | 812 | TEST_F(AssemblerX86Test, PCmpgtB) { |
| 813 | DriverStr(RepeatFF(&x86::X86Assembler::pcmpgtb, "pcmpgtb %{reg2}, %{reg1}"), "cmpgtb"); |
| 814 | } |
| 815 | |
| 816 | TEST_F(AssemblerX86Test, PCmpgtW) { |
| 817 | DriverStr(RepeatFF(&x86::X86Assembler::pcmpgtw, "pcmpgtw %{reg2}, %{reg1}"), "cmpgtw"); |
| 818 | } |
| 819 | |
| 820 | TEST_F(AssemblerX86Test, PCmpgtD) { |
| 821 | DriverStr(RepeatFF(&x86::X86Assembler::pcmpgtd, "pcmpgtd %{reg2}, %{reg1}"), "cmpgtd"); |
| 822 | } |
| 823 | |
| 824 | TEST_F(AssemblerX86Test, PCmpgtQ) { |
| 825 | DriverStr(RepeatFF(&x86::X86Assembler::pcmpgtq, "pcmpgtq %{reg2}, %{reg1}"), "cmpgtq"); |
| 826 | } |
| 827 | |
Aart Bik | 12e06ed | 2017-01-31 16:11:24 -0800 | [diff] [blame] | 828 | TEST_F(AssemblerX86Test, ShufPS) { |
| 829 | DriverStr(RepeatFFI(&x86::X86Assembler::shufps, 1, "shufps ${imm}, %{reg2}, %{reg1}"), "shufps"); |
| 830 | } |
| 831 | |
| 832 | TEST_F(AssemblerX86Test, ShufPD) { |
| 833 | DriverStr(RepeatFFI(&x86::X86Assembler::shufpd, 1, "shufpd ${imm}, %{reg2}, %{reg1}"), "shufpd"); |
Aart Bik | c778226 | 2017-01-13 16:20:08 -0800 | [diff] [blame] | 834 | } |
| 835 | |
Aart Bik | 68555e9 | 2017-02-13 14:28:45 -0800 | [diff] [blame] | 836 | TEST_F(AssemblerX86Test, PShufD) { |
| 837 | DriverStr(RepeatFFI(&x86::X86Assembler::pshufd, 1, "pshufd ${imm}, %{reg2}, %{reg1}"), "pshufd"); |
| 838 | } |
| 839 | |
Aart Bik | e69d7a9 | 2017-02-17 11:48:23 -0800 | [diff] [blame] | 840 | TEST_F(AssemblerX86Test, Punpcklbw) { |
| 841 | DriverStr(RepeatFF(&x86::X86Assembler::punpcklbw, "punpcklbw %{reg2}, %{reg1}"), "punpcklbw"); |
| 842 | } |
| 843 | |
| 844 | TEST_F(AssemblerX86Test, Punpcklwd) { |
| 845 | DriverStr(RepeatFF(&x86::X86Assembler::punpcklwd, "punpcklwd %{reg2}, %{reg1}"), "punpcklwd"); |
| 846 | } |
| 847 | |
| 848 | TEST_F(AssemblerX86Test, Punpckldq) { |
| 849 | DriverStr(RepeatFF(&x86::X86Assembler::punpckldq, "punpckldq %{reg2}, %{reg1}"), "punpckldq"); |
| 850 | } |
| 851 | |
| 852 | TEST_F(AssemblerX86Test, Punpcklqdq) { |
| 853 | DriverStr(RepeatFF(&x86::X86Assembler::punpcklqdq, "punpcklqdq %{reg2}, %{reg1}"), "punpcklqdq"); |
| 854 | } |
| 855 | |
Aart Bik | 3332db8 | 2017-08-11 15:10:30 -0700 | [diff] [blame] | 856 | TEST_F(AssemblerX86Test, Punpckhbw) { |
| 857 | DriverStr(RepeatFF(&x86::X86Assembler::punpckhbw, "punpckhbw %{reg2}, %{reg1}"), "punpckhbw"); |
| 858 | } |
| 859 | |
| 860 | TEST_F(AssemblerX86Test, Punpckhwd) { |
| 861 | DriverStr(RepeatFF(&x86::X86Assembler::punpckhwd, "punpckhwd %{reg2}, %{reg1}"), "punpckhwd"); |
| 862 | } |
| 863 | |
| 864 | TEST_F(AssemblerX86Test, Punpckhdq) { |
| 865 | DriverStr(RepeatFF(&x86::X86Assembler::punpckhdq, "punpckhdq %{reg2}, %{reg1}"), "punpckhdq"); |
| 866 | } |
| 867 | |
| 868 | TEST_F(AssemblerX86Test, Punpckhqdq) { |
| 869 | DriverStr(RepeatFF(&x86::X86Assembler::punpckhqdq, "punpckhqdq %{reg2}, %{reg1}"), "punpckhqdq"); |
| 870 | } |
| 871 | |
Aart Bik | e69d7a9 | 2017-02-17 11:48:23 -0800 | [diff] [blame] | 872 | TEST_F(AssemblerX86Test, psllw) { |
| 873 | GetAssembler()->psllw(x86::XMM0, CreateImmediate(16)); |
| 874 | DriverStr("psllw $0x10, %xmm0\n", "psllwi"); |
| 875 | } |
| 876 | |
| 877 | TEST_F(AssemblerX86Test, pslld) { |
| 878 | GetAssembler()->pslld(x86::XMM0, CreateImmediate(16)); |
| 879 | DriverStr("pslld $0x10, %xmm0\n", "pslldi"); |
| 880 | } |
| 881 | |
| 882 | TEST_F(AssemblerX86Test, psllq) { |
| 883 | GetAssembler()->psllq(x86::XMM0, CreateImmediate(16)); |
| 884 | DriverStr("psllq $0x10, %xmm0\n", "psllqi"); |
| 885 | } |
| 886 | |
| 887 | TEST_F(AssemblerX86Test, psraw) { |
| 888 | GetAssembler()->psraw(x86::XMM0, CreateImmediate(16)); |
| 889 | DriverStr("psraw $0x10, %xmm0\n", "psrawi"); |
| 890 | } |
| 891 | |
| 892 | TEST_F(AssemblerX86Test, psrad) { |
| 893 | GetAssembler()->psrad(x86::XMM0, CreateImmediate(16)); |
| 894 | DriverStr("psrad $0x10, %xmm0\n", "psradi"); |
| 895 | } |
| 896 | |
| 897 | TEST_F(AssemblerX86Test, psrlw) { |
| 898 | GetAssembler()->psrlw(x86::XMM0, CreateImmediate(16)); |
| 899 | DriverStr("psrlw $0x10, %xmm0\n", "psrlwi"); |
| 900 | } |
| 901 | |
| 902 | TEST_F(AssemblerX86Test, psrld) { |
| 903 | GetAssembler()->psrld(x86::XMM0, CreateImmediate(16)); |
| 904 | DriverStr("psrld $0x10, %xmm0\n", "psrldi"); |
| 905 | } |
| 906 | |
| 907 | TEST_F(AssemblerX86Test, psrlq) { |
| 908 | GetAssembler()->psrlq(x86::XMM0, CreateImmediate(16)); |
| 909 | DriverStr("psrlq $0x10, %xmm0\n", "psrlqi"); |
| 910 | } |
| 911 | |
| 912 | TEST_F(AssemblerX86Test, psrldq) { |
| 913 | GetAssembler()->psrldq(x86::XMM0, CreateImmediate(16)); |
| 914 | DriverStr("psrldq $0x10, %xmm0\n", "psrldqi"); |
| 915 | } |
| 916 | |
Mark Mendell | 73f455e | 2015-08-21 09:30:05 -0400 | [diff] [blame] | 917 | TEST_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 Mendell | 73f455e | 2015-08-21 09:30:05 -0400 | [diff] [blame] | 926 | DriverStr(expected, "jecxz"); |
| 927 | } |
| 928 | |
| 929 | TEST_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 Mendell | 73f455e | 2015-08-21 09:30:05 -0400 | [diff] [blame] | 947 | DriverStr(expected, "near_label"); |
| 948 | } |
| 949 | |
Serguei Katkov | 3b62593 | 2016-05-06 10:24:17 +0600 | [diff] [blame] | 950 | TEST_F(AssemblerX86Test, Cmpb) { |
Aart Bik | f7754e8 | 2017-09-20 10:33:06 -0700 | [diff] [blame] | 951 | DriverStr(RepeatAI(&x86::X86Assembler::cmpb, |
| 952 | /*imm_bytes*/ 1U, |
| 953 | "cmpb ${imm}, {mem}"), "cmpb"); |
| 954 | } |
| 955 | |
| 956 | TEST_F(AssemblerX86Test, Cmpw) { |
Vladimir Marko | 29a8d84 | 2018-02-13 13:46:15 +0000 | [diff] [blame] | 957 | DriverStr(RepeatAI(&x86::X86Assembler::cmpw, /*imm_bytes*/ 2U, "cmpw ${imm}, {mem}"), "cmpw"); |
Serguei Katkov | 3b62593 | 2016-05-06 10:24:17 +0600 | [diff] [blame] | 958 | } |
| 959 | |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 960 | } // namespace art |