1 /*
2 * Copyright (C) 2023 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "assembler_riscv64.h"
18
19 #include <inttypes.h>
20
21 #include <map>
22
23 #include "base/bit_utils.h"
24 #include "utils/assembler_test.h"
25
26 #define __ GetAssembler()->
27
28 namespace art HIDDEN {
29 namespace riscv64 {
30
31 struct RISCV64CpuRegisterCompare {
operator ()art::riscv64::RISCV64CpuRegisterCompare32 bool operator()(const XRegister& a, const XRegister& b) const { return a < b; }
33 };
34
35 class AssemblerRISCV64Test : public AssemblerTest<Riscv64Assembler,
36 Riscv64Label,
37 XRegister,
38 FRegister,
39 int32_t,
40 VRegister> {
41 public:
42 using Base =
43 AssemblerTest<Riscv64Assembler, Riscv64Label, XRegister, FRegister, int32_t, VRegister>;
44
AssemblerRISCV64Test()45 AssemblerRISCV64Test() {}
46
47 protected:
CreateAssembler(ArenaAllocator * allocator)48 Riscv64Assembler* CreateAssembler(ArenaAllocator* allocator) override {
49 return new (allocator) Riscv64Assembler(allocator, kRiscv64AllExtensionsMask);
50 }
51
GetIsa()52 InstructionSet GetIsa() override { return InstructionSet::kRiscv64; }
53
54 class ScopedMarchOverride {
55 public:
ScopedMarchOverride(AssemblerRISCV64Test * test,const std::string & march)56 ScopedMarchOverride(AssemblerRISCV64Test* test, const std::string& march)
57 : test_(test), old_override_(test->march_override_) {
58 test->march_override_ = march;
59 }
60
~ScopedMarchOverride()61 ~ScopedMarchOverride() {
62 test_->march_override_ = old_override_;
63 }
64
65 private:
66 AssemblerRISCV64Test* const test_;
67 std::optional<std::string> const old_override_;
68 };
69
70 class ScopedCSuppression {
71 public:
ScopedCSuppression(AssemblerRISCV64Test * test)72 explicit ScopedCSuppression(AssemblerRISCV64Test* test)
73 : smo_(test, "-march=rv64imafdv_zba_zbb"),
74 exclusion_(test->GetAssembler()) {}
75
76 private:
77 ScopedMarchOverride smo_;
78 ScopedExtensionsExclusion<kRiscv64CompressedExtensionsMask> exclusion_;
79 };
80
81 class ScopedZbaAndCSuppression {
82 public:
ScopedZbaAndCSuppression(AssemblerRISCV64Test * test)83 explicit ScopedZbaAndCSuppression(AssemblerRISCV64Test* test)
84 : smo_(test, "-march=rv64imafdv_zbb"),
85 exclusion_(test->GetAssembler()) {}
86
87 private:
88 static constexpr Riscv64ExtensionMask kExcludedExtensions =
89 Riscv64ExtensionBit(Riscv64Extension::kZba) | kRiscv64CompressedExtensionsMask;
90
91 ScopedMarchOverride smo_;
92 ScopedExtensionsExclusion<kExcludedExtensions> exclusion_;
93 };
94
95 class ScopedZbbSuppression {
96 public:
ScopedZbbSuppression(AssemblerRISCV64Test * test)97 explicit ScopedZbbSuppression(AssemblerRISCV64Test* test)
98 : smo_(test, "-march=rv64imafdcv_zba"), exclusion_(test->GetAssembler()) {}
99
100 private:
101 static constexpr Riscv64ExtensionMask kExcludedExtensions =
102 Riscv64ExtensionBit(Riscv64Extension::kZbb);
103
104 ScopedMarchOverride smo_;
105 ScopedExtensionsExclusion<kExcludedExtensions> exclusion_;
106 };
107
108 class ScopedZbaSuppression {
109 public:
ScopedZbaSuppression(AssemblerRISCV64Test * test)110 explicit ScopedZbaSuppression(AssemblerRISCV64Test* test)
111 : smo_(test, "-march=rv64imafdcv_zbb"), exclusion_(test->GetAssembler()) {}
112
113 private:
114 static constexpr Riscv64ExtensionMask kExcludedExtensions =
115 Riscv64ExtensionBit(Riscv64Extension::kZba);
116
117 ScopedMarchOverride smo_;
118 ScopedExtensionsExclusion<kExcludedExtensions> exclusion_;
119 };
120
121 class ScopedZbbAndCSuppression {
122 public:
ScopedZbbAndCSuppression(AssemblerRISCV64Test * test)123 explicit ScopedZbbAndCSuppression(AssemblerRISCV64Test* test)
124 : smo_(test, "-march=rv64imafdv_zba"),
125 exclusion_(test->GetAssembler()) {}
126
127 private:
128 static constexpr Riscv64ExtensionMask kExcludedExtensions =
129 Riscv64ExtensionBit(Riscv64Extension::kZbb) | kRiscv64CompressedExtensionsMask;
130
131 ScopedMarchOverride smo_;
132 ScopedExtensionsExclusion<kExcludedExtensions> exclusion_;
133 };
134
135 class ScopedZbaZbbAndCSuppression {
136 public:
ScopedZbaZbbAndCSuppression(AssemblerRISCV64Test * test)137 explicit ScopedZbaZbbAndCSuppression(AssemblerRISCV64Test* test)
138 : smo_(test, "-march=rv64imafdv"), exclusion_(test->GetAssembler()) {}
139
140 private:
141 static constexpr Riscv64ExtensionMask kExcludedExtensions =
142 Riscv64ExtensionBit(Riscv64Extension::kZbb) |
143 Riscv64ExtensionBit(Riscv64Extension::kZba) |
144 kRiscv64CompressedExtensionsMask;
145
146 ScopedMarchOverride smo_;
147 ScopedExtensionsExclusion<kExcludedExtensions> exclusion_;
148 };
149
GetAssemblerCommand()150 std::vector<std::string> GetAssemblerCommand() override {
151 std::vector<std::string> result = Base::GetAssemblerCommand();
152 if (march_override_.has_value()) {
153 auto it = std::find_if(result.begin(),
154 result.end(),
155 [](const std::string& s) { return s.starts_with("-march="); });
156 CHECK(it != result.end());
157 *it = march_override_.value();
158 }
159 return result;
160 }
161
SetUpHelpers()162 void SetUpHelpers() override {
163 if (secondary_register_names_.empty()) {
164 secondary_register_names_.emplace(Zero, "zero");
165 secondary_register_names_.emplace(RA, "ra");
166 secondary_register_names_.emplace(SP, "sp");
167 secondary_register_names_.emplace(GP, "gp");
168 secondary_register_names_.emplace(TP, "tp");
169 secondary_register_names_.emplace(T0, "t0");
170 secondary_register_names_.emplace(T1, "t1");
171 secondary_register_names_.emplace(T2, "t2");
172 secondary_register_names_.emplace(S0, "s0"); // s0/fp
173 secondary_register_names_.emplace(S1, "s1");
174 secondary_register_names_.emplace(A0, "a0");
175 secondary_register_names_.emplace(A1, "a1");
176 secondary_register_names_.emplace(A2, "a2");
177 secondary_register_names_.emplace(A3, "a3");
178 secondary_register_names_.emplace(A4, "a4");
179 secondary_register_names_.emplace(A5, "a5");
180 secondary_register_names_.emplace(A6, "a6");
181 secondary_register_names_.emplace(A7, "a7");
182 secondary_register_names_.emplace(S2, "s2");
183 secondary_register_names_.emplace(S3, "s3");
184 secondary_register_names_.emplace(S4, "s4");
185 secondary_register_names_.emplace(S5, "s5");
186 secondary_register_names_.emplace(S6, "s6");
187 secondary_register_names_.emplace(S7, "s7");
188 secondary_register_names_.emplace(S8, "s8");
189 secondary_register_names_.emplace(S9, "s9");
190 secondary_register_names_.emplace(S10, "s10");
191 secondary_register_names_.emplace(S11, "s11");
192 secondary_register_names_.emplace(T3, "t3");
193 secondary_register_names_.emplace(T4, "t4");
194 secondary_register_names_.emplace(T5, "t5");
195 secondary_register_names_.emplace(T6, "t6");
196 }
197 }
198
TearDown()199 void TearDown() override {
200 AssemblerTest::TearDown();
201 }
202
GetAddresses()203 std::vector<Riscv64Label> GetAddresses() override {
204 UNIMPLEMENTED(FATAL) << "Feature not implemented yet";
205 UNREACHABLE();
206 }
207
GetRegisters()208 ArrayRef<const XRegister> GetRegisters() override {
209 static constexpr XRegister kXRegisters[] = {
210 Zero,
211 RA,
212 SP,
213 GP,
214 TP,
215 T0,
216 T1,
217 T2,
218 S0,
219 S1,
220 A0,
221 A1,
222 A2,
223 A3,
224 A4,
225 A5,
226 A6,
227 A7,
228 S2,
229 S3,
230 S4,
231 S5,
232 S6,
233 S7,
234 S8,
235 S9,
236 S10,
237 S11,
238 T3,
239 T4,
240 T5,
241 T6,
242 };
243 return ArrayRef<const XRegister>(kXRegisters);
244 }
245
GetRegistersShort()246 ArrayRef<const XRegister> GetRegistersShort() {
247 static constexpr XRegister kXRegistersShort[] = {
248 S0,
249 S1,
250 A0,
251 A1,
252 A2,
253 A3,
254 A4,
255 A5,
256 };
257 return ArrayRef<const XRegister>(kXRegistersShort);
258 }
259
GetFPRegisters()260 ArrayRef<const FRegister> GetFPRegisters() override {
261 static constexpr FRegister kFRegisters[] = {
262 FT0,
263 FT1,
264 FT2,
265 FT3,
266 FT4,
267 FT5,
268 FT6,
269 FT7,
270 FS0,
271 FS1,
272 FA0,
273 FA1,
274 FA2,
275 FA3,
276 FA4,
277 FA5,
278 FA6,
279 FA7,
280 FS2,
281 FS3,
282 FS4,
283 FS5,
284 FS6,
285 FS7,
286 FS8,
287 FS9,
288 FS10,
289 FS11,
290 FT8,
291 FT9,
292 FT10,
293 FT11,
294 };
295 return ArrayRef<const FRegister>(kFRegisters);
296 }
297
GetVectorRegisters()298 ArrayRef<const VRegister> GetVectorRegisters() override {
299 static constexpr VRegister kVRegisters[] = {
300 V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15,
301 V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30, V31
302 };
303 return ArrayRef<const VRegister>(kVRegisters);
304 }
305
GetFPRegistersShort()306 ArrayRef<const FRegister> GetFPRegistersShort() {
307 static constexpr FRegister kFRegistersShort[] = {
308 FS0,
309 FS1,
310 FA0,
311 FA1,
312 FA2,
313 FA3,
314 FA4,
315 FA5,
316 };
317 return ArrayRef<const FRegister>(kFRegistersShort);
318 }
319
GetSecondaryRegisterName(const XRegister & reg)320 std::string GetSecondaryRegisterName(const XRegister& reg) override {
321 CHECK(secondary_register_names_.find(reg) != secondary_register_names_.end());
322 return secondary_register_names_[reg];
323 }
324
CreateImmediate(int64_t imm_value)325 int32_t CreateImmediate(int64_t imm_value) override {
326 return dchecked_integral_cast<int32_t>(imm_value);
327 }
328
329 template <typename Emit>
RepeatInsn(size_t count,const std::string & insn,Emit && emit)330 std::string RepeatInsn(size_t count, const std::string& insn, Emit&& emit) {
331 std::string result;
332 for (; count != 0u; --count) {
333 result += insn;
334 emit();
335 }
336 return result;
337 }
338
EmitNops(size_t size)339 std::string EmitNops(size_t size) {
340 const size_t nop_size = GetAssembler()->IsExtensionEnabled(Riscv64Extension::kZca) ?
341 sizeof(uint16_t) :
342 sizeof(uint32_t);
343 DCHECK(IsAlignedParam(size, nop_size));
344 const size_t num_nops = size / nop_size;
345 return RepeatInsn(num_nops, "nop\n", [&]() { __ Nop(); });
346 }
347
348 template <typename EmitLoadConst>
TestLoadConst64(const std::string & test_name,bool can_use_tmp,EmitLoadConst && emit_load_const)349 void TestLoadConst64(const std::string& test_name,
350 bool can_use_tmp,
351 EmitLoadConst&& emit_load_const) {
352 std::string expected;
353 // Test standard immediates. Unlike other instructions, `Li()` accepts an `int64_t` but
354 // this is unsupported by `CreateImmediate()`, so we cannot use `RepeatRIb()` for these.
355 // Note: This `CreateImmediateValuesBits()` call does not produce any values where
356 // `LoadConst64()` would emit different code from `Li()`.
357 for (int64_t value : CreateImmediateValuesBits(64, /*as_uint=*/ false)) {
358 emit_load_const(A0, value);
359 expected += "li a0, " + std::to_string(value) + "\n";
360 }
361 // Test various registers with a few small values.
362 // (Even Zero is an accepted register even if that does not really load the requested value.)
363 for (XRegister reg : GetRegisters()) {
364 ScratchRegisterScope srs(GetAssembler());
365 srs.ExcludeXRegister(reg);
366 std::string rd = GetRegisterName(reg);
367 emit_load_const(reg, -1);
368 expected += "li " + rd + ", -1\n";
369 emit_load_const(reg, 0);
370 expected += "li " + rd + ", 0\n";
371 emit_load_const(reg, 1);
372 expected += "li " + rd + ", 1\n";
373 }
374 // Test some significant values. Some may just repeat the tests above but other values
375 // show some complex patterns, even exposing a value where clang (and therefore also this
376 // assembler) does not generate the shortest sequence.
377 // For the following values, `LoadConst64()` emits the same code as `Li()`.
378 int64_t test_values1[] = {
379 // Small values, either ADDI, ADDI+SLLI, LUI, or LUI+ADDIW.
380 // The ADDI+LUI is presumably used to allow shorter code for RV64C.
381 -4097, -4096, -4095, -2176, -2049, -2048, -2047, -1025, -1024, -1023, -2, -1,
382 0, 1, 2, 1023, 1024, 1025, 2047, 2048, 2049, 2176, 4095, 4096, 4097,
383 // Just below std::numeric_limits<int32_t>::min()
384 INT64_C(-0x80000001), // LUI+ADDI
385 INT64_C(-0x80000800), // LUI+ADDI
386 INT64_C(-0x80000801), // LUI+ADDIW+SLLI+ADDI; LUI+ADDI+ADDI would be shorter.
387 INT64_C(-0x80000800123), // LUI+ADDIW+SLLI+ADDI
388 INT64_C(0x0123450000000123), // LUI+SLLI+ADDI
389 INT64_C(-0x7654300000000123), // LUI+SLLI+ADDI
390 INT64_C(0x0fffffffffff0000), // LUI+SRLI
391 INT64_C(0x0ffffffffffff000), // LUI+SRLI
392 INT64_C(0x0ffffffffffff010), // LUI+ADDIW+SRLI
393 INT64_C(0x0fffffffffffff10), // ADDI+SLLI+ADDI; LUI+ADDIW+SRLI would be same length.
394 INT64_C(0x0fffffffffffff80), // ADDI+SRLI
395 INT64_C(0x0ffffffff7ffff80), // LUI+ADDI+SRLI
396 INT64_C(0x0123450000001235), // LUI+SLLI+ADDI+SLLI+ADDI
397 INT64_C(0x0123450000001234), // LUI+SLLI+ADDI+SLLI
398 INT64_C(0x0000000fff808010), // LUI+SLLI+SRLI
399 INT64_C(0x00000000fff80801), // LUI+SLLI+SRLI
400 INT64_C(0x00000000ffffffff), // ADDI+SRLI
401 INT64_C(0x00000001ffffffff), // ADDI+SRLI
402 INT64_C(0x00000003ffffffff), // ADDI+SRLI
403 INT64_C(0x00000000ffc00801), // LUI+ADDIW+SLLI+ADDI
404 INT64_C(0x00000001fffff7fe), // ADDI+SLLI+SRLI
405 };
406 for (int64_t value : test_values1) {
407 emit_load_const(A0, value);
408 expected += "li a0, " + std::to_string(value) + "\n";
409 }
410 // For the following values, `LoadConst64()` emits different code than `Li()`.
411 std::pair<int64_t, const char*> test_values2[] = {
412 // Li: LUI+ADDIW+SLLI+ADDI+SLLI+ADDI+SLLI+ADDI
413 // LoadConst: LUI+ADDIW+LUI+ADDIW+SLLI+ADD (using TMP)
414 { INT64_C(0x1234567812345678),
415 "li {reg1}, 0x12345678 / 8\n" // Trailing zero bits in high word are handled by SLLI.
416 "li {reg2}, 0x12345678\n"
417 "slli {reg1}, {reg1}, 32 + 3\n"
418 "add {reg1}, {reg1}, {reg2}\n" },
419 { INT64_C(0x1234567887654321),
420 "li {reg1}, 0x12345678 + 1\n" // One higher to compensate for negative TMP.
421 "li {reg2}, 0x87654321 - 0x100000000\n"
422 "slli {reg1}, {reg1}, 32\n"
423 "add {reg1}, {reg1}, {reg2}\n" },
424 { INT64_C(-0x1234567887654321),
425 "li {reg1}, -0x12345678 - 1\n" // High 32 bits of the constant.
426 "li {reg2}, 0x100000000 - 0x87654321\n" // Low 32 bits of the constant.
427 "slli {reg1}, {reg1}, 32\n"
428 "add {reg1}, {reg1}, {reg2}\n" },
429
430 // Li: LUI+SLLI+ADDI+SLLI+ADDI+SLLI
431 // LoadConst: LUI+LUI+SLLI+ADD (using TMP)
432 { INT64_C(0x1234500012345000),
433 "lui {reg1}, 0x12345\n"
434 "lui {reg2}, 0x12345\n"
435 "slli {reg1}, {reg1}, 44 - 12\n"
436 "add {reg1}, {reg1}, {reg2}\n" },
437 { INT64_C(0x0123450012345000),
438 "lui {reg1}, 0x12345\n"
439 "lui {reg2}, 0x12345\n"
440 "slli {reg1}, {reg1}, 40 - 12\n"
441 "add {reg1}, {reg1}, {reg2}\n" },
442
443 // Li: LUI+ADDIW+SLLI+ADDI+SLLI+ADDI
444 // LoadConst: LUI+LUI+ADDIW+SLLI+ADD (using TMP)
445 { INT64_C(0x0001234512345678),
446 "lui {reg1}, 0x12345\n"
447 "li {reg2}, 0x12345678\n"
448 "slli {reg1}, {reg1}, 32 - 12\n"
449 "add {reg1}, {reg1}, {reg2}\n" },
450 { INT64_C(0x0012345012345678),
451 "lui {reg1}, 0x12345\n"
452 "li {reg2}, 0x12345678\n"
453 "slli {reg1}, {reg1}, 36 - 12\n"
454 "add {reg1}, {reg1}, {reg2}\n" },
455 };
456 for (auto [value, fmt] : test_values2) {
457 emit_load_const(A0, value);
458 if (can_use_tmp) {
459 std::string base = fmt;
460 ReplaceReg(REG1_TOKEN, GetRegisterName(A0), &base);
461 ReplaceReg(REG2_TOKEN, GetRegisterName(TMP), &base);
462 expected += base;
463 } else {
464 expected += "li a0, " + std::to_string(value) + "\n";
465 }
466 }
467
468 DriverStr(expected, test_name);
469 }
470
StripZeroArg(const std::string & args)471 static std::string StripZeroArg(const std::string& args) {
472 static constexpr char kZeroSuffix[] = ", zero";
473 CHECK(args.ends_with(kZeroSuffix));
474 return args.substr(0u, args.size() - strlen(kZeroSuffix));
475 }
476
GetPrintBcond()477 auto GetPrintBcond() {
478 return [](const std::string& cond,
479 [[maybe_unused]] const std::string& opposite_cond,
480 const std::string& args,
481 const std::string& target) {
482 return "b" + cond + args + ", " + target + "\n";
483 };
484 }
485
GetPrintCBcond()486 auto GetPrintCBcond() {
487 return [](const std::string& cond,
488 [[maybe_unused]] const std::string& opposite_cond,
489 const std::string& args,
490 const std::string& target) {
491 return "c.b" + cond + "z" + StripZeroArg(args) + ", " + target + "\n";
492 };
493 }
494
GetPrintBcondOppositeAndJ(const std::string & skip_label)495 auto GetPrintBcondOppositeAndJ(const std::string& skip_label) {
496 return [=]([[maybe_unused]] const std::string& cond,
497 const std::string& opposite_cond,
498 const std::string& args,
499 const std::string& target) {
500 return "b" + opposite_cond + args + ", " + skip_label + "f\n" +
501 "j " + target + "\n" +
502 skip_label + ":\n";
503 };
504 }
505
GetPrintCBcondOppositeAndJ(const std::string & skip_label)506 auto GetPrintCBcondOppositeAndJ(const std::string& skip_label) {
507 return [=]([[maybe_unused]] const std::string& cond,
508 const std::string& opposite_cond,
509 const std::string& args,
510 const std::string& target) {
511 return "c.b" + opposite_cond + "z" + StripZeroArg(args) + ", " + skip_label + "f\n" +
512 "j " + target + "\n" +
513 skip_label + ":\n";
514 };
515 }
516
GetPrintBcondOppositeAndTail(const std::string & skip_label,const std::string & base_label)517 auto GetPrintBcondOppositeAndTail(const std::string& skip_label, const std::string& base_label) {
518 return [=]([[maybe_unused]] const std::string& cond,
519 const std::string& opposite_cond,
520 const std::string& args,
521 const std::string& target) {
522 return "b" + opposite_cond + args + ", " + skip_label + "f\n" +
523 base_label + ":\n" +
524 "auipc t6, %pcrel_hi(" + target + ")\n" +
525 "jalr x0, %pcrel_lo(" + base_label + "b)(t6)\n" +
526 skip_label + ":\n";
527 };
528 }
529
530 // Helper function for basic tests that all branch conditions map to the correct opcodes,
531 // whether with branch expansion (a conditional branch with opposite condition over an
532 // unconditional branch) or without.
533 template <typename PrintBcond>
EmitBcondForAllConditions(Riscv64Label * label,const std::string & target,PrintBcond && print_bcond,bool is_bare)534 std::string EmitBcondForAllConditions(Riscv64Label* label,
535 const std::string& target,
536 PrintBcond&& print_bcond,
537 bool is_bare) {
538 XRegister rs = A0;
539 __ Beqz(rs, label, is_bare);
540 __ Bnez(rs, label, is_bare);
541 __ Blez(rs, label, is_bare);
542 __ Bgez(rs, label, is_bare);
543 __ Bltz(rs, label, is_bare);
544 __ Bgtz(rs, label, is_bare);
545 XRegister rt = A1;
546 __ Beq(rs, rt, label, is_bare);
547 __ Bne(rs, rt, label, is_bare);
548 __ Ble(rs, rt, label, is_bare);
549 __ Bge(rs, rt, label, is_bare);
550 __ Blt(rs, rt, label, is_bare);
551 __ Bgt(rs, rt, label, is_bare);
552 __ Bleu(rs, rt, label, is_bare);
553 __ Bgeu(rs, rt, label, is_bare);
554 __ Bltu(rs, rt, label, is_bare);
555 __ Bgtu(rs, rt, label, is_bare);
556
557 return
558 print_bcond("eq", "ne", "z a0", target) +
559 print_bcond("ne", "eq", "z a0", target) +
560 print_bcond("le", "gt", "z a0", target) +
561 print_bcond("ge", "lt", "z a0", target) +
562 print_bcond("lt", "ge", "z a0", target) +
563 print_bcond("gt", "le", "z a0", target) +
564 print_bcond("eq", "ne", " a0, a1", target) +
565 print_bcond("ne", "eq", " a0, a1", target) +
566 print_bcond("le", "gt", " a0, a1", target) +
567 print_bcond("ge", "lt", " a0, a1", target) +
568 print_bcond("lt", "ge", " a0, a1", target) +
569 print_bcond("gt", "le", " a0, a1", target) +
570 print_bcond("leu", "gtu", " a0, a1", target) +
571 print_bcond("geu", "ltu", " a0, a1", target) +
572 print_bcond("ltu", "geu", " a0, a1", target) +
573 print_bcond("gtu", "leu", " a0, a1", target);
574 }
575
576 // Test Bcond for forward branches with all conditions.
577 // The gap must be such that either all branches expand, or none does.
578 template <typename PrintBcond>
TestBcondForward(const std::string & test_name,size_t gap_size,const std::string & target_label,PrintBcond && print_bcond,bool is_bare=false)579 void TestBcondForward(const std::string& test_name,
580 size_t gap_size,
581 const std::string& target_label,
582 PrintBcond&& print_bcond,
583 bool is_bare = false) {
584 std::string expected;
585 Riscv64Label label;
586 expected += EmitBcondForAllConditions(&label, target_label + "f", print_bcond, is_bare);
587 expected += EmitNops(gap_size);
588 __ Bind(&label);
589 expected += target_label + ":\n";
590 DriverStr(expected, test_name);
591 }
592
593 // Test Bcond for backward branches with all conditions.
594 // The gap must be such that either all branches expand, or none does.
595 template <typename PrintBcond>
TestBcondBackward(const std::string & test_name,size_t gap_size,const std::string & target_label,PrintBcond && print_bcond,bool is_bare=false)596 void TestBcondBackward(const std::string& test_name,
597 size_t gap_size,
598 const std::string& target_label,
599 PrintBcond&& print_bcond,
600 bool is_bare = false) {
601 std::string expected;
602 Riscv64Label label;
603 __ Bind(&label);
604 expected += target_label + ":\n";
605 expected += EmitNops(gap_size);
606 expected += EmitBcondForAllConditions(&label, target_label + "b", print_bcond, is_bare);
607 DriverStr(expected, test_name);
608 }
609
MaxOffset9BackwardDistance() const610 size_t MaxOffset9BackwardDistance() const { return KB / 4; }
MaxOffset9ForwardDistance() const611 size_t MaxOffset9ForwardDistance() const { return KB / 4 - 2; }
612
MaxOffset12BackwardDistance() const613 size_t MaxOffset12BackwardDistance() const { return 2 * KB; }
MaxOffset12ForwardDistance() const614 size_t MaxOffset12ForwardDistance() const { return 2 * KB - 2; }
615
MaxOffset13BackwardDistance() const616 size_t MaxOffset13BackwardDistance() const { return 4 * KB; }
MaxOffset13ForwardDistance() const617 size_t MaxOffset13ForwardDistance() const { return 4 * KB - 2; }
618
MaxOffset13BackwardDistance_WithoutC() const619 size_t MaxOffset13BackwardDistance_WithoutC() const { return 4 * KB; }
MaxOffset13ForwardDistance_WithoutC() const620 size_t MaxOffset13ForwardDistance_WithoutC() const { return 4 * KB - 4; }
621
MaxOffset21BackwardDistance() const622 size_t MaxOffset21BackwardDistance() const { return 1 * MB; }
MaxOffset21ForwardDistance() const623 size_t MaxOffset21ForwardDistance() const { return 1 * MB - 2; }
624
MaxOffset21BackwardDistance_WithoutC()625 size_t MaxOffset21BackwardDistance_WithoutC() { return 1 * MB; }
MaxOffset21ForwardDistance_WithoutC()626 size_t MaxOffset21ForwardDistance_WithoutC() { return 1 * MB - 4; }
627
628 template <typename PrintBcond>
TestBcondA0RegForward(const std::string & test_name,void (Riscv64Assembler::* f)(XRegister,XRegister,Riscv64Label *,bool),XRegister reg,size_t nops_size,PrintBcond && print_bcond,const std::string & cond,const std::string & opposite_cond,const std::string & target_label,bool is_bare)629 void TestBcondA0RegForward(const std::string& test_name,
630 void (Riscv64Assembler::*f)(XRegister, XRegister, Riscv64Label*, bool),
631 XRegister reg,
632 size_t nops_size,
633 PrintBcond&& print_bcond,
634 const std::string& cond,
635 const std::string& opposite_cond,
636 const std::string& target_label,
637 bool is_bare) {
638 std::string expected;
639 Riscv64Label label;
640 (GetAssembler()->*f)(A0, reg, &label, is_bare);
641 std::string args = " a0, " + GetRegisterName(reg);
642 expected += print_bcond(cond, opposite_cond, args, target_label + "f");
643 expected += EmitNops(nops_size);
644 __ Bind(&label);
645 expected += target_label + ":\n";
646 DriverStr(expected, test_name);
647 }
648
649 template <typename PrintBcond>
TestBeqzA0Forward(const std::string & test_name,size_t nops_size,PrintBcond && print_bcond,const std::string & target_label,bool is_bare=false)650 void TestBeqzA0Forward(const std::string& test_name,
651 size_t nops_size,
652 PrintBcond&& print_bcond,
653 const std::string& target_label,
654 bool is_bare = false) {
655 TestBcondA0RegForward(test_name,
656 &Riscv64Assembler::Beq,
657 Zero,
658 nops_size,
659 std::move(print_bcond),
660 "eq",
661 "ne",
662 target_label,
663 is_bare);
664 }
665
666 template <typename PrintBcond>
TestBnezA0Forward(const std::string & test_name,size_t nops_size,PrintBcond && print_bcond,const std::string & target_label,bool is_bare=false)667 void TestBnezA0Forward(const std::string& test_name,
668 size_t nops_size,
669 PrintBcond&& print_bcond,
670 const std::string& target_label,
671 bool is_bare = false) {
672 TestBcondA0RegForward(test_name,
673 &Riscv64Assembler::Bne,
674 Zero,
675 nops_size,
676 std::move(print_bcond),
677 "ne",
678 "eq",
679 target_label,
680 is_bare);
681 }
682
683 template <typename PrintBcond>
TestBeqA0A1Forward(const std::string & test_name,size_t nops_size,PrintBcond && print_bcond,const std::string & target_label,bool is_bare=false)684 void TestBeqA0A1Forward(const std::string& test_name,
685 size_t nops_size,
686 PrintBcond&& print_bcond,
687 const std::string& target_label,
688 bool is_bare = false) {
689 TestBcondA0RegForward(test_name,
690 &Riscv64Assembler::Beq,
691 A1,
692 nops_size,
693 std::move(print_bcond),
694 "eq",
695 "ne",
696 target_label,
697 is_bare);
698 }
699
700 template <typename PrintBcond>
TestBcondA0RegBackward(const std::string & test_name,void (Riscv64Assembler::* f)(XRegister,XRegister,Riscv64Label *,bool),XRegister reg,size_t nops_size,PrintBcond && print_bcond,const std::string & cond,const std::string & opposite_cond,const std::string & target_label,bool is_bare)701 void TestBcondA0RegBackward(
702 const std::string& test_name,
703 void (Riscv64Assembler::*f)(XRegister, XRegister, Riscv64Label*, bool),
704 XRegister reg,
705 size_t nops_size,
706 PrintBcond&& print_bcond,
707 const std::string& cond,
708 const std::string& opposite_cond,
709 const std::string& target_label,
710 bool is_bare) {
711 std::string expected;
712 Riscv64Label label;
713 __ Bind(&label);
714 expected += target_label + ":\n";
715 expected += EmitNops(nops_size);
716 (GetAssembler()->*f)(A0, reg, &label, is_bare);
717 std::string args = " a0, " + GetRegisterName(reg);
718 expected += print_bcond(cond, opposite_cond, args, target_label + "b");
719 DriverStr(expected, test_name);
720 }
721
722 template <typename PrintBcond>
TestBeqzA0Backward(const std::string & test_name,size_t nops_size,PrintBcond && print_bcond,const std::string & target_label,bool is_bare=false)723 void TestBeqzA0Backward(const std::string& test_name,
724 size_t nops_size,
725 PrintBcond&& print_bcond,
726 const std::string& target_label,
727 bool is_bare = false) {
728 TestBcondA0RegBackward(test_name,
729 &Riscv64Assembler::Beq,
730 Zero,
731 nops_size,
732 std::move(print_bcond),
733 "eq",
734 "ne",
735 target_label,
736 is_bare);
737 }
738
739 template <typename PrintBcond>
TestBnezA0Backward(const std::string & test_name,size_t nops_size,PrintBcond && print_bcond,const std::string & target_label,bool is_bare=false)740 void TestBnezA0Backward(const std::string& test_name,
741 size_t nops_size,
742 PrintBcond&& print_bcond,
743 const std::string& target_label,
744 bool is_bare = false) {
745 TestBcondA0RegBackward(test_name,
746 &Riscv64Assembler::Bne,
747 Zero,
748 nops_size,
749 std::move(print_bcond),
750 "ne",
751 "eq",
752 target_label,
753 is_bare);
754 }
755
756 template <typename PrintBcond>
TestBeqA0A1Backward(const std::string & test_name,size_t nops_size,PrintBcond && print_bcond,const std::string & target_label,bool is_bare=false)757 void TestBeqA0A1Backward(const std::string& test_name,
758 size_t nops_size,
759 PrintBcond&& print_bcond,
760 const std::string& target_label,
761 bool is_bare = false) {
762 TestBcondA0RegBackward(test_name,
763 &Riscv64Assembler::Beq,
764 A1,
765 nops_size,
766 std::move(print_bcond),
767 "eq",
768 "ne",
769 target_label,
770 is_bare);
771 }
772
773 // Test a branch setup where expanding one branch causes expanding another branch
774 // which causes expanding another branch, etc. The argument `cascade` determines
775 // whether we push the first branch to expand, or not.
776 template <typename PrintBcond>
TestBeqA0A1MaybeCascade(const std::string & test_name,bool cascade,PrintBcond && print_bcond)777 void TestBeqA0A1MaybeCascade(const std::string& test_name,
778 bool cascade,
779 PrintBcond&& print_bcond) {
780 const size_t kNumBeqs = MaxOffset13ForwardDistance() / sizeof(uint32_t) / 2u;
781 auto label_name = [](size_t i) { return ".L" + std::to_string(i); };
782
783 std::string expected;
784 std::vector<Riscv64Label> labels(kNumBeqs);
785 for (size_t i = 0; i != kNumBeqs; ++i) {
786 __ Beq(A0, A1, &labels[i]);
787 expected += print_bcond("eq", "ne", " a0, a1", label_name(i));
788 }
789 if (cascade) {
790 expected += EmitNops(sizeof(uint32_t));
791 }
792 for (size_t i = 0; i != kNumBeqs; ++i) {
793 expected += EmitNops(2 * sizeof(uint32_t));
794 __ Bind(&labels[i]);
795 expected += label_name(i) + ":\n";
796 }
797 DriverStr(expected, test_name);
798 }
799
TestBcondElimination(const std::string & test_name,const std::string & nop)800 void TestBcondElimination(const std::string& test_name, const std::string& nop) {
801 Riscv64Label label;
802 __ Bind(&label);
803 __ Nop();
804 for (XRegister reg : GetRegisters()) {
805 __ Bne(reg, reg, &label);
806 __ Blt(reg, reg, &label);
807 __ Bgt(reg, reg, &label);
808 __ Bltu(reg, reg, &label);
809 __ Bgtu(reg, reg, &label);
810 }
811 DriverStr(nop + "\n", test_name);
812 }
813
TestBcondUnconditional(const std::string & test_name,const std::string & j)814 void TestBcondUnconditional(const std::string& test_name, const std::string& j) {
815 Riscv64Label label;
816 __ Bind(&label);
817 __ Nop();
818 for (XRegister reg : GetRegisters()) {
819 __ Beq(reg, reg, &label);
820 __ Bge(reg, reg, &label);
821 __ Ble(reg, reg, &label);
822 __ Bleu(reg, reg, &label);
823 __ Bgeu(reg, reg, &label);
824 }
825 std::string expected =
826 "1:\n"
827 "nop\n" +
828 RepeatInsn(5u * GetRegisters().size(), j + " 1b\n", []() {});
829 DriverStr(expected, test_name);
830 }
831
GetPrintJalRd()832 auto GetPrintJalRd() {
833 return [=](XRegister rd, const std::string& target) {
834 std::string rd_name = GetRegisterName(rd);
835 return "jal " + rd_name + ", " + target + "\n";
836 };
837 }
838
GetPrintCallRd(const std::string & base_label)839 auto GetPrintCallRd(const std::string& base_label) {
840 return [=](XRegister rd, const std::string& target) {
841 std::string rd_name = GetRegisterName(rd);
842 std::string temp_name = (rd != Zero) ? rd_name : GetRegisterName(TMP);
843 return base_label + ":\n" +
844 "auipc " + temp_name + ", %pcrel_hi(" + target + ")\n" +
845 "jalr " + rd_name + ", %pcrel_lo(" + base_label + "b)(" + temp_name + ")\n";
846 };
847 }
848
849 template <typename PrintJalRd>
TestJalRdForward(const std::string & test_name,size_t gap_size,const std::string & label_name,PrintJalRd && print_jalrd,bool is_bare=false)850 void TestJalRdForward(const std::string& test_name,
851 size_t gap_size,
852 const std::string& label_name,
853 PrintJalRd&& print_jalrd,
854 bool is_bare = false) {
855 std::string expected;
856 Riscv64Label label;
857 for (XRegister reg : GetRegisters()) {
858 __ Jal(reg, &label, is_bare);
859 expected += print_jalrd(reg, label_name + "f");
860 }
861 expected += EmitNops(gap_size);
862 __ Bind(&label);
863 expected += label_name + ":\n";
864 DriverStr(expected, test_name);
865 }
866
867 template <typename PrintJalRd>
TestJalRdBackward(const std::string & test_name,size_t gap_size,const std::string & label_name,PrintJalRd && print_jalrd,bool is_bare=false)868 void TestJalRdBackward(const std::string& test_name,
869 size_t gap_size,
870 const std::string& label_name,
871 PrintJalRd&& print_jalrd,
872 bool is_bare = false) {
873 std::string expected;
874 Riscv64Label label;
875 __ Bind(&label);
876 expected += label_name + ":\n";
877 expected += EmitNops(gap_size);
878 for (XRegister reg : GetRegisters()) {
879 __ Jal(reg, &label, is_bare);
880 expected += print_jalrd(reg, label_name + "b");
881 }
882 DriverStr(expected, test_name);
883 }
884
GetEmitJ(bool is_bare=false)885 auto GetEmitJ(bool is_bare = false) {
886 return [=](Riscv64Label* label) { __ J(label, is_bare); };
887 }
888
GetEmitJal()889 auto GetEmitJal() {
890 return [=](Riscv64Label* label) { __ Jal(label); };
891 }
892
GetPrintJ()893 auto GetPrintJ() {
894 return [=](const std::string& target) {
895 return "j " + target + "\n";
896 };
897 }
898
GetPrintCJ()899 auto GetPrintCJ() {
900 return [=](const std::string& target) {
901 return "c.j " + target + "\n";
902 };
903 }
904
GetPrintJal()905 auto GetPrintJal() {
906 return [=](const std::string& target) {
907 return "jal " + target + "\n";
908 };
909 }
910
GetPrintTail(const std::string & base_label)911 auto GetPrintTail(const std::string& base_label) {
912 return [=](const std::string& target) {
913 return base_label + ":\n" +
914 "auipc t6, %pcrel_hi(" + target + ")\n" +
915 "jalr x0, %pcrel_lo(" + base_label + "b)(t6)\n";
916 };
917 }
918
GetPrintCall(const std::string & base_label)919 auto GetPrintCall(const std::string& base_label) {
920 return [=](const std::string& target) {
921 return base_label + ":\n" +
922 "auipc ra, %pcrel_hi(" + target + ")\n" +
923 "jalr ra, %pcrel_lo(" + base_label + "b)(ra)\n";
924 };
925 }
926
927 template <typename EmitBuncond, typename PrintBuncond>
TestBuncondForward(const std::string & test_name,size_t gap_size,const std::string & label_name,EmitBuncond && emit_buncond,PrintBuncond && print_buncond)928 void TestBuncondForward(const std::string& test_name,
929 size_t gap_size,
930 const std::string& label_name,
931 EmitBuncond&& emit_buncond,
932 PrintBuncond&& print_buncond) {
933 std::string expected;
934 Riscv64Label label;
935 emit_buncond(&label);
936 expected += print_buncond(label_name + "f");
937 expected += EmitNops(gap_size);
938 __ Bind(&label);
939 expected += label_name + ":\n";
940 DriverStr(expected, test_name);
941 }
942
943 template <typename EmitBuncond, typename PrintBuncond>
TestBuncondBackward(const std::string & test_name,size_t gap_size,const std::string & label_name,EmitBuncond && emit_buncond,PrintBuncond && print_buncond)944 void TestBuncondBackward(const std::string& test_name,
945 size_t gap_size,
946 const std::string& label_name,
947 EmitBuncond&& emit_buncond,
948 PrintBuncond&& print_buncond) {
949 std::string expected;
950 Riscv64Label label;
951 __ Bind(&label);
952 expected += label_name + ":\n";
953 expected += EmitNops(gap_size);
954 emit_buncond(&label);
955 expected += print_buncond(label_name + "b");
956 DriverStr(expected, test_name);
957 }
958
959 template <typename EmitOp>
TestAddConst(const std::string & test_name,size_t bits,const std::string & suffix,EmitOp && emit_op)960 void TestAddConst(const std::string& test_name,
961 size_t bits,
962 const std::string& suffix,
963 EmitOp&& emit_op) {
964 int64_t kImm12s[] = {
965 0, 1, 2, 0xff, 0x100, 0x1ff, 0x200, 0x3ff, 0x400, 0x7ff,
966 -1, -2, -0x100, -0x101, -0x200, -0x201, -0x400, -0x401, -0x800,
967 };
968 int64_t kSimplePositiveValues[] = {
969 0x800, 0x801, 0xbff, 0xc00, 0xff0, 0xff7, 0xff8, 0xffb, 0xffc, 0xffd, 0xffe,
970 };
971 int64_t kSimpleNegativeValues[] = {
972 -0x801, -0x802, -0xbff, -0xc00, -0xff0, -0xff8, -0xffc, -0xffe, -0xfff, -0x1000,
973 };
974 std::vector<int64_t> large_values = CreateImmediateValuesBits(bits, /*as_uint=*/ false);
975 auto kept_end = std::remove_if(large_values.begin(),
976 large_values.end(),
977 [](int64_t value) { return IsInt<13>(value); });
978 large_values.erase(kept_end, large_values.end());
979 large_values.push_back(0xfff);
980
981 std::string expected;
982 for (XRegister rd : GetRegisters()) {
983 std::string rd_name = GetRegisterName(rd);
984 std::string addi_rd = ART_FORMAT("addi{} {}, ", suffix, rd_name);
985 std::string add_rd = ART_FORMAT("add{} {}, ", suffix, rd_name);
986 for (XRegister rs1 : GetRegisters()) {
987 ScratchRegisterScope srs(GetAssembler());
988 srs.ExcludeXRegister(rs1);
989 srs.ExcludeXRegister(rd);
990
991 std::string rs1_name = GetRegisterName(rs1);
992 std::string tmp_name = GetRegisterName((rs1 != TMP) ? TMP : TMP2);
993 std::string addi_tmp = ART_FORMAT("addi{} {}, ", suffix, tmp_name);
994
995 for (int64_t imm : kImm12s) {
996 emit_op(rd, rs1, imm);
997 expected += ART_FORMAT("{}{}, {}\n", addi_rd, rs1_name, std::to_string(imm));
998 }
999
1000 auto emit_simple_ops = [&](ArrayRef<const int64_t> imms, int64_t adjustment) {
1001 for (int64_t imm : imms) {
1002 emit_op(rd, rs1, imm);
1003 expected += ART_FORMAT("{}{}, {}\n", addi_tmp, rs1_name, std::to_string(adjustment));
1004 expected +=
1005 ART_FORMAT("{}{}, {}\n", addi_rd, tmp_name, std::to_string(imm - adjustment));
1006 }
1007 };
1008 emit_simple_ops(ArrayRef<const int64_t>(kSimplePositiveValues), 0x7ff);
1009 emit_simple_ops(ArrayRef<const int64_t>(kSimpleNegativeValues), -0x800);
1010
1011 for (int64_t imm : large_values) {
1012 emit_op(rd, rs1, imm);
1013 expected += ART_FORMAT("li {}, {}\n", tmp_name, std::to_string(imm));
1014 expected += ART_FORMAT("{}{}, {}\n", add_rd, rs1_name, tmp_name);
1015 }
1016 }
1017 }
1018 DriverStr(expected, test_name);
1019 }
1020
1021 template <typename GetTemp, typename EmitOp>
RepeatLoadStoreArbitraryOffset(const std::string & head,GetTemp && get_temp,EmitOp && emit_op)1022 std::string RepeatLoadStoreArbitraryOffset(const std::string& head,
1023 GetTemp&& get_temp,
1024 EmitOp&& emit_op) {
1025 int64_t kImm12s[] = {
1026 0, 1, 2, 0xff, 0x100, 0x1ff, 0x200, 0x3ff, 0x400, 0x7ff,
1027 -1, -2, -0x100, -0x101, -0x200, -0x201, -0x400, -0x401, -0x800,
1028 };
1029 int64_t kSimplePositiveOffsetsAlign8[] = {
1030 0x800, 0x801, 0xbff, 0xc00, 0xff0, 0xff4, 0xff6, 0xff7
1031 };
1032 int64_t kSimplePositiveOffsetsAlign4[] = {
1033 0xff8, 0xff9, 0xffa, 0xffb
1034 };
1035 int64_t kSimplePositiveOffsetsAlign2[] = {
1036 0xffc, 0xffd
1037 };
1038 int64_t kSimplePositiveOffsetsNoAlign[] = {
1039 0xffe
1040 };
1041 int64_t kSimpleNegativeOffsets[] = {
1042 -0x801, -0x802, -0xbff, -0xc00, -0xff0, -0xff8, -0xffc, -0xffe, -0xfff, -0x1000,
1043 };
1044 int64_t kSplitOffsets[] = {
1045 0xfff, 0x1000, 0x1001, 0x17ff, 0x1800, 0x1fff, 0x2000, 0x2001, 0x27ff, 0x2800,
1046 0x7fffe7ff, 0x7fffe800, 0x7fffefff, 0x7ffff000, 0x7ffff001, 0x7ffff7ff,
1047 -0x1001, -0x1002, -0x17ff, -0x1800, -0x1801, -0x2000, -0x2001, -0x2800, -0x2801,
1048 -0x7ffff000, -0x7ffff001, -0x7ffff800, -0x7ffff801, -0x7fffffff, -0x80000000,
1049 };
1050 int64_t kSpecialOffsets[] = {
1051 0x7ffff800, 0x7ffff801, 0x7ffffffe, 0x7fffffff
1052 };
1053
1054 std::string expected;
1055 for (XRegister rs1 : GetRegisters()) {
1056 XRegister tmp = get_temp(rs1);
1057 if (tmp == kNoXRegister) {
1058 continue; // Unsupported register combination.
1059 }
1060 std::string tmp_name = GetRegisterName(tmp);
1061 ScratchRegisterScope srs(GetAssembler());
1062 srs.ExcludeXRegister(rs1);
1063 std::string rs1_name = GetRegisterName(rs1);
1064
1065 for (int64_t imm : kImm12s) {
1066 emit_op(rs1, imm);
1067 expected += ART_FORMAT("{}, {}({})\n", head, std::to_string(imm), rs1_name);
1068 }
1069
1070 auto emit_simple_ops = [&](ArrayRef<const int64_t> imms, int64_t adjustment) {
1071 for (int64_t imm : imms) {
1072 emit_op(rs1, imm);
1073 expected +=
1074 ART_FORMAT("addi {}, {}, {}\n", tmp_name, rs1_name, std::to_string(adjustment));
1075 expected += ART_FORMAT("{}, {}({})\n", head, std::to_string(imm - adjustment), tmp_name);
1076 }
1077 };
1078 emit_simple_ops(ArrayRef<const int64_t>(kSimplePositiveOffsetsAlign8), 0x7f8);
1079 emit_simple_ops(ArrayRef<const int64_t>(kSimplePositiveOffsetsAlign4), 0x7fc);
1080 emit_simple_ops(ArrayRef<const int64_t>(kSimplePositiveOffsetsAlign2), 0x7fe);
1081 emit_simple_ops(ArrayRef<const int64_t>(kSimplePositiveOffsetsNoAlign), 0x7ff);
1082 emit_simple_ops(ArrayRef<const int64_t>(kSimpleNegativeOffsets), -0x800);
1083
1084 for (int64_t imm : kSplitOffsets) {
1085 emit_op(rs1, imm);
1086 uint32_t imm20 = ((imm >> 12) + ((imm >> 11) & 1)) & 0xfffff;
1087 int32_t small_offset = (imm & 0xfff) - ((imm & 0x800) << 1);
1088 expected += ART_FORMAT("lui {}, {}\n", tmp_name, std::to_string(imm20));
1089 expected += ART_FORMAT("add {}, {}, {}\n", tmp_name, tmp_name, rs1_name);
1090 expected += ART_FORMAT("{},{}({})\n", head, std::to_string(small_offset), tmp_name);
1091 }
1092
1093 for (int64_t imm : kSpecialOffsets) {
1094 emit_op(rs1, imm);
1095 expected += ART_FORMAT("lui {}, 0x80000\n", tmp_name);
1096 expected +=
1097 ART_FORMAT("addiw {}, {}, {}\n", tmp_name, tmp_name, std::to_string(imm - 0x80000000));
1098 expected += ART_FORMAT("add {}, {}, {}\n", tmp_name, tmp_name, rs1_name);
1099 expected += ART_FORMAT("{}, ({})\n", head, tmp_name);
1100 }
1101 }
1102 return expected;
1103 }
1104
TestLoadStoreArbitraryOffset(const std::string & test_name,const std::string & insn,void (Riscv64Assembler::* fn)(XRegister,XRegister,int32_t),bool is_store)1105 void TestLoadStoreArbitraryOffset(const std::string& test_name,
1106 const std::string& insn,
1107 void (Riscv64Assembler::*fn)(XRegister, XRegister, int32_t),
1108 bool is_store) {
1109 std::string expected;
1110 for (XRegister rd : GetRegisters()) {
1111 ScratchRegisterScope srs(GetAssembler());
1112 srs.ExcludeXRegister(rd);
1113 auto get_temp = [&](XRegister rs1) {
1114 if (is_store) {
1115 return (rs1 != TMP && rd != TMP)
1116 ? TMP
1117 : (rs1 != TMP2 && rd != TMP2) ? TMP2 : kNoXRegister;
1118 } else {
1119 return rs1 != TMP ? TMP : TMP2;
1120 }
1121 };
1122 expected += RepeatLoadStoreArbitraryOffset(
1123 insn + " " + GetRegisterName(rd),
1124 get_temp,
1125 [&](XRegister rs1, int64_t offset) { (GetAssembler()->*fn)(rd, rs1, offset); });
1126 }
1127 DriverStr(expected, test_name);
1128 }
1129
TestFPLoadStoreArbitraryOffset(const std::string & test_name,const std::string & insn,void (Riscv64Assembler::* fn)(FRegister,XRegister,int32_t))1130 void TestFPLoadStoreArbitraryOffset(const std::string& test_name,
1131 const std::string& insn,
1132 void (Riscv64Assembler::*fn)(FRegister, XRegister, int32_t)) {
1133 std::string expected;
1134 for (FRegister rd : GetFPRegisters()) {
1135 expected += RepeatLoadStoreArbitraryOffset(
1136 insn + " " + GetFPRegName(rd),
1137 [&](XRegister rs1) { return rs1 != TMP ? TMP : TMP2; },
1138 [&](XRegister rs1, int64_t offset) { (GetAssembler()->*fn)(rd, rs1, offset); });
1139 }
1140 DriverStr(expected, test_name);
1141 }
1142
TestLoadLiteral(const std::string & test_name,bool with_padding_for_long)1143 void TestLoadLiteral(const std::string& test_name, bool with_padding_for_long) {
1144 std::string expected;
1145 Literal* narrow_literal = __ NewLiteral<uint32_t>(0x12345678);
1146 Literal* wide_literal = __ NewLiteral<uint64_t>(0x1234567887654321);
1147 auto print_load = [&](const std::string& load, XRegister rd, const std::string& label) {
1148 std::string rd_name = GetRegisterName(rd);
1149 expected += "1:\n"
1150 "auipc " + rd_name + ", %pcrel_hi(" + label + "f)\n" +
1151 load + " " + rd_name + ", %pcrel_lo(1b)(" + rd_name + ")\n";
1152 };
1153 for (XRegister reg : GetRegisters()) {
1154 if (reg != Zero) {
1155 __ Loadw(reg, narrow_literal);
1156 print_load("lw", reg, "2");
1157 __ Loadwu(reg, narrow_literal);
1158 print_load("lwu", reg, "2");
1159 __ Loadd(reg, wide_literal);
1160 print_load("ld", reg, "3");
1161 }
1162 }
1163 std::string tmp = GetRegisterName(TMP);
1164 auto print_fp_load = [&](const std::string& load, FRegister rd, const std::string& label) {
1165 std::string rd_name = GetFPRegName(rd);
1166 expected += "1:\n"
1167 "auipc " + tmp + ", %pcrel_hi(" + label + "f)\n" +
1168 load + " " + rd_name + ", %pcrel_lo(1b)(" + tmp + ")\n";
1169 };
1170 for (FRegister freg : GetFPRegisters()) {
1171 __ FLoadw(freg, narrow_literal);
1172 print_fp_load("flw", freg, "2");
1173 __ FLoadd(freg, wide_literal);
1174 print_fp_load("fld", freg, "3");
1175 }
1176 // All literal loads above emit 8 bytes of code. The narrow literal shall emit 4 bytes of code.
1177 // If we do not add another instruction, we shall end up with padding before the long literal.
1178 expected += EmitNops(with_padding_for_long ? 0u : sizeof(uint32_t));
1179 expected += "2:\n"
1180 ".4byte 0x12345678\n" +
1181 std::string(with_padding_for_long ? ".4byte 0\n" : "") +
1182 "3:\n"
1183 ".8byte 0x1234567887654321\n";
1184 DriverStr(expected, test_name);
1185 }
1186
RepeatFFFFRoundingMode(void (Riscv64Assembler::* f)(FRegister,FRegister,FRegister,FRegister,FPRoundingMode),const std::string & fmt)1187 std::string RepeatFFFFRoundingMode(
1188 void (Riscv64Assembler::*f)(FRegister, FRegister, FRegister, FRegister, FPRoundingMode),
1189 const std::string& fmt) {
1190 CHECK(f != nullptr);
1191 std::string str;
1192 ArrayRef<const FRegister> fp_regs = GetFPRegisters();
1193 for (FRegister reg1 : fp_regs) {
1194 std::string base1 = fmt;
1195 ReplaceReg(REG1_TOKEN, GetFPRegName(reg1), &base1);
1196 for (FRegister reg2 : fp_regs) {
1197 std::string base2 = base1;
1198 ReplaceReg(REG2_TOKEN, GetFPRegName(reg2), &base2);
1199 for (FRegister reg3 : fp_regs) {
1200 std::string base3 = base2;
1201 ReplaceReg(REG3_TOKEN, GetFPRegName(reg3), &base3);
1202 for (FRegister reg4 : fp_regs) {
1203 std::string base4 = base3;
1204 ReplaceReg(REG4_TOKEN, GetFPRegName(reg4), &base4);
1205 for (FPRoundingMode rm : kRoundingModes) {
1206 (GetAssembler()->*f)(reg1, reg2, reg3, reg4, rm);
1207
1208 std::string base = base4;
1209 ReplaceRoundingMode(rm, &base);
1210 str += base;
1211 str += "\n";
1212 }
1213 }
1214 }
1215 }
1216 }
1217 return str;
1218 }
1219
RepeatFFFRoundingMode(void (Riscv64Assembler::* f)(FRegister,FRegister,FRegister,FPRoundingMode),const std::string & fmt)1220 std::string RepeatFFFRoundingMode(
1221 void (Riscv64Assembler::*f)(FRegister, FRegister, FRegister, FPRoundingMode),
1222 const std::string& fmt) {
1223 CHECK(f != nullptr);
1224 std::string str;
1225 ArrayRef<const FRegister> fp_regs = GetFPRegisters();
1226 for (FRegister reg1 : fp_regs) {
1227 std::string base1 = fmt;
1228 ReplaceReg(REG1_TOKEN, GetFPRegName(reg1), &base1);
1229 for (FRegister reg2 : fp_regs) {
1230 std::string base2 = base1;
1231 ReplaceReg(REG2_TOKEN, GetFPRegName(reg2), &base2);
1232 for (FRegister reg3 : fp_regs) {
1233 std::string base3 = base2;
1234 ReplaceReg(REG3_TOKEN, GetFPRegName(reg3), &base3);
1235 for (FPRoundingMode rm : kRoundingModes) {
1236 (GetAssembler()->*f)(reg1, reg2, reg3, rm);
1237
1238 std::string base = base3;
1239 ReplaceRoundingMode(rm, &base);
1240 str += base;
1241 str += "\n";
1242 }
1243 }
1244 }
1245 }
1246 return str;
1247 }
1248
1249 template <typename Reg, typename Imm>
RepeatCTemplateRegImm(void (Riscv64Assembler::* f)(Reg,Imm),ArrayRef<const Reg> registers,std::string (Base::* GetName)(const Reg &),int imm_bits,int shift,bool no_zero_imm,const std::string & fmt)1250 std::string RepeatCTemplateRegImm(void (Riscv64Assembler::*f)(Reg, Imm),
1251 ArrayRef<const Reg> registers,
1252 std::string (Base::*GetName)(const Reg&),
1253 int imm_bits,
1254 int shift,
1255 bool no_zero_imm,
1256 const std::string& fmt) {
1257 auto imms = CreateImmediateValuesBits(abs(imm_bits), /*as_uint=*/imm_bits > 0, shift);
1258
1259 CHECK(f != nullptr);
1260 std::string str;
1261 for (Reg reg : registers) {
1262 for (int64_t imm_raw : imms) {
1263 if (no_zero_imm && imm_raw == 0) {
1264 continue;
1265 }
1266
1267 Imm imm = CreateImmediate(imm_raw);
1268 (GetAssembler()->*f)(reg, imm);
1269
1270 std::string base = fmt;
1271 ReplaceReg(REG_TOKEN, (this->*GetName)(reg), &base);
1272 ReplaceImm(imm, /*bias=*/0, /*multiplier=*/1, &base);
1273 str += base;
1274 str += "\n";
1275 }
1276 }
1277 return str;
1278 }
1279
1280 template <typename Imm>
RepeatCRImm(void (Riscv64Assembler::* f)(XRegister,Imm),bool is_short,bool no_zero_reg,bool no_zero_imm,int imm_bits,int shift,const std::string & fmt)1281 std::string RepeatCRImm(void (Riscv64Assembler::*f)(XRegister, Imm),
1282 bool is_short,
1283 bool no_zero_reg,
1284 bool no_zero_imm,
1285 int imm_bits,
1286 int shift,
1287 const std::string& fmt) {
1288 auto regs = is_short ? GetRegistersShort() : GetRegisters();
1289 if (no_zero_reg) {
1290 CHECK(!is_short);
1291 CHECK_EQ(regs[0], Zero);
1292 regs = regs.SubArray(1);
1293 }
1294 return RepeatCTemplateRegImm(
1295 f, regs, &AssemblerRISCV64Test::GetRegisterName, imm_bits, shift, no_zero_imm, fmt);
1296 }
1297
1298 template <typename Imm>
RepeatCFImm(void (Riscv64Assembler::* f)(FRegister,Imm),int imm_bits,int shift,const std::string & fmt)1299 std::string RepeatCFImm(void (Riscv64Assembler::*f)(FRegister, Imm),
1300 int imm_bits,
1301 int shift,
1302 const std::string& fmt) {
1303 auto regs = GetFPRegisters();
1304 return RepeatCTemplateRegImm(
1305 f, regs, &AssemblerRISCV64Test::GetFPRegName, imm_bits, shift, /*no_zero_imm=*/false, fmt);
1306 }
1307
1308 template <typename Reg1>
RepeatTemplatedShortRegistersImm(void (Riscv64Assembler::* f)(Reg1,XRegister,int32_t),ArrayRef<const Reg1> reg1_registers,std::string (Base::* GetName1)(const Reg1 &),int imm_bits,int shift,bool no_zero_imm,const std::string & fmt)1309 std::string RepeatTemplatedShortRegistersImm(void (Riscv64Assembler::*f)(Reg1,
1310 XRegister,
1311 int32_t),
1312 ArrayRef<const Reg1> reg1_registers,
1313 std::string (Base::*GetName1)(const Reg1&),
1314 int imm_bits,
1315 int shift,
1316 bool no_zero_imm,
1317 const std::string& fmt) {
1318 CHECK(f != nullptr);
1319 auto imms = CreateImmediateValuesBits(abs(imm_bits), imm_bits > 0, shift);
1320 std::string str;
1321 for (Reg1 reg1 : reg1_registers) {
1322 for (XRegister reg2 : GetRegistersShort()) {
1323 for (int64_t imm_raw : imms) {
1324 if (no_zero_imm && imm_raw == 0) {
1325 continue;
1326 }
1327
1328 int32_t imm = CreateImmediate(imm_raw);
1329 (GetAssembler()->*f)(reg1, reg2, imm);
1330
1331 std::string base = fmt;
1332 ReplaceReg(REG1_TOKEN, (this->*GetName1)(reg1), &base);
1333 ReplaceReg(REG2_TOKEN, GetRegisterName(reg2), &base);
1334 ReplaceImm(imm, /*bias=*/0, /*multiplier=*/1, &base);
1335 str += base;
1336 str += "\n";
1337 }
1338 }
1339 }
1340 return str;
1341 }
1342
RepeatCRRImm(void (Riscv64Assembler::* f)(XRegister,XRegister,int32_t),int imm_bits,int shift,const std::string & fmt)1343 std::string RepeatCRRImm(void (Riscv64Assembler::*f)(XRegister, XRegister, int32_t),
1344 int imm_bits,
1345 int shift,
1346 const std::string& fmt) {
1347 return RepeatTemplatedShortRegistersImm(f,
1348 GetRegistersShort(),
1349 &AssemblerRISCV64Test::GetRegisterName,
1350 imm_bits,
1351 shift,
1352 /*no_zero_imm=*/false,
1353 fmt);
1354 }
1355
RepeatCFRImm(void (Riscv64Assembler::* f)(FRegister,XRegister,int32_t),int imm_bits,int shift,const std::string & fmt)1356 std::string RepeatCFRImm(void (Riscv64Assembler::*f)(FRegister, XRegister, int32_t),
1357 int imm_bits,
1358 int shift,
1359 const std::string& fmt) {
1360 return RepeatTemplatedShortRegistersImm(f,
1361 GetFPRegistersShort(),
1362 &AssemblerRISCV64Test::GetFPRegName,
1363 imm_bits,
1364 shift,
1365 /*no_zero_imm=*/false,
1366 fmt);
1367 }
1368
RepeatCRRShort(void (Riscv64Assembler::* f)(XRegister,XRegister),const std::string & fmt)1369 std::string RepeatCRRShort(void (Riscv64Assembler::*f)(XRegister, XRegister),
1370 const std::string& fmt) {
1371 return RepeatTemplatedRegisters(f,
1372 GetRegistersShort(),
1373 GetRegistersShort(),
1374 &AssemblerRISCV64Test::GetRegisterName,
1375 &AssemblerRISCV64Test::GetRegisterName,
1376 fmt);
1377 }
1378
RepeatCRRNonZero(void (Riscv64Assembler::* f)(XRegister,XRegister),const std::string & fmt)1379 std::string RepeatCRRNonZero(void (Riscv64Assembler::*f)(XRegister, XRegister),
1380 const std::string& fmt) {
1381 auto regs = GetRegisters();
1382 CHECK_EQ(regs[0], Zero);
1383 auto regs_no_zero = regs.SubArray(1);
1384 return RepeatTemplatedRegisters(f,
1385 regs_no_zero,
1386 regs_no_zero,
1387 &AssemblerRISCV64Test::GetRegisterName,
1388 &AssemblerRISCV64Test::GetRegisterName,
1389 fmt);
1390 }
1391
RepeatCRShort(void (Riscv64Assembler::* f)(XRegister),const std::string & fmt)1392 std::string RepeatCRShort(void (Riscv64Assembler::*f)(XRegister), const std::string& fmt) {
1393 return RepeatTemplatedRegister(
1394 f, GetRegistersShort(), &AssemblerRISCV64Test::GetRegisterName, fmt);
1395 }
1396
1397 template <typename Imm>
RepeatImm(void (Riscv64Assembler::* f)(Imm),bool no_zero_imm,int imm_bits,int shift,const std::string & fmt)1398 std::string RepeatImm(void (Riscv64Assembler::*f)(Imm),
1399 bool no_zero_imm,
1400 int imm_bits,
1401 int shift,
1402 const std::string& fmt) {
1403 auto imms = CreateImmediateValuesBits(abs(imm_bits), imm_bits > 0, shift);
1404 std::string str;
1405 for (int64_t imm_raw : imms) {
1406 if (no_zero_imm && imm_raw == 0) {
1407 continue;
1408 }
1409
1410 Imm imm = CreateImmediate(imm_raw);
1411 (GetAssembler()->*f)(imm);
1412
1413 std::string base = fmt;
1414 ReplaceImm(imm, /*bias=*/0, /*multiplier=*/1, &base);
1415 str += base;
1416 str += "\n";
1417 }
1418
1419 return str;
1420 }
1421
RepeatRNoZero(void (Riscv64Assembler::* f)(XRegister),const std::string & fmt)1422 std::string RepeatRNoZero(void (Riscv64Assembler::*f)(XRegister), const std::string& fmt) {
1423 auto regs = GetRegisters();
1424 CHECK_EQ(regs[0], Zero);
1425 return RepeatTemplatedRegister(
1426 f, regs.SubArray(1), &AssemblerRISCV64Test::GetRegisterName, fmt);
1427 }
1428
1429 template <typename Reg1, typename Reg2>
RepeatTemplatedRegistersRoundingMode(void (Riscv64Assembler::* f)(Reg1,Reg2,FPRoundingMode),ArrayRef<const Reg1> reg1_registers,ArrayRef<const Reg2> reg2_registers,std::string (Base::* GetName1)(const Reg1 &),std::string (Base::* GetName2)(const Reg2 &),const std::string & fmt)1430 std::string RepeatTemplatedRegistersRoundingMode(
1431 void (Riscv64Assembler::*f)(Reg1, Reg2, FPRoundingMode),
1432 ArrayRef<const Reg1> reg1_registers,
1433 ArrayRef<const Reg2> reg2_registers,
1434 std::string (Base::*GetName1)(const Reg1&),
1435 std::string (Base::*GetName2)(const Reg2&),
1436 const std::string& fmt) {
1437 CHECK(f != nullptr);
1438 std::string str;
1439 for (Reg1 reg1 : reg1_registers) {
1440 for (Reg2 reg2 : reg2_registers) {
1441 for (FPRoundingMode rm : kRoundingModes) {
1442 (GetAssembler()->*f)(reg1, reg2, rm);
1443
1444 std::string base = fmt;
1445 ReplaceReg(REG1_TOKEN, (this->*GetName1)(reg1), &base);
1446 ReplaceReg(REG2_TOKEN, (this->*GetName2)(reg2), &base);
1447 ReplaceRoundingMode(rm, &base);
1448 str += base;
1449 str += "\n";
1450 }
1451 }
1452 }
1453 return str;
1454 }
1455
RepeatFFRoundingMode(void (Riscv64Assembler::* f)(FRegister,FRegister,FPRoundingMode),const std::string & fmt)1456 std::string RepeatFFRoundingMode(
1457 void (Riscv64Assembler::*f)(FRegister, FRegister, FPRoundingMode),
1458 const std::string& fmt) {
1459 return RepeatTemplatedRegistersRoundingMode(f,
1460 GetFPRegisters(),
1461 GetFPRegisters(),
1462 &AssemblerRISCV64Test::GetFPRegName,
1463 &AssemblerRISCV64Test::GetFPRegName,
1464 fmt);
1465 }
1466
RepeatrFRoundingMode(void (Riscv64Assembler::* f)(XRegister,FRegister,FPRoundingMode),const std::string & fmt)1467 std::string RepeatrFRoundingMode(
1468 void (Riscv64Assembler::*f)(XRegister, FRegister, FPRoundingMode),
1469 const std::string& fmt) {
1470 return RepeatTemplatedRegistersRoundingMode(f,
1471 GetRegisters(),
1472 GetFPRegisters(),
1473 &Base::GetSecondaryRegisterName,
1474 &AssemblerRISCV64Test::GetFPRegName,
1475 fmt);
1476 }
1477
RepeatFrRoundingMode(void (Riscv64Assembler::* f)(FRegister,XRegister,FPRoundingMode),const std::string & fmt)1478 std::string RepeatFrRoundingMode(
1479 void (Riscv64Assembler::*f)(FRegister, XRegister, FPRoundingMode),
1480 const std::string& fmt) {
1481 return RepeatTemplatedRegistersRoundingMode(f,
1482 GetFPRegisters(),
1483 GetRegisters(),
1484 &AssemblerRISCV64Test::GetFPRegName,
1485 &Base::GetSecondaryRegisterName,
1486 fmt);
1487 }
1488
1489 template <typename InvalidAqRl>
RepeatRRAqRl(void (Riscv64Assembler::* f)(XRegister,XRegister,AqRl),const std::string & fmt,InvalidAqRl && invalid_aqrl)1490 std::string RepeatRRAqRl(void (Riscv64Assembler::*f)(XRegister, XRegister, AqRl),
1491 const std::string& fmt,
1492 InvalidAqRl&& invalid_aqrl) {
1493 CHECK(f != nullptr);
1494 std::string str;
1495 for (XRegister reg1 : GetRegisters()) {
1496 for (XRegister reg2 : GetRegisters()) {
1497 for (AqRl aqrl : kAqRls) {
1498 if (invalid_aqrl(aqrl)) {
1499 continue;
1500 }
1501 (GetAssembler()->*f)(reg1, reg2, aqrl);
1502
1503 std::string base = fmt;
1504 ReplaceReg(REG1_TOKEN, GetRegisterName(reg1), &base);
1505 ReplaceReg(REG2_TOKEN, GetRegisterName(reg2), &base);
1506 ReplaceAqRl(aqrl, &base);
1507 str += base;
1508 str += "\n";
1509 }
1510 }
1511 }
1512 return str;
1513 }
1514
1515 template <typename InvalidAqRl>
RepeatRRRAqRl(void (Riscv64Assembler::* f)(XRegister,XRegister,XRegister,AqRl),const std::string & fmt,InvalidAqRl && invalid_aqrl)1516 std::string RepeatRRRAqRl(void (Riscv64Assembler::*f)(XRegister, XRegister, XRegister, AqRl),
1517 const std::string& fmt,
1518 InvalidAqRl&& invalid_aqrl) {
1519 CHECK(f != nullptr);
1520 std::string str;
1521 ArrayRef<const XRegister> regs = GetRegisters();
1522 for (XRegister reg1 : regs) {
1523 std::string base1 = fmt;
1524 ReplaceReg(REG1_TOKEN, GetRegisterName(reg1), &base1);
1525 for (XRegister reg2 : regs) {
1526 std::string base2 = base1;
1527 ReplaceReg(REG2_TOKEN, GetRegisterName(reg2), &base2);
1528 for (XRegister reg3 : regs) {
1529 std::string base3 = base2;
1530 ReplaceReg(REG3_TOKEN, GetRegisterName(reg3), &base3);
1531 for (AqRl aqrl : kAqRls) {
1532 if (invalid_aqrl(aqrl)) {
1533 continue;
1534 }
1535 (GetAssembler()->*f)(reg1, reg2, reg3, aqrl);
1536
1537 std::string base = base3;
1538 ReplaceAqRl(aqrl, &base);
1539 str += base;
1540 str += "\n";
1541 }
1542 }
1543 }
1544 }
1545 return str;
1546 }
1547
RepeatRRRAqRl(void (Riscv64Assembler::* f)(XRegister,XRegister,XRegister,AqRl),const std::string & fmt)1548 std::string RepeatRRRAqRl(void (Riscv64Assembler::*f)(XRegister, XRegister, XRegister, AqRl),
1549 const std::string& fmt) {
1550 return RepeatRRRAqRl(f, fmt, [](AqRl) { return false; });
1551 }
1552
RepeatCsrrX(void (Riscv64Assembler::* f)(XRegister,uint32_t,XRegister),const std::string & fmt)1553 std::string RepeatCsrrX(void (Riscv64Assembler::*f)(XRegister, uint32_t, XRegister),
1554 const std::string& fmt) {
1555 CHECK(f != nullptr);
1556 std::vector<int64_t> csrs = CreateImmediateValuesBits(12, /*as_uint=*/ true);
1557 std::string str;
1558 for (XRegister reg1 : GetRegisters()) {
1559 for (int64_t csr : csrs) {
1560 for (XRegister reg2 : GetRegisters()) {
1561 (GetAssembler()->*f)(reg1, dchecked_integral_cast<uint32_t>(csr), reg2);
1562
1563 std::string base = fmt;
1564 ReplaceReg(REG1_TOKEN, GetRegisterName(reg1), &base);
1565 ReplaceCsrrImm(CSR_TOKEN, csr, &base);
1566 ReplaceReg(REG2_TOKEN, GetRegisterName(reg2), &base);
1567 str += base;
1568 str += "\n";
1569 }
1570 }
1571 }
1572 return str;
1573 }
1574
RepeatCsrrXi(void (Riscv64Assembler::* f)(XRegister,uint32_t,uint32_t),const std::string & fmt)1575 std::string RepeatCsrrXi(void (Riscv64Assembler::*f)(XRegister, uint32_t, uint32_t),
1576 const std::string& fmt) {
1577 CHECK(f != nullptr);
1578 std::vector<int64_t> csrs = CreateImmediateValuesBits(12, /*as_uint=*/ true);
1579 std::vector<int64_t> uimms = CreateImmediateValuesBits(2, /*as_uint=*/ true);
1580 std::string str;
1581 for (XRegister reg : GetRegisters()) {
1582 for (int64_t csr : csrs) {
1583 for (int64_t uimm : uimms) {
1584 (GetAssembler()->*f)(
1585 reg, dchecked_integral_cast<uint32_t>(csr), dchecked_integral_cast<uint32_t>(uimm));
1586
1587 std::string base = fmt;
1588 ReplaceReg(REG_TOKEN, GetRegisterName(reg), &base);
1589 ReplaceCsrrImm(CSR_TOKEN, csr, &base);
1590 ReplaceCsrrImm(UIMM_TOKEN, uimm, &base);
1591 str += base;
1592 str += "\n";
1593 }
1594 }
1595 }
1596 return str;
1597 }
1598
RepeatVRAligned(void (Riscv64Assembler::* f)(VRegister,XRegister),uint32_t alignment,const std::string & fmt)1599 std::string RepeatVRAligned(void (Riscv64Assembler::*f)(VRegister, XRegister),
1600 uint32_t alignment,
1601 const std::string& fmt) {
1602 WarnOnCombinations(GetVectorRegisters().size() * GetRegisters().size());
1603 CHECK(f != nullptr);
1604
1605 std::string str;
1606 for (auto reg1 : GetVectorRegisters()) {
1607 for (auto reg2 : GetRegisters()) {
1608 if ((static_cast<uint32_t>(reg1) % alignment) != 0) {
1609 continue;
1610 }
1611
1612 (GetAssembler()->*f)(reg1, reg2);
1613 std::string base = fmt;
1614
1615 ReplaceReg(REG1_TOKEN, GetVecRegName(reg1), &base);
1616 ReplaceReg(REG2_TOKEN, GetRegisterName(reg2), &base);
1617
1618 str += base;
1619 str += "\n";
1620 }
1621 }
1622 return str;
1623 }
1624
RepeatVVAligned(void (Riscv64Assembler::* f)(VRegister,VRegister),uint32_t alignment,const std::string & fmt)1625 std::string RepeatVVAligned(void (Riscv64Assembler::*f)(VRegister, VRegister),
1626 uint32_t alignment,
1627 const std::string& fmt) {
1628 WarnOnCombinations(GetVectorRegisters().size() * GetRegisters().size());
1629 CHECK(f != nullptr);
1630
1631 std::string str;
1632 for (auto reg1 : GetVectorRegisters()) {
1633 if ((static_cast<uint32_t>(reg1) % alignment) != 0) {
1634 continue;
1635 }
1636 for (auto reg2 : GetVectorRegisters()) {
1637 if ((static_cast<uint32_t>(reg2) % alignment) != 0) {
1638 continue;
1639 }
1640
1641 (GetAssembler()->*f)(reg1, reg2);
1642 std::string base = fmt;
1643
1644 ReplaceReg(REG1_TOKEN, GetVecRegName(reg1), &base);
1645 ReplaceReg(REG2_TOKEN, GetVecRegName(reg2), &base);
1646
1647 str += base;
1648 str += "\n";
1649 }
1650 }
1651 return str;
1652 }
1653
1654 template <typename Reg1, typename Reg2, typename Reg3, typename Predicate>
RepeatTemplatedRegistersVmFiltered(void (Riscv64Assembler::* f)(Reg1,Reg2,Reg3,Riscv64Assembler::VM),ArrayRef<const Reg1> reg1_registers,ArrayRef<const Reg2> reg2_registers,ArrayRef<const Reg3> reg3_registers,std::string (AssemblerTest::* GetName1)(const Reg1 &),std::string (AssemblerTest::* GetName2)(const Reg2 &),std::string (AssemblerTest::* GetName3)(const Reg3 &),Predicate && pred,const std::string & fmt)1655 std::string RepeatTemplatedRegistersVmFiltered(
1656 void (Riscv64Assembler::*f)(Reg1, Reg2, Reg3, Riscv64Assembler::VM),
1657 ArrayRef<const Reg1> reg1_registers,
1658 ArrayRef<const Reg2> reg2_registers,
1659 ArrayRef<const Reg3> reg3_registers,
1660 std::string (AssemblerTest::*GetName1)(const Reg1&),
1661 std::string (AssemblerTest::*GetName2)(const Reg2&),
1662 std::string (AssemblerTest::*GetName3)(const Reg3&),
1663 Predicate&& pred,
1664 const std::string& fmt) {
1665 WarnOnCombinations(reg1_registers.size() * reg2_registers.size() * reg3_registers.size());
1666 CHECK(f != nullptr);
1667
1668 std::string str;
1669 for (auto reg1 : reg1_registers) {
1670 std::string base1 = fmt;
1671 ReplaceReg(REG1_TOKEN, (this->*GetName1)(reg1), &base1);
1672 for (auto reg2 : reg2_registers) {
1673 std::string base2 = base1;
1674 ReplaceReg(REG2_TOKEN, (this->*GetName2)(reg2), &base2);
1675 for (auto reg3 : reg3_registers) {
1676 std::string base3 = base2;
1677 ReplaceReg(REG3_TOKEN, (this->*GetName3)(reg3), &base3);
1678 for (Riscv64Assembler::VM vm : kVMs) {
1679 if (!pred(reg1, reg2, reg3, vm)) {
1680 continue;
1681 }
1682
1683 (GetAssembler()->*f)(reg1, reg2, reg3, vm);
1684 std::string base = base3;
1685
1686 ReplaceVm(vm, &base);
1687
1688 str += base;
1689 str += "\n";
1690 }
1691 }
1692 }
1693 }
1694 return str;
1695 }
1696
1697 template <typename Predicate>
RepeatVRRVmFiltered(void (Riscv64Assembler::* f)(VRegister,XRegister,XRegister,Riscv64Assembler::VM),const std::string & fmt,Predicate && pred)1698 std::string RepeatVRRVmFiltered(
1699 void (Riscv64Assembler::*f)(VRegister, XRegister, XRegister, Riscv64Assembler::VM),
1700 const std::string& fmt,
1701 Predicate&& pred) {
1702 return RepeatTemplatedRegistersVmFiltered(f,
1703 GetVectorRegisters(),
1704 GetRegisters(),
1705 GetRegisters(),
1706 &AssemblerRISCV64Test::GetVecRegName,
1707 &AssemblerRISCV64Test::GetRegisterName,
1708 &AssemblerRISCV64Test::GetRegisterName,
1709 std::forward<Predicate>(pred),
1710 fmt);
1711 }
1712
RepeatVRRVm(void (Riscv64Assembler::* f)(VRegister,XRegister,XRegister,Riscv64Assembler::VM),const std::string & fmt)1713 std::string RepeatVRRVm(
1714 void (Riscv64Assembler::*f)(VRegister, XRegister, XRegister, Riscv64Assembler::VM),
1715 const std::string& fmt) {
1716 return RepeatVRRVmFiltered(
1717 f, fmt, [](VRegister, XRegister, XRegister, Riscv64Assembler::VM) { return true; });
1718 }
1719
1720 template <typename Predicate>
RepeatVVRVmFiltered(void (Riscv64Assembler::* f)(VRegister,VRegister,XRegister,Riscv64Assembler::VM),const std::string & fmt,Predicate && pred)1721 std::string RepeatVVRVmFiltered(
1722 void (Riscv64Assembler::*f)(VRegister, VRegister, XRegister, Riscv64Assembler::VM),
1723 const std::string& fmt,
1724 Predicate&& pred) {
1725 return RepeatTemplatedRegistersVmFiltered(f,
1726 GetVectorRegisters(),
1727 GetVectorRegisters(),
1728 GetRegisters(),
1729 &AssemblerRISCV64Test::GetVecRegName,
1730 &AssemblerRISCV64Test::GetVecRegName,
1731 &AssemblerRISCV64Test::GetRegisterName,
1732 std::forward<Predicate>(pred),
1733 fmt);
1734 }
1735
1736 template <typename Predicate>
RepeatVRVVmFiltered(void (Riscv64Assembler::* f)(VRegister,XRegister,VRegister,Riscv64Assembler::VM),const std::string & fmt,Predicate && pred)1737 std::string RepeatVRVVmFiltered(
1738 void (Riscv64Assembler::*f)(VRegister, XRegister, VRegister, Riscv64Assembler::VM),
1739 const std::string& fmt,
1740 Predicate&& pred) {
1741 return RepeatTemplatedRegistersVmFiltered(f,
1742 GetVectorRegisters(),
1743 GetRegisters(),
1744 GetVectorRegisters(),
1745 &AssemblerRISCV64Test::GetVecRegName,
1746 &AssemblerRISCV64Test::GetRegisterName,
1747 &AssemblerRISCV64Test::GetVecRegName,
1748 std::forward<Predicate>(pred),
1749 fmt);
1750 }
1751
RepeatVRVVm(void (Riscv64Assembler::* f)(VRegister,XRegister,VRegister,Riscv64Assembler::VM),const std::string & fmt)1752 std::string RepeatVRVVm(
1753 void (Riscv64Assembler::*f)(VRegister, XRegister, VRegister, Riscv64Assembler::VM),
1754 const std::string& fmt) {
1755 return RepeatVRVVmFiltered(
1756 f, fmt, [](VRegister, XRegister, VRegister, Riscv64Assembler::VM) { return true; });
1757 }
1758
1759 template <typename Predicate>
RepeatVVVVmFiltered(void (Riscv64Assembler::* f)(VRegister,VRegister,VRegister,Riscv64Assembler::VM),const std::string & fmt,Predicate && pred)1760 std::string RepeatVVVVmFiltered(
1761 void (Riscv64Assembler::*f)(VRegister, VRegister, VRegister, Riscv64Assembler::VM),
1762 const std::string& fmt,
1763 Predicate&& pred) {
1764 return RepeatTemplatedRegistersVmFiltered(f,
1765 GetVectorRegisters(),
1766 GetVectorRegisters(),
1767 GetVectorRegisters(),
1768 &AssemblerRISCV64Test::GetVecRegName,
1769 &AssemblerRISCV64Test::GetVecRegName,
1770 &AssemblerRISCV64Test::GetVecRegName,
1771 std::forward<Predicate>(pred),
1772 fmt);
1773 }
1774
RepeatVVVVm(void (Riscv64Assembler::* f)(VRegister,VRegister,VRegister,Riscv64Assembler::VM),const std::string & fmt)1775 std::string RepeatVVVVm(
1776 void (Riscv64Assembler::*f)(VRegister, VRegister, VRegister, Riscv64Assembler::VM),
1777 const std::string& fmt) {
1778 return RepeatVVVVmFiltered(
1779 f, fmt, [](VRegister, VRegister, VRegister, Riscv64Assembler::VM) { return true; });
1780 }
1781
1782 template <typename Predicate>
RepeatVVFVmFiltered(void (Riscv64Assembler::* f)(VRegister,VRegister,FRegister,Riscv64Assembler::VM),const std::string & fmt,Predicate && pred)1783 std::string RepeatVVFVmFiltered(
1784 void (Riscv64Assembler::*f)(VRegister, VRegister, FRegister, Riscv64Assembler::VM),
1785 const std::string& fmt,
1786 Predicate&& pred) {
1787 return RepeatTemplatedRegistersVmFiltered(f,
1788 GetVectorRegisters(),
1789 GetVectorRegisters(),
1790 GetFPRegisters(),
1791 &AssemblerRISCV64Test::GetVecRegName,
1792 &AssemblerRISCV64Test::GetVecRegName,
1793 &AssemblerRISCV64Test::GetFPRegName,
1794 std::forward<Predicate>(pred),
1795 fmt);
1796 }
1797
1798 template <typename Predicate>
RepeatVFVVmFiltered(void (Riscv64Assembler::* f)(VRegister,FRegister,VRegister,Riscv64Assembler::VM),const std::string & fmt,Predicate && pred)1799 std::string RepeatVFVVmFiltered(
1800 void (Riscv64Assembler::*f)(VRegister, FRegister, VRegister, Riscv64Assembler::VM),
1801 const std::string& fmt,
1802 Predicate&& pred) {
1803 return RepeatTemplatedRegistersVmFiltered(f,
1804 GetVectorRegisters(),
1805 GetFPRegisters(),
1806 GetVectorRegisters(),
1807 &AssemblerRISCV64Test::GetVecRegName,
1808 &AssemblerRISCV64Test::GetFPRegName,
1809 &AssemblerRISCV64Test::GetVecRegName,
1810 std::forward<Predicate>(pred),
1811 fmt);
1812 }
1813
1814 template <typename Reg1, typename Reg2, typename Reg3, typename Predicate>
RepeatTemplatedRegistersFiltered(void (Riscv64Assembler::* f)(Reg1,Reg2,Reg3),ArrayRef<const Reg1> reg1_registers,ArrayRef<const Reg2> reg2_registers,ArrayRef<const Reg3> reg3_registers,std::string (AssemblerTest::* GetName1)(const Reg1 &),std::string (AssemblerTest::* GetName2)(const Reg2 &),std::string (AssemblerTest::* GetName3)(const Reg3 &),Predicate && pred,const std::string & fmt)1815 std::string RepeatTemplatedRegistersFiltered(void (Riscv64Assembler::*f)(Reg1, Reg2, Reg3),
1816 ArrayRef<const Reg1> reg1_registers,
1817 ArrayRef<const Reg2> reg2_registers,
1818 ArrayRef<const Reg3> reg3_registers,
1819 std::string (AssemblerTest::*GetName1)(const Reg1&),
1820 std::string (AssemblerTest::*GetName2)(const Reg2&),
1821 std::string (AssemblerTest::*GetName3)(const Reg3&),
1822 Predicate&& pred,
1823 const std::string& fmt) {
1824 WarnOnCombinations(reg1_registers.size() * reg2_registers.size() * reg3_registers.size());
1825 CHECK(f != nullptr);
1826
1827 std::string str;
1828 for (auto reg1 : reg1_registers) {
1829 for (auto reg2 : reg2_registers) {
1830 for (auto reg3 : reg3_registers) {
1831 if (!pred(reg1, reg2, reg3)) {
1832 continue;
1833 }
1834
1835 (GetAssembler()->*f)(reg1, reg2, reg3);
1836 std::string base = fmt;
1837
1838 ReplaceReg(REG1_TOKEN, (this->*GetName1)(reg1), &base);
1839 ReplaceReg(REG2_TOKEN, (this->*GetName2)(reg2), &base);
1840 ReplaceReg(REG3_TOKEN, (this->*GetName3)(reg3), &base);
1841
1842 str += base;
1843 str += "\n";
1844 }
1845 }
1846 }
1847 return str;
1848 }
1849
1850 template <typename Predicate>
RepeatVVRFiltered(void (Riscv64Assembler::* f)(VRegister,VRegister,XRegister),const std::string & fmt,Predicate && pred)1851 std::string RepeatVVRFiltered(void (Riscv64Assembler::*f)(VRegister, VRegister, XRegister),
1852 const std::string& fmt,
1853 Predicate&& pred) {
1854 return RepeatTemplatedRegistersFiltered(f,
1855 GetVectorRegisters(),
1856 GetVectorRegisters(),
1857 GetRegisters(),
1858 &AssemblerRISCV64Test::GetVecRegName,
1859 &AssemblerRISCV64Test::GetVecRegName,
1860 &AssemblerRISCV64Test::GetRegisterName,
1861 std::forward<Predicate>(pred),
1862 fmt);
1863 }
1864
1865 template <typename Predicate>
RepeatVVVFiltered(void (Riscv64Assembler::* f)(VRegister,VRegister,VRegister),const std::string & fmt,Predicate && pred)1866 std::string RepeatVVVFiltered(void (Riscv64Assembler::*f)(VRegister, VRegister, VRegister),
1867 const std::string& fmt,
1868 Predicate&& pred) {
1869 return RepeatTemplatedRegistersFiltered(f,
1870 GetVectorRegisters(),
1871 GetVectorRegisters(),
1872 GetVectorRegisters(),
1873 &AssemblerRISCV64Test::GetVecRegName,
1874 &AssemblerRISCV64Test::GetVecRegName,
1875 &AssemblerRISCV64Test::GetVecRegName,
1876 std::forward<Predicate>(pred),
1877 fmt);
1878 }
1879
1880 template <typename Predicate>
RepeatVVFFiltered(void (Riscv64Assembler::* f)(VRegister,VRegister,FRegister),const std::string & fmt,Predicate && pred)1881 std::string RepeatVVFFiltered(void (Riscv64Assembler::*f)(VRegister, VRegister, FRegister),
1882 const std::string& fmt,
1883 Predicate&& pred) {
1884 return RepeatTemplatedRegistersFiltered(f,
1885 GetVectorRegisters(),
1886 GetVectorRegisters(),
1887 GetFPRegisters(),
1888 &AssemblerRISCV64Test::GetVecRegName,
1889 &AssemblerRISCV64Test::GetVecRegName,
1890 &AssemblerRISCV64Test::GetFPRegName,
1891 std::forward<Predicate>(pred),
1892 fmt);
1893 }
1894
1895 template <typename Predicate, typename ImmType>
RepeatVVIFiltered(void (Riscv64Assembler::* f)(VRegister,VRegister,ImmType),int imm_bits,const std::string & fmt,Predicate && pred)1896 std::string RepeatVVIFiltered(void (Riscv64Assembler::*f)(VRegister, VRegister, ImmType),
1897 int imm_bits,
1898 const std::string& fmt,
1899 Predicate&& pred) {
1900 CHECK(f != nullptr);
1901 std::string str;
1902 std::vector<int64_t> imms = CreateImmediateValuesBits(abs(imm_bits), (imm_bits > 0));
1903
1904 WarnOnCombinations(GetVectorRegisters().size() * GetVectorRegisters().size() * imms.size());
1905
1906 for (VRegister reg1 : GetVectorRegisters()) {
1907 for (VRegister reg2 : GetVectorRegisters()) {
1908 for (int64_t imm : imms) {
1909 ImmType new_imm = CreateImmediate(imm);
1910
1911 if (!pred(reg1, reg2, new_imm)) {
1912 continue;
1913 }
1914
1915 (GetAssembler()->*f)(reg1, reg2, new_imm);
1916
1917 std::string base = fmt;
1918 ReplaceReg(REG1_TOKEN, GetVecRegName(reg1), &base);
1919 ReplaceReg(REG2_TOKEN, GetVecRegName(reg2), &base);
1920 ReplaceImm(imm, /*bias=*/ 0, /*multiplier=*/ 1, &base);
1921 str += base;
1922 str += "\n";
1923 }
1924 }
1925 }
1926 return str;
1927 }
1928
1929 template <typename Predicate, typename ImmType>
RepeatVVIbVmFiltered(void (Riscv64Assembler::* f)(VRegister,VRegister,ImmType,Riscv64Assembler::VM),int imm_bits,const std::string & fmt,Predicate && pred,ImmType bias=0)1930 std::string RepeatVVIbVmFiltered(
1931 void (Riscv64Assembler::*f)(VRegister, VRegister, ImmType, Riscv64Assembler::VM),
1932 int imm_bits,
1933 const std::string& fmt,
1934 Predicate&& pred,
1935 ImmType bias = 0) {
1936 CHECK(f != nullptr);
1937 std::string str;
1938 std::vector<int64_t> imms = CreateImmediateValuesBits(abs(imm_bits), (imm_bits > 0));
1939
1940 WarnOnCombinations(2 * GetVectorRegisters().size() * GetVectorRegisters().size() * imms.size());
1941
1942 ArrayRef<const VRegister> vector_regs = GetVectorRegisters();
1943 for (auto reg1 : vector_regs) {
1944 std::string base1 = fmt;
1945 ReplaceReg(REG1_TOKEN, GetVecRegName(reg1), &base1);
1946 for (auto reg2 : vector_regs) {
1947 std::string base2 = base1;
1948 ReplaceReg(REG2_TOKEN, GetVecRegName(reg2), &base2);
1949 for (int64_t imm : imms) {
1950 std::string base3 = base2;
1951 ReplaceImm(imm, bias, /*multiplier=*/ 1, &base3);
1952 for (Riscv64Assembler::VM vm : kVMs) {
1953 if (!pred(reg1, reg2, imm, vm)) {
1954 continue;
1955 }
1956
1957 ImmType new_imm = CreateImmediate(imm) + bias;
1958 (GetAssembler()->*f)(reg1, reg2, new_imm, vm);
1959
1960 std::string base = base3;
1961 ReplaceVm(vm, &base);
1962 str += base;
1963 str += "\n";
1964 }
1965 }
1966 }
1967 }
1968 return str;
1969 }
1970
1971 template <typename Reg1, typename Reg2, typename Predicate>
RepeatTemplatedRegistersVmFiltered(void (Riscv64Assembler::* f)(Reg1,Reg2,Riscv64Assembler::VM),ArrayRef<const Reg1> reg1_registers,ArrayRef<const Reg2> reg2_registers,std::string (AssemblerTest::* GetName1)(const Reg1 &),std::string (AssemblerTest::* GetName2)(const Reg2 &),Predicate && pred,const std::string & fmt)1972 std::string RepeatTemplatedRegistersVmFiltered(
1973 void (Riscv64Assembler::*f)(Reg1, Reg2, Riscv64Assembler::VM),
1974 ArrayRef<const Reg1> reg1_registers,
1975 ArrayRef<const Reg2> reg2_registers,
1976 std::string (AssemblerTest::*GetName1)(const Reg1&),
1977 std::string (AssemblerTest::*GetName2)(const Reg2&),
1978 Predicate&& pred,
1979 const std::string& fmt) {
1980 CHECK(f != nullptr);
1981
1982 WarnOnCombinations(2 * reg2_registers.size() * reg1_registers.size());
1983
1984 std::string str;
1985 for (auto reg1 : reg1_registers) {
1986 for (auto reg2 : reg2_registers) {
1987 for (Riscv64Assembler::VM vm : kVMs) {
1988 if (!pred(reg1, reg2, vm)) {
1989 continue;
1990 }
1991
1992 (GetAssembler()->*f)(reg1, reg2, vm);
1993 std::string base = fmt;
1994
1995 ReplaceReg(REG1_TOKEN, (this->*GetName1)(reg1), &base);
1996 ReplaceReg(REG2_TOKEN, (this->*GetName2)(reg2), &base);
1997 ReplaceVm(vm, &base);
1998
1999 str += base;
2000 str += "\n";
2001 }
2002 }
2003 }
2004 return str;
2005 }
2006
2007 template <typename Predicate>
RepeatRVVmFiltered(void (Riscv64Assembler::* f)(XRegister,VRegister,Riscv64Assembler::VM),const std::string & fmt,Predicate && pred)2008 std::string RepeatRVVmFiltered(void (Riscv64Assembler::*f)(XRegister,
2009 VRegister,
2010 Riscv64Assembler::VM),
2011 const std::string& fmt,
2012 Predicate&& pred) {
2013 return RepeatTemplatedRegistersVmFiltered(f,
2014 GetRegisters(),
2015 GetVectorRegisters(),
2016 &AssemblerRISCV64Test::GetRegisterName,
2017 &AssemblerRISCV64Test::GetVecRegName,
2018 std::forward<Predicate>(pred),
2019 fmt);
2020 }
2021
RepeatRVVm(void (Riscv64Assembler::* f)(XRegister,VRegister,Riscv64Assembler::VM vm),const std::string & fmt)2022 std::string RepeatRVVm(void (Riscv64Assembler::*f)(XRegister, VRegister, Riscv64Assembler::VM vm),
2023 const std::string& fmt) {
2024 return RepeatRVVmFiltered(
2025 f, fmt, [](XRegister, VRegister, Riscv64Assembler::VM) { return true; });
2026 }
2027
2028 template <typename Predicate>
RepeatVRVmFiltered(void (Riscv64Assembler::* f)(VRegister,XRegister,Riscv64Assembler::VM),const std::string & fmt,Predicate && pred)2029 std::string RepeatVRVmFiltered(void (Riscv64Assembler::*f)(VRegister,
2030 XRegister,
2031 Riscv64Assembler::VM),
2032 const std::string& fmt,
2033 Predicate&& pred) {
2034 return RepeatTemplatedRegistersVmFiltered(f,
2035 GetVectorRegisters(),
2036 GetRegisters(),
2037 &AssemblerRISCV64Test::GetVecRegName,
2038 &AssemblerRISCV64Test::GetRegisterName,
2039 std::forward<Predicate>(pred),
2040 fmt);
2041 }
2042
RepeatVRVm(void (Riscv64Assembler::* f)(VRegister,XRegister,Riscv64Assembler::VM),const std::string & fmt)2043 std::string RepeatVRVm(void (Riscv64Assembler::*f)(VRegister, XRegister, Riscv64Assembler::VM),
2044 const std::string& fmt) {
2045 return RepeatVRVmFiltered(
2046 f, fmt, [](VRegister, XRegister, Riscv64Assembler::VM) { return true; });
2047 }
2048
2049 template <typename Predicate>
RepeatVVVmFiltered(void (Riscv64Assembler::* f)(VRegister,VRegister,Riscv64Assembler::VM),const std::string & fmt,Predicate && pred)2050 std::string RepeatVVVmFiltered(void (Riscv64Assembler::*f)(VRegister,
2051 VRegister,
2052 Riscv64Assembler::VM),
2053 const std::string& fmt,
2054 Predicate&& pred) {
2055 return RepeatTemplatedRegistersVmFiltered(f,
2056 GetVectorRegisters(),
2057 GetVectorRegisters(),
2058 &AssemblerRISCV64Test::GetVecRegName,
2059 &AssemblerRISCV64Test::GetVecRegName,
2060 std::forward<Predicate>(pred),
2061 fmt);
2062 }
2063
2064 template <typename Predicate>
RepeatVVmFiltered(void (Riscv64Assembler::* f)(VRegister,Riscv64Assembler::VM),const std::string & fmt,Predicate && pred)2065 std::string RepeatVVmFiltered(void (Riscv64Assembler::*f)(VRegister, Riscv64Assembler::VM),
2066 const std::string& fmt,
2067 Predicate&& pred) {
2068 WarnOnCombinations(2 * GetVectorRegisters().size());
2069 CHECK(f != nullptr);
2070 std::string str;
2071 for (VRegister reg1 : GetVectorRegisters()) {
2072 for (Riscv64Assembler::VM vm : kVMs) {
2073 if (!pred(reg1, vm)) {
2074 continue;
2075 }
2076
2077 (GetAssembler()->*f)(reg1, vm);
2078
2079 std::string base = fmt;
2080 ReplaceReg(REG_TOKEN, GetVecRegName(reg1), &base);
2081 ReplaceVm(vm, &base);
2082 str += base;
2083 str += "\n";
2084 }
2085 }
2086 return str;
2087 }
2088
IsVdAllowed(VRegister vd,Riscv64Assembler::VM vm)2089 static constexpr bool IsVdAllowed(VRegister vd, Riscv64Assembler::VM vm) {
2090 return vm != Riscv64Assembler::VM::kV0_t || vd != V0;
2091 }
2092
2093 template <typename Reg2>
VXVVmSkipV0VmAndNoR1R3Overlap()2094 auto VXVVmSkipV0VmAndNoR1R3Overlap() {
2095 return [](VRegister vd, Reg2, VRegister vs1, Riscv64Assembler::VM vm) {
2096 return IsVdAllowed(vd, vm) && vd != vs1;
2097 };
2098 }
2099
2100 template <typename Reg3>
VXVVmSkipV0VmAndNoR1R2Overlap()2101 auto VXVVmSkipV0VmAndNoR1R2Overlap() {
2102 return [](VRegister vd, VRegister vs2, Reg3, Riscv64Assembler::VM vm) {
2103 return IsVdAllowed(vd, vm) && vd != vs2;
2104 };
2105 }
2106
VXVVmSkipV0VmAndNoR1R2R3Overlap()2107 auto VXVVmSkipV0VmAndNoR1R2R3Overlap() {
2108 return [](VRegister vd, VRegister vs2, VRegister vs1, Riscv64Assembler::VM vm) {
2109 return IsVdAllowed(vd, vm) && vd != vs1 && vd != vs2;
2110 };
2111 }
2112
VVVmSkipV0VmAndNoR1R2Overlap()2113 auto VVVmSkipV0VmAndNoR1R2Overlap() {
2114 return [](VRegister vd, VRegister vs2, Riscv64Assembler::VM vm) {
2115 return IsVdAllowed(vd, vm) && vd != vs2;
2116 };
2117 }
2118
2119 template <typename Reg2, typename Reg3>
SkipV0Vm()2120 auto SkipV0Vm() {
2121 return [](VRegister vd, Reg2, Reg3, Riscv64Assembler::VM vm) { return IsVdAllowed(vd, vm); };
2122 }
2123
2124 template <typename Reg2>
SkipV0Vm()2125 auto SkipV0Vm() {
2126 return [](VRegister vd, Reg2, Riscv64Assembler::VM vm) { return IsVdAllowed(vd, vm); };
2127 }
2128
SkipV0Vm()2129 auto SkipV0Vm() {
2130 return [](VRegister vd, Riscv64Assembler::VM vm) { return IsVdAllowed(vd, vm); };
2131 }
2132
2133 template <typename Reg2, typename Reg3>
SkipV0()2134 auto SkipV0() {
2135 return [](VRegister vd, Reg2, Reg3) { return vd != V0; };
2136 }
2137
VVVNoR1R2R3Overlap()2138 auto VVVNoR1R2R3Overlap() {
2139 return [](VRegister vd, VRegister vs2, VRegister vs1) { return vd != vs1 && vd != vs2; };
2140 }
2141
2142 template <typename Arg, typename Args, typename Replacer>
TestVSetI(void (Riscv64Assembler::* f)(XRegister,Arg,uint32_t),Args && arguments,Replacer && replacer,const std::string & fmt)2143 std::string TestVSetI(void (Riscv64Assembler::*f)(XRegister, Arg, uint32_t),
2144 Args&& arguments,
2145 Replacer&& replacer,
2146 const std::string& fmt) {
2147 CHECK(f != nullptr);
2148
2149 std::string str;
2150 for (auto reg1 : GetRegisters()) {
2151 for (auto arg : arguments) {
2152 for (Riscv64Assembler::VectorMaskAgnostic vma : kVMAs) {
2153 for (Riscv64Assembler::VectorTailAgnostic vta : kVTAs) {
2154 for (Riscv64Assembler::SelectedElementWidth sew : kSEWs) {
2155 for (Riscv64Assembler::LengthMultiplier lmul : kLMULs) {
2156 uint32_t vtype = Riscv64Assembler::VTypeiValue(vma, vta, sew, lmul);
2157 (GetAssembler()->*f)(reg1, arg, vtype);
2158 std::string base = fmt;
2159
2160 ReplaceReg(REG1_TOKEN, GetRegisterName(reg1), &base);
2161 replacer(arg, &base);
2162 ReplaceVMA(vma, &base);
2163 ReplaceVTA(vta, &base);
2164 ReplaceSEW(sew, &base);
2165 ReplaceLMUL(lmul, &base);
2166
2167 str += base;
2168 str += "\n";
2169 }
2170 }
2171 }
2172 }
2173 }
2174 }
2175 return str;
2176 }
2177
2178 template <typename EmitCssrX>
TestCsrrXMacro(const std::string & test_name,const std::string & fmt,EmitCssrX && emit_csrrx)2179 void TestCsrrXMacro(const std::string& test_name,
2180 const std::string& fmt,
2181 EmitCssrX&& emit_csrrx) {
2182 std::vector<int64_t> csrs = CreateImmediateValuesBits(12, /*as_uint=*/ true);
2183 std::string expected;
2184 for (XRegister reg : GetRegisters()) {
2185 for (int64_t csr : csrs) {
2186 emit_csrrx(dchecked_integral_cast<uint32_t>(csr), reg);
2187
2188 std::string base = fmt;
2189 ReplaceReg(REG_TOKEN, GetRegisterName(reg), &base);
2190 ReplaceCsrrImm(CSR_TOKEN, csr, &base);
2191 expected += base;
2192 expected += "\n";
2193 }
2194 }
2195 DriverStr(expected, test_name);
2196 }
2197
2198 template <typename EmitCssrXi>
TestCsrrXiMacro(const std::string & test_name,const std::string & fmt,EmitCssrXi && emit_csrrxi)2199 void TestCsrrXiMacro(const std::string& test_name,
2200 const std::string& fmt,
2201 EmitCssrXi&& emit_csrrxi) {
2202 std::vector<int64_t> csrs = CreateImmediateValuesBits(12, /*as_uint=*/ true);
2203 std::vector<int64_t> uimms = CreateImmediateValuesBits(2, /*as_uint=*/ true);
2204 std::string expected;
2205 for (int64_t csr : csrs) {
2206 for (int64_t uimm : uimms) {
2207 emit_csrrxi(dchecked_integral_cast<uint32_t>(csr), dchecked_integral_cast<uint32_t>(uimm));
2208
2209 std::string base = fmt;
2210 ReplaceCsrrImm(CSR_TOKEN, csr, &base);
2211 ReplaceCsrrImm(UIMM_TOKEN, uimm, &base);
2212 expected += base;
2213 expected += "\n";
2214 }
2215 }
2216 DriverStr(expected, test_name);
2217 }
2218
2219 private:
2220 static constexpr const char* RM_TOKEN = "{rm}";
2221 static constexpr const char* AQRL_TOKEN = "{aqrl}";
2222 static constexpr const char* CSR_TOKEN = "{csr}";
2223 static constexpr const char* UIMM_TOKEN = "{uimm}";
2224 static constexpr const char* VM_TOKEN = "{vm}";
2225 static constexpr const char* VMA_TOKEN = "{vma}";
2226 static constexpr const char* VTA_TOKEN = "{vta}";
2227 static constexpr const char* SEW_TOKEN = "{sew}";
2228 static constexpr const char* LMUL_TOKEN = "{lmul}";
2229
2230 static constexpr AqRl kAqRls[] = { AqRl::kNone, AqRl::kRelease, AqRl::kAcquire, AqRl::kAqRl };
2231
2232 static constexpr Riscv64Assembler::VM kVMs[] = {Riscv64Assembler::VM::kUnmasked,
2233 Riscv64Assembler::VM::kV0_t};
2234
2235 static constexpr Riscv64Assembler::VectorMaskAgnostic kVMAs[] = {
2236 Riscv64Assembler::VectorMaskAgnostic::kAgnostic,
2237 Riscv64Assembler::VectorMaskAgnostic::kUndisturbed};
2238
2239 static constexpr Riscv64Assembler::VectorTailAgnostic kVTAs[] = {
2240 Riscv64Assembler::VectorTailAgnostic::kAgnostic,
2241 Riscv64Assembler::VectorTailAgnostic::kUndisturbed};
2242
2243 static constexpr Riscv64Assembler::SelectedElementWidth kSEWs[] = {
2244 Riscv64Assembler::SelectedElementWidth::kE8,
2245 Riscv64Assembler::SelectedElementWidth::kE16,
2246 Riscv64Assembler::SelectedElementWidth::kE32,
2247 Riscv64Assembler::SelectedElementWidth::kE64};
2248
2249 static constexpr Riscv64Assembler::LengthMultiplier kLMULs[] = {
2250 Riscv64Assembler::LengthMultiplier::kM1Over8,
2251 Riscv64Assembler::LengthMultiplier::kM1Over4,
2252 Riscv64Assembler::LengthMultiplier::kM1Over2,
2253 Riscv64Assembler::LengthMultiplier::kM1,
2254 Riscv64Assembler::LengthMultiplier::kM2,
2255 Riscv64Assembler::LengthMultiplier::kM4,
2256 Riscv64Assembler::LengthMultiplier::kM8};
2257
2258 static constexpr FPRoundingMode kRoundingModes[] = {
2259 FPRoundingMode::kRNE,
2260 FPRoundingMode::kRTZ,
2261 FPRoundingMode::kRDN,
2262 FPRoundingMode::kRUP,
2263 FPRoundingMode::kRMM,
2264 FPRoundingMode::kDYN
2265 };
2266
ReplaceRoundingMode(FPRoundingMode rm,std::string * str)2267 void ReplaceRoundingMode(FPRoundingMode rm, /*inout*/ std::string* str) {
2268 const char* replacement;
2269 switch (rm) {
2270 case FPRoundingMode::kRNE:
2271 replacement = "rne";
2272 break;
2273 case FPRoundingMode::kRTZ:
2274 replacement = "rtz";
2275 break;
2276 case FPRoundingMode::kRDN:
2277 replacement = "rdn";
2278 break;
2279 case FPRoundingMode::kRUP:
2280 replacement = "rup";
2281 break;
2282 case FPRoundingMode::kRMM:
2283 replacement = "rmm";
2284 break;
2285 case FPRoundingMode::kDYN:
2286 replacement = "dyn";
2287 break;
2288 }
2289 size_t rm_index = str->find(RM_TOKEN);
2290 EXPECT_NE(rm_index, std::string::npos);
2291 if (rm_index != std::string::npos) {
2292 str->replace(rm_index, ConstexprStrLen(RM_TOKEN), replacement);
2293 }
2294 }
2295
ReplaceAqRl(AqRl aqrl,std::string * str)2296 void ReplaceAqRl(AqRl aqrl, /*inout*/ std::string* str) {
2297 const char* replacement;
2298 switch (aqrl) {
2299 case AqRl::kNone:
2300 replacement = "";
2301 break;
2302 case AqRl::kRelease:
2303 replacement = ".rl";
2304 break;
2305 case AqRl::kAcquire:
2306 replacement = ".aq";
2307 break;
2308 case AqRl::kAqRl:
2309 replacement = ".aqrl";
2310 break;
2311 }
2312 size_t aqrl_index = str->find(AQRL_TOKEN);
2313 EXPECT_NE(aqrl_index, std::string::npos);
2314 if (aqrl_index != std::string::npos) {
2315 str->replace(aqrl_index, ConstexprStrLen(AQRL_TOKEN), replacement);
2316 }
2317 }
2318
ReplaceVm(Riscv64Assembler::VM vm,std::string * str)2319 void ReplaceVm(Riscv64Assembler::VM vm, /*inout*/ std::string* str) {
2320 const char* replacement;
2321 switch (vm) {
2322 case Riscv64Assembler::VM::kUnmasked:
2323 replacement = "";
2324 break;
2325 case Riscv64Assembler::VM::kV0_t:
2326 replacement = ", v0.t";
2327 break;
2328 }
2329 size_t vm_index = str->find(VM_TOKEN);
2330 EXPECT_NE(vm_index, std::string::npos);
2331 if (vm_index != std::string::npos) {
2332 str->replace(vm_index, ConstexprStrLen(VM_TOKEN), replacement);
2333 }
2334 }
2335
ReplaceVMA(Riscv64Assembler::VectorMaskAgnostic vma,std::string * str)2336 void ReplaceVMA(Riscv64Assembler::VectorMaskAgnostic vma, /*inout*/ std::string* str) {
2337 const char* replacement;
2338 switch (vma) {
2339 case Riscv64Assembler::VectorMaskAgnostic::kAgnostic:
2340 replacement = "ma";
2341 break;
2342 case Riscv64Assembler::VectorMaskAgnostic::kUndisturbed:
2343 replacement = "mu";
2344 break;
2345 }
2346 size_t vma_index = str->find(VMA_TOKEN);
2347 EXPECT_NE(vma_index, std::string::npos);
2348 if (vma_index != std::string::npos) {
2349 str->replace(vma_index, ConstexprStrLen(VMA_TOKEN), replacement);
2350 }
2351 }
2352
ReplaceVTA(Riscv64Assembler::VectorTailAgnostic vta,std::string * str)2353 void ReplaceVTA(Riscv64Assembler::VectorTailAgnostic vta, /*inout*/ std::string* str) {
2354 const char* replacement;
2355 switch (vta) {
2356 case Riscv64Assembler::VectorTailAgnostic::kAgnostic:
2357 replacement = "ta";
2358 break;
2359 case Riscv64Assembler::VectorTailAgnostic::kUndisturbed:
2360 replacement = "tu";
2361 break;
2362 }
2363 size_t vta_index = str->find(VTA_TOKEN);
2364 EXPECT_NE(vta_index, std::string::npos);
2365 if (vta_index != std::string::npos) {
2366 str->replace(vta_index, ConstexprStrLen(VTA_TOKEN), replacement);
2367 }
2368 }
2369
ReplaceSEW(Riscv64Assembler::SelectedElementWidth sew,std::string * str)2370 void ReplaceSEW(Riscv64Assembler::SelectedElementWidth sew, /*inout*/ std::string* str) {
2371 const char* replacement;
2372 switch (sew) {
2373 case Riscv64Assembler::SelectedElementWidth::kE8:
2374 replacement = "e8";
2375 break;
2376 case Riscv64Assembler::SelectedElementWidth::kE16:
2377 replacement = "e16";
2378 break;
2379 case Riscv64Assembler::SelectedElementWidth::kE32:
2380 replacement = "e32";
2381 break;
2382 case Riscv64Assembler::SelectedElementWidth::kE64:
2383 replacement = "e64";
2384 break;
2385 default:
2386 LOG(FATAL) << "Unexpected value for `SelectedElementWidth`: " << enum_cast<uint32_t>(sew);
2387 UNREACHABLE();
2388 }
2389 size_t sew_index = str->find(SEW_TOKEN);
2390 EXPECT_NE(sew_index, std::string::npos);
2391 if (sew_index != std::string::npos) {
2392 str->replace(sew_index, ConstexprStrLen(SEW_TOKEN), replacement);
2393 }
2394 }
2395
ReplaceLMUL(Riscv64Assembler::LengthMultiplier lmul,std::string * str)2396 void ReplaceLMUL(Riscv64Assembler::LengthMultiplier lmul, /*inout*/ std::string* str) {
2397 const char* replacement;
2398 switch (lmul) {
2399 case Riscv64Assembler::LengthMultiplier::kM1Over8:
2400 replacement = "mf8";
2401 break;
2402 case Riscv64Assembler::LengthMultiplier::kM1Over4:
2403 replacement = "mf4";
2404 break;
2405 case Riscv64Assembler::LengthMultiplier::kM1Over2:
2406 replacement = "mf2";
2407 break;
2408 case Riscv64Assembler::LengthMultiplier::kM1:
2409 replacement = "m1";
2410 break;
2411 case Riscv64Assembler::LengthMultiplier::kM2:
2412 replacement = "m2";
2413 break;
2414 case Riscv64Assembler::LengthMultiplier::kM4:
2415 replacement = "m4";
2416 break;
2417 case Riscv64Assembler::LengthMultiplier::kM8:
2418 replacement = "m8";
2419 break;
2420 default:
2421 LOG(FATAL) << "Unexpected value for `LengthMultiplier`: " << enum_cast<uint32_t>(lmul);
2422 UNREACHABLE();
2423 }
2424 size_t lmul_index = str->find(LMUL_TOKEN);
2425 EXPECT_NE(lmul_index, std::string::npos);
2426 if (lmul_index != std::string::npos) {
2427 str->replace(lmul_index, ConstexprStrLen(LMUL_TOKEN), replacement);
2428 }
2429 }
2430
ReplaceCsrrImm(const std::string & imm_token,int64_t imm,std::string * str)2431 static void ReplaceCsrrImm(const std::string& imm_token,
2432 int64_t imm,
2433 /*inout*/ std::string* str) {
2434 size_t imm_index = str->find(imm_token);
2435 EXPECT_NE(imm_index, std::string::npos);
2436 if (imm_index != std::string::npos) {
2437 str->replace(imm_index, imm_token.length(), std::to_string(imm));
2438 }
2439 }
2440
2441 std::map<XRegister, std::string, RISCV64CpuRegisterCompare> secondary_register_names_;
2442
2443 std::optional<std::string> march_override_;
2444 };
2445
TEST_F(AssemblerRISCV64Test,Toolchain)2446 TEST_F(AssemblerRISCV64Test, Toolchain) { EXPECT_TRUE(CheckTools()); }
2447
TEST_F(AssemblerRISCV64Test,Lui)2448 TEST_F(AssemblerRISCV64Test, Lui) {
2449 DriverStr(RepeatRIb(&Riscv64Assembler::Lui, /*imm_bits=*/20, "lui {reg}, {imm}"), "Lui");
2450 }
2451
TEST_F(AssemblerRISCV64Test,Lui_WithoutC)2452 TEST_F(AssemblerRISCV64Test, Lui_WithoutC) {
2453 ScopedCSuppression scs(this);
2454 DriverStr(RepeatRIb(&Riscv64Assembler::Lui, /*imm_bits=*/20, "lui {reg}, {imm}"), "Lui_WithoutC");
2455 }
2456
TEST_F(AssemblerRISCV64Test,Auipc)2457 TEST_F(AssemblerRISCV64Test, Auipc) {
2458 DriverStr(RepeatRIb(&Riscv64Assembler::Auipc, /*imm_bits=*/20, "auipc {reg}, {imm}"), "Auipc");
2459 }
2460
TEST_F(AssemblerRISCV64Test,Jal)2461 TEST_F(AssemblerRISCV64Test, Jal) {
2462 DriverStr(RepeatRIbS(&Riscv64Assembler::Jal, /*imm_bits=*/-20, /*shift=*/1, "jal {reg}, {imm}\n"),
2463 "Jal");
2464 }
2465
TEST_F(AssemblerRISCV64Test,Jal_WithoutC)2466 TEST_F(AssemblerRISCV64Test, Jal_WithoutC) {
2467 ScopedCSuppression scs(this);
2468 DriverStr(RepeatRIbS(&Riscv64Assembler::Jal, /*imm_bits=*/-19, /*shift=*/2, "jal {reg}, {imm}\n"),
2469 "Jal_WithoutC");
2470 }
2471
TEST_F(AssemblerRISCV64Test,Jalr)2472 TEST_F(AssemblerRISCV64Test, Jalr) {
2473 DriverStr(RepeatRRIb(&Riscv64Assembler::Jalr, /*imm_bits=*/-12, "jalr {reg1}, {reg2}, {imm}\n"),
2474 "Jalr");
2475 }
2476
TEST_F(AssemblerRISCV64Test,Jalr_WithoutC)2477 TEST_F(AssemblerRISCV64Test, Jalr_WithoutC) {
2478 ScopedCSuppression scs(this);
2479 DriverStr(RepeatRRIb(&Riscv64Assembler::Jalr, /*imm_bits=*/-12, "jalr {reg1}, {reg2}, {imm}\n"),
2480 "Jalr_WithoutC");
2481 }
2482
TEST_F(AssemblerRISCV64Test,Beq)2483 TEST_F(AssemblerRISCV64Test, Beq) {
2484 DriverStr(
2485 RepeatRRIbS(
2486 &Riscv64Assembler::Beq, /*imm_bits=*/-12, /*shift=*/1, "beq {reg1}, {reg2}, {imm}\n"),
2487 "Beq");
2488 }
2489
TEST_F(AssemblerRISCV64Test,Beq_WithoutC)2490 TEST_F(AssemblerRISCV64Test, Beq_WithoutC) {
2491 ScopedCSuppression scs(this);
2492 DriverStr(
2493 RepeatRRIbS(
2494 &Riscv64Assembler::Beq, /*imm_bits=*/-11, /*shift=*/2, "beq {reg1}, {reg2}, {imm}\n"),
2495 "Beq_WithoutC");
2496 }
2497
TEST_F(AssemblerRISCV64Test,Bne)2498 TEST_F(AssemblerRISCV64Test, Bne) {
2499 DriverStr(
2500 RepeatRRIbS(
2501 &Riscv64Assembler::Bne, /*imm_bits=*/-12, /*shift=*/1, "bne {reg1}, {reg2}, {imm}\n"),
2502 "Bne");
2503 }
2504
TEST_F(AssemblerRISCV64Test,Bne_WithoutC)2505 TEST_F(AssemblerRISCV64Test, Bne_WithoutC) {
2506 ScopedCSuppression scs(this);
2507 DriverStr(
2508 RepeatRRIbS(
2509 &Riscv64Assembler::Bne, /*imm_bits=*/-11, /*shift=*/2, "bne {reg1}, {reg2}, {imm}\n"),
2510 "Bne_WithoutC");
2511 }
2512
TEST_F(AssemblerRISCV64Test,Blt)2513 TEST_F(AssemblerRISCV64Test, Blt) {
2514 DriverStr(
2515 RepeatRRIbS(
2516 &Riscv64Assembler::Blt, /*imm_bits=*/-12, /*shift=*/1, "blt {reg1}, {reg2}, {imm}\n"),
2517 "Blt");
2518 }
2519
TEST_F(AssemblerRISCV64Test,Bge)2520 TEST_F(AssemblerRISCV64Test, Bge) {
2521 DriverStr(
2522 RepeatRRIbS(
2523 &Riscv64Assembler::Bge, /*imm_bits=*/-12, /*shift=*/1, "bge {reg1}, {reg2}, {imm}\n"),
2524 "Bge");
2525 }
2526
TEST_F(AssemblerRISCV64Test,Bltu)2527 TEST_F(AssemblerRISCV64Test, Bltu) {
2528 DriverStr(
2529 RepeatRRIbS(
2530 &Riscv64Assembler::Bltu, /*imm_bits=*/-12, /*shift=*/1, "bltu {reg1}, {reg2}, {imm}\n"),
2531 "Bltu");
2532 }
2533
TEST_F(AssemblerRISCV64Test,Bgeu)2534 TEST_F(AssemblerRISCV64Test, Bgeu) {
2535 DriverStr(
2536 RepeatRRIbS(
2537 &Riscv64Assembler::Bgeu, /*imm_bits=*/-12, /*shift=*/1, "bgeu {reg1}, {reg2}, {imm}\n"),
2538 "Bgeu");
2539 }
2540
TEST_F(AssemblerRISCV64Test,Lb)2541 TEST_F(AssemblerRISCV64Test, Lb) {
2542 // Note: There is no 16-bit instruction for `Lb()`.
2543 DriverStr(RepeatRRIb(&Riscv64Assembler::Lb, /*imm_bits=*/-12, "lb {reg1}, {imm}({reg2})"), "Lb");
2544 }
2545
TEST_F(AssemblerRISCV64Test,Lh)2546 TEST_F(AssemblerRISCV64Test, Lh) {
2547 DriverStr(RepeatRRIb(&Riscv64Assembler::Lh, /*imm_bits=*/-12, "lh {reg1}, {imm}({reg2})"), "Lh");
2548 }
2549
TEST_F(AssemblerRISCV64Test,Lh_WithoutC)2550 TEST_F(AssemblerRISCV64Test, Lh_WithoutC) {
2551 ScopedCSuppression scs(this);
2552 DriverStr(RepeatRRIb(&Riscv64Assembler::Lh, /*imm_bits=*/-12, "lh {reg1}, {imm}({reg2})"),
2553 "Lh_WithoutC");
2554 }
2555
TEST_F(AssemblerRISCV64Test,Lw)2556 TEST_F(AssemblerRISCV64Test, Lw) {
2557 DriverStr(RepeatRRIb(&Riscv64Assembler::Lw, /*imm_bits=*/-12, "lw {reg1}, {imm}({reg2})"), "Lw");
2558 }
2559
TEST_F(AssemblerRISCV64Test,Lw_WithoutC)2560 TEST_F(AssemblerRISCV64Test, Lw_WithoutC) {
2561 ScopedCSuppression scs(this);
2562 DriverStr(RepeatRRIb(&Riscv64Assembler::Lw, /*imm_bits=*/-12, "lw {reg1}, {imm}({reg2})"),
2563 "Lw_WithoutC");
2564 }
2565
TEST_F(AssemblerRISCV64Test,Ld)2566 TEST_F(AssemblerRISCV64Test, Ld) {
2567 DriverStr(RepeatRRIb(&Riscv64Assembler::Ld, /*imm_bits=*/-12, "ld {reg1}, {imm}({reg2})"), "Ld");
2568 }
2569
TEST_F(AssemblerRISCV64Test,Ld_WithoutC)2570 TEST_F(AssemblerRISCV64Test, Ld_WithoutC) {
2571 ScopedCSuppression scs(this);
2572 DriverStr(RepeatRRIb(&Riscv64Assembler::Ld, /*imm_bits=*/-12, "ld {reg1}, {imm}({reg2})"),
2573 "Ld_WithoutC");
2574 }
2575
TEST_F(AssemblerRISCV64Test,Lbu)2576 TEST_F(AssemblerRISCV64Test, Lbu) {
2577 DriverStr(RepeatRRIb(&Riscv64Assembler::Lbu, /*imm_bits=*/-12, "lbu {reg1}, {imm}({reg2})"), "Lbu");
2578 }
2579
TEST_F(AssemblerRISCV64Test,Lbu_WithoutC)2580 TEST_F(AssemblerRISCV64Test, Lbu_WithoutC) {
2581 ScopedCSuppression scs(this);
2582 DriverStr(RepeatRRIb(&Riscv64Assembler::Lbu, /*imm_bits=*/-12, "lbu {reg1}, {imm}({reg2})"),
2583 "Lbu_WithoutC");
2584 }
2585
TEST_F(AssemblerRISCV64Test,Lhu)2586 TEST_F(AssemblerRISCV64Test, Lhu) {
2587 DriverStr(RepeatRRIb(&Riscv64Assembler::Lhu, /*imm_bits=*/-12, "lhu {reg1}, {imm}({reg2})"), "Lhu");
2588 }
2589
TEST_F(AssemblerRISCV64Test,Lhu_WithoutC)2590 TEST_F(AssemblerRISCV64Test, Lhu_WithoutC) {
2591 ScopedCSuppression scs(this);
2592 DriverStr(RepeatRRIb(&Riscv64Assembler::Lhu, /*imm_bits=*/-12, "lhu {reg1}, {imm}({reg2})"),
2593 "Lhu_WithoutC");
2594 }
2595
TEST_F(AssemblerRISCV64Test,Lwu)2596 TEST_F(AssemblerRISCV64Test, Lwu) {
2597 // Note: There is no 16-bit instruction for `Lwu()`.
2598 DriverStr(RepeatRRIb(&Riscv64Assembler::Lwu, /*imm_bits=*/-12, "lwu {reg1}, {imm}({reg2})"), "Lwu");
2599 }
2600
TEST_F(AssemblerRISCV64Test,Sb)2601 TEST_F(AssemblerRISCV64Test, Sb) {
2602 DriverStr(RepeatRRIb(&Riscv64Assembler::Sb, /*imm_bits=*/-12, "sb {reg1}, {imm}({reg2})"), "Sb");
2603 }
2604
TEST_F(AssemblerRISCV64Test,Sb_WithoutC)2605 TEST_F(AssemblerRISCV64Test, Sb_WithoutC) {
2606 ScopedCSuppression scs(this);
2607 DriverStr(RepeatRRIb(&Riscv64Assembler::Sb, /*imm_bits=*/-12, "sb {reg1}, {imm}({reg2})"),
2608 "Sb_WithoutC");
2609 }
2610
TEST_F(AssemblerRISCV64Test,Sh)2611 TEST_F(AssemblerRISCV64Test, Sh) {
2612 DriverStr(RepeatRRIb(&Riscv64Assembler::Sh, /*imm_bits=*/-12, "sh {reg1}, {imm}({reg2})"), "Sh");
2613 }
2614
TEST_F(AssemblerRISCV64Test,Sh_WithoutC)2615 TEST_F(AssemblerRISCV64Test, Sh_WithoutC) {
2616 ScopedCSuppression scs(this);
2617 DriverStr(RepeatRRIb(&Riscv64Assembler::Sh, /*imm_bits=*/-12, "sh {reg1}, {imm}({reg2})"),
2618 "Sh_WithoutC");
2619 }
2620
TEST_F(AssemblerRISCV64Test,Sw)2621 TEST_F(AssemblerRISCV64Test, Sw) {
2622 DriverStr(RepeatRRIb(&Riscv64Assembler::Sw, /*imm_bits=*/-12, "sw {reg1}, {imm}({reg2})"), "Sw");
2623 }
2624
TEST_F(AssemblerRISCV64Test,Sw_WithoutC)2625 TEST_F(AssemblerRISCV64Test, Sw_WithoutC) {
2626 ScopedCSuppression scs(this);
2627 DriverStr(RepeatRRIb(&Riscv64Assembler::Sw, /*imm_bits=*/-12, "sw {reg1}, {imm}({reg2})"), "Sw_WithoutC");
2628 }
2629
TEST_F(AssemblerRISCV64Test,Sd)2630 TEST_F(AssemblerRISCV64Test, Sd) {
2631 DriverStr(RepeatRRIb(&Riscv64Assembler::Sd, /*imm_bits=*/-12, "sd {reg1}, {imm}({reg2})"), "Sd");
2632 }
2633
TEST_F(AssemblerRISCV64Test,Sd_WithoutC)2634 TEST_F(AssemblerRISCV64Test, Sd_WithoutC) {
2635 ScopedCSuppression scs(this);
2636 DriverStr(RepeatRRIb(&Riscv64Assembler::Sd, /*imm_bits=*/-12, "sd {reg1}, {imm}({reg2})"), "Sd_WithoutC");
2637 }
2638
TEST_F(AssemblerRISCV64Test,Addi)2639 TEST_F(AssemblerRISCV64Test, Addi) {
2640 DriverStr(RepeatRRIb(&Riscv64Assembler::Addi, /*imm_bits=*/-12, "addi {reg1}, {reg2}, {imm}"), "Addi");
2641 }
2642
TEST_F(AssemblerRISCV64Test,Addi_WithoutC)2643 TEST_F(AssemblerRISCV64Test, Addi_WithoutC) {
2644 ScopedCSuppression scs(this);
2645 DriverStr(RepeatRRIb(&Riscv64Assembler::Addi, /*imm_bits=*/-12, "addi {reg1}, {reg2}, {imm}"),
2646 "Addi_WithoutC");
2647 }
2648
TEST_F(AssemblerRISCV64Test,Slti)2649 TEST_F(AssemblerRISCV64Test, Slti) {
2650 DriverStr(RepeatRRIb(&Riscv64Assembler::Slti, /*imm_bits=*/-12, "slti {reg1}, {reg2}, {imm}"), "Slti");
2651 }
2652
TEST_F(AssemblerRISCV64Test,Sltiu)2653 TEST_F(AssemblerRISCV64Test, Sltiu) {
2654 DriverStr(RepeatRRIb(&Riscv64Assembler::Sltiu, /*imm_bits=*/-12, "sltiu {reg1}, {reg2}, {imm}"), "Sltiu");
2655 }
2656
TEST_F(AssemblerRISCV64Test,Xori)2657 TEST_F(AssemblerRISCV64Test, Xori) {
2658 DriverStr(RepeatRRIb(&Riscv64Assembler::Xori, /*imm_bits=*/-12, "xori {reg1}, {reg2}, {imm}"),
2659 "Xori");
2660 }
2661
TEST_F(AssemblerRISCV64Test,Xori_WithoutC)2662 TEST_F(AssemblerRISCV64Test, Xori_WithoutC) {
2663 ScopedCSuppression scs(this);
2664 DriverStr(RepeatRRIb(&Riscv64Assembler::Xori, /*imm_bits=*/-12, "xori {reg1}, {reg2}, {imm}"),
2665 "Xori_WithoutC");
2666 }
2667
TEST_F(AssemblerRISCV64Test,Ori)2668 TEST_F(AssemblerRISCV64Test, Ori) {
2669 DriverStr(RepeatRRIb(&Riscv64Assembler::Ori, /*imm_bits=*/-12, "ori {reg1}, {reg2}, {imm}"), "Ori");
2670 }
2671
TEST_F(AssemblerRISCV64Test,Andi)2672 TEST_F(AssemblerRISCV64Test, Andi) {
2673 DriverStr(RepeatRRIb(&Riscv64Assembler::Andi, /*imm_bits=*/-12, "andi {reg1}, {reg2}, {imm}"), "Andi");
2674 }
2675
TEST_F(AssemblerRISCV64Test,Andi_WithoutC)2676 TEST_F(AssemblerRISCV64Test, Andi_WithoutC) {
2677 ScopedCSuppression scs(this);
2678 DriverStr(RepeatRRIb(&Riscv64Assembler::Andi, /*imm_bits=*/6, "andi {reg1}, {reg2}, {imm}"), "Andi_WithoutC");
2679 }
2680
TEST_F(AssemblerRISCV64Test,Slli)2681 TEST_F(AssemblerRISCV64Test, Slli) {
2682 DriverStr(RepeatRRIb(&Riscv64Assembler::Slli, /*imm_bits=*/6, "slli {reg1}, {reg2}, {imm}"), "Slli");
2683 }
2684
TEST_F(AssemblerRISCV64Test,Slli_WithoutC)2685 TEST_F(AssemblerRISCV64Test, Slli_WithoutC) {
2686 ScopedCSuppression scs(this);
2687 DriverStr(RepeatRRIb(&Riscv64Assembler::Slli, /*imm_bits=*/6, "slli {reg1}, {reg2}, {imm}"), "Slli_WithoutC");
2688 }
2689
TEST_F(AssemblerRISCV64Test,Srli)2690 TEST_F(AssemblerRISCV64Test, Srli) {
2691 DriverStr(RepeatRRIb(&Riscv64Assembler::Srli, /*imm_bits=*/6, "srli {reg1}, {reg2}, {imm}"), "Srli");
2692 }
2693
TEST_F(AssemblerRISCV64Test,Srli_WithoutC)2694 TEST_F(AssemblerRISCV64Test, Srli_WithoutC) {
2695 ScopedCSuppression scs(this);
2696 DriverStr(RepeatRRIb(&Riscv64Assembler::Srli, /*imm_bits=*/6, "srli {reg1}, {reg2}, {imm}"), "Slli_WithoutC");
2697 }
2698
TEST_F(AssemblerRISCV64Test,Srai)2699 TEST_F(AssemblerRISCV64Test, Srai) {
2700 DriverStr(RepeatRRIb(&Riscv64Assembler::Srai, /*imm_bits=*/6, "srai {reg1}, {reg2}, {imm}"), "Srai");
2701 }
2702
TEST_F(AssemblerRISCV64Test,Srai_WithoutC)2703 TEST_F(AssemblerRISCV64Test, Srai_WithoutC) {
2704 ScopedCSuppression scs(this);
2705 DriverStr(RepeatRRIb(&Riscv64Assembler::Srai, /*imm_bits=*/6, "srai {reg1}, {reg2}, {imm}"), "Srai_WithoutC");
2706 }
2707
TEST_F(AssemblerRISCV64Test,Add)2708 TEST_F(AssemblerRISCV64Test, Add) {
2709 DriverStr(RepeatRRR(&Riscv64Assembler::Add, "add {reg1}, {reg2}, {reg3}"), "Add");
2710 }
2711
TEST_F(AssemblerRISCV64Test,Add_WithoutC)2712 TEST_F(AssemblerRISCV64Test, Add_WithoutC) {
2713 ScopedCSuppression scs(this);
2714 DriverStr(RepeatRRR(&Riscv64Assembler::Add, "add {reg1}, {reg2}, {reg3}"), "Add_WithoutC");
2715 }
2716
TEST_F(AssemblerRISCV64Test,Sub)2717 TEST_F(AssemblerRISCV64Test, Sub) {
2718 DriverStr(RepeatRRR(&Riscv64Assembler::Sub, "sub {reg1}, {reg2}, {reg3}"), "Sub");
2719 }
2720
TEST_F(AssemblerRISCV64Test,Sub_WithoutC)2721 TEST_F(AssemblerRISCV64Test, Sub_WithoutC) {
2722 ScopedCSuppression scs(this);
2723 DriverStr(RepeatRRR(&Riscv64Assembler::Sub, "sub {reg1}, {reg2}, {reg3}"), "Sub_WithoutC");
2724 }
2725
TEST_F(AssemblerRISCV64Test,Slt)2726 TEST_F(AssemblerRISCV64Test, Slt) {
2727 DriverStr(RepeatRRR(&Riscv64Assembler::Slt, "slt {reg1}, {reg2}, {reg3}"), "Slt");
2728 }
2729
TEST_F(AssemblerRISCV64Test,Sltu)2730 TEST_F(AssemblerRISCV64Test, Sltu) {
2731 DriverStr(RepeatRRR(&Riscv64Assembler::Sltu, "sltu {reg1}, {reg2}, {reg3}"), "Sltu");
2732 }
2733
TEST_F(AssemblerRISCV64Test,Xor)2734 TEST_F(AssemblerRISCV64Test, Xor) {
2735 DriverStr(RepeatRRR(&Riscv64Assembler::Xor, "xor {reg1}, {reg2}, {reg3}"), "Xor");
2736 }
2737
TEST_F(AssemblerRISCV64Test,Xor_WithoutC)2738 TEST_F(AssemblerRISCV64Test, Xor_WithoutC) {
2739 ScopedCSuppression scs(this);
2740 DriverStr(RepeatRRR(&Riscv64Assembler::Xor, "xor {reg1}, {reg2}, {reg3}"), "Xor_WithoutC");
2741 }
2742
TEST_F(AssemblerRISCV64Test,Or)2743 TEST_F(AssemblerRISCV64Test, Or) {
2744 DriverStr(RepeatRRR(&Riscv64Assembler::Or, "or {reg1}, {reg2}, {reg3}"), "Or");
2745 }
2746
TEST_F(AssemblerRISCV64Test,Or_WithoutC)2747 TEST_F(AssemblerRISCV64Test, Or_WithoutC) {
2748 ScopedCSuppression scs(this);
2749 DriverStr(RepeatRRR(&Riscv64Assembler::Or, "or {reg1}, {reg2}, {reg3}"), "Or_WithoutC");
2750 }
2751
TEST_F(AssemblerRISCV64Test,And)2752 TEST_F(AssemblerRISCV64Test, And) {
2753 DriverStr(RepeatRRR(&Riscv64Assembler::And, "and {reg1}, {reg2}, {reg3}"), "And");
2754 }
2755
TEST_F(AssemblerRISCV64Test,And_WithoutC)2756 TEST_F(AssemblerRISCV64Test, And_WithoutC) {
2757 ScopedCSuppression scs(this);
2758 DriverStr(RepeatRRR(&Riscv64Assembler::And, "and {reg1}, {reg2}, {reg3}"), "And_WithoutC");
2759 }
2760
TEST_F(AssemblerRISCV64Test,Sll)2761 TEST_F(AssemblerRISCV64Test, Sll) {
2762 DriverStr(RepeatRRR(&Riscv64Assembler::Sll, "sll {reg1}, {reg2}, {reg3}"), "Sll");
2763 }
2764
TEST_F(AssemblerRISCV64Test,Srl)2765 TEST_F(AssemblerRISCV64Test, Srl) {
2766 DriverStr(RepeatRRR(&Riscv64Assembler::Srl, "srl {reg1}, {reg2}, {reg3}"), "Srl");
2767 }
2768
TEST_F(AssemblerRISCV64Test,Sra)2769 TEST_F(AssemblerRISCV64Test, Sra) {
2770 DriverStr(RepeatRRR(&Riscv64Assembler::Sra, "sra {reg1}, {reg2}, {reg3}"), "Sra");
2771 }
2772
TEST_F(AssemblerRISCV64Test,Addiw)2773 TEST_F(AssemblerRISCV64Test, Addiw) {
2774 DriverStr(RepeatRRIb(&Riscv64Assembler::Addiw, /*imm_bits=*/-12, "addiw {reg1}, {reg2}, {imm}"), "Addiw");
2775 }
2776
TEST_F(AssemblerRISCV64Test,Addiw_WithoutC)2777 TEST_F(AssemblerRISCV64Test, Addiw_WithoutC) {
2778 ScopedCSuppression scs(this);
2779 DriverStr(RepeatRRIb(&Riscv64Assembler::Addiw, /*imm_bits=*/-12, "addiw {reg1}, {reg2}, {imm}"),
2780 "Addiw_WithoutC");
2781 }
2782
TEST_F(AssemblerRISCV64Test,Slliw)2783 TEST_F(AssemblerRISCV64Test, Slliw) {
2784 DriverStr(RepeatRRIb(&Riscv64Assembler::Slliw, /*imm_bits=*/5, "slliw {reg1}, {reg2}, {imm}"),
2785 "Slliw");
2786 }
2787
TEST_F(AssemblerRISCV64Test,Srliw)2788 TEST_F(AssemblerRISCV64Test, Srliw) {
2789 DriverStr(RepeatRRIb(&Riscv64Assembler::Srliw, /*imm_bits=*/5, "srliw {reg1}, {reg2}, {imm}"),
2790 "Srliw");
2791 }
2792
TEST_F(AssemblerRISCV64Test,Sraiw)2793 TEST_F(AssemblerRISCV64Test, Sraiw) {
2794 DriverStr(RepeatRRIb(&Riscv64Assembler::Sraiw, /*imm_bits=*/5, "sraiw {reg1}, {reg2}, {imm}"),
2795 "Sraiw");
2796 }
2797
TEST_F(AssemblerRISCV64Test,Addw)2798 TEST_F(AssemblerRISCV64Test, Addw) {
2799 DriverStr(RepeatRRR(&Riscv64Assembler::Addw, "addw {reg1}, {reg2}, {reg3}"), "Addw");
2800 }
2801
TEST_F(AssemblerRISCV64Test,Addw_WithoutC)2802 TEST_F(AssemblerRISCV64Test, Addw_WithoutC) {
2803 ScopedCSuppression scs(this);
2804 DriverStr(RepeatRRR(&Riscv64Assembler::Addw, "addw {reg1}, {reg2}, {reg3}"), "Addw_WithoutC");
2805 }
2806
TEST_F(AssemblerRISCV64Test,Subw)2807 TEST_F(AssemblerRISCV64Test, Subw) {
2808 DriverStr(RepeatRRR(&Riscv64Assembler::Subw, "subw {reg1}, {reg2}, {reg3}"), "Subw");
2809 }
2810
TEST_F(AssemblerRISCV64Test,Subw_WithoutC)2811 TEST_F(AssemblerRISCV64Test, Subw_WithoutC) {
2812 ScopedCSuppression scs(this);
2813 DriverStr(RepeatRRR(&Riscv64Assembler::Subw, "subw {reg1}, {reg2}, {reg3}"), "Subw_WithoutC");
2814 }
2815
TEST_F(AssemblerRISCV64Test,Sllw)2816 TEST_F(AssemblerRISCV64Test, Sllw) {
2817 DriverStr(RepeatRRR(&Riscv64Assembler::Sllw, "sllw {reg1}, {reg2}, {reg3}"), "Sllw");
2818 }
2819
TEST_F(AssemblerRISCV64Test,Srlw)2820 TEST_F(AssemblerRISCV64Test, Srlw) {
2821 DriverStr(RepeatRRR(&Riscv64Assembler::Srlw, "srlw {reg1}, {reg2}, {reg3}"), "Srlw");
2822 }
2823
TEST_F(AssemblerRISCV64Test,Sraw)2824 TEST_F(AssemblerRISCV64Test, Sraw) {
2825 DriverStr(RepeatRRR(&Riscv64Assembler::Sraw, "sraw {reg1}, {reg2}, {reg3}"), "Sraw");
2826 }
2827
TEST_F(AssemblerRISCV64Test,Ecall)2828 TEST_F(AssemblerRISCV64Test, Ecall) {
2829 __ Ecall();
2830 DriverStr("ecall\n", "Ecall");
2831 }
2832
TEST_F(AssemblerRISCV64Test,Ebreak)2833 TEST_F(AssemblerRISCV64Test, Ebreak) {
2834 __ Ebreak();
2835 DriverStr("ebreak\n", "Ebreak");
2836 }
2837
TEST_F(AssemblerRISCV64Test,Ebreak_WithoutC)2838 TEST_F(AssemblerRISCV64Test, Ebreak_WithoutC) {
2839 ScopedCSuppression scs(this);
2840 __ Ebreak();
2841 DriverStr("ebreak\n", "Ebreak_WithoutC");
2842 }
2843
TEST_F(AssemblerRISCV64Test,Fence)2844 TEST_F(AssemblerRISCV64Test, Fence) {
2845 auto get_fence_type_string = [](uint32_t fence_type) {
2846 CHECK_LE(fence_type, 0xfu);
2847 std::string result;
2848 if ((fence_type & kFenceInput) != 0u) {
2849 result += "i";
2850 }
2851 if ((fence_type & kFenceOutput) != 0u) {
2852 result += "o";
2853 }
2854 if ((fence_type & kFenceRead) != 0u) {
2855 result += "r";
2856 }
2857 if ((fence_type & kFenceWrite) != 0u) {
2858 result += "w";
2859 }
2860 if (result.empty()) {
2861 result += "0";
2862 }
2863 return result;
2864 };
2865
2866 std::string expected;
2867 // Note: The `pred` and `succ` are 4 bits each.
2868 // Some combinations are not really useful but the assembler can emit them all.
2869 for (uint32_t pred = 0u; pred != 0x10; ++pred) {
2870 for (uint32_t succ = 0u; succ != 0x10; ++succ) {
2871 __ Fence(pred, succ);
2872 expected +=
2873 "fence " + get_fence_type_string(pred) + ", " + get_fence_type_string(succ) + "\n";
2874 }
2875 }
2876 DriverStr(expected, "Fence");
2877 }
2878
TEST_F(AssemblerRISCV64Test,FenceTso)2879 TEST_F(AssemblerRISCV64Test, FenceTso) {
2880 __ FenceTso();
2881 DriverStr("fence.tso", "FenceTso");
2882 }
2883
TEST_F(AssemblerRISCV64Test,FenceI)2884 TEST_F(AssemblerRISCV64Test, FenceI) {
2885 __ FenceI();
2886 DriverStr("fence.i", "FenceI");
2887 }
2888
TEST_F(AssemblerRISCV64Test,Mul)2889 TEST_F(AssemblerRISCV64Test, Mul) {
2890 DriverStr(RepeatRRR(&Riscv64Assembler::Mul, "mul {reg1}, {reg2}, {reg3}"), "Mul");
2891 }
2892
TEST_F(AssemblerRISCV64Test,Mul_WithoutC)2893 TEST_F(AssemblerRISCV64Test, Mul_WithoutC) {
2894 ScopedCSuppression scs(this);
2895 DriverStr(RepeatRRR(&Riscv64Assembler::Mul, "mul {reg1}, {reg2}, {reg3}"), "Mul_WithoutC");
2896 }
2897
TEST_F(AssemblerRISCV64Test,Mulh)2898 TEST_F(AssemblerRISCV64Test, Mulh) {
2899 DriverStr(RepeatRRR(&Riscv64Assembler::Mulh, "mulh {reg1}, {reg2}, {reg3}"), "Mulh");
2900 }
2901
TEST_F(AssemblerRISCV64Test,Mulhsu)2902 TEST_F(AssemblerRISCV64Test, Mulhsu) {
2903 DriverStr(RepeatRRR(&Riscv64Assembler::Mulhsu, "mulhsu {reg1}, {reg2}, {reg3}"), "Mulhsu");
2904 }
2905
TEST_F(AssemblerRISCV64Test,Mulhu)2906 TEST_F(AssemblerRISCV64Test, Mulhu) {
2907 DriverStr(RepeatRRR(&Riscv64Assembler::Mulhu, "mulhu {reg1}, {reg2}, {reg3}"), "Mulhu");
2908 }
2909
TEST_F(AssemblerRISCV64Test,Div)2910 TEST_F(AssemblerRISCV64Test, Div) {
2911 DriverStr(RepeatRRR(&Riscv64Assembler::Div, "div {reg1}, {reg2}, {reg3}"), "Div");
2912 }
2913
TEST_F(AssemblerRISCV64Test,Divu)2914 TEST_F(AssemblerRISCV64Test, Divu) {
2915 DriverStr(RepeatRRR(&Riscv64Assembler::Divu, "divu {reg1}, {reg2}, {reg3}"), "Divu");
2916 }
2917
TEST_F(AssemblerRISCV64Test,Rem)2918 TEST_F(AssemblerRISCV64Test, Rem) {
2919 DriverStr(RepeatRRR(&Riscv64Assembler::Rem, "rem {reg1}, {reg2}, {reg3}"), "Rem");
2920 }
2921
TEST_F(AssemblerRISCV64Test,Remu)2922 TEST_F(AssemblerRISCV64Test, Remu) {
2923 DriverStr(RepeatRRR(&Riscv64Assembler::Remu, "remu {reg1}, {reg2}, {reg3}"), "Remu");
2924 }
2925
TEST_F(AssemblerRISCV64Test,Mulw)2926 TEST_F(AssemblerRISCV64Test, Mulw) {
2927 DriverStr(RepeatRRR(&Riscv64Assembler::Mulw, "mulw {reg1}, {reg2}, {reg3}"), "Mulw");
2928 }
2929
TEST_F(AssemblerRISCV64Test,Divw)2930 TEST_F(AssemblerRISCV64Test, Divw) {
2931 DriverStr(RepeatRRR(&Riscv64Assembler::Divw, "divw {reg1}, {reg2}, {reg3}"), "Divw");
2932 }
2933
TEST_F(AssemblerRISCV64Test,Divuw)2934 TEST_F(AssemblerRISCV64Test, Divuw) {
2935 DriverStr(RepeatRRR(&Riscv64Assembler::Divuw, "divuw {reg1}, {reg2}, {reg3}"), "Divuw");
2936 }
2937
TEST_F(AssemblerRISCV64Test,Remw)2938 TEST_F(AssemblerRISCV64Test, Remw) {
2939 DriverStr(RepeatRRR(&Riscv64Assembler::Remw, "remw {reg1}, {reg2}, {reg3}"), "Remw");
2940 }
2941
TEST_F(AssemblerRISCV64Test,Remuw)2942 TEST_F(AssemblerRISCV64Test, Remuw) {
2943 DriverStr(RepeatRRR(&Riscv64Assembler::Remuw, "remuw {reg1}, {reg2}, {reg3}"), "Remuw");
2944 }
2945
TEST_F(AssemblerRISCV64Test,LrW)2946 TEST_F(AssemblerRISCV64Test, LrW) {
2947 auto invalid_aqrl = [](AqRl aqrl) { return aqrl == AqRl::kRelease; };
2948 DriverStr(RepeatRRAqRl(&Riscv64Assembler::LrW, "lr.w{aqrl} {reg1}, ({reg2})", invalid_aqrl),
2949 "LrW");
2950 }
2951
TEST_F(AssemblerRISCV64Test,LrD)2952 TEST_F(AssemblerRISCV64Test, LrD) {
2953 auto invalid_aqrl = [](AqRl aqrl) { return aqrl == AqRl::kRelease; };
2954 DriverStr(RepeatRRAqRl(&Riscv64Assembler::LrD, "lr.d{aqrl} {reg1}, ({reg2})", invalid_aqrl),
2955 "LrD");
2956 }
2957
TEST_F(AssemblerRISCV64Test,ScW)2958 TEST_F(AssemblerRISCV64Test, ScW) {
2959 auto invalid_aqrl = [](AqRl aqrl) { return aqrl == AqRl::kAcquire; };
2960 DriverStr(
2961 RepeatRRRAqRl(&Riscv64Assembler::ScW, "sc.w{aqrl} {reg1}, {reg2}, ({reg3})", invalid_aqrl),
2962 "ScW");
2963 }
2964
TEST_F(AssemblerRISCV64Test,ScD)2965 TEST_F(AssemblerRISCV64Test, ScD) {
2966 auto invalid_aqrl = [](AqRl aqrl) { return aqrl == AqRl::kAcquire; };
2967 DriverStr(
2968 RepeatRRRAqRl(&Riscv64Assembler::ScD, "sc.d{aqrl} {reg1}, {reg2}, ({reg3})", invalid_aqrl),
2969 "ScD");
2970 }
2971
TEST_F(AssemblerRISCV64Test,AmoSwapW)2972 TEST_F(AssemblerRISCV64Test, AmoSwapW) {
2973 DriverStr(RepeatRRRAqRl(&Riscv64Assembler::AmoSwapW, "amoswap.w{aqrl} {reg1}, {reg2}, ({reg3})"),
2974 "AmoSwapW");
2975 }
2976
TEST_F(AssemblerRISCV64Test,AmoSwapD)2977 TEST_F(AssemblerRISCV64Test, AmoSwapD) {
2978 DriverStr(RepeatRRRAqRl(&Riscv64Assembler::AmoSwapD, "amoswap.d{aqrl} {reg1}, {reg2}, ({reg3})"),
2979 "AmoSwapD");
2980 }
2981
TEST_F(AssemblerRISCV64Test,AmoAddW)2982 TEST_F(AssemblerRISCV64Test, AmoAddW) {
2983 DriverStr(RepeatRRRAqRl(&Riscv64Assembler::AmoAddW, "amoadd.w{aqrl} {reg1}, {reg2}, ({reg3})"),
2984 "AmoAddW");
2985 }
2986
TEST_F(AssemblerRISCV64Test,AmoAddD)2987 TEST_F(AssemblerRISCV64Test, AmoAddD) {
2988 DriverStr(RepeatRRRAqRl(&Riscv64Assembler::AmoAddD, "amoadd.d{aqrl} {reg1}, {reg2}, ({reg3})"),
2989 "AmoAddD");
2990 }
2991
TEST_F(AssemblerRISCV64Test,AmoXorW)2992 TEST_F(AssemblerRISCV64Test, AmoXorW) {
2993 DriverStr(RepeatRRRAqRl(&Riscv64Assembler::AmoXorW, "amoxor.w{aqrl} {reg1}, {reg2}, ({reg3})"),
2994 "AmoXorW");
2995 }
2996
TEST_F(AssemblerRISCV64Test,AmoXorD)2997 TEST_F(AssemblerRISCV64Test, AmoXorD) {
2998 DriverStr(RepeatRRRAqRl(&Riscv64Assembler::AmoXorD, "amoxor.d{aqrl} {reg1}, {reg2}, ({reg3})"),
2999 "AmoXorD");
3000 }
3001
TEST_F(AssemblerRISCV64Test,AmoAndW)3002 TEST_F(AssemblerRISCV64Test, AmoAndW) {
3003 DriverStr(RepeatRRRAqRl(&Riscv64Assembler::AmoAndW, "amoand.w{aqrl} {reg1}, {reg2}, ({reg3})"),
3004 "AmoAndW");
3005 }
3006
TEST_F(AssemblerRISCV64Test,AmoAndD)3007 TEST_F(AssemblerRISCV64Test, AmoAndD) {
3008 DriverStr(RepeatRRRAqRl(&Riscv64Assembler::AmoAndD, "amoand.d{aqrl} {reg1}, {reg2}, ({reg3})"),
3009 "AmoAndD");
3010 }
3011
TEST_F(AssemblerRISCV64Test,AmoOrW)3012 TEST_F(AssemblerRISCV64Test, AmoOrW) {
3013 DriverStr(RepeatRRRAqRl(&Riscv64Assembler::AmoOrW, "amoor.w{aqrl} {reg1}, {reg2}, ({reg3})"),
3014 "AmoOrW");
3015 }
3016
TEST_F(AssemblerRISCV64Test,AmoOrD)3017 TEST_F(AssemblerRISCV64Test, AmoOrD) {
3018 DriverStr(RepeatRRRAqRl(&Riscv64Assembler::AmoOrD, "amoor.d{aqrl} {reg1}, {reg2}, ({reg3})"),
3019 "AmoOrD");
3020 }
3021
TEST_F(AssemblerRISCV64Test,AmoMinW)3022 TEST_F(AssemblerRISCV64Test, AmoMinW) {
3023 DriverStr(RepeatRRRAqRl(&Riscv64Assembler::AmoMinW, "amomin.w{aqrl} {reg1}, {reg2}, ({reg3})"),
3024 "AmoMinW");
3025 }
3026
TEST_F(AssemblerRISCV64Test,AmoMinD)3027 TEST_F(AssemblerRISCV64Test, AmoMinD) {
3028 DriverStr(RepeatRRRAqRl(&Riscv64Assembler::AmoMinD, "amomin.d{aqrl} {reg1}, {reg2}, ({reg3})"),
3029 "AmoMinD");
3030 }
3031
TEST_F(AssemblerRISCV64Test,AmoMaxW)3032 TEST_F(AssemblerRISCV64Test, AmoMaxW) {
3033 DriverStr(RepeatRRRAqRl(&Riscv64Assembler::AmoMaxW, "amomax.w{aqrl} {reg1}, {reg2}, ({reg3})"),
3034 "AmoMaxW");
3035 }
3036
TEST_F(AssemblerRISCV64Test,AmoMaxD)3037 TEST_F(AssemblerRISCV64Test, AmoMaxD) {
3038 DriverStr(RepeatRRRAqRl(&Riscv64Assembler::AmoMaxD, "amomax.d{aqrl} {reg1}, {reg2}, ({reg3})"),
3039 "AmoMaxD");
3040 }
3041
TEST_F(AssemblerRISCV64Test,AmoMinuW)3042 TEST_F(AssemblerRISCV64Test, AmoMinuW) {
3043 DriverStr(RepeatRRRAqRl(&Riscv64Assembler::AmoMinuW, "amominu.w{aqrl} {reg1}, {reg2}, ({reg3})"),
3044 "AmoMinuW");
3045 }
3046
TEST_F(AssemblerRISCV64Test,AmoMinuD)3047 TEST_F(AssemblerRISCV64Test, AmoMinuD) {
3048 DriverStr(RepeatRRRAqRl(&Riscv64Assembler::AmoMinuD, "amominu.d{aqrl} {reg1}, {reg2}, ({reg3})"),
3049 "AmoMinuD");
3050 }
3051
TEST_F(AssemblerRISCV64Test,AmoMaxuW)3052 TEST_F(AssemblerRISCV64Test, AmoMaxuW) {
3053 DriverStr(RepeatRRRAqRl(&Riscv64Assembler::AmoMaxuW, "amomaxu.w{aqrl} {reg1}, {reg2}, ({reg3})"),
3054 "AmoMaxuW");
3055 }
3056
TEST_F(AssemblerRISCV64Test,AmoMaxuD)3057 TEST_F(AssemblerRISCV64Test, AmoMaxuD) {
3058 DriverStr(RepeatRRRAqRl(&Riscv64Assembler::AmoMaxuD, "amomaxu.d{aqrl} {reg1}, {reg2}, ({reg3})"),
3059 "AmoMaxuD");
3060 }
3061
TEST_F(AssemblerRISCV64Test,Csrrw)3062 TEST_F(AssemblerRISCV64Test, Csrrw) {
3063 DriverStr(RepeatCsrrX(&Riscv64Assembler::Csrrw, "csrrw {reg1}, {csr}, {reg2}"), "Csrrw");
3064 }
3065
TEST_F(AssemblerRISCV64Test,Csrrs)3066 TEST_F(AssemblerRISCV64Test, Csrrs) {
3067 DriverStr(RepeatCsrrX(&Riscv64Assembler::Csrrs, "csrrs {reg1}, {csr}, {reg2}"), "Csrrs");
3068 }
3069
TEST_F(AssemblerRISCV64Test,Csrrc)3070 TEST_F(AssemblerRISCV64Test, Csrrc) {
3071 DriverStr(RepeatCsrrX(&Riscv64Assembler::Csrrc, "csrrc {reg1}, {csr}, {reg2}"), "Csrrc");
3072 }
3073
TEST_F(AssemblerRISCV64Test,Csrrwi)3074 TEST_F(AssemblerRISCV64Test, Csrrwi) {
3075 DriverStr(RepeatCsrrXi(&Riscv64Assembler::Csrrwi, "csrrwi {reg}, {csr}, {uimm}"), "Csrrwi");
3076 }
3077
TEST_F(AssemblerRISCV64Test,Csrrsi)3078 TEST_F(AssemblerRISCV64Test, Csrrsi) {
3079 DriverStr(RepeatCsrrXi(&Riscv64Assembler::Csrrsi, "csrrsi {reg}, {csr}, {uimm}"), "Csrrsi");
3080 }
3081
TEST_F(AssemblerRISCV64Test,Csrrci)3082 TEST_F(AssemblerRISCV64Test, Csrrci) {
3083 DriverStr(RepeatCsrrXi(&Riscv64Assembler::Csrrci, "csrrci {reg}, {csr}, {uimm}"), "Csrrci");
3084 }
3085
TEST_F(AssemblerRISCV64Test,FLw)3086 TEST_F(AssemblerRISCV64Test, FLw) {
3087 // Note: 16-bit variants of `flw` are not available on riscv64.
3088 DriverStr(RepeatFRIb(&Riscv64Assembler::FLw, /*imm_bits=*/-12, "flw {reg1}, {imm}({reg2})"), "FLw");
3089 }
3090
TEST_F(AssemblerRISCV64Test,FLd)3091 TEST_F(AssemblerRISCV64Test, FLd) {
3092 DriverStr(RepeatFRIb(&Riscv64Assembler::FLd, /*imm_bits=*/-12, "fld {reg1}, {imm}({reg2})"), "FLd");
3093 }
3094
TEST_F(AssemblerRISCV64Test,FLd_WithoutC)3095 TEST_F(AssemblerRISCV64Test, FLd_WithoutC) {
3096 ScopedCSuppression scs(this);
3097 DriverStr(RepeatFRIb(&Riscv64Assembler::FLd, /*imm_bits=*/-12, "fld {reg1}, {imm}({reg2})"),
3098 "FLd_WithoutC");
3099 }
3100
TEST_F(AssemblerRISCV64Test,FSw)3101 TEST_F(AssemblerRISCV64Test, FSw) {
3102 // Note: 16-bit variants of `fsw` are not available on riscv64.
3103 DriverStr(RepeatFRIb(&Riscv64Assembler::FSw, /*imm_bits=*/2, "fsw {reg1}, {imm}({reg2})"), "FSw");
3104 }
3105
TEST_F(AssemblerRISCV64Test,FSd)3106 TEST_F(AssemblerRISCV64Test, FSd) {
3107 DriverStr(RepeatFRIb(&Riscv64Assembler::FSd, /*imm_bits=*/2, "fsd {reg1}, {imm}({reg2})"), "FSd");
3108 }
3109
TEST_F(AssemblerRISCV64Test,FSd_WithoutC)3110 TEST_F(AssemblerRISCV64Test, FSd_WithoutC) {
3111 ScopedCSuppression scs(this);
3112 DriverStr(RepeatFRIb(&Riscv64Assembler::FSd, /*imm_bits=*/-12, "fsd {reg1}, {imm}({reg2})"),
3113 "FSd_WithoutC");
3114 }
3115
TEST_F(AssemblerRISCV64Test,FMAddS)3116 TEST_F(AssemblerRISCV64Test, FMAddS) {
3117 DriverStr(RepeatFFFFRoundingMode(&Riscv64Assembler::FMAddS,
3118 "fmadd.s {reg1}, {reg2}, {reg3}, {reg4}, {rm}"), "FMAddS");
3119 }
3120
TEST_F(AssemblerRISCV64Test,FMAddS_Default)3121 TEST_F(AssemblerRISCV64Test, FMAddS_Default) {
3122 DriverStr(RepeatFFFF(&Riscv64Assembler::FMAddS, "fmadd.s {reg1}, {reg2}, {reg3}, {reg4}"),
3123 "FMAddS_Default");
3124 }
3125
TEST_F(AssemblerRISCV64Test,FMAddD)3126 TEST_F(AssemblerRISCV64Test, FMAddD) {
3127 DriverStr(RepeatFFFFRoundingMode(&Riscv64Assembler::FMAddD,
3128 "fmadd.d {reg1}, {reg2}, {reg3}, {reg4}, {rm}"), "FMAddD");
3129 }
3130
TEST_F(AssemblerRISCV64Test,FMAddD_Default)3131 TEST_F(AssemblerRISCV64Test, FMAddD_Default) {
3132 DriverStr(RepeatFFFF(&Riscv64Assembler::FMAddD, "fmadd.d {reg1}, {reg2}, {reg3}, {reg4}"),
3133 "FMAddD_Default");
3134 }
3135
TEST_F(AssemblerRISCV64Test,FMSubS)3136 TEST_F(AssemblerRISCV64Test, FMSubS) {
3137 DriverStr(RepeatFFFFRoundingMode(&Riscv64Assembler::FMSubS,
3138 "fmsub.s {reg1}, {reg2}, {reg3}, {reg4}, {rm}"), "FMSubS");
3139 }
3140
TEST_F(AssemblerRISCV64Test,FMSubS_Default)3141 TEST_F(AssemblerRISCV64Test, FMSubS_Default) {
3142 DriverStr(RepeatFFFF(&Riscv64Assembler::FMSubS, "fmsub.s {reg1}, {reg2}, {reg3}, {reg4}"),
3143 "FMSubS_Default");
3144 }
3145
TEST_F(AssemblerRISCV64Test,FMSubD)3146 TEST_F(AssemblerRISCV64Test, FMSubD) {
3147 DriverStr(RepeatFFFFRoundingMode(&Riscv64Assembler::FMSubD,
3148 "fmsub.d {reg1}, {reg2}, {reg3}, {reg4}, {rm}"), "FMSubD");
3149 }
3150
TEST_F(AssemblerRISCV64Test,FMSubD_Default)3151 TEST_F(AssemblerRISCV64Test, FMSubD_Default) {
3152 DriverStr(RepeatFFFF(&Riscv64Assembler::FMSubD, "fmsub.d {reg1}, {reg2}, {reg3}, {reg4}"),
3153 "FMSubD_Default");
3154 }
3155
TEST_F(AssemblerRISCV64Test,FNMSubS)3156 TEST_F(AssemblerRISCV64Test, FNMSubS) {
3157 DriverStr(RepeatFFFFRoundingMode(&Riscv64Assembler::FNMSubS,
3158 "fnmsub.s {reg1}, {reg2}, {reg3}, {reg4}, {rm}"), "FNMSubS");
3159 }
3160
TEST_F(AssemblerRISCV64Test,FNMSubS_Default)3161 TEST_F(AssemblerRISCV64Test, FNMSubS_Default) {
3162 DriverStr(RepeatFFFF(&Riscv64Assembler::FNMSubS, "fnmsub.s {reg1}, {reg2}, {reg3}, {reg4}"),
3163 "FNMSubS_Default");
3164 }
3165
TEST_F(AssemblerRISCV64Test,FNMSubD)3166 TEST_F(AssemblerRISCV64Test, FNMSubD) {
3167 DriverStr(RepeatFFFFRoundingMode(&Riscv64Assembler::FNMSubD,
3168 "fnmsub.d {reg1}, {reg2}, {reg3}, {reg4}, {rm}"), "FNMSubD");
3169 }
3170
TEST_F(AssemblerRISCV64Test,FNMSubD_Default)3171 TEST_F(AssemblerRISCV64Test, FNMSubD_Default) {
3172 DriverStr(RepeatFFFF(&Riscv64Assembler::FNMSubD, "fnmsub.d {reg1}, {reg2}, {reg3}, {reg4}"),
3173 "FNMSubD_Default");
3174 }
3175
TEST_F(AssemblerRISCV64Test,FNMAddS)3176 TEST_F(AssemblerRISCV64Test, FNMAddS) {
3177 DriverStr(RepeatFFFFRoundingMode(&Riscv64Assembler::FNMAddS,
3178 "fnmadd.s {reg1}, {reg2}, {reg3}, {reg4}, {rm}"), "FNMAddS");
3179 }
3180
TEST_F(AssemblerRISCV64Test,FNMAddS_Default)3181 TEST_F(AssemblerRISCV64Test, FNMAddS_Default) {
3182 DriverStr(RepeatFFFF(&Riscv64Assembler::FNMAddS, "fnmadd.s {reg1}, {reg2}, {reg3}, {reg4}"),
3183 "FNMAddS_Default");
3184 }
3185
TEST_F(AssemblerRISCV64Test,FNMAddD)3186 TEST_F(AssemblerRISCV64Test, FNMAddD) {
3187 DriverStr(RepeatFFFFRoundingMode(&Riscv64Assembler::FNMAddD,
3188 "fnmadd.d {reg1}, {reg2}, {reg3}, {reg4}, {rm}"), "FNMAddD");
3189 }
3190
TEST_F(AssemblerRISCV64Test,FNMAddD_Default)3191 TEST_F(AssemblerRISCV64Test, FNMAddD_Default) {
3192 DriverStr(RepeatFFFF(&Riscv64Assembler::FNMAddD, "fnmadd.d {reg1}, {reg2}, {reg3}, {reg4}"),
3193 "FNMAddD_Default");
3194 }
3195
TEST_F(AssemblerRISCV64Test,FAddS)3196 TEST_F(AssemblerRISCV64Test, FAddS) {
3197 DriverStr(RepeatFFFRoundingMode(&Riscv64Assembler::FAddS, "fadd.s {reg1}, {reg2}, {reg3}, {rm}"),
3198 "FAddS");
3199 }
3200
TEST_F(AssemblerRISCV64Test,FAddS_Default)3201 TEST_F(AssemblerRISCV64Test, FAddS_Default) {
3202 DriverStr(RepeatFFF(&Riscv64Assembler::FAddS, "fadd.s {reg1}, {reg2}, {reg3}"), "FAddS_Default");
3203 }
3204
TEST_F(AssemblerRISCV64Test,FAddD)3205 TEST_F(AssemblerRISCV64Test, FAddD) {
3206 DriverStr(RepeatFFFRoundingMode(&Riscv64Assembler::FAddD, "fadd.d {reg1}, {reg2}, {reg3}, {rm}"),
3207 "FAddD");
3208 }
3209
TEST_F(AssemblerRISCV64Test,FAddD_Default)3210 TEST_F(AssemblerRISCV64Test, FAddD_Default) {
3211 DriverStr(RepeatFFF(&Riscv64Assembler::FAddD, "fadd.d {reg1}, {reg2}, {reg3}"), "FAddD_Default");
3212 }
3213
TEST_F(AssemblerRISCV64Test,FSubS)3214 TEST_F(AssemblerRISCV64Test, FSubS) {
3215 DriverStr(RepeatFFFRoundingMode(&Riscv64Assembler::FSubS, "fsub.s {reg1}, {reg2}, {reg3}, {rm}"),
3216 "FSubS");
3217 }
3218
TEST_F(AssemblerRISCV64Test,FSubS_Default)3219 TEST_F(AssemblerRISCV64Test, FSubS_Default) {
3220 DriverStr(RepeatFFF(&Riscv64Assembler::FSubS, "fsub.s {reg1}, {reg2}, {reg3}"), "FSubS_Default");
3221 }
3222
TEST_F(AssemblerRISCV64Test,FSubD)3223 TEST_F(AssemblerRISCV64Test, FSubD) {
3224 DriverStr(RepeatFFFRoundingMode(&Riscv64Assembler::FSubD, "fsub.d {reg1}, {reg2}, {reg3}, {rm}"),
3225 "FSubD");
3226 }
3227
TEST_F(AssemblerRISCV64Test,FSubD_Default)3228 TEST_F(AssemblerRISCV64Test, FSubD_Default) {
3229 DriverStr(RepeatFFF(&Riscv64Assembler::FSubD, "fsub.d {reg1}, {reg2}, {reg3}"), "FSubD_Default");
3230 }
3231
TEST_F(AssemblerRISCV64Test,FMulS)3232 TEST_F(AssemblerRISCV64Test, FMulS) {
3233 DriverStr(RepeatFFFRoundingMode(&Riscv64Assembler::FMulS, "fmul.s {reg1}, {reg2}, {reg3}, {rm}"),
3234 "FMulS");
3235 }
3236
TEST_F(AssemblerRISCV64Test,FMulS_Default)3237 TEST_F(AssemblerRISCV64Test, FMulS_Default) {
3238 DriverStr(RepeatFFF(&Riscv64Assembler::FMulS, "fmul.s {reg1}, {reg2}, {reg3}"), "FMulS_Default");
3239 }
3240
TEST_F(AssemblerRISCV64Test,FMulD)3241 TEST_F(AssemblerRISCV64Test, FMulD) {
3242 DriverStr(RepeatFFFRoundingMode(&Riscv64Assembler::FMulD, "fmul.d {reg1}, {reg2}, {reg3}, {rm}"),
3243 "FMulD");
3244 }
3245
TEST_F(AssemblerRISCV64Test,FMulD_Default)3246 TEST_F(AssemblerRISCV64Test, FMulD_Default) {
3247 DriverStr(RepeatFFF(&Riscv64Assembler::FMulD, "fmul.d {reg1}, {reg2}, {reg3}"), "FMulD_Default");
3248 }
3249
TEST_F(AssemblerRISCV64Test,FDivS)3250 TEST_F(AssemblerRISCV64Test, FDivS) {
3251 DriverStr(RepeatFFFRoundingMode(&Riscv64Assembler::FDivS, "fdiv.s {reg1}, {reg2}, {reg3}, {rm}"),
3252 "FDivS");
3253 }
3254
TEST_F(AssemblerRISCV64Test,FDivS_Default)3255 TEST_F(AssemblerRISCV64Test, FDivS_Default) {
3256 DriverStr(RepeatFFF(&Riscv64Assembler::FDivS, "fdiv.s {reg1}, {reg2}, {reg3}"), "FDivS_Default");
3257 }
3258
TEST_F(AssemblerRISCV64Test,FDivD)3259 TEST_F(AssemblerRISCV64Test, FDivD) {
3260 DriverStr(RepeatFFFRoundingMode(&Riscv64Assembler::FDivD, "fdiv.d {reg1}, {reg2}, {reg3}, {rm}"),
3261 "FDivD");
3262 }
3263
TEST_F(AssemblerRISCV64Test,FDivD_Default)3264 TEST_F(AssemblerRISCV64Test, FDivD_Default) {
3265 DriverStr(RepeatFFF(&Riscv64Assembler::FDivD, "fdiv.d {reg1}, {reg2}, {reg3}"), "FDivD_Default");
3266 }
3267
TEST_F(AssemblerRISCV64Test,FSqrtS)3268 TEST_F(AssemblerRISCV64Test, FSqrtS) {
3269 DriverStr(RepeatFFRoundingMode(&Riscv64Assembler::FSqrtS, "fsqrt.s {reg1}, {reg2}, {rm}"),
3270 "FSqrtS");
3271 }
3272
TEST_F(AssemblerRISCV64Test,FSqrtS_Default)3273 TEST_F(AssemblerRISCV64Test, FSqrtS_Default) {
3274 DriverStr(RepeatFF(&Riscv64Assembler::FSqrtS, "fsqrt.s {reg1}, {reg2}"), "FSqrtS_Default");
3275 }
3276
TEST_F(AssemblerRISCV64Test,FSqrtD)3277 TEST_F(AssemblerRISCV64Test, FSqrtD) {
3278 DriverStr(RepeatFFRoundingMode(&Riscv64Assembler::FSqrtD, "fsqrt.d {reg1}, {reg2}, {rm}"),
3279 "FSqrtD");
3280 }
3281
TEST_F(AssemblerRISCV64Test,FSqrtD_Default)3282 TEST_F(AssemblerRISCV64Test, FSqrtD_Default) {
3283 DriverStr(RepeatFF(&Riscv64Assembler::FSqrtD, "fsqrt.d {reg1}, {reg2}"), "FSqrtD_Default");
3284 }
3285
TEST_F(AssemblerRISCV64Test,FSgnjS)3286 TEST_F(AssemblerRISCV64Test, FSgnjS) {
3287 DriverStr(RepeatFFF(&Riscv64Assembler::FSgnjS, "fsgnj.s {reg1}, {reg2}, {reg3}"), "FSgnjS");
3288 }
3289
TEST_F(AssemblerRISCV64Test,FSgnjD)3290 TEST_F(AssemblerRISCV64Test, FSgnjD) {
3291 DriverStr(RepeatFFF(&Riscv64Assembler::FSgnjD, "fsgnj.d {reg1}, {reg2}, {reg3}"), "FSgnjD");
3292 }
3293
TEST_F(AssemblerRISCV64Test,FSgnjnS)3294 TEST_F(AssemblerRISCV64Test, FSgnjnS) {
3295 DriverStr(RepeatFFF(&Riscv64Assembler::FSgnjnS, "fsgnjn.s {reg1}, {reg2}, {reg3}"), "FSgnjnS");
3296 }
3297
TEST_F(AssemblerRISCV64Test,FSgnjnD)3298 TEST_F(AssemblerRISCV64Test, FSgnjnD) {
3299 DriverStr(RepeatFFF(&Riscv64Assembler::FSgnjnD, "fsgnjn.d {reg1}, {reg2}, {reg3}"), "FSgnjnD");
3300 }
3301
TEST_F(AssemblerRISCV64Test,FSgnjxS)3302 TEST_F(AssemblerRISCV64Test, FSgnjxS) {
3303 DriverStr(RepeatFFF(&Riscv64Assembler::FSgnjxS, "fsgnjx.s {reg1}, {reg2}, {reg3}"), "FSgnjxS");
3304 }
3305
TEST_F(AssemblerRISCV64Test,FSgnjxD)3306 TEST_F(AssemblerRISCV64Test, FSgnjxD) {
3307 DriverStr(RepeatFFF(&Riscv64Assembler::FSgnjxD, "fsgnjx.d {reg1}, {reg2}, {reg3}"), "FSgnjxD");
3308 }
3309
TEST_F(AssemblerRISCV64Test,FMinS)3310 TEST_F(AssemblerRISCV64Test, FMinS) {
3311 DriverStr(RepeatFFF(&Riscv64Assembler::FMinS, "fmin.s {reg1}, {reg2}, {reg3}"), "FMinS");
3312 }
3313
TEST_F(AssemblerRISCV64Test,FMinD)3314 TEST_F(AssemblerRISCV64Test, FMinD) {
3315 DriverStr(RepeatFFF(&Riscv64Assembler::FMinD, "fmin.d {reg1}, {reg2}, {reg3}"), "FMinD");
3316 }
3317
TEST_F(AssemblerRISCV64Test,FMaxS)3318 TEST_F(AssemblerRISCV64Test, FMaxS) {
3319 DriverStr(RepeatFFF(&Riscv64Assembler::FMaxS, "fmax.s {reg1}, {reg2}, {reg3}"), "FMaxS");
3320 }
3321
TEST_F(AssemblerRISCV64Test,FMaxD)3322 TEST_F(AssemblerRISCV64Test, FMaxD) {
3323 DriverStr(RepeatFFF(&Riscv64Assembler::FMaxD, "fmax.d {reg1}, {reg2}, {reg3}"), "FMaxD");
3324 }
3325
TEST_F(AssemblerRISCV64Test,FCvtSD)3326 TEST_F(AssemblerRISCV64Test, FCvtSD) {
3327 DriverStr(RepeatFFRoundingMode(&Riscv64Assembler::FCvtSD, "fcvt.s.d {reg1}, {reg2}, {rm}"),
3328 "FCvtSD");
3329 }
3330
TEST_F(AssemblerRISCV64Test,FCvtSD_Default)3331 TEST_F(AssemblerRISCV64Test, FCvtSD_Default) {
3332 DriverStr(RepeatFF(&Riscv64Assembler::FCvtSD, "fcvt.s.d {reg1}, {reg2}"), "FCvtSD_Default");
3333 }
3334
3335 // This conversion is lossless, so the rounding mode is meaningless and the assembler we're
3336 // testing against does not even accept the rounding mode argument, so this test is disabled.
TEST_F(AssemblerRISCV64Test,DISABLED_FCvtDS)3337 TEST_F(AssemblerRISCV64Test, DISABLED_FCvtDS) {
3338 DriverStr(RepeatFFRoundingMode(&Riscv64Assembler::FCvtDS, "fcvt.d.s {reg1}, {reg2}, {rm}"),
3339 "FCvtDS");
3340 }
3341
TEST_F(AssemblerRISCV64Test,FCvtDS_Default)3342 TEST_F(AssemblerRISCV64Test, FCvtDS_Default) {
3343 DriverStr(RepeatFF(&Riscv64Assembler::FCvtDS, "fcvt.d.s {reg1}, {reg2}"), "FCvtDS_Default");
3344 }
3345
TEST_F(AssemblerRISCV64Test,FEqS)3346 TEST_F(AssemblerRISCV64Test, FEqS) {
3347 DriverStr(RepeatRFF(&Riscv64Assembler::FEqS, "feq.s {reg1}, {reg2}, {reg3}"), "FEqS");
3348 }
3349
TEST_F(AssemblerRISCV64Test,FEqD)3350 TEST_F(AssemblerRISCV64Test, FEqD) {
3351 DriverStr(RepeatRFF(&Riscv64Assembler::FEqD, "feq.d {reg1}, {reg2}, {reg3}"), "FEqD");
3352 }
3353
TEST_F(AssemblerRISCV64Test,FLtS)3354 TEST_F(AssemblerRISCV64Test, FLtS) {
3355 DriverStr(RepeatRFF(&Riscv64Assembler::FLtS, "flt.s {reg1}, {reg2}, {reg3}"), "FLtS");
3356 }
3357
TEST_F(AssemblerRISCV64Test,FLtD)3358 TEST_F(AssemblerRISCV64Test, FLtD) {
3359 DriverStr(RepeatRFF(&Riscv64Assembler::FLtD, "flt.d {reg1}, {reg2}, {reg3}"), "FLtD");
3360 }
3361
TEST_F(AssemblerRISCV64Test,FLeS)3362 TEST_F(AssemblerRISCV64Test, FLeS) {
3363 DriverStr(RepeatRFF(&Riscv64Assembler::FLeS, "fle.s {reg1}, {reg2}, {reg3}"), "FLeS");
3364 }
3365
TEST_F(AssemblerRISCV64Test,FLeD)3366 TEST_F(AssemblerRISCV64Test, FLeD) {
3367 DriverStr(RepeatRFF(&Riscv64Assembler::FLeD, "fle.d {reg1}, {reg2}, {reg3}"), "FLeD");
3368 }
3369
TEST_F(AssemblerRISCV64Test,FCvtWS)3370 TEST_F(AssemblerRISCV64Test, FCvtWS) {
3371 DriverStr(RepeatrFRoundingMode(&Riscv64Assembler::FCvtWS, "fcvt.w.s {reg1}, {reg2}, {rm}"),
3372 "FCvtWS");
3373 }
3374
TEST_F(AssemblerRISCV64Test,FCvtWS_Default)3375 TEST_F(AssemblerRISCV64Test, FCvtWS_Default) {
3376 DriverStr(RepeatrF(&Riscv64Assembler::FCvtWS, "fcvt.w.s {reg1}, {reg2}"), "FCvtWS_Default");
3377 }
3378
TEST_F(AssemblerRISCV64Test,FCvtWD)3379 TEST_F(AssemblerRISCV64Test, FCvtWD) {
3380 DriverStr(RepeatrFRoundingMode(&Riscv64Assembler::FCvtWD, "fcvt.w.d {reg1}, {reg2}, {rm}"),
3381 "FCvtWD");
3382 }
3383
TEST_F(AssemblerRISCV64Test,FCvtWD_Default)3384 TEST_F(AssemblerRISCV64Test, FCvtWD_Default) {
3385 DriverStr(RepeatrF(&Riscv64Assembler::FCvtWD, "fcvt.w.d {reg1}, {reg2}"), "FCvtWD_Default");
3386 }
3387
TEST_F(AssemblerRISCV64Test,FCvtWuS)3388 TEST_F(AssemblerRISCV64Test, FCvtWuS) {
3389 DriverStr(RepeatrFRoundingMode(&Riscv64Assembler::FCvtWuS, "fcvt.wu.s {reg1}, {reg2}, {rm}"),
3390 "FCvtWuS");
3391 }
3392
TEST_F(AssemblerRISCV64Test,FCvtWuS_Default)3393 TEST_F(AssemblerRISCV64Test, FCvtWuS_Default) {
3394 DriverStr(RepeatrF(&Riscv64Assembler::FCvtWuS, "fcvt.wu.s {reg1}, {reg2}"), "FCvtWuS_Default");
3395 }
3396
TEST_F(AssemblerRISCV64Test,FCvtWuD)3397 TEST_F(AssemblerRISCV64Test, FCvtWuD) {
3398 DriverStr(RepeatrFRoundingMode(&Riscv64Assembler::FCvtWuD, "fcvt.wu.d {reg1}, {reg2}, {rm}"),
3399 "FCvtWuD");
3400 }
3401
TEST_F(AssemblerRISCV64Test,FCvtWuD_Default)3402 TEST_F(AssemblerRISCV64Test, FCvtWuD_Default) {
3403 DriverStr(RepeatrF(&Riscv64Assembler::FCvtWuD, "fcvt.wu.d {reg1}, {reg2}"), "FCvtWuD_Default");
3404 }
3405
TEST_F(AssemblerRISCV64Test,FCvtLS)3406 TEST_F(AssemblerRISCV64Test, FCvtLS) {
3407 DriverStr(RepeatrFRoundingMode(&Riscv64Assembler::FCvtLS, "fcvt.l.s {reg1}, {reg2}, {rm}"),
3408 "FCvtLS");
3409 }
3410
TEST_F(AssemblerRISCV64Test,FCvtLS_Default)3411 TEST_F(AssemblerRISCV64Test, FCvtLS_Default) {
3412 DriverStr(RepeatrF(&Riscv64Assembler::FCvtLS, "fcvt.l.s {reg1}, {reg2}"), "FCvtLS_Default");
3413 }
3414
TEST_F(AssemblerRISCV64Test,FCvtLD)3415 TEST_F(AssemblerRISCV64Test, FCvtLD) {
3416 DriverStr(RepeatrFRoundingMode(&Riscv64Assembler::FCvtLD, "fcvt.l.d {reg1}, {reg2}, {rm}"),
3417 "FCvtLD");
3418 }
3419
TEST_F(AssemblerRISCV64Test,FCvtLD_Default)3420 TEST_F(AssemblerRISCV64Test, FCvtLD_Default) {
3421 DriverStr(RepeatrF(&Riscv64Assembler::FCvtLD, "fcvt.l.d {reg1}, {reg2}"), "FCvtLD_Default");
3422 }
3423
TEST_F(AssemblerRISCV64Test,FCvtLuS)3424 TEST_F(AssemblerRISCV64Test, FCvtLuS) {
3425 DriverStr(RepeatrFRoundingMode(&Riscv64Assembler::FCvtLuS, "fcvt.lu.s {reg1}, {reg2}, {rm}"),
3426 "FCvtLuS");
3427 }
3428
TEST_F(AssemblerRISCV64Test,FCvtLuS_Default)3429 TEST_F(AssemblerRISCV64Test, FCvtLuS_Default) {
3430 DriverStr(RepeatrF(&Riscv64Assembler::FCvtLuS, "fcvt.lu.s {reg1}, {reg2}"), "FCvtLuS_Default");
3431 }
3432
TEST_F(AssemblerRISCV64Test,FCvtLuD)3433 TEST_F(AssemblerRISCV64Test, FCvtLuD) {
3434 DriverStr(RepeatrFRoundingMode(&Riscv64Assembler::FCvtLuD, "fcvt.lu.d {reg1}, {reg2}, {rm}"),
3435 "FCvtLuD");
3436 }
3437
TEST_F(AssemblerRISCV64Test,FCvtLuD_Default)3438 TEST_F(AssemblerRISCV64Test, FCvtLuD_Default) {
3439 DriverStr(RepeatrF(&Riscv64Assembler::FCvtLuD, "fcvt.lu.d {reg1}, {reg2}"), "FCvtLuD_Default");
3440 }
3441
TEST_F(AssemblerRISCV64Test,FCvtSW)3442 TEST_F(AssemblerRISCV64Test, FCvtSW) {
3443 DriverStr(RepeatFrRoundingMode(&Riscv64Assembler::FCvtSW, "fcvt.s.w {reg1}, {reg2}, {rm}"),
3444 "FCvtSW");
3445 }
3446
TEST_F(AssemblerRISCV64Test,FCvtSW_Default)3447 TEST_F(AssemblerRISCV64Test, FCvtSW_Default) {
3448 DriverStr(RepeatFr(&Riscv64Assembler::FCvtSW, "fcvt.s.w {reg1}, {reg2}"), "FCvtSW_Default");
3449 }
3450
3451 // This conversion is lossless, so the rounding mode is meaningless and the assembler we're
3452 // testing against does not even accept the rounding mode argument, so this test is disabled.
TEST_F(AssemblerRISCV64Test,DISABLED_FCvtDW)3453 TEST_F(AssemblerRISCV64Test, DISABLED_FCvtDW) {
3454 DriverStr(RepeatFrRoundingMode(&Riscv64Assembler::FCvtDW, "fcvt.d.w {reg1}, {reg2}, {rm}"),
3455 "FCvtDW");
3456 }
3457
TEST_F(AssemblerRISCV64Test,FCvtDW_Default)3458 TEST_F(AssemblerRISCV64Test, FCvtDW_Default) {
3459 DriverStr(RepeatFr(&Riscv64Assembler::FCvtDW, "fcvt.d.w {reg1}, {reg2}"), "FCvtDW_Default");
3460 }
3461
TEST_F(AssemblerRISCV64Test,FCvtSWu)3462 TEST_F(AssemblerRISCV64Test, FCvtSWu) {
3463 DriverStr(RepeatFrRoundingMode(&Riscv64Assembler::FCvtSWu, "fcvt.s.wu {reg1}, {reg2}, {rm}"),
3464 "FCvtSWu");
3465 }
3466
TEST_F(AssemblerRISCV64Test,FCvtSWu_Default)3467 TEST_F(AssemblerRISCV64Test, FCvtSWu_Default) {
3468 DriverStr(RepeatFr(&Riscv64Assembler::FCvtSWu, "fcvt.s.wu {reg1}, {reg2}"), "FCvtSWu_Default");
3469 }
3470
3471 // This conversion is lossless, so the rounding mode is meaningless and the assembler we're
3472 // testing against does not even accept the rounding mode argument, so this test is disabled.
TEST_F(AssemblerRISCV64Test,DISABLED_FCvtDWu)3473 TEST_F(AssemblerRISCV64Test, DISABLED_FCvtDWu) {
3474 DriverStr(RepeatFrRoundingMode(&Riscv64Assembler::FCvtDWu, "fcvt.d.wu {reg1}, {reg2}, {rm}"),
3475 "FCvtDWu");
3476 }
3477
TEST_F(AssemblerRISCV64Test,FCvtDWu_Default)3478 TEST_F(AssemblerRISCV64Test, FCvtDWu_Default) {
3479 DriverStr(RepeatFr(&Riscv64Assembler::FCvtDWu, "fcvt.d.wu {reg1}, {reg2}"), "FCvtDWu_Default");
3480 }
3481
TEST_F(AssemblerRISCV64Test,FCvtSL)3482 TEST_F(AssemblerRISCV64Test, FCvtSL) {
3483 DriverStr(RepeatFrRoundingMode(&Riscv64Assembler::FCvtSL, "fcvt.s.l {reg1}, {reg2}, {rm}"),
3484 "FCvtSL");
3485 }
3486
TEST_F(AssemblerRISCV64Test,FCvtSL_Default)3487 TEST_F(AssemblerRISCV64Test, FCvtSL_Default) {
3488 DriverStr(RepeatFr(&Riscv64Assembler::FCvtSL, "fcvt.s.l {reg1}, {reg2}"), "FCvtSL_Default");
3489 }
3490
TEST_F(AssemblerRISCV64Test,FCvtDL)3491 TEST_F(AssemblerRISCV64Test, FCvtDL) {
3492 DriverStr(RepeatFrRoundingMode(&Riscv64Assembler::FCvtDL, "fcvt.d.l {reg1}, {reg2}, {rm}"),
3493 "FCvtDL");
3494 }
3495
TEST_F(AssemblerRISCV64Test,FCvtDL_Default)3496 TEST_F(AssemblerRISCV64Test, FCvtDL_Default) {
3497 DriverStr(RepeatFr(&Riscv64Assembler::FCvtDL, "fcvt.d.l {reg1}, {reg2}"), "FCvtDL_Default");
3498 }
3499
TEST_F(AssemblerRISCV64Test,FCvtSLu)3500 TEST_F(AssemblerRISCV64Test, FCvtSLu) {
3501 DriverStr(RepeatFrRoundingMode(&Riscv64Assembler::FCvtSLu, "fcvt.s.lu {reg1}, {reg2}, {rm}"),
3502 "FCvtSLu");
3503 }
3504
TEST_F(AssemblerRISCV64Test,FCvtSLu_Default)3505 TEST_F(AssemblerRISCV64Test, FCvtSLu_Default) {
3506 DriverStr(RepeatFr(&Riscv64Assembler::FCvtSLu, "fcvt.s.lu {reg1}, {reg2}"), "FCvtSLu_Default");
3507 }
3508
TEST_F(AssemblerRISCV64Test,FCvtDLu)3509 TEST_F(AssemblerRISCV64Test, FCvtDLu) {
3510 DriverStr(RepeatFrRoundingMode(&Riscv64Assembler::FCvtDLu, "fcvt.d.lu {reg1}, {reg2}, {rm}"),
3511 "FCvtDLu");
3512 }
3513
TEST_F(AssemblerRISCV64Test,FCvtDLu_Default)3514 TEST_F(AssemblerRISCV64Test, FCvtDLu_Default) {
3515 DriverStr(RepeatFr(&Riscv64Assembler::FCvtDLu, "fcvt.d.lu {reg1}, {reg2}"), "FCvtDLu_Default");
3516 }
3517
TEST_F(AssemblerRISCV64Test,FMvXW)3518 TEST_F(AssemblerRISCV64Test, FMvXW) {
3519 DriverStr(RepeatRF(&Riscv64Assembler::FMvXW, "fmv.x.w {reg1}, {reg2}"), "FMvXW");
3520 }
3521
TEST_F(AssemblerRISCV64Test,FMvXD)3522 TEST_F(AssemblerRISCV64Test, FMvXD) {
3523 DriverStr(RepeatRF(&Riscv64Assembler::FMvXD, "fmv.x.d {reg1}, {reg2}"), "FMvXD");
3524 }
3525
TEST_F(AssemblerRISCV64Test,FMvWX)3526 TEST_F(AssemblerRISCV64Test, FMvWX) {
3527 DriverStr(RepeatFR(&Riscv64Assembler::FMvWX, "fmv.w.x {reg1}, {reg2}"), "FMvWX");
3528 }
3529
TEST_F(AssemblerRISCV64Test,FMvDX)3530 TEST_F(AssemblerRISCV64Test, FMvDX) {
3531 DriverStr(RepeatFR(&Riscv64Assembler::FMvDX, "fmv.d.x {reg1}, {reg2}"), "FMvDX");
3532 }
3533
TEST_F(AssemblerRISCV64Test,FClassS)3534 TEST_F(AssemblerRISCV64Test, FClassS) {
3535 DriverStr(RepeatRF(&Riscv64Assembler::FClassS, "fclass.s {reg1}, {reg2}"), "FClassS");
3536 }
3537
TEST_F(AssemblerRISCV64Test,FClassD)3538 TEST_F(AssemblerRISCV64Test, FClassD) {
3539 DriverStr(RepeatrF(&Riscv64Assembler::FClassD, "fclass.d {reg1}, {reg2}"), "FClassD");
3540 }
3541
TEST_F(AssemblerRISCV64Test,CLwsp)3542 TEST_F(AssemblerRISCV64Test, CLwsp) {
3543 DriverStr(RepeatCRImm(&Riscv64Assembler::CLwsp,
3544 /*is_short=*/false,
3545 /*no_zero_reg=*/true,
3546 /*no_zero_imm=*/false,
3547 /*imm_bits=*/6,
3548 /*shift=*/2,
3549 "c.lwsp {reg}, {imm}(sp)"),
3550 "CLwsp");
3551 }
3552
TEST_F(AssemblerRISCV64Test,CLdsp)3553 TEST_F(AssemblerRISCV64Test, CLdsp) {
3554 DriverStr(RepeatCRImm(&Riscv64Assembler::CLdsp,
3555 /*is_short=*/false,
3556 /*no_zero_reg=*/true,
3557 /*no_zero_imm=*/false,
3558 /*imm_bits=*/6,
3559 /*shift=*/3,
3560 "c.ldsp {reg}, {imm}(sp)"),
3561 "CLdsp");
3562 }
3563
TEST_F(AssemblerRISCV64Test,CFLdsp)3564 TEST_F(AssemblerRISCV64Test, CFLdsp) {
3565 DriverStr(RepeatCFImm(
3566 &Riscv64Assembler::CFLdsp, /*imm_bits=*/6, /*shift=*/3, "c.fldsp {reg}, {imm}(sp)"),
3567 "CFLdsp");
3568 }
3569
TEST_F(AssemblerRISCV64Test,CSwsp)3570 TEST_F(AssemblerRISCV64Test, CSwsp) {
3571 DriverStr(RepeatCRImm(&Riscv64Assembler::CSwsp,
3572 /*is_short=*/false,
3573 /*no_zero_reg=*/false,
3574 /*no_zero_imm=*/false,
3575 /*imm_bits=*/6,
3576 /*shift=*/2,
3577 "c.swsp {reg}, {imm}(sp)"),
3578 "CLwsp");
3579 }
3580
TEST_F(AssemblerRISCV64Test,CSdsp)3581 TEST_F(AssemblerRISCV64Test, CSdsp) {
3582 DriverStr(RepeatCRImm(&Riscv64Assembler::CSdsp,
3583 /*is_short=*/false,
3584 /*no_zero_reg=*/false,
3585 /*no_zero_imm=*/false,
3586 /*imm_bits=*/6,
3587 /*shift=*/3,
3588 "c.sdsp {reg}, {imm}(sp)"),
3589 "CLdsp");
3590 }
3591
TEST_F(AssemblerRISCV64Test,CFSdsp)3592 TEST_F(AssemblerRISCV64Test, CFSdsp) {
3593 DriverStr(RepeatCFImm(
3594 &Riscv64Assembler::CFSdsp, /*imm_bits=*/6, /*shift=*/3, "c.fsdsp {reg}, {imm}(sp)"),
3595 "CFLdsp");
3596 }
3597
TEST_F(AssemblerRISCV64Test,CLw)3598 TEST_F(AssemblerRISCV64Test, CLw) {
3599 DriverStr(RepeatCRRImm(
3600 &Riscv64Assembler::CLw, /*imm_bits=*/5, /*shift=*/2, "c.lw {reg1}, {imm}({reg2})"),
3601 "CLw");
3602 }
3603
TEST_F(AssemblerRISCV64Test,CLd)3604 TEST_F(AssemblerRISCV64Test, CLd) {
3605 DriverStr(RepeatCRRImm(
3606 &Riscv64Assembler::CLd, /*imm_bits=*/5, /*shift=*/3, "c.ld {reg1}, {imm}({reg2})"),
3607 "CLd");
3608 }
3609
TEST_F(AssemblerRISCV64Test,CFLd)3610 TEST_F(AssemblerRISCV64Test, CFLd) {
3611 DriverStr(RepeatCFRImm(&Riscv64Assembler::CFLd,
3612 /*imm_bits=*/5,
3613 /*shift=*/3,
3614 "c.fld {reg1}, {imm}({reg2})"),
3615 "CFLd");
3616 }
3617
TEST_F(AssemblerRISCV64Test,CSw)3618 TEST_F(AssemblerRISCV64Test, CSw) {
3619 DriverStr(RepeatCRRImm(
3620 &Riscv64Assembler::CSw, /*imm_bits=*/5, /*shift=*/2, "c.sw {reg1}, {imm}({reg2})"),
3621 "CSw");
3622 }
3623
TEST_F(AssemblerRISCV64Test,CSd)3624 TEST_F(AssemblerRISCV64Test, CSd) {
3625 DriverStr(RepeatCRRImm(
3626 &Riscv64Assembler::CSd, /*imm_bits=*/5, /*shift=*/3, "c.sd {reg1}, {imm}({reg2})"),
3627 "CSd");
3628 }
3629
TEST_F(AssemblerRISCV64Test,CFSd)3630 TEST_F(AssemblerRISCV64Test, CFSd) {
3631 DriverStr(RepeatCFRImm(&Riscv64Assembler::CFSd,
3632 /*imm_bits=*/5,
3633 /*shift=*/3,
3634 "c.fsd {reg1}, {imm}({reg2})"),
3635 "CFSd");
3636 }
3637
TEST_F(AssemblerRISCV64Test,CLi)3638 TEST_F(AssemblerRISCV64Test, CLi) {
3639 DriverStr(RepeatCRImm(&Riscv64Assembler::CLi,
3640 /*is_short=*/false,
3641 /*no_zero_reg=*/true,
3642 /*no_zero_imm=*/false,
3643 /*imm_bits=*/-6,
3644 /*shift=*/0,
3645 "c.li {reg}, {imm}"),
3646 "CLi");
3647 }
3648
TEST_F(AssemblerRISCV64Test,CLui)3649 TEST_F(AssemblerRISCV64Test, CLui) {
3650 std::string str;
3651 auto imms = CreateImmediateValuesBits(/*imm_bits=*/5, /*as_uint=*/true);
3652 for (uint32_t v = 0xfffe0; v <= 0xfffff; ++v) {
3653 imms.push_back(v);
3654 }
3655
3656 for (XRegister reg : GetRegisters()) {
3657 for (int64_t imm_raw : imms) {
3658 if (imm_raw == 0) {
3659 continue;
3660 }
3661
3662 if (reg == Zero || reg == SP) {
3663 continue;
3664 }
3665
3666 uint32_t imm = CreateImmediate(imm_raw);
3667 GetAssembler()->CLui(reg, imm);
3668
3669 std::string base = "c.lui {reg}, {imm}";
3670 ReplaceReg(REG_TOKEN, GetRegisterName(reg), &base);
3671 ReplaceImm(imm, /*bias=*/0, /*multiplier=*/1, &base);
3672 str += base;
3673 str += "\n";
3674 }
3675 }
3676
3677 DriverStr(str, "CLui");
3678 }
3679
TEST_F(AssemblerRISCV64Test,CAddi)3680 TEST_F(AssemblerRISCV64Test, CAddi) {
3681 DriverStr(RepeatCRImm(&Riscv64Assembler::CAddi,
3682 /*is_short=*/false,
3683 /*no_zero_reg=*/true,
3684 /*no_zero_imm=*/true,
3685 /*imm_bits=*/-6,
3686 /*shift=*/0,
3687 "c.addi {reg}, {imm}"),
3688 "CAddi");
3689 }
3690
TEST_F(AssemblerRISCV64Test,CAddiw)3691 TEST_F(AssemblerRISCV64Test, CAddiw) {
3692 DriverStr(RepeatCRImm(&Riscv64Assembler::CAddiw,
3693 /*is_short=*/false,
3694 /*no_zero_reg=*/true,
3695 /*no_zero_imm=*/false,
3696 /*imm_bits=*/-6,
3697 /*shift=*/0,
3698 "c.addiw {reg}, {imm}"),
3699 "CAddiw");
3700 }
3701
TEST_F(AssemblerRISCV64Test,CAddi16Sp)3702 TEST_F(AssemblerRISCV64Test, CAddi16Sp) {
3703 DriverStr(RepeatImm(&Riscv64Assembler::CAddi16Sp,
3704 /*no_zero_imm=*/true,
3705 /*imm_bits=*/-6,
3706 /*shift=*/4,
3707 "c.addi16sp sp, {imm}"),
3708 "CAddi16Sp");
3709 }
3710
TEST_F(AssemblerRISCV64Test,CAddi4Spn)3711 TEST_F(AssemblerRISCV64Test, CAddi4Spn) {
3712 DriverStr(RepeatCRImm(&Riscv64Assembler::CAddi4Spn,
3713 /*is_short=*/true,
3714 /*no_zero_reg=*/false,
3715 /*no_zero_imm=*/true,
3716 /*imm_bits=*/8,
3717 /*shift=*/2,
3718 "c.addi4spn {reg}, sp, {imm}"),
3719 "CAddi4Spn");
3720 }
3721
TEST_F(AssemblerRISCV64Test,CSlli)3722 TEST_F(AssemblerRISCV64Test, CSlli) {
3723 DriverStr(RepeatCRImm(&Riscv64Assembler::CSlli,
3724 /*is_short=*/false,
3725 /*no_zero_reg=*/true,
3726 /*no_zero_imm=*/true,
3727 /*imm_bits=*/6,
3728 /*shift=*/0,
3729 "c.slli {reg}, {imm}"),
3730 "CSlli");
3731 }
3732
TEST_F(AssemblerRISCV64Test,CSRli)3733 TEST_F(AssemblerRISCV64Test, CSRli) {
3734 DriverStr(RepeatCRImm(&Riscv64Assembler::CSrli,
3735 /*is_short=*/true,
3736 /*no_zero_reg=*/false,
3737 /*no_zero_imm=*/true,
3738 /*imm_bits=*/6,
3739 /*shift=*/0,
3740 "c.srli {reg}, {imm}"),
3741 "CSRli");
3742 }
3743
TEST_F(AssemblerRISCV64Test,CSRai)3744 TEST_F(AssemblerRISCV64Test, CSRai) {
3745 DriverStr(RepeatCRImm(&Riscv64Assembler::CSrai,
3746 /*is_short=*/true,
3747 /*no_zero_reg=*/false,
3748 /*no_zero_imm=*/true,
3749 /*imm_bits=*/6,
3750 /*shift=*/0,
3751 "c.srai {reg}, {imm}"),
3752 "CSRai");
3753 }
3754
TEST_F(AssemblerRISCV64Test,CAndi)3755 TEST_F(AssemblerRISCV64Test, CAndi) {
3756 DriverStr(RepeatCRImm(&Riscv64Assembler::CAndi,
3757 /*is_short=*/true,
3758 /*no_zero_reg=*/false,
3759 /*no_zero_imm=*/false,
3760 /*imm_bits=*/-6,
3761 /*shift=*/0,
3762 "c.andi {reg}, {imm}"),
3763 "CAndi");
3764 }
3765
TEST_F(AssemblerRISCV64Test,CMv)3766 TEST_F(AssemblerRISCV64Test, CMv) {
3767 DriverStr(RepeatCRRNonZero(&Riscv64Assembler::CMv, "c.mv {reg1}, {reg2}"), "CMv");
3768 }
3769
TEST_F(AssemblerRISCV64Test,CAdd)3770 TEST_F(AssemblerRISCV64Test, CAdd) {
3771 DriverStr(RepeatCRRNonZero(&Riscv64Assembler::CAdd, "c.add {reg1}, {reg2}"), "CAdd");
3772 }
3773
TEST_F(AssemblerRISCV64Test,CAnd)3774 TEST_F(AssemblerRISCV64Test, CAnd) {
3775 DriverStr(RepeatCRRShort(&Riscv64Assembler::CAnd, "c.and {reg1}, {reg2}"), "CAnd");
3776 }
3777
TEST_F(AssemblerRISCV64Test,COr)3778 TEST_F(AssemblerRISCV64Test, COr) {
3779 DriverStr(RepeatCRRShort(&Riscv64Assembler::COr, "c.or {reg1}, {reg2}"), "COr");
3780 }
3781
TEST_F(AssemblerRISCV64Test,CXor)3782 TEST_F(AssemblerRISCV64Test, CXor) {
3783 DriverStr(RepeatCRRShort(&Riscv64Assembler::CXor, "c.xor {reg1}, {reg2}"), "CXor");
3784 }
3785
TEST_F(AssemblerRISCV64Test,CSub)3786 TEST_F(AssemblerRISCV64Test, CSub) {
3787 DriverStr(RepeatCRRShort(&Riscv64Assembler::CSub, "c.sub {reg1}, {reg2}"), "CSub");
3788 }
3789
TEST_F(AssemblerRISCV64Test,CAddw)3790 TEST_F(AssemblerRISCV64Test, CAddw) {
3791 DriverStr(RepeatCRRShort(&Riscv64Assembler::CAddw, "c.addw {reg1}, {reg2}"), "CAddw");
3792 }
3793
TEST_F(AssemblerRISCV64Test,CSubw)3794 TEST_F(AssemblerRISCV64Test, CSubw) {
3795 DriverStr(RepeatCRRShort(&Riscv64Assembler::CSubw, "c.subw {reg1}, {reg2}"), "CSubw");
3796 }
3797
TEST_F(AssemblerRISCV64Test,CLbu)3798 TEST_F(AssemblerRISCV64Test, CLbu) {
3799 DriverStr(RepeatCRRImm(&Riscv64Assembler::CLbu,
3800 /*imm_bits=*/2,
3801 /*shift=*/0,
3802 "c.lbu {reg1}, {imm}({reg2})"),
3803 "CLbu");
3804 }
3805
TEST_F(AssemblerRISCV64Test,CLhu)3806 TEST_F(AssemblerRISCV64Test, CLhu) {
3807 DriverStr(RepeatCRRImm(&Riscv64Assembler::CLhu,
3808 /*imm_bits=*/1,
3809 /*shift=*/1,
3810 "c.lhu {reg1}, {imm}({reg2})"),
3811 "CLhu");
3812 }
3813
TEST_F(AssemblerRISCV64Test,CLh)3814 TEST_F(AssemblerRISCV64Test, CLh) {
3815 DriverStr(RepeatCRRImm(&Riscv64Assembler::CLh,
3816 /*imm_bits=*/1,
3817 /*shift=*/1,
3818 "c.lh {reg1}, {imm}({reg2})"),
3819 "CLh");
3820 }
3821
TEST_F(AssemblerRISCV64Test,CSb)3822 TEST_F(AssemblerRISCV64Test, CSb) {
3823 DriverStr(RepeatCRRImm(&Riscv64Assembler::CSb,
3824 /*imm_bits=*/2,
3825 /*shift=*/0,
3826 "c.sb {reg1}, {imm}({reg2})"),
3827 "CSb");
3828 }
3829
TEST_F(AssemblerRISCV64Test,CSh)3830 TEST_F(AssemblerRISCV64Test, CSh) {
3831 DriverStr(RepeatCRRImm(&Riscv64Assembler::CSh,
3832 /*imm_bits=*/1,
3833 /*shift=*/1,
3834 "c.sh {reg1}, {imm}({reg2})"),
3835 "CSh");
3836 }
3837
TEST_F(AssemblerRISCV64Test,CZextB)3838 TEST_F(AssemblerRISCV64Test, CZextB) {
3839 DriverStr(RepeatCRShort(&Riscv64Assembler::CZextB, "c.zext.b {reg}"), "CZextB");
3840 }
3841
TEST_F(AssemblerRISCV64Test,CSextB)3842 TEST_F(AssemblerRISCV64Test, CSextB) {
3843 DriverStr(RepeatCRShort(&Riscv64Assembler::CSextB, "c.sext.b {reg}"), "CSextB");
3844 }
3845
TEST_F(AssemblerRISCV64Test,CZextH)3846 TEST_F(AssemblerRISCV64Test, CZextH) {
3847 DriverStr(RepeatCRShort(&Riscv64Assembler::CZextH, "c.zext.h {reg}"), "CZextH");
3848 }
3849
TEST_F(AssemblerRISCV64Test,CSextH)3850 TEST_F(AssemblerRISCV64Test, CSextH) {
3851 DriverStr(RepeatCRShort(&Riscv64Assembler::CSextH, "c.sext.h {reg}"), "CSextH");
3852 }
3853
TEST_F(AssemblerRISCV64Test,CZextW)3854 TEST_F(AssemblerRISCV64Test, CZextW) {
3855 DriverStr(RepeatCRShort(&Riscv64Assembler::CZextW, "c.zext.w {reg}"), "CZextW");
3856 }
3857
TEST_F(AssemblerRISCV64Test,CNot)3858 TEST_F(AssemblerRISCV64Test, CNot) {
3859 DriverStr(RepeatCRShort(&Riscv64Assembler::CNot, "c.not {reg}"), "CNot");
3860 }
3861
TEST_F(AssemblerRISCV64Test,CMul)3862 TEST_F(AssemblerRISCV64Test, CMul) {
3863 DriverStr(RepeatCRRShort(&Riscv64Assembler::CMul, "c.mul {reg1}, {reg2}"), "CMul");
3864 }
3865
TEST_F(AssemblerRISCV64Test,CJ)3866 TEST_F(AssemblerRISCV64Test, CJ) {
3867 DriverStr(
3868 RepeatImm(
3869 &Riscv64Assembler::CJ, /*no_zero_imm=*/false, /*imm_bits=*/-11, /*shift=*/1, "c.j {imm}"),
3870 "CJ");
3871 }
3872
TEST_F(AssemblerRISCV64Test,CJr)3873 TEST_F(AssemblerRISCV64Test, CJr) {
3874 DriverStr(RepeatRNoZero(&Riscv64Assembler::CJr, "c.jr {reg}"), "CJr");
3875 }
3876
TEST_F(AssemblerRISCV64Test,CJalr)3877 TEST_F(AssemblerRISCV64Test, CJalr) {
3878 DriverStr(RepeatRNoZero(&Riscv64Assembler::CJalr, "c.jalr {reg}"), "CJalr");
3879 }
3880
TEST_F(AssemblerRISCV64Test,CBeqz)3881 TEST_F(AssemblerRISCV64Test, CBeqz) {
3882 DriverStr(RepeatCRImm(&Riscv64Assembler::CBeqz,
3883 /*is_short=*/true,
3884 /*no_zero_reg=*/false,
3885 /*no_zero_imm=*/false,
3886 /*imm_bits=*/-8,
3887 /*shift=*/1,
3888 "c.beqz {reg}, {imm}"),
3889 "CBeqz");
3890 }
3891
TEST_F(AssemblerRISCV64Test,CBnez)3892 TEST_F(AssemblerRISCV64Test, CBnez) {
3893 DriverStr(RepeatCRImm(&Riscv64Assembler::CBnez,
3894 /*is_short=*/true,
3895 /*no_zero_reg=*/false,
3896 /*no_zero_imm=*/false,
3897 /*imm_bits=*/-8,
3898 /*shift=*/1,
3899 "c.bnez {reg}, {imm}"),
3900 "CBnez");
3901 }
3902
TEST_F(AssemblerRISCV64Test,CEbreak)3903 TEST_F(AssemblerRISCV64Test, CEbreak) {
3904 __ CEbreak();
3905 DriverStr("c.ebreak", "CEbreak");
3906 }
3907
TEST_F(AssemblerRISCV64Test,CNop)3908 TEST_F(AssemblerRISCV64Test, CNop) {
3909 __ CNop();
3910 DriverStr("c.nop", "CNop");
3911 }
3912
TEST_F(AssemblerRISCV64Test,CUnimp)3913 TEST_F(AssemblerRISCV64Test, CUnimp) {
3914 __ CUnimp();
3915 DriverStr("c.unimp", "CUnimp");
3916 }
3917
TEST_F(AssemblerRISCV64Test,AddUw)3918 TEST_F(AssemblerRISCV64Test, AddUw) {
3919 ScopedCSuppression scs(this); // Avoid `c.zext.w`.
3920 DriverStr(RepeatRRR(&Riscv64Assembler::AddUw, "add.uw {reg1}, {reg2}, {reg3}"), "AddUw");
3921 }
3922
TEST_F(AssemblerRISCV64Test,Sh1Add)3923 TEST_F(AssemblerRISCV64Test, Sh1Add) {
3924 DriverStr(RepeatRRR(&Riscv64Assembler::Sh1Add, "sh1add {reg1}, {reg2}, {reg3}"), "Sh1Add");
3925 }
3926
TEST_F(AssemblerRISCV64Test,Sh1AddUw)3927 TEST_F(AssemblerRISCV64Test, Sh1AddUw) {
3928 DriverStr(RepeatRRR(&Riscv64Assembler::Sh1AddUw, "sh1add.uw {reg1}, {reg2}, {reg3}"), "Sh1AddUw");
3929 }
3930
TEST_F(AssemblerRISCV64Test,Sh2Add)3931 TEST_F(AssemblerRISCV64Test, Sh2Add) {
3932 DriverStr(RepeatRRR(&Riscv64Assembler::Sh2Add, "sh2add {reg1}, {reg2}, {reg3}"), "Sh2Add");
3933 }
3934
TEST_F(AssemblerRISCV64Test,Sh2AddUw)3935 TEST_F(AssemblerRISCV64Test, Sh2AddUw) {
3936 DriverStr(RepeatRRR(&Riscv64Assembler::Sh2AddUw, "sh2add.uw {reg1}, {reg2}, {reg3}"), "Sh2AddUw");
3937 }
3938
TEST_F(AssemblerRISCV64Test,Sh3Add)3939 TEST_F(AssemblerRISCV64Test, Sh3Add) {
3940 DriverStr(RepeatRRR(&Riscv64Assembler::Sh3Add, "sh3add {reg1}, {reg2}, {reg3}"), "Sh3Add");
3941 }
3942
TEST_F(AssemblerRISCV64Test,Sh3AddUw)3943 TEST_F(AssemblerRISCV64Test, Sh3AddUw) {
3944 DriverStr(RepeatRRR(&Riscv64Assembler::Sh3AddUw, "sh3add.uw {reg1}, {reg2}, {reg3}"), "Sh3AddUw");
3945 }
3946
TEST_F(AssemblerRISCV64Test,SlliUw)3947 TEST_F(AssemblerRISCV64Test, SlliUw) {
3948 DriverStr(RepeatRRIb(&Riscv64Assembler::SlliUw, /*imm_bits=*/6, "slli.uw {reg1}, {reg2}, {imm}"), "SlliUw");
3949 }
3950
TEST_F(AssemblerRISCV64Test,Andn)3951 TEST_F(AssemblerRISCV64Test, Andn) {
3952 DriverStr(RepeatRRR(&Riscv64Assembler::Andn, "andn {reg1}, {reg2}, {reg3}"), "Andn");
3953 }
3954
TEST_F(AssemblerRISCV64Test,Orn)3955 TEST_F(AssemblerRISCV64Test, Orn) {
3956 DriverStr(RepeatRRR(&Riscv64Assembler::Orn, "orn {reg1}, {reg2}, {reg3}"), "Orn");
3957 }
3958
TEST_F(AssemblerRISCV64Test,Xnor)3959 TEST_F(AssemblerRISCV64Test, Xnor) {
3960 DriverStr(RepeatRRR(&Riscv64Assembler::Xnor, "xnor {reg1}, {reg2}, {reg3}"), "Xnor");
3961 }
3962
TEST_F(AssemblerRISCV64Test,Clz)3963 TEST_F(AssemblerRISCV64Test, Clz) {
3964 DriverStr(RepeatRR(&Riscv64Assembler::Clz, "clz {reg1}, {reg2}"), "Clz");
3965 }
3966
TEST_F(AssemblerRISCV64Test,Clzw)3967 TEST_F(AssemblerRISCV64Test, Clzw) {
3968 DriverStr(RepeatRR(&Riscv64Assembler::Clzw, "clzw {reg1}, {reg2}"), "Clzw");
3969 }
3970
TEST_F(AssemblerRISCV64Test,Ctz)3971 TEST_F(AssemblerRISCV64Test, Ctz) {
3972 DriverStr(RepeatRR(&Riscv64Assembler::Ctz, "ctz {reg1}, {reg2}"), "Ctz");
3973 }
3974
TEST_F(AssemblerRISCV64Test,Ctzw)3975 TEST_F(AssemblerRISCV64Test, Ctzw) {
3976 DriverStr(RepeatRR(&Riscv64Assembler::Ctzw, "ctzw {reg1}, {reg2}"), "Ctzw");
3977 }
3978
TEST_F(AssemblerRISCV64Test,Cpop)3979 TEST_F(AssemblerRISCV64Test, Cpop) {
3980 DriverStr(RepeatRR(&Riscv64Assembler::Cpop, "cpop {reg1}, {reg2}"), "Cpop");
3981 }
3982
TEST_F(AssemblerRISCV64Test,Cpopw)3983 TEST_F(AssemblerRISCV64Test, Cpopw) {
3984 DriverStr(RepeatRR(&Riscv64Assembler::Cpopw, "cpopw {reg1}, {reg2}"), "Cpopw");
3985 }
3986
TEST_F(AssemblerRISCV64Test,Min)3987 TEST_F(AssemblerRISCV64Test, Min) {
3988 DriverStr(RepeatRRR(&Riscv64Assembler::Min, "min {reg1}, {reg2}, {reg3}"), "Min");
3989 }
3990
TEST_F(AssemblerRISCV64Test,Minu)3991 TEST_F(AssemblerRISCV64Test, Minu) {
3992 DriverStr(RepeatRRR(&Riscv64Assembler::Minu, "minu {reg1}, {reg2}, {reg3}"), "Minu");
3993 }
3994
TEST_F(AssemblerRISCV64Test,Max)3995 TEST_F(AssemblerRISCV64Test, Max) {
3996 DriverStr(RepeatRRR(&Riscv64Assembler::Max, "max {reg1}, {reg2}, {reg3}"), "Max");
3997 }
3998
TEST_F(AssemblerRISCV64Test,Maxu)3999 TEST_F(AssemblerRISCV64Test, Maxu) {
4000 DriverStr(RepeatRRR(&Riscv64Assembler::Maxu, "maxu {reg1}, {reg2}, {reg3}"), "Maxu");
4001 }
4002
TEST_F(AssemblerRISCV64Test,Rol)4003 TEST_F(AssemblerRISCV64Test, Rol) {
4004 DriverStr(RepeatRRR(&Riscv64Assembler::Rol, "rol {reg1}, {reg2}, {reg3}"), "Rol");
4005 }
4006
TEST_F(AssemblerRISCV64Test,Rolw)4007 TEST_F(AssemblerRISCV64Test, Rolw) {
4008 DriverStr(RepeatRRR(&Riscv64Assembler::Rolw, "rolw {reg1}, {reg2}, {reg3}"), "Rolw");
4009 }
4010
TEST_F(AssemblerRISCV64Test,Ror)4011 TEST_F(AssemblerRISCV64Test, Ror) {
4012 DriverStr(RepeatRRR(&Riscv64Assembler::Ror, "ror {reg1}, {reg2}, {reg3}"), "Ror");
4013 }
4014
TEST_F(AssemblerRISCV64Test,Rorw)4015 TEST_F(AssemblerRISCV64Test, Rorw) {
4016 DriverStr(RepeatRRR(&Riscv64Assembler::Rorw, "rorw {reg1}, {reg2}, {reg3}"), "Rorw");
4017 }
4018
TEST_F(AssemblerRISCV64Test,Rori)4019 TEST_F(AssemblerRISCV64Test, Rori) {
4020 DriverStr(RepeatRRIb(&Riscv64Assembler::Rori, /*imm_bits=*/6, "rori {reg1}, {reg2}, {imm}"), "Rori");
4021 }
4022
TEST_F(AssemblerRISCV64Test,Roriw)4023 TEST_F(AssemblerRISCV64Test, Roriw) {
4024 DriverStr(RepeatRRIb(&Riscv64Assembler::Roriw, /*imm_bits=*/5, "roriw {reg1}, {reg2}, {imm}"),
4025 "Roriw");
4026 }
4027
TEST_F(AssemblerRISCV64Test,OrcB)4028 TEST_F(AssemblerRISCV64Test, OrcB) {
4029 DriverStr(RepeatRR(&Riscv64Assembler::OrcB, "orc.b {reg1}, {reg2}"), "OrcB");
4030 }
4031
TEST_F(AssemblerRISCV64Test,Rev8)4032 TEST_F(AssemblerRISCV64Test, Rev8) {
4033 DriverStr(RepeatRR(&Riscv64Assembler::Rev8, "rev8 {reg1}, {reg2}"), "Rev8");
4034 }
4035
TEST_F(AssemblerRISCV64Test,ZbbSextB)4036 TEST_F(AssemblerRISCV64Test, ZbbSextB) {
4037 ScopedCSuppression scs(this);
4038 DriverStr(RepeatRR(&Riscv64Assembler::ZbbSextB, "sext.b {reg1}, {reg2}"), "ZbbSextB");
4039 }
4040
TEST_F(AssemblerRISCV64Test,ZbbSextH)4041 TEST_F(AssemblerRISCV64Test, ZbbSextH) {
4042 ScopedCSuppression scs(this);
4043 DriverStr(RepeatRR(&Riscv64Assembler::ZbbSextH, "sext.h {reg1}, {reg2}"), "ZbbSextH");
4044 }
4045
TEST_F(AssemblerRISCV64Test,ZbbZextH)4046 TEST_F(AssemblerRISCV64Test, ZbbZextH) {
4047 ScopedCSuppression scs(this);
4048 DriverStr(RepeatRR(&Riscv64Assembler::ZbbZextH, "zext.h {reg1}, {reg2}"), "ZbbZextH");
4049 }
4050
TEST_F(AssemblerRISCV64Test,Bclr)4051 TEST_F(AssemblerRISCV64Test, Bclr) {
4052 DriverStr(RepeatRRR(&Riscv64Assembler::Bclr, "bclr {reg1}, {reg2}, {reg3}"), "Bclr");
4053 }
4054
TEST_F(AssemblerRISCV64Test,Bclri)4055 TEST_F(AssemblerRISCV64Test, Bclri) {
4056 DriverStr(RepeatRRIb(&Riscv64Assembler::Bclri, /*imm_bits=*/6, "bclri {reg1}, {reg2}, {imm}"),
4057 "Bclri");
4058 }
4059
TEST_F(AssemblerRISCV64Test,Bext)4060 TEST_F(AssemblerRISCV64Test, Bext) {
4061 DriverStr(RepeatRRR(&Riscv64Assembler::Bext, "bext {reg1}, {reg2}, {reg3}"), "Bext");
4062 }
4063
TEST_F(AssemblerRISCV64Test,Bexti)4064 TEST_F(AssemblerRISCV64Test, Bexti) {
4065 DriverStr(RepeatRRIb(&Riscv64Assembler::Bexti, /*imm_bits=*/6, "bexti {reg1}, {reg2}, {imm}"),
4066 "Bexti");
4067 }
4068
TEST_F(AssemblerRISCV64Test,Binv)4069 TEST_F(AssemblerRISCV64Test, Binv) {
4070 DriverStr(RepeatRRR(&Riscv64Assembler::Binv, "binv {reg1}, {reg2}, {reg3}"), "Binv");
4071 }
4072
TEST_F(AssemblerRISCV64Test,Binvi)4073 TEST_F(AssemblerRISCV64Test, Binvi) {
4074 DriverStr(RepeatRRIb(&Riscv64Assembler::Binvi, /*imm_bits=*/6, "binvi {reg1}, {reg2}, {imm}"),
4075 "Binvi");
4076 }
4077
TEST_F(AssemblerRISCV64Test,Bset)4078 TEST_F(AssemblerRISCV64Test, Bset) {
4079 DriverStr(RepeatRRR(&Riscv64Assembler::Bset, "bset {reg1}, {reg2}, {reg3}"), "Bset");
4080 }
4081
TEST_F(AssemblerRISCV64Test,Bseti)4082 TEST_F(AssemblerRISCV64Test, Bseti) {
4083 DriverStr(RepeatRRIb(&Riscv64Assembler::Bseti, /*imm_bits=*/6, "bseti {reg1}, {reg2}, {imm}"),
4084 "Bseti");
4085 }
4086
4087 // Vector Instructions
4088
TEST_F(AssemblerRISCV64Test,VSetvl)4089 TEST_F(AssemblerRISCV64Test, VSetvl) {
4090 DriverStr(RepeatRRR(&Riscv64Assembler::VSetvl, "vsetvl {reg1}, {reg2}, {reg3}"), "VSetvl");
4091 }
4092
TEST_F(AssemblerRISCV64Test,VSetivli)4093 TEST_F(AssemblerRISCV64Test, VSetivli) {
4094 auto replacer = [=](uint32_t uimm, std::string* s) {
4095 ReplaceImm(uimm, /*bias=*/ 0, /*multiplier=*/ 1, s);
4096 };
4097
4098 std::vector<int64_t> imms = CreateImmediateValuesBits(5, true);
4099
4100 DriverStr(TestVSetI(&Riscv64Assembler::VSetivli,
4101 imms,
4102 replacer,
4103 "vsetivli {reg1}, {imm}, {sew}, {lmul}, {vta}, {vma}"),
4104 "VSetivli");
4105 }
4106
TEST_F(AssemblerRISCV64Test,VSetvli)4107 TEST_F(AssemblerRISCV64Test, VSetvli) {
4108 auto replacer = [=](XRegister reg, std::string* s) {
4109 ReplaceReg(REG2_TOKEN, GetRegisterName(reg), s);
4110 };
4111
4112 DriverStr(TestVSetI(&Riscv64Assembler::VSetvli,
4113 GetRegisters(),
4114 replacer,
4115 "vsetvli {reg1}, {reg2}, {sew}, {lmul}, {vta}, {vma}"),
4116 "VSetvli");
4117 }
4118
TEST_F(AssemblerRISCV64Test,VLe8)4119 TEST_F(AssemblerRISCV64Test, VLe8) {
4120 DriverStr(RepeatVRVmFiltered(
4121 &Riscv64Assembler::VLe8, "vle8.v {reg1}, ({reg2}){vm}", SkipV0Vm<XRegister>()),
4122 "VLe8");
4123 }
4124
TEST_F(AssemblerRISCV64Test,VLe16)4125 TEST_F(AssemblerRISCV64Test, VLe16) {
4126 DriverStr(RepeatVRVmFiltered(
4127 &Riscv64Assembler::VLe16, "vle16.v {reg1}, ({reg2}){vm}", SkipV0Vm<XRegister>()),
4128 "VLe16");
4129 }
4130
TEST_F(AssemblerRISCV64Test,VLe32)4131 TEST_F(AssemblerRISCV64Test, VLe32) {
4132 DriverStr(RepeatVRVmFiltered(
4133 &Riscv64Assembler::VLe32, "vle32.v {reg1}, ({reg2}){vm}", SkipV0Vm<XRegister>()),
4134 "VLe32");
4135 }
4136
TEST_F(AssemblerRISCV64Test,VLe64)4137 TEST_F(AssemblerRISCV64Test, VLe64) {
4138 DriverStr(RepeatVRVmFiltered(
4139 &Riscv64Assembler::VLe64, "vle64.v {reg1}, ({reg2}){vm}", SkipV0Vm<XRegister>()),
4140 "VLe64");
4141 }
4142
TEST_F(AssemblerRISCV64Test,VLm)4143 TEST_F(AssemblerRISCV64Test, VLm) {
4144 DriverStr(RepeatVR(&Riscv64Assembler::VLm, "vlm.v {reg1}, ({reg2})"), "VLm");
4145 }
4146
TEST_F(AssemblerRISCV64Test,VSe8)4147 TEST_F(AssemblerRISCV64Test, VSe8) {
4148 DriverStr(RepeatVRVm(&Riscv64Assembler::VSe8, "vse8.v {reg1}, ({reg2}){vm}"), "VSe8");
4149 }
4150
TEST_F(AssemblerRISCV64Test,VSe16)4151 TEST_F(AssemblerRISCV64Test, VSe16) {
4152 DriverStr(RepeatVRVm(&Riscv64Assembler::VSe16, "vse16.v {reg1}, ({reg2}){vm}"), "VSe16");
4153 }
4154
TEST_F(AssemblerRISCV64Test,VSe32)4155 TEST_F(AssemblerRISCV64Test, VSe32) {
4156 DriverStr(RepeatVRVm(&Riscv64Assembler::VSe32, "vse32.v {reg1}, ({reg2}){vm}"), "VSe32");
4157 }
4158
TEST_F(AssemblerRISCV64Test,VSe64)4159 TEST_F(AssemblerRISCV64Test, VSe64) {
4160 DriverStr(RepeatVRVm(&Riscv64Assembler::VSe64, "vse64.v {reg1}, ({reg2}){vm}"), "VSe64");
4161 }
4162
TEST_F(AssemblerRISCV64Test,VSm)4163 TEST_F(AssemblerRISCV64Test, VSm) {
4164 DriverStr(RepeatVR(&Riscv64Assembler::VSm, "vsm.v {reg1}, ({reg2})"), "VSm");
4165 }
4166
TEST_F(AssemblerRISCV64Test,VLe8ff)4167 TEST_F(AssemblerRISCV64Test, VLe8ff) {
4168 DriverStr(RepeatVR(&Riscv64Assembler::VLe8ff, "vle8ff.v {reg1}, ({reg2})"), "VLe8ff");
4169 }
4170
TEST_F(AssemblerRISCV64Test,VLe16ff)4171 TEST_F(AssemblerRISCV64Test, VLe16ff) {
4172 DriverStr(RepeatVR(&Riscv64Assembler::VLe16ff, "vle16ff.v {reg1}, ({reg2})"), "VLe16ff");
4173 }
4174
TEST_F(AssemblerRISCV64Test,VLe32ff)4175 TEST_F(AssemblerRISCV64Test, VLe32ff) {
4176 DriverStr(RepeatVR(&Riscv64Assembler::VLe32ff, "vle32ff.v {reg1}, ({reg2})"), "VLe32ff");
4177 }
4178
TEST_F(AssemblerRISCV64Test,VLe64ff)4179 TEST_F(AssemblerRISCV64Test, VLe64ff) {
4180 DriverStr(RepeatVR(&Riscv64Assembler::VLe64ff, "vle64ff.v {reg1}, ({reg2})"), "VLe64ff");
4181 }
4182
TEST_F(AssemblerRISCV64Test,VLse8)4183 TEST_F(AssemblerRISCV64Test, VLse8) {
4184 DriverStr(RepeatVRRVmFiltered(&Riscv64Assembler::VLse8,
4185 "vlse8.v {reg1}, ({reg2}), {reg3}{vm}",
4186 SkipV0Vm<XRegister, XRegister>()),
4187 "VLse8");
4188 }
4189
TEST_F(AssemblerRISCV64Test,VLse16)4190 TEST_F(AssemblerRISCV64Test, VLse16) {
4191 DriverStr(RepeatVRRVmFiltered(&Riscv64Assembler::VLse16,
4192 "vlse16.v {reg1}, ({reg2}), {reg3}{vm}",
4193 SkipV0Vm<XRegister, XRegister>()),
4194 "VLse16");
4195 }
4196
TEST_F(AssemblerRISCV64Test,VLse32)4197 TEST_F(AssemblerRISCV64Test, VLse32) {
4198 DriverStr(RepeatVRRVmFiltered(&Riscv64Assembler::VLse32,
4199 "vlse32.v {reg1}, ({reg2}), {reg3}{vm}",
4200 SkipV0Vm<XRegister, XRegister>()),
4201 "VLse32");
4202 }
4203
TEST_F(AssemblerRISCV64Test,VLse64)4204 TEST_F(AssemblerRISCV64Test, VLse64) {
4205 DriverStr(RepeatVRRVmFiltered(&Riscv64Assembler::VLse64,
4206 "vlse64.v {reg1}, ({reg2}), {reg3}{vm}",
4207 SkipV0Vm<XRegister, XRegister>()),
4208 "VLse64");
4209 }
4210
TEST_F(AssemblerRISCV64Test,VSse8)4211 TEST_F(AssemblerRISCV64Test, VSse8) {
4212 DriverStr(RepeatVRRVm(&Riscv64Assembler::VSse8, "vsse8.v {reg1}, ({reg2}), {reg3}{vm}"), "VSse8");
4213 }
4214
TEST_F(AssemblerRISCV64Test,VSse16)4215 TEST_F(AssemblerRISCV64Test, VSse16) {
4216 DriverStr(RepeatVRRVm(&Riscv64Assembler::VSse16, "vsse16.v {reg1}, ({reg2}), {reg3}{vm}"),
4217 "VSse16");
4218 }
4219
TEST_F(AssemblerRISCV64Test,VSse32)4220 TEST_F(AssemblerRISCV64Test, VSse32) {
4221 DriverStr(RepeatVRRVm(&Riscv64Assembler::VSse32, "vsse32.v {reg1}, ({reg2}), {reg3}{vm}"),
4222 "VSse32");
4223 }
4224
TEST_F(AssemblerRISCV64Test,VSse64)4225 TEST_F(AssemblerRISCV64Test, VSse64) {
4226 DriverStr(RepeatVRRVm(&Riscv64Assembler::VSse64, "vsse64.v {reg1}, ({reg2}), {reg3}{vm}"),
4227 "VSse64");
4228 }
4229
TEST_F(AssemblerRISCV64Test,VLoxei8)4230 TEST_F(AssemblerRISCV64Test, VLoxei8) {
4231 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLoxei8,
4232 "vloxei8.v {reg1}, ({reg2}), {reg3}{vm}",
4233 SkipV0Vm<XRegister, VRegister>()),
4234 "VLoxei8");
4235 }
4236
TEST_F(AssemblerRISCV64Test,VLoxei16)4237 TEST_F(AssemblerRISCV64Test, VLoxei16) {
4238 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLoxei16,
4239 "vloxei16.v {reg1}, ({reg2}), {reg3}{vm}",
4240 SkipV0Vm<XRegister, VRegister>()),
4241 "VLoxei16");
4242 }
4243
TEST_F(AssemblerRISCV64Test,VLoxei32)4244 TEST_F(AssemblerRISCV64Test, VLoxei32) {
4245 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLoxei32,
4246 "vloxei32.v {reg1}, ({reg2}), {reg3}{vm}",
4247 SkipV0Vm<XRegister, VRegister>()),
4248 "VLoxei32");
4249 }
4250
TEST_F(AssemblerRISCV64Test,VLoxei64)4251 TEST_F(AssemblerRISCV64Test, VLoxei64) {
4252 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLoxei64,
4253 "vloxei64.v {reg1}, ({reg2}), {reg3}{vm}",
4254 SkipV0Vm<XRegister, VRegister>()),
4255 "VLoxei64");
4256 }
4257
TEST_F(AssemblerRISCV64Test,VLuxei8)4258 TEST_F(AssemblerRISCV64Test, VLuxei8) {
4259 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLuxei8,
4260 "vluxei8.v {reg1}, ({reg2}), {reg3}{vm}",
4261 SkipV0Vm<XRegister, VRegister>()),
4262 "VLuxei8");
4263 }
4264
TEST_F(AssemblerRISCV64Test,VLuxei16)4265 TEST_F(AssemblerRISCV64Test, VLuxei16) {
4266 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLuxei16,
4267 "vluxei16.v {reg1}, ({reg2}), {reg3}{vm}",
4268 SkipV0Vm<XRegister, VRegister>()),
4269 "VLuxei16");
4270 }
4271
TEST_F(AssemblerRISCV64Test,VLuxei32)4272 TEST_F(AssemblerRISCV64Test, VLuxei32) {
4273 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLuxei32,
4274 "vluxei32.v {reg1}, ({reg2}), {reg3}{vm}",
4275 SkipV0Vm<XRegister, VRegister>()),
4276 "VLuxei32");
4277 }
4278
TEST_F(AssemblerRISCV64Test,VLuxei64)4279 TEST_F(AssemblerRISCV64Test, VLuxei64) {
4280 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLuxei64,
4281 "vluxei64.v {reg1}, ({reg2}), {reg3}{vm}",
4282 SkipV0Vm<XRegister, VRegister>()),
4283 "VLuxei64");
4284 }
4285
TEST_F(AssemblerRISCV64Test,VSoxei8)4286 TEST_F(AssemblerRISCV64Test, VSoxei8) {
4287 DriverStr(RepeatVRVVm(&Riscv64Assembler::VSoxei8, "vsoxei8.v {reg1}, ({reg2}), {reg3}{vm}"),
4288 "VSoxei8");
4289 }
4290
TEST_F(AssemblerRISCV64Test,VSoxei16)4291 TEST_F(AssemblerRISCV64Test, VSoxei16) {
4292 DriverStr(RepeatVRVVm(&Riscv64Assembler::VSoxei16, "vsoxei16.v {reg1}, ({reg2}), {reg3}{vm}"),
4293 "VSoxei16");
4294 }
4295
TEST_F(AssemblerRISCV64Test,VSoxei32)4296 TEST_F(AssemblerRISCV64Test, VSoxei32) {
4297 DriverStr(RepeatVRVVm(&Riscv64Assembler::VSoxei32, "vsoxei32.v {reg1}, ({reg2}), {reg3}{vm}"),
4298 "VSoxei32");
4299 }
4300
TEST_F(AssemblerRISCV64Test,VSoxei64)4301 TEST_F(AssemblerRISCV64Test, VSoxei64) {
4302 DriverStr(RepeatVRVVm(&Riscv64Assembler::VSoxei64, "vsoxei64.v {reg1}, ({reg2}), {reg3}{vm}"),
4303 "VSoxei64");
4304 }
4305
TEST_F(AssemblerRISCV64Test,VSuxei8)4306 TEST_F(AssemblerRISCV64Test, VSuxei8) {
4307 DriverStr(RepeatVRVVm(&Riscv64Assembler::VSuxei8, "vsuxei8.v {reg1}, ({reg2}), {reg3}{vm}"),
4308 "VSuxei8");
4309 }
4310
TEST_F(AssemblerRISCV64Test,VSuxei16)4311 TEST_F(AssemblerRISCV64Test, VSuxei16) {
4312 DriverStr(RepeatVRVVm(&Riscv64Assembler::VSuxei16, "vsuxei16.v {reg1}, ({reg2}), {reg3}{vm}"),
4313 "VSuxei16");
4314 }
4315
TEST_F(AssemblerRISCV64Test,VSuxei32)4316 TEST_F(AssemblerRISCV64Test, VSuxei32) {
4317 DriverStr(RepeatVRVVm(&Riscv64Assembler::VSuxei32, "vsuxei32.v {reg1}, ({reg2}), {reg3}{vm}"),
4318 "VSuxei32");
4319 }
4320
TEST_F(AssemblerRISCV64Test,VSuxei64)4321 TEST_F(AssemblerRISCV64Test, VSuxei64) {
4322 DriverStr(RepeatVRVVm(&Riscv64Assembler::VSuxei64, "vsuxei64.v {reg1}, ({reg2}), {reg3}{vm}"),
4323 "VSuxei64");
4324 }
4325
TEST_F(AssemblerRISCV64Test,VLseg2e8)4326 TEST_F(AssemblerRISCV64Test, VLseg2e8) {
4327 DriverStr(
4328 RepeatVRVmFiltered(
4329 &Riscv64Assembler::VLseg2e8, "vlseg2e8.v {reg1}, ({reg2}){vm}", SkipV0Vm<XRegister>()),
4330 "VLseg2e8");
4331 }
4332
TEST_F(AssemblerRISCV64Test,VLseg2e16)4333 TEST_F(AssemblerRISCV64Test, VLseg2e16) {
4334 DriverStr(
4335 RepeatVRVmFiltered(
4336 &Riscv64Assembler::VLseg2e16, "vlseg2e16.v {reg1}, ({reg2}){vm}", SkipV0Vm<XRegister>()),
4337 "VLseg2e16");
4338 }
4339
TEST_F(AssemblerRISCV64Test,VLseg2e32)4340 TEST_F(AssemblerRISCV64Test, VLseg2e32) {
4341 DriverStr(
4342 RepeatVRVmFiltered(
4343 &Riscv64Assembler::VLseg2e32, "vlseg2e32.v {reg1}, ({reg2}){vm}", SkipV0Vm<XRegister>()),
4344 "VLseg2e32");
4345 }
4346
TEST_F(AssemblerRISCV64Test,VLseg2e64)4347 TEST_F(AssemblerRISCV64Test, VLseg2e64) {
4348 DriverStr(
4349 RepeatVRVmFiltered(
4350 &Riscv64Assembler::VLseg2e64, "vlseg2e64.v {reg1}, ({reg2}){vm}", SkipV0Vm<XRegister>()),
4351 "VLseg2e64");
4352 }
4353
TEST_F(AssemblerRISCV64Test,VLseg3e8)4354 TEST_F(AssemblerRISCV64Test, VLseg3e8) {
4355 DriverStr(
4356 RepeatVRVmFiltered(
4357 &Riscv64Assembler::VLseg3e8, "vlseg3e8.v {reg1}, ({reg2}){vm}", SkipV0Vm<XRegister>()),
4358 "VLseg3e8");
4359 }
4360
TEST_F(AssemblerRISCV64Test,VLseg3e16)4361 TEST_F(AssemblerRISCV64Test, VLseg3e16) {
4362 DriverStr(
4363 RepeatVRVmFiltered(
4364 &Riscv64Assembler::VLseg3e16, "vlseg3e16.v {reg1}, ({reg2}){vm}", SkipV0Vm<XRegister>()),
4365 "VLseg3e16");
4366 }
4367
TEST_F(AssemblerRISCV64Test,VLseg3e32)4368 TEST_F(AssemblerRISCV64Test, VLseg3e32) {
4369 DriverStr(
4370 RepeatVRVmFiltered(
4371 &Riscv64Assembler::VLseg3e32, "vlseg3e32.v {reg1}, ({reg2}){vm}", SkipV0Vm<XRegister>()),
4372 "VLseg3e32");
4373 }
4374
TEST_F(AssemblerRISCV64Test,VLseg3e64)4375 TEST_F(AssemblerRISCV64Test, VLseg3e64) {
4376 DriverStr(
4377 RepeatVRVmFiltered(
4378 &Riscv64Assembler::VLseg3e64, "vlseg3e64.v {reg1}, ({reg2}){vm}", SkipV0Vm<XRegister>()),
4379 "VLseg3e64");
4380 }
4381
TEST_F(AssemblerRISCV64Test,VLseg4e8)4382 TEST_F(AssemblerRISCV64Test, VLseg4e8) {
4383 DriverStr(
4384 RepeatVRVmFiltered(
4385 &Riscv64Assembler::VLseg4e8, "vlseg4e8.v {reg1}, ({reg2}){vm}", SkipV0Vm<XRegister>()),
4386 "VLseg4e8");
4387 }
4388
TEST_F(AssemblerRISCV64Test,VLseg4e16)4389 TEST_F(AssemblerRISCV64Test, VLseg4e16) {
4390 DriverStr(
4391 RepeatVRVmFiltered(
4392 &Riscv64Assembler::VLseg4e16, "vlseg4e16.v {reg1}, ({reg2}){vm}", SkipV0Vm<XRegister>()),
4393 "VLseg4e16");
4394 }
4395
TEST_F(AssemblerRISCV64Test,VLseg4e32)4396 TEST_F(AssemblerRISCV64Test, VLseg4e32) {
4397 DriverStr(
4398 RepeatVRVmFiltered(
4399 &Riscv64Assembler::VLseg4e32, "vlseg4e32.v {reg1}, ({reg2}){vm}", SkipV0Vm<XRegister>()),
4400 "VLseg4e32");
4401 }
4402
TEST_F(AssemblerRISCV64Test,VLseg4e64)4403 TEST_F(AssemblerRISCV64Test, VLseg4e64) {
4404 DriverStr(
4405 RepeatVRVmFiltered(
4406 &Riscv64Assembler::VLseg4e64, "vlseg4e64.v {reg1}, ({reg2}){vm}", SkipV0Vm<XRegister>()),
4407 "VLseg4e64");
4408 }
4409
TEST_F(AssemblerRISCV64Test,VLseg5e8)4410 TEST_F(AssemblerRISCV64Test, VLseg5e8) {
4411 DriverStr(
4412 RepeatVRVmFiltered(
4413 &Riscv64Assembler::VLseg5e8, "vlseg5e8.v {reg1}, ({reg2}){vm}", SkipV0Vm<XRegister>()),
4414 "VLseg5e8");
4415 }
4416
TEST_F(AssemblerRISCV64Test,VLseg5e16)4417 TEST_F(AssemblerRISCV64Test, VLseg5e16) {
4418 DriverStr(
4419 RepeatVRVmFiltered(
4420 &Riscv64Assembler::VLseg5e16, "vlseg5e16.v {reg1}, ({reg2}){vm}", SkipV0Vm<XRegister>()),
4421 "VLseg5e16");
4422 }
4423
TEST_F(AssemblerRISCV64Test,VLseg5e32)4424 TEST_F(AssemblerRISCV64Test, VLseg5e32) {
4425 DriverStr(
4426 RepeatVRVmFiltered(
4427 &Riscv64Assembler::VLseg5e32, "vlseg5e32.v {reg1}, ({reg2}){vm}", SkipV0Vm<XRegister>()),
4428 "VLseg5e32");
4429 }
4430
TEST_F(AssemblerRISCV64Test,VLseg5e64)4431 TEST_F(AssemblerRISCV64Test, VLseg5e64) {
4432 DriverStr(
4433 RepeatVRVmFiltered(
4434 &Riscv64Assembler::VLseg5e64, "vlseg5e64.v {reg1}, ({reg2}){vm}", SkipV0Vm<XRegister>()),
4435 "VLseg5e64");
4436 }
4437
TEST_F(AssemblerRISCV64Test,VLseg6e8)4438 TEST_F(AssemblerRISCV64Test, VLseg6e8) {
4439 DriverStr(
4440 RepeatVRVmFiltered(
4441 &Riscv64Assembler::VLseg6e8, "vlseg6e8.v {reg1}, ({reg2}){vm}", SkipV0Vm<XRegister>()),
4442 "VLseg6e8");
4443 }
4444
TEST_F(AssemblerRISCV64Test,VLseg6e16)4445 TEST_F(AssemblerRISCV64Test, VLseg6e16) {
4446 DriverStr(
4447 RepeatVRVmFiltered(
4448 &Riscv64Assembler::VLseg6e16, "vlseg6e16.v {reg1}, ({reg2}){vm}", SkipV0Vm<XRegister>()),
4449 "VLseg6e16");
4450 }
4451
TEST_F(AssemblerRISCV64Test,VLseg6e32)4452 TEST_F(AssemblerRISCV64Test, VLseg6e32) {
4453 DriverStr(
4454 RepeatVRVmFiltered(
4455 &Riscv64Assembler::VLseg6e32, "vlseg6e32.v {reg1}, ({reg2}){vm}", SkipV0Vm<XRegister>()),
4456 "VLseg6e32");
4457 }
4458
TEST_F(AssemblerRISCV64Test,VLseg6e64)4459 TEST_F(AssemblerRISCV64Test, VLseg6e64) {
4460 DriverStr(
4461 RepeatVRVmFiltered(
4462 &Riscv64Assembler::VLseg6e64, "vlseg6e64.v {reg1}, ({reg2}){vm}", SkipV0Vm<XRegister>()),
4463 "VLseg6e64");
4464 }
4465
TEST_F(AssemblerRISCV64Test,VLseg7e8)4466 TEST_F(AssemblerRISCV64Test, VLseg7e8) {
4467 DriverStr(
4468 RepeatVRVmFiltered(
4469 &Riscv64Assembler::VLseg7e8, "vlseg7e8.v {reg1}, ({reg2}){vm}", SkipV0Vm<XRegister>()),
4470 "VLseg7e8");
4471 }
4472
TEST_F(AssemblerRISCV64Test,VLseg7e16)4473 TEST_F(AssemblerRISCV64Test, VLseg7e16) {
4474 DriverStr(
4475 RepeatVRVmFiltered(
4476 &Riscv64Assembler::VLseg7e16, "vlseg7e16.v {reg1}, ({reg2}){vm}", SkipV0Vm<XRegister>()),
4477 "VLseg7e16");
4478 }
4479
TEST_F(AssemblerRISCV64Test,VLseg7e32)4480 TEST_F(AssemblerRISCV64Test, VLseg7e32) {
4481 DriverStr(
4482 RepeatVRVmFiltered(
4483 &Riscv64Assembler::VLseg7e32, "vlseg7e32.v {reg1}, ({reg2}){vm}", SkipV0Vm<XRegister>()),
4484 "VLseg7e32");
4485 }
4486
TEST_F(AssemblerRISCV64Test,VLseg7e64)4487 TEST_F(AssemblerRISCV64Test, VLseg7e64) {
4488 DriverStr(
4489 RepeatVRVmFiltered(
4490 &Riscv64Assembler::VLseg7e64, "vlseg7e64.v {reg1}, ({reg2}){vm}", SkipV0Vm<XRegister>()),
4491 "VLseg7e64");
4492 }
4493
TEST_F(AssemblerRISCV64Test,VLseg8e8)4494 TEST_F(AssemblerRISCV64Test, VLseg8e8) {
4495 DriverStr(
4496 RepeatVRVmFiltered(
4497 &Riscv64Assembler::VLseg8e8, "vlseg8e8.v {reg1}, ({reg2}){vm}", SkipV0Vm<XRegister>()),
4498 "VLseg8e8");
4499 }
4500
TEST_F(AssemblerRISCV64Test,VLseg8e16)4501 TEST_F(AssemblerRISCV64Test, VLseg8e16) {
4502 DriverStr(
4503 RepeatVRVmFiltered(
4504 &Riscv64Assembler::VLseg8e16, "vlseg8e16.v {reg1}, ({reg2}){vm}", SkipV0Vm<XRegister>()),
4505 "VLseg8e16");
4506 }
4507
TEST_F(AssemblerRISCV64Test,VLseg8e32)4508 TEST_F(AssemblerRISCV64Test, VLseg8e32) {
4509 DriverStr(
4510 RepeatVRVmFiltered(
4511 &Riscv64Assembler::VLseg8e32, "vlseg8e32.v {reg1}, ({reg2}){vm}", SkipV0Vm<XRegister>()),
4512 "VLseg8e32");
4513 }
4514
TEST_F(AssemblerRISCV64Test,VLseg8e64)4515 TEST_F(AssemblerRISCV64Test, VLseg8e64) {
4516 DriverStr(
4517 RepeatVRVmFiltered(
4518 &Riscv64Assembler::VLseg8e64, "vlseg8e64.v {reg1}, ({reg2}){vm}", SkipV0Vm<XRegister>()),
4519 "VLseg8e64");
4520 }
4521
TEST_F(AssemblerRISCV64Test,VSseg2e8)4522 TEST_F(AssemblerRISCV64Test, VSseg2e8) {
4523 DriverStr(RepeatVRVm(&Riscv64Assembler::VSseg2e8, "vsseg2e8.v {reg1}, ({reg2}){vm}"), "VSseg2e8");
4524 }
4525
TEST_F(AssemblerRISCV64Test,VSseg2e16)4526 TEST_F(AssemblerRISCV64Test, VSseg2e16) {
4527 DriverStr(RepeatVRVm(&Riscv64Assembler::VSseg2e16, "vsseg2e16.v {reg1}, ({reg2}){vm}"),
4528 "VSseg2e16");
4529 }
4530
TEST_F(AssemblerRISCV64Test,VSseg2e32)4531 TEST_F(AssemblerRISCV64Test, VSseg2e32) {
4532 DriverStr(RepeatVRVm(&Riscv64Assembler::VSseg2e32, "vsseg2e32.v {reg1}, ({reg2}){vm}"),
4533 "VSseg2e32");
4534 }
4535
TEST_F(AssemblerRISCV64Test,VSseg2e64)4536 TEST_F(AssemblerRISCV64Test, VSseg2e64) {
4537 DriverStr(RepeatVRVm(&Riscv64Assembler::VSseg2e64, "vsseg2e64.v {reg1}, ({reg2}){vm}"),
4538 "VSseg2e64");
4539 }
4540
TEST_F(AssemblerRISCV64Test,VSseg3e8)4541 TEST_F(AssemblerRISCV64Test, VSseg3e8) {
4542 DriverStr(RepeatVRVm(&Riscv64Assembler::VSseg3e8, "vsseg3e8.v {reg1}, ({reg2}){vm}"), "VSseg3e8");
4543 }
4544
TEST_F(AssemblerRISCV64Test,VSseg3e16)4545 TEST_F(AssemblerRISCV64Test, VSseg3e16) {
4546 DriverStr(RepeatVRVm(&Riscv64Assembler::VSseg3e16, "vsseg3e16.v {reg1}, ({reg2}){vm}"),
4547 "VSseg3e16");
4548 }
4549
TEST_F(AssemblerRISCV64Test,VSseg3e32)4550 TEST_F(AssemblerRISCV64Test, VSseg3e32) {
4551 DriverStr(RepeatVRVm(&Riscv64Assembler::VSseg3e32, "vsseg3e32.v {reg1}, ({reg2}){vm}"),
4552 "VSseg3e32");
4553 }
4554
TEST_F(AssemblerRISCV64Test,VSseg3e64)4555 TEST_F(AssemblerRISCV64Test, VSseg3e64) {
4556 DriverStr(RepeatVRVm(&Riscv64Assembler::VSseg3e64, "vsseg3e64.v {reg1}, ({reg2}){vm}"),
4557 "VSseg3e64");
4558 }
4559
TEST_F(AssemblerRISCV64Test,VSseg4e8)4560 TEST_F(AssemblerRISCV64Test, VSseg4e8) {
4561 DriverStr(RepeatVRVm(&Riscv64Assembler::VSseg4e8, "vsseg4e8.v {reg1}, ({reg2}){vm}"), "VSseg4e8");
4562 }
4563
TEST_F(AssemblerRISCV64Test,VSseg4e16)4564 TEST_F(AssemblerRISCV64Test, VSseg4e16) {
4565 DriverStr(RepeatVRVm(&Riscv64Assembler::VSseg4e16, "vsseg4e16.v {reg1}, ({reg2}){vm}"),
4566 "VSseg4e16");
4567 }
4568
TEST_F(AssemblerRISCV64Test,VSseg4e32)4569 TEST_F(AssemblerRISCV64Test, VSseg4e32) {
4570 DriverStr(RepeatVRVm(&Riscv64Assembler::VSseg4e32, "vsseg4e32.v {reg1}, ({reg2}){vm}"),
4571 "VSseg4e32");
4572 }
4573
TEST_F(AssemblerRISCV64Test,VSseg4e64)4574 TEST_F(AssemblerRISCV64Test, VSseg4e64) {
4575 DriverStr(RepeatVRVm(&Riscv64Assembler::VSseg4e64, "vsseg4e64.v {reg1}, ({reg2}){vm}"),
4576 "VSseg4e64");
4577 }
4578
TEST_F(AssemblerRISCV64Test,VSseg5e8)4579 TEST_F(AssemblerRISCV64Test, VSseg5e8) {
4580 DriverStr(RepeatVRVm(&Riscv64Assembler::VSseg5e8, "vsseg5e8.v {reg1}, ({reg2}){vm}"), "VSseg5e8");
4581 }
4582
TEST_F(AssemblerRISCV64Test,VSseg5e16)4583 TEST_F(AssemblerRISCV64Test, VSseg5e16) {
4584 DriverStr(RepeatVRVm(&Riscv64Assembler::VSseg5e16, "vsseg5e16.v {reg1}, ({reg2}){vm}"),
4585 "VSseg5e16");
4586 }
4587
TEST_F(AssemblerRISCV64Test,VSseg5e32)4588 TEST_F(AssemblerRISCV64Test, VSseg5e32) {
4589 DriverStr(RepeatVRVm(&Riscv64Assembler::VSseg5e32, "vsseg5e32.v {reg1}, ({reg2}){vm}"),
4590 "VSseg5e32");
4591 }
4592
TEST_F(AssemblerRISCV64Test,VSseg5e64)4593 TEST_F(AssemblerRISCV64Test, VSseg5e64) {
4594 DriverStr(RepeatVRVm(&Riscv64Assembler::VSseg5e64, "vsseg5e64.v {reg1}, ({reg2}){vm}"),
4595 "VSseg5e64");
4596 }
4597
TEST_F(AssemblerRISCV64Test,VSseg6e8)4598 TEST_F(AssemblerRISCV64Test, VSseg6e8) {
4599 DriverStr(RepeatVRVm(&Riscv64Assembler::VSseg6e8, "vsseg6e8.v {reg1}, ({reg2}){vm}"), "VSseg6e8");
4600 }
4601
TEST_F(AssemblerRISCV64Test,VSseg6e16)4602 TEST_F(AssemblerRISCV64Test, VSseg6e16) {
4603 DriverStr(RepeatVRVm(&Riscv64Assembler::VSseg6e16, "vsseg6e16.v {reg1}, ({reg2}){vm}"),
4604 "VSseg6e16");
4605 }
4606
TEST_F(AssemblerRISCV64Test,VSseg6e32)4607 TEST_F(AssemblerRISCV64Test, VSseg6e32) {
4608 DriverStr(RepeatVRVm(&Riscv64Assembler::VSseg6e32, "vsseg6e32.v {reg1}, ({reg2}){vm}"),
4609 "VSseg6e32");
4610 }
4611
TEST_F(AssemblerRISCV64Test,VSseg6e64)4612 TEST_F(AssemblerRISCV64Test, VSseg6e64) {
4613 DriverStr(RepeatVRVm(&Riscv64Assembler::VSseg6e64, "vsseg6e64.v {reg1}, ({reg2}){vm}"),
4614 "VSseg6e64");
4615 }
4616
TEST_F(AssemblerRISCV64Test,VSseg7e8)4617 TEST_F(AssemblerRISCV64Test, VSseg7e8) {
4618 DriverStr(RepeatVRVm(&Riscv64Assembler::VSseg7e8, "vsseg7e8.v {reg1}, ({reg2}){vm}"), "VSseg7e8");
4619 }
4620
TEST_F(AssemblerRISCV64Test,VSseg7e16)4621 TEST_F(AssemblerRISCV64Test, VSseg7e16) {
4622 DriverStr(RepeatVRVm(&Riscv64Assembler::VSseg7e16, "vsseg7e16.v {reg1}, ({reg2}){vm}"),
4623 "VSseg7e16");
4624 }
4625
TEST_F(AssemblerRISCV64Test,VSseg7e32)4626 TEST_F(AssemblerRISCV64Test, VSseg7e32) {
4627 DriverStr(RepeatVRVm(&Riscv64Assembler::VSseg7e32, "vsseg7e32.v {reg1}, ({reg2}){vm}"),
4628 "VSseg7e32");
4629 }
4630
TEST_F(AssemblerRISCV64Test,VSseg7e64)4631 TEST_F(AssemblerRISCV64Test, VSseg7e64) {
4632 DriverStr(RepeatVRVm(&Riscv64Assembler::VSseg7e64, "vsseg7e64.v {reg1}, ({reg2}){vm}"),
4633 "VSseg7e64");
4634 }
4635
TEST_F(AssemblerRISCV64Test,VSseg8e8)4636 TEST_F(AssemblerRISCV64Test, VSseg8e8) {
4637 DriverStr(RepeatVRVm(&Riscv64Assembler::VSseg8e8, "vsseg8e8.v {reg1}, ({reg2}){vm}"), "VSseg8e8");
4638 }
4639
TEST_F(AssemblerRISCV64Test,VSseg8e16)4640 TEST_F(AssemblerRISCV64Test, VSseg8e16) {
4641 DriverStr(RepeatVRVm(&Riscv64Assembler::VSseg8e16, "vsseg8e16.v {reg1}, ({reg2}){vm}"),
4642 "VSseg8e16");
4643 }
4644
TEST_F(AssemblerRISCV64Test,VSseg8e32)4645 TEST_F(AssemblerRISCV64Test, VSseg8e32) {
4646 DriverStr(RepeatVRVm(&Riscv64Assembler::VSseg8e32, "vsseg8e32.v {reg1}, ({reg2}){vm}"),
4647 "VSseg8e32");
4648 }
4649
TEST_F(AssemblerRISCV64Test,VSseg8e64)4650 TEST_F(AssemblerRISCV64Test, VSseg8e64) {
4651 DriverStr(RepeatVRVm(&Riscv64Assembler::VSseg8e64, "vsseg8e64.v {reg1}, ({reg2}){vm}"),
4652 "VSseg8e64");
4653 }
4654
TEST_F(AssemblerRISCV64Test,VLseg2e8ff)4655 TEST_F(AssemblerRISCV64Test, VLseg2e8ff) {
4656 DriverStr(RepeatVRVmFiltered(&Riscv64Assembler::VLseg2e8ff,
4657 "vlseg2e8ff.v {reg1}, ({reg2}){vm}",
4658 SkipV0Vm<XRegister>()),
4659 "VLseg2e8ff");
4660 }
4661
TEST_F(AssemblerRISCV64Test,VLseg2e16ff)4662 TEST_F(AssemblerRISCV64Test, VLseg2e16ff) {
4663 DriverStr(RepeatVRVmFiltered(&Riscv64Assembler::VLseg2e16ff,
4664 "vlseg2e16ff.v {reg1}, ({reg2}){vm}",
4665 SkipV0Vm<XRegister>()),
4666 "VLseg2e16ff");
4667 }
4668
TEST_F(AssemblerRISCV64Test,VLseg2e32ff)4669 TEST_F(AssemblerRISCV64Test, VLseg2e32ff) {
4670 DriverStr(RepeatVRVmFiltered(&Riscv64Assembler::VLseg2e32ff,
4671 "vlseg2e32ff.v {reg1}, ({reg2}){vm}",
4672 SkipV0Vm<XRegister>()),
4673 "VLseg2e32ff");
4674 }
4675
TEST_F(AssemblerRISCV64Test,VLseg2e64ff)4676 TEST_F(AssemblerRISCV64Test, VLseg2e64ff) {
4677 DriverStr(RepeatVRVmFiltered(&Riscv64Assembler::VLseg2e64ff,
4678 "vlseg2e64ff.v {reg1}, ({reg2}){vm}",
4679 SkipV0Vm<XRegister>()),
4680 "VLseg2e64ff");
4681 }
4682
TEST_F(AssemblerRISCV64Test,VLseg3e8ff)4683 TEST_F(AssemblerRISCV64Test, VLseg3e8ff) {
4684 DriverStr(RepeatVRVmFiltered(&Riscv64Assembler::VLseg3e8ff,
4685 "vlseg3e8ff.v {reg1}, ({reg2}){vm}",
4686 SkipV0Vm<XRegister>()),
4687 "VLseg3e8ff");
4688 }
4689
TEST_F(AssemblerRISCV64Test,VLseg3e16ff)4690 TEST_F(AssemblerRISCV64Test, VLseg3e16ff) {
4691 DriverStr(RepeatVRVmFiltered(&Riscv64Assembler::VLseg3e16ff,
4692 "vlseg3e16ff.v {reg1}, ({reg2}){vm}",
4693 SkipV0Vm<XRegister>()),
4694 "VLseg3e16ff");
4695 }
4696
TEST_F(AssemblerRISCV64Test,VLseg3e32ff)4697 TEST_F(AssemblerRISCV64Test, VLseg3e32ff) {
4698 DriverStr(RepeatVRVmFiltered(&Riscv64Assembler::VLseg3e32ff,
4699 "vlseg3e32ff.v {reg1}, ({reg2}){vm}",
4700 SkipV0Vm<XRegister>()),
4701 "VLseg3e32ff");
4702 }
4703
TEST_F(AssemblerRISCV64Test,VLseg3e64ff)4704 TEST_F(AssemblerRISCV64Test, VLseg3e64ff) {
4705 DriverStr(RepeatVRVmFiltered(&Riscv64Assembler::VLseg3e64ff,
4706 "vlseg3e64ff.v {reg1}, ({reg2}){vm}",
4707 SkipV0Vm<XRegister>()),
4708 "VLseg3e64ff");
4709 }
4710
TEST_F(AssemblerRISCV64Test,VLseg4e8ff)4711 TEST_F(AssemblerRISCV64Test, VLseg4e8ff) {
4712 DriverStr(RepeatVRVmFiltered(&Riscv64Assembler::VLseg4e8ff,
4713 "vlseg4e8ff.v {reg1}, ({reg2}){vm}",
4714 SkipV0Vm<XRegister>()),
4715 "VLseg4e8ff");
4716 }
4717
TEST_F(AssemblerRISCV64Test,VLseg4e16ff)4718 TEST_F(AssemblerRISCV64Test, VLseg4e16ff) {
4719 DriverStr(RepeatVRVmFiltered(&Riscv64Assembler::VLseg4e16ff,
4720 "vlseg4e16ff.v {reg1}, ({reg2}){vm}",
4721 SkipV0Vm<XRegister>()),
4722 "VLseg4e16ff");
4723 }
4724
TEST_F(AssemblerRISCV64Test,VLseg4e32ff)4725 TEST_F(AssemblerRISCV64Test, VLseg4e32ff) {
4726 DriverStr(RepeatVRVmFiltered(&Riscv64Assembler::VLseg4e32ff,
4727 "vlseg4e32ff.v {reg1}, ({reg2}){vm}",
4728 SkipV0Vm<XRegister>()),
4729 "VLseg4e32ff");
4730 }
4731
TEST_F(AssemblerRISCV64Test,VLseg4e64ff)4732 TEST_F(AssemblerRISCV64Test, VLseg4e64ff) {
4733 DriverStr(RepeatVRVmFiltered(&Riscv64Assembler::VLseg4e64ff,
4734 "vlseg4e64ff.v {reg1}, ({reg2}){vm}",
4735 SkipV0Vm<XRegister>()),
4736 "VLseg4e64ff");
4737 }
4738
TEST_F(AssemblerRISCV64Test,VLseg5e8ff)4739 TEST_F(AssemblerRISCV64Test, VLseg5e8ff) {
4740 DriverStr(RepeatVRVmFiltered(&Riscv64Assembler::VLseg5e8ff,
4741 "vlseg5e8ff.v {reg1}, ({reg2}){vm}",
4742 SkipV0Vm<XRegister>()),
4743 "VLseg5e8ff");
4744 }
4745
TEST_F(AssemblerRISCV64Test,VLseg5e16ff)4746 TEST_F(AssemblerRISCV64Test, VLseg5e16ff) {
4747 DriverStr(RepeatVRVmFiltered(&Riscv64Assembler::VLseg5e16ff,
4748 "vlseg5e16ff.v {reg1}, ({reg2}){vm}",
4749 SkipV0Vm<XRegister>()),
4750 "VLseg5e16ff");
4751 }
4752
TEST_F(AssemblerRISCV64Test,VLseg5e32ff)4753 TEST_F(AssemblerRISCV64Test, VLseg5e32ff) {
4754 DriverStr(RepeatVRVmFiltered(&Riscv64Assembler::VLseg5e32ff,
4755 "vlseg5e32ff.v {reg1}, ({reg2}){vm}",
4756 SkipV0Vm<XRegister>()),
4757 "VLseg5e32ff");
4758 }
4759
TEST_F(AssemblerRISCV64Test,VLseg5e64ff)4760 TEST_F(AssemblerRISCV64Test, VLseg5e64ff) {
4761 DriverStr(RepeatVRVmFiltered(&Riscv64Assembler::VLseg5e64ff,
4762 "vlseg5e64ff.v {reg1}, ({reg2}){vm}",
4763 SkipV0Vm<XRegister>()),
4764 "VLseg5e64ff");
4765 }
4766
TEST_F(AssemblerRISCV64Test,VLseg6e8ff)4767 TEST_F(AssemblerRISCV64Test, VLseg6e8ff) {
4768 DriverStr(RepeatVRVmFiltered(&Riscv64Assembler::VLseg6e8ff,
4769 "vlseg6e8ff.v {reg1}, ({reg2}){vm}",
4770 SkipV0Vm<XRegister>()),
4771 "VLseg6e8ff");
4772 }
4773
TEST_F(AssemblerRISCV64Test,VLseg6e16ff)4774 TEST_F(AssemblerRISCV64Test, VLseg6e16ff) {
4775 DriverStr(RepeatVRVmFiltered(&Riscv64Assembler::VLseg6e16ff,
4776 "vlseg6e16ff.v {reg1}, ({reg2}){vm}",
4777 SkipV0Vm<XRegister>()),
4778 "VLseg6e16ff");
4779 }
4780
TEST_F(AssemblerRISCV64Test,VLseg6e32ff)4781 TEST_F(AssemblerRISCV64Test, VLseg6e32ff) {
4782 DriverStr(RepeatVRVmFiltered(&Riscv64Assembler::VLseg6e32ff,
4783 "vlseg6e32ff.v {reg1}, ({reg2}){vm}",
4784 SkipV0Vm<XRegister>()),
4785 "VLseg6e32ff");
4786 }
4787
TEST_F(AssemblerRISCV64Test,VLseg6e64ff)4788 TEST_F(AssemblerRISCV64Test, VLseg6e64ff) {
4789 DriverStr(RepeatVRVmFiltered(&Riscv64Assembler::VLseg6e64ff,
4790 "vlseg6e64ff.v {reg1}, ({reg2}){vm}",
4791 SkipV0Vm<XRegister>()),
4792 "VLseg6e64ff");
4793 }
4794
TEST_F(AssemblerRISCV64Test,VLseg7e8ff)4795 TEST_F(AssemblerRISCV64Test, VLseg7e8ff) {
4796 DriverStr(RepeatVRVmFiltered(&Riscv64Assembler::VLseg7e8ff,
4797 "vlseg7e8ff.v {reg1}, ({reg2}){vm}",
4798 SkipV0Vm<XRegister>()),
4799 "VLseg7e8ff");
4800 }
4801
TEST_F(AssemblerRISCV64Test,VLseg7e16ff)4802 TEST_F(AssemblerRISCV64Test, VLseg7e16ff) {
4803 DriverStr(RepeatVRVmFiltered(&Riscv64Assembler::VLseg7e16ff,
4804 "vlseg7e16ff.v {reg1}, ({reg2}){vm}",
4805 SkipV0Vm<XRegister>()),
4806 "VLseg7e16ff");
4807 }
4808
TEST_F(AssemblerRISCV64Test,VLseg7e32ff)4809 TEST_F(AssemblerRISCV64Test, VLseg7e32ff) {
4810 DriverStr(RepeatVRVmFiltered(&Riscv64Assembler::VLseg7e32ff,
4811 "vlseg7e32ff.v {reg1}, ({reg2}){vm}",
4812 SkipV0Vm<XRegister>()),
4813 "VLseg7e32ff");
4814 }
4815
TEST_F(AssemblerRISCV64Test,VLseg7e64ff)4816 TEST_F(AssemblerRISCV64Test, VLseg7e64ff) {
4817 DriverStr(RepeatVRVmFiltered(&Riscv64Assembler::VLseg7e64ff,
4818 "vlseg7e64ff.v {reg1}, ({reg2}){vm}",
4819 SkipV0Vm<XRegister>()),
4820 "VLseg7e64ff");
4821 }
4822
TEST_F(AssemblerRISCV64Test,VLseg8e8ff)4823 TEST_F(AssemblerRISCV64Test, VLseg8e8ff) {
4824 DriverStr(RepeatVRVmFiltered(&Riscv64Assembler::VLseg8e8ff,
4825 "vlseg8e8ff.v {reg1}, ({reg2}){vm}",
4826 SkipV0Vm<XRegister>()),
4827 "VLseg8e8ff");
4828 }
4829
TEST_F(AssemblerRISCV64Test,VLseg8e16ff)4830 TEST_F(AssemblerRISCV64Test, VLseg8e16ff) {
4831 DriverStr(RepeatVRVmFiltered(&Riscv64Assembler::VLseg8e16ff,
4832 "vlseg8e16ff.v {reg1}, ({reg2}){vm}",
4833 SkipV0Vm<XRegister>()),
4834 "VLseg8e16ff");
4835 }
4836
TEST_F(AssemblerRISCV64Test,VLseg8e32ff)4837 TEST_F(AssemblerRISCV64Test, VLseg8e32ff) {
4838 DriverStr(RepeatVRVmFiltered(&Riscv64Assembler::VLseg8e32ff,
4839 "vlseg8e32ff.v {reg1}, ({reg2}){vm}",
4840 SkipV0Vm<XRegister>()),
4841 "VLseg8e32ff");
4842 }
4843
TEST_F(AssemblerRISCV64Test,VLseg8e64ff)4844 TEST_F(AssemblerRISCV64Test, VLseg8e64ff) {
4845 DriverStr(RepeatVRVmFiltered(&Riscv64Assembler::VLseg8e64ff,
4846 "vlseg8e64ff.v {reg1}, ({reg2}){vm}",
4847 SkipV0Vm<XRegister>()),
4848 "VLseg8e64ff");
4849 }
4850
TEST_F(AssemblerRISCV64Test,VLsseg2e8)4851 TEST_F(AssemblerRISCV64Test, VLsseg2e8) {
4852 DriverStr(RepeatVRRVmFiltered(&Riscv64Assembler::VLsseg2e8,
4853 "vlsseg2e8.v {reg1}, ({reg2}), {reg3}{vm}",
4854 SkipV0Vm<XRegister, XRegister>()),
4855 "VLsseg2e8");
4856 }
4857
TEST_F(AssemblerRISCV64Test,VLsseg2e16)4858 TEST_F(AssemblerRISCV64Test, VLsseg2e16) {
4859 DriverStr(RepeatVRRVmFiltered(&Riscv64Assembler::VLsseg2e16,
4860 "vlsseg2e16.v {reg1}, ({reg2}), {reg3}{vm}",
4861 SkipV0Vm<XRegister, XRegister>()),
4862 "VLsseg2e16");
4863 }
4864
TEST_F(AssemblerRISCV64Test,VLsseg2e32)4865 TEST_F(AssemblerRISCV64Test, VLsseg2e32) {
4866 DriverStr(RepeatVRRVmFiltered(&Riscv64Assembler::VLsseg2e32,
4867 "vlsseg2e32.v {reg1}, ({reg2}), {reg3}{vm}",
4868 SkipV0Vm<XRegister, XRegister>()),
4869 "VLsseg2e32");
4870 }
4871
TEST_F(AssemblerRISCV64Test,VLsseg2e64)4872 TEST_F(AssemblerRISCV64Test, VLsseg2e64) {
4873 DriverStr(RepeatVRRVmFiltered(&Riscv64Assembler::VLsseg2e64,
4874 "vlsseg2e64.v {reg1}, ({reg2}), {reg3}{vm}",
4875 SkipV0Vm<XRegister, XRegister>()),
4876 "VLsseg2e64");
4877 }
4878
TEST_F(AssemblerRISCV64Test,VLsseg3e8)4879 TEST_F(AssemblerRISCV64Test, VLsseg3e8) {
4880 DriverStr(RepeatVRRVmFiltered(&Riscv64Assembler::VLsseg3e8,
4881 "vlsseg3e8.v {reg1}, ({reg2}), {reg3}{vm}",
4882 SkipV0Vm<XRegister, XRegister>()),
4883 "VLsseg3e8");
4884 }
4885
TEST_F(AssemblerRISCV64Test,VLsseg3e16)4886 TEST_F(AssemblerRISCV64Test, VLsseg3e16) {
4887 DriverStr(RepeatVRRVmFiltered(&Riscv64Assembler::VLsseg3e16,
4888 "vlsseg3e16.v {reg1}, ({reg2}), {reg3}{vm}",
4889 SkipV0Vm<XRegister, XRegister>()),
4890 "VLsseg3e16");
4891 }
4892
TEST_F(AssemblerRISCV64Test,VLsseg3e32)4893 TEST_F(AssemblerRISCV64Test, VLsseg3e32) {
4894 DriverStr(RepeatVRRVmFiltered(&Riscv64Assembler::VLsseg3e32,
4895 "vlsseg3e32.v {reg1}, ({reg2}), {reg3}{vm}",
4896 SkipV0Vm<XRegister, XRegister>()),
4897 "VLsseg3e32");
4898 }
4899
TEST_F(AssemblerRISCV64Test,VLsseg3e64)4900 TEST_F(AssemblerRISCV64Test, VLsseg3e64) {
4901 DriverStr(RepeatVRRVmFiltered(&Riscv64Assembler::VLsseg3e64,
4902 "vlsseg3e64.v {reg1}, ({reg2}), {reg3}{vm}",
4903 SkipV0Vm<XRegister, XRegister>()),
4904 "VLsseg3e64");
4905 }
4906
TEST_F(AssemblerRISCV64Test,VLsseg4e8)4907 TEST_F(AssemblerRISCV64Test, VLsseg4e8) {
4908 DriverStr(RepeatVRRVmFiltered(&Riscv64Assembler::VLsseg4e8,
4909 "vlsseg4e8.v {reg1}, ({reg2}), {reg3}{vm}",
4910 SkipV0Vm<XRegister, XRegister>()),
4911 "VLsseg4e8");
4912 }
4913
TEST_F(AssemblerRISCV64Test,VLsseg4e16)4914 TEST_F(AssemblerRISCV64Test, VLsseg4e16) {
4915 DriverStr(RepeatVRRVmFiltered(&Riscv64Assembler::VLsseg4e16,
4916 "vlsseg4e16.v {reg1}, ({reg2}), {reg3}{vm}",
4917 SkipV0Vm<XRegister, XRegister>()),
4918 "VLsseg4e16");
4919 }
4920
TEST_F(AssemblerRISCV64Test,VLsseg4e32)4921 TEST_F(AssemblerRISCV64Test, VLsseg4e32) {
4922 DriverStr(RepeatVRRVmFiltered(&Riscv64Assembler::VLsseg4e32,
4923 "vlsseg4e32.v {reg1}, ({reg2}), {reg3}{vm}",
4924 SkipV0Vm<XRegister, XRegister>()),
4925 "VLsseg4e32");
4926 }
4927
TEST_F(AssemblerRISCV64Test,VLsseg4e64)4928 TEST_F(AssemblerRISCV64Test, VLsseg4e64) {
4929 DriverStr(RepeatVRRVmFiltered(&Riscv64Assembler::VLsseg4e64,
4930 "vlsseg4e64.v {reg1}, ({reg2}), {reg3}{vm}",
4931 SkipV0Vm<XRegister, XRegister>()),
4932 "VLsseg4e64");
4933 }
4934
TEST_F(AssemblerRISCV64Test,VLsseg5e8)4935 TEST_F(AssemblerRISCV64Test, VLsseg5e8) {
4936 DriverStr(RepeatVRRVmFiltered(&Riscv64Assembler::VLsseg5e8,
4937 "vlsseg5e8.v {reg1}, ({reg2}), {reg3}{vm}",
4938 SkipV0Vm<XRegister, XRegister>()),
4939 "VLsseg5e8");
4940 }
4941
TEST_F(AssemblerRISCV64Test,VLsseg5e16)4942 TEST_F(AssemblerRISCV64Test, VLsseg5e16) {
4943 DriverStr(RepeatVRRVmFiltered(&Riscv64Assembler::VLsseg5e16,
4944 "vlsseg5e16.v {reg1}, ({reg2}), {reg3}{vm}",
4945 SkipV0Vm<XRegister, XRegister>()),
4946 "VLsseg5e16");
4947 }
4948
TEST_F(AssemblerRISCV64Test,VLsseg5e32)4949 TEST_F(AssemblerRISCV64Test, VLsseg5e32) {
4950 DriverStr(RepeatVRRVmFiltered(&Riscv64Assembler::VLsseg5e32,
4951 "vlsseg5e32.v {reg1}, ({reg2}), {reg3}{vm}",
4952 SkipV0Vm<XRegister, XRegister>()),
4953 "VLsseg5e32");
4954 }
4955
TEST_F(AssemblerRISCV64Test,VLsseg5e64)4956 TEST_F(AssemblerRISCV64Test, VLsseg5e64) {
4957 DriverStr(RepeatVRRVmFiltered(&Riscv64Assembler::VLsseg5e64,
4958 "vlsseg5e64.v {reg1}, ({reg2}), {reg3}{vm}",
4959 SkipV0Vm<XRegister, XRegister>()),
4960 "VLsseg5e64");
4961 }
4962
TEST_F(AssemblerRISCV64Test,VLsseg6e8)4963 TEST_F(AssemblerRISCV64Test, VLsseg6e8) {
4964 DriverStr(RepeatVRRVmFiltered(&Riscv64Assembler::VLsseg6e8,
4965 "vlsseg6e8.v {reg1}, ({reg2}), {reg3}{vm}",
4966 SkipV0Vm<XRegister, XRegister>()),
4967 "VLsseg6e8");
4968 }
4969
TEST_F(AssemblerRISCV64Test,VLsseg6e16)4970 TEST_F(AssemblerRISCV64Test, VLsseg6e16) {
4971 DriverStr(RepeatVRRVmFiltered(&Riscv64Assembler::VLsseg6e16,
4972 "vlsseg6e16.v {reg1}, ({reg2}), {reg3}{vm}",
4973 SkipV0Vm<XRegister, XRegister>()),
4974 "VLsseg6e16");
4975 }
4976
TEST_F(AssemblerRISCV64Test,VLsseg6e32)4977 TEST_F(AssemblerRISCV64Test, VLsseg6e32) {
4978 DriverStr(RepeatVRRVmFiltered(&Riscv64Assembler::VLsseg6e32,
4979 "vlsseg6e32.v {reg1}, ({reg2}), {reg3}{vm}",
4980 SkipV0Vm<XRegister, XRegister>()),
4981 "VLsseg6e32");
4982 }
4983
TEST_F(AssemblerRISCV64Test,VLsseg6e64)4984 TEST_F(AssemblerRISCV64Test, VLsseg6e64) {
4985 DriverStr(RepeatVRRVmFiltered(&Riscv64Assembler::VLsseg6e64,
4986 "vlsseg6e64.v {reg1}, ({reg2}), {reg3}{vm}",
4987 SkipV0Vm<XRegister, XRegister>()),
4988 "VLsseg6e64");
4989 }
4990
TEST_F(AssemblerRISCV64Test,VLsseg7e8)4991 TEST_F(AssemblerRISCV64Test, VLsseg7e8) {
4992 DriverStr(RepeatVRRVmFiltered(&Riscv64Assembler::VLsseg7e8,
4993 "vlsseg7e8.v {reg1}, ({reg2}), {reg3}{vm}",
4994 SkipV0Vm<XRegister, XRegister>()),
4995 "VLsseg7e8");
4996 }
4997
TEST_F(AssemblerRISCV64Test,VLsseg7e16)4998 TEST_F(AssemblerRISCV64Test, VLsseg7e16) {
4999 DriverStr(RepeatVRRVmFiltered(&Riscv64Assembler::VLsseg7e16,
5000 "vlsseg7e16.v {reg1}, ({reg2}), {reg3}{vm}",
5001 SkipV0Vm<XRegister, XRegister>()),
5002 "VLsseg7e16");
5003 }
5004
TEST_F(AssemblerRISCV64Test,VLsseg7e32)5005 TEST_F(AssemblerRISCV64Test, VLsseg7e32) {
5006 DriverStr(RepeatVRRVmFiltered(&Riscv64Assembler::VLsseg7e32,
5007 "vlsseg7e32.v {reg1}, ({reg2}), {reg3}{vm}",
5008 SkipV0Vm<XRegister, XRegister>()),
5009 "VLsseg7e32");
5010 }
5011
TEST_F(AssemblerRISCV64Test,VLsseg7e64)5012 TEST_F(AssemblerRISCV64Test, VLsseg7e64) {
5013 DriverStr(RepeatVRRVmFiltered(&Riscv64Assembler::VLsseg7e64,
5014 "vlsseg7e64.v {reg1}, ({reg2}), {reg3}{vm}",
5015 SkipV0Vm<XRegister, XRegister>()),
5016 "VLsseg7e64");
5017 }
5018
TEST_F(AssemblerRISCV64Test,VLsseg8e8)5019 TEST_F(AssemblerRISCV64Test, VLsseg8e8) {
5020 DriverStr(RepeatVRRVmFiltered(&Riscv64Assembler::VLsseg8e8,
5021 "vlsseg8e8.v {reg1}, ({reg2}), {reg3}{vm}",
5022 SkipV0Vm<XRegister, XRegister>()),
5023 "VLsseg8e8");
5024 }
5025
TEST_F(AssemblerRISCV64Test,VLsseg8e16)5026 TEST_F(AssemblerRISCV64Test, VLsseg8e16) {
5027 DriverStr(RepeatVRRVmFiltered(&Riscv64Assembler::VLsseg8e16,
5028 "vlsseg8e16.v {reg1}, ({reg2}), {reg3}{vm}",
5029 SkipV0Vm<XRegister, XRegister>()),
5030 "VLsseg8e16");
5031 }
5032
TEST_F(AssemblerRISCV64Test,VLsseg8e32)5033 TEST_F(AssemblerRISCV64Test, VLsseg8e32) {
5034 DriverStr(RepeatVRRVmFiltered(&Riscv64Assembler::VLsseg8e32,
5035 "vlsseg8e32.v {reg1}, ({reg2}), {reg3}{vm}",
5036 SkipV0Vm<XRegister, XRegister>()),
5037 "VLsseg8e32");
5038 }
5039
TEST_F(AssemblerRISCV64Test,VLsseg8e64)5040 TEST_F(AssemblerRISCV64Test, VLsseg8e64) {
5041 DriverStr(RepeatVRRVmFiltered(&Riscv64Assembler::VLsseg8e64,
5042 "vlsseg8e64.v {reg1}, ({reg2}), {reg3}{vm}",
5043 SkipV0Vm<XRegister, XRegister>()),
5044 "VLsseg8e64");
5045 }
5046
TEST_F(AssemblerRISCV64Test,VSsseg2e8)5047 TEST_F(AssemblerRISCV64Test, VSsseg2e8) {
5048 DriverStr(RepeatVRRVm(&Riscv64Assembler::VSsseg2e8, "vssseg2e8.v {reg1}, ({reg2}), {reg3}{vm}"),
5049 "VSsseg2e8");
5050 }
5051
TEST_F(AssemblerRISCV64Test,VSsseg2e16)5052 TEST_F(AssemblerRISCV64Test, VSsseg2e16) {
5053 DriverStr(RepeatVRRVm(&Riscv64Assembler::VSsseg2e16, "vssseg2e16.v {reg1}, ({reg2}), {reg3}{vm}"),
5054 "VSsseg2e16");
5055 }
5056
TEST_F(AssemblerRISCV64Test,VSsseg2e32)5057 TEST_F(AssemblerRISCV64Test, VSsseg2e32) {
5058 DriverStr(RepeatVRRVm(&Riscv64Assembler::VSsseg2e32, "vssseg2e32.v {reg1}, ({reg2}), {reg3}{vm}"),
5059 "VSsseg2e32");
5060 }
5061
TEST_F(AssemblerRISCV64Test,VSsseg2e64)5062 TEST_F(AssemblerRISCV64Test, VSsseg2e64) {
5063 DriverStr(RepeatVRRVm(&Riscv64Assembler::VSsseg2e64, "vssseg2e64.v {reg1}, ({reg2}), {reg3}{vm}"),
5064 "VSsseg2e64");
5065 }
5066
TEST_F(AssemblerRISCV64Test,VSsseg3e8)5067 TEST_F(AssemblerRISCV64Test, VSsseg3e8) {
5068 DriverStr(RepeatVRRVm(&Riscv64Assembler::VSsseg3e8, "vssseg3e8.v {reg1}, ({reg2}), {reg3}{vm}"),
5069 "VSsseg3e8");
5070 }
5071
TEST_F(AssemblerRISCV64Test,VSsseg3e16)5072 TEST_F(AssemblerRISCV64Test, VSsseg3e16) {
5073 DriverStr(RepeatVRRVm(&Riscv64Assembler::VSsseg3e16, "vssseg3e16.v {reg1}, ({reg2}), {reg3}{vm}"),
5074 "VSsseg3e16");
5075 }
5076
TEST_F(AssemblerRISCV64Test,VSsseg3e32)5077 TEST_F(AssemblerRISCV64Test, VSsseg3e32) {
5078 DriverStr(RepeatVRRVm(&Riscv64Assembler::VSsseg3e32, "vssseg3e32.v {reg1}, ({reg2}), {reg3}{vm}"),
5079 "VSsseg3e32");
5080 }
5081
TEST_F(AssemblerRISCV64Test,VSsseg3e64)5082 TEST_F(AssemblerRISCV64Test, VSsseg3e64) {
5083 DriverStr(RepeatVRRVm(&Riscv64Assembler::VSsseg3e64, "vssseg3e64.v {reg1}, ({reg2}), {reg3}{vm}"),
5084 "VSsseg3e64");
5085 }
5086
TEST_F(AssemblerRISCV64Test,VSsseg4e8)5087 TEST_F(AssemblerRISCV64Test, VSsseg4e8) {
5088 DriverStr(RepeatVRRVm(&Riscv64Assembler::VSsseg4e8, "vssseg4e8.v {reg1}, ({reg2}), {reg3}{vm}"),
5089 "VSsseg4e8");
5090 }
5091
TEST_F(AssemblerRISCV64Test,VSsseg4e16)5092 TEST_F(AssemblerRISCV64Test, VSsseg4e16) {
5093 DriverStr(RepeatVRRVm(&Riscv64Assembler::VSsseg4e16, "vssseg4e16.v {reg1}, ({reg2}), {reg3}{vm}"),
5094 "VSsseg4e16");
5095 }
5096
TEST_F(AssemblerRISCV64Test,VSsseg4e32)5097 TEST_F(AssemblerRISCV64Test, VSsseg4e32) {
5098 DriverStr(RepeatVRRVm(&Riscv64Assembler::VSsseg4e32, "vssseg4e32.v {reg1}, ({reg2}), {reg3}{vm}"),
5099 "VSsseg4e32");
5100 }
5101
TEST_F(AssemblerRISCV64Test,VSsseg4e64)5102 TEST_F(AssemblerRISCV64Test, VSsseg4e64) {
5103 DriverStr(RepeatVRRVm(&Riscv64Assembler::VSsseg4e64, "vssseg4e64.v {reg1}, ({reg2}), {reg3}{vm}"),
5104 "VSsseg4e64");
5105 }
5106
TEST_F(AssemblerRISCV64Test,VSsseg5e8)5107 TEST_F(AssemblerRISCV64Test, VSsseg5e8) {
5108 DriverStr(RepeatVRRVm(&Riscv64Assembler::VSsseg5e8, "vssseg5e8.v {reg1}, ({reg2}), {reg3}{vm}"),
5109 "VSsseg5e8");
5110 }
5111
TEST_F(AssemblerRISCV64Test,VSsseg5e16)5112 TEST_F(AssemblerRISCV64Test, VSsseg5e16) {
5113 DriverStr(RepeatVRRVm(&Riscv64Assembler::VSsseg5e16, "vssseg5e16.v {reg1}, ({reg2}), {reg3}{vm}"),
5114 "VSsseg5e16");
5115 }
5116
TEST_F(AssemblerRISCV64Test,VSsseg5e32)5117 TEST_F(AssemblerRISCV64Test, VSsseg5e32) {
5118 DriverStr(RepeatVRRVm(&Riscv64Assembler::VSsseg5e32, "vssseg5e32.v {reg1}, ({reg2}), {reg3}{vm}"),
5119 "VSsseg5e32");
5120 }
5121
TEST_F(AssemblerRISCV64Test,VSsseg5e64)5122 TEST_F(AssemblerRISCV64Test, VSsseg5e64) {
5123 DriverStr(RepeatVRRVm(&Riscv64Assembler::VSsseg5e64, "vssseg5e64.v {reg1}, ({reg2}), {reg3}{vm}"),
5124 "VSsseg5e64");
5125 }
5126
TEST_F(AssemblerRISCV64Test,VSsseg6e8)5127 TEST_F(AssemblerRISCV64Test, VSsseg6e8) {
5128 DriverStr(RepeatVRRVm(&Riscv64Assembler::VSsseg6e8, "vssseg6e8.v {reg1}, ({reg2}), {reg3}{vm}"),
5129 "VSsseg6e8");
5130 }
5131
TEST_F(AssemblerRISCV64Test,VSsseg6e16)5132 TEST_F(AssemblerRISCV64Test, VSsseg6e16) {
5133 DriverStr(RepeatVRRVm(&Riscv64Assembler::VSsseg6e16, "vssseg6e16.v {reg1}, ({reg2}), {reg3}{vm}"),
5134 "VSsseg6e16");
5135 }
5136
TEST_F(AssemblerRISCV64Test,VSsseg6e32)5137 TEST_F(AssemblerRISCV64Test, VSsseg6e32) {
5138 DriverStr(RepeatVRRVm(&Riscv64Assembler::VSsseg6e32, "vssseg6e32.v {reg1}, ({reg2}), {reg3}{vm}"),
5139 "VSsseg6e32");
5140 }
5141
TEST_F(AssemblerRISCV64Test,VSsseg6e64)5142 TEST_F(AssemblerRISCV64Test, VSsseg6e64) {
5143 DriverStr(RepeatVRRVm(&Riscv64Assembler::VSsseg6e64, "vssseg6e64.v {reg1}, ({reg2}), {reg3}{vm}"),
5144 "VSsseg6e64");
5145 }
5146
TEST_F(AssemblerRISCV64Test,VSsseg7e8)5147 TEST_F(AssemblerRISCV64Test, VSsseg7e8) {
5148 DriverStr(RepeatVRRVm(&Riscv64Assembler::VSsseg7e8, "vssseg7e8.v {reg1}, ({reg2}), {reg3}{vm}"),
5149 "VSsseg7e8");
5150 }
5151
TEST_F(AssemblerRISCV64Test,VSsseg7e16)5152 TEST_F(AssemblerRISCV64Test, VSsseg7e16) {
5153 DriverStr(RepeatVRRVm(&Riscv64Assembler::VSsseg7e16, "vssseg7e16.v {reg1}, ({reg2}), {reg3}{vm}"),
5154 "VSsseg7e16");
5155 }
5156
TEST_F(AssemblerRISCV64Test,VSsseg7e32)5157 TEST_F(AssemblerRISCV64Test, VSsseg7e32) {
5158 DriverStr(RepeatVRRVm(&Riscv64Assembler::VSsseg7e32, "vssseg7e32.v {reg1}, ({reg2}), {reg3}{vm}"),
5159 "VSsseg7e32");
5160 }
5161
TEST_F(AssemblerRISCV64Test,VSsseg7e64)5162 TEST_F(AssemblerRISCV64Test, VSsseg7e64) {
5163 DriverStr(RepeatVRRVm(&Riscv64Assembler::VSsseg7e64, "vssseg7e64.v {reg1}, ({reg2}), {reg3}{vm}"),
5164 "VSsseg7e64");
5165 }
5166
TEST_F(AssemblerRISCV64Test,VSsseg8e8)5167 TEST_F(AssemblerRISCV64Test, VSsseg8e8) {
5168 DriverStr(RepeatVRRVm(&Riscv64Assembler::VSsseg8e8, "vssseg8e8.v {reg1}, ({reg2}), {reg3}{vm}"),
5169 "VSsseg8e8");
5170 }
5171
TEST_F(AssemblerRISCV64Test,VSsseg8e16)5172 TEST_F(AssemblerRISCV64Test, VSsseg8e16) {
5173 DriverStr(RepeatVRRVm(&Riscv64Assembler::VSsseg8e16, "vssseg8e16.v {reg1}, ({reg2}), {reg3}{vm}"),
5174 "VSsseg8e16");
5175 }
5176
TEST_F(AssemblerRISCV64Test,VSsseg8e32)5177 TEST_F(AssemblerRISCV64Test, VSsseg8e32) {
5178 DriverStr(RepeatVRRVm(&Riscv64Assembler::VSsseg8e32, "vssseg8e32.v {reg1}, ({reg2}), {reg3}{vm}"),
5179 "VSsseg8e32");
5180 }
5181
TEST_F(AssemblerRISCV64Test,VSsseg8e64)5182 TEST_F(AssemblerRISCV64Test, VSsseg8e64) {
5183 DriverStr(RepeatVRRVm(&Riscv64Assembler::VSsseg8e64, "vssseg8e64.v {reg1}, ({reg2}), {reg3}{vm}"),
5184 "VSsseg8e64");
5185 }
5186
TEST_F(AssemblerRISCV64Test,VLuxseg2ei8)5187 TEST_F(AssemblerRISCV64Test, VLuxseg2ei8) {
5188 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLuxseg2ei8,
5189 "vluxseg2ei8.v {reg1}, ({reg2}), {reg3}{vm}",
5190 SkipV0Vm<XRegister, VRegister>()),
5191 "VLuxseg2ei8");
5192 }
5193
TEST_F(AssemblerRISCV64Test,VLuxseg2ei16)5194 TEST_F(AssemblerRISCV64Test, VLuxseg2ei16) {
5195 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLuxseg2ei16,
5196 "vluxseg2ei16.v {reg1}, ({reg2}), {reg3}{vm}",
5197 SkipV0Vm<XRegister, VRegister>()),
5198 "VLuxseg2ei16");
5199 }
5200
TEST_F(AssemblerRISCV64Test,VLuxseg2ei32)5201 TEST_F(AssemblerRISCV64Test, VLuxseg2ei32) {
5202 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLuxseg2ei32,
5203 "vluxseg2ei32.v {reg1}, ({reg2}), {reg3}{vm}",
5204 SkipV0Vm<XRegister, VRegister>()),
5205 "VLuxseg2ei32");
5206 }
5207
TEST_F(AssemblerRISCV64Test,VLuxseg2ei64)5208 TEST_F(AssemblerRISCV64Test, VLuxseg2ei64) {
5209 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLuxseg2ei64,
5210 "vluxseg2ei64.v {reg1}, ({reg2}), {reg3}{vm}",
5211 SkipV0Vm<XRegister, VRegister>()),
5212 "VLuxseg2ei64");
5213 }
5214
TEST_F(AssemblerRISCV64Test,VLuxseg3ei8)5215 TEST_F(AssemblerRISCV64Test, VLuxseg3ei8) {
5216 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLuxseg3ei8,
5217 "vluxseg3ei8.v {reg1}, ({reg2}), {reg3}{vm}",
5218 SkipV0Vm<XRegister, VRegister>()),
5219 "VLuxseg3ei8");
5220 }
5221
TEST_F(AssemblerRISCV64Test,VLuxseg3ei16)5222 TEST_F(AssemblerRISCV64Test, VLuxseg3ei16) {
5223 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLuxseg3ei16,
5224 "vluxseg3ei16.v {reg1}, ({reg2}), {reg3}{vm}",
5225 SkipV0Vm<XRegister, VRegister>()),
5226 "VLuxseg3ei16");
5227 }
5228
TEST_F(AssemblerRISCV64Test,VLuxseg3ei32)5229 TEST_F(AssemblerRISCV64Test, VLuxseg3ei32) {
5230 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLuxseg3ei32,
5231 "vluxseg3ei32.v {reg1}, ({reg2}), {reg3}{vm}",
5232 SkipV0Vm<XRegister, VRegister>()),
5233 "VLuxseg3ei32");
5234 }
5235
TEST_F(AssemblerRISCV64Test,VLuxseg3ei64)5236 TEST_F(AssemblerRISCV64Test, VLuxseg3ei64) {
5237 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLuxseg3ei64,
5238 "vluxseg3ei64.v {reg1}, ({reg2}), {reg3}{vm}",
5239 SkipV0Vm<XRegister, VRegister>()),
5240 "VLuxseg3ei64");
5241 }
5242
TEST_F(AssemblerRISCV64Test,VLuxseg4ei8)5243 TEST_F(AssemblerRISCV64Test, VLuxseg4ei8) {
5244 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLuxseg4ei8,
5245 "vluxseg4ei8.v {reg1}, ({reg2}), {reg3}{vm}",
5246 SkipV0Vm<XRegister, VRegister>()),
5247 "VLuxseg4ei8");
5248 }
5249
TEST_F(AssemblerRISCV64Test,VLuxseg4ei16)5250 TEST_F(AssemblerRISCV64Test, VLuxseg4ei16) {
5251 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLuxseg4ei16,
5252 "vluxseg4ei16.v {reg1}, ({reg2}), {reg3}{vm}",
5253 SkipV0Vm<XRegister, VRegister>()),
5254 "VLuxseg4ei16");
5255 }
5256
TEST_F(AssemblerRISCV64Test,VLuxseg4ei32)5257 TEST_F(AssemblerRISCV64Test, VLuxseg4ei32) {
5258 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLuxseg4ei32,
5259 "vluxseg4ei32.v {reg1}, ({reg2}), {reg3}{vm}",
5260 SkipV0Vm<XRegister, VRegister>()),
5261 "VLuxseg4ei32");
5262 }
5263
TEST_F(AssemblerRISCV64Test,VLuxseg4ei64)5264 TEST_F(AssemblerRISCV64Test, VLuxseg4ei64) {
5265 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLuxseg4ei64,
5266 "vluxseg4ei64.v {reg1}, ({reg2}), {reg3}{vm}",
5267 SkipV0Vm<XRegister, VRegister>()),
5268 "VLuxseg4ei64");
5269 }
5270
TEST_F(AssemblerRISCV64Test,VLuxseg5ei8)5271 TEST_F(AssemblerRISCV64Test, VLuxseg5ei8) {
5272 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLuxseg5ei8,
5273 "vluxseg5ei8.v {reg1}, ({reg2}), {reg3}{vm}",
5274 SkipV0Vm<XRegister, VRegister>()),
5275 "VLuxseg5ei8");
5276 }
5277
TEST_F(AssemblerRISCV64Test,VLuxseg5ei16)5278 TEST_F(AssemblerRISCV64Test, VLuxseg5ei16) {
5279 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLuxseg5ei16,
5280 "vluxseg5ei16.v {reg1}, ({reg2}), {reg3}{vm}",
5281 SkipV0Vm<XRegister, VRegister>()),
5282 "VLuxseg5ei16");
5283 }
5284
TEST_F(AssemblerRISCV64Test,VLuxseg5ei32)5285 TEST_F(AssemblerRISCV64Test, VLuxseg5ei32) {
5286 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLuxseg5ei32,
5287 "vluxseg5ei32.v {reg1}, ({reg2}), {reg3}{vm}",
5288 SkipV0Vm<XRegister, VRegister>()),
5289 "VLuxseg5ei32");
5290 }
5291
TEST_F(AssemblerRISCV64Test,VLuxseg5ei64)5292 TEST_F(AssemblerRISCV64Test, VLuxseg5ei64) {
5293 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLuxseg5ei64,
5294 "vluxseg5ei64.v {reg1}, ({reg2}), {reg3}{vm}",
5295 SkipV0Vm<XRegister, VRegister>()),
5296 "VLuxseg5ei64");
5297 }
5298
TEST_F(AssemblerRISCV64Test,VLuxseg6ei8)5299 TEST_F(AssemblerRISCV64Test, VLuxseg6ei8) {
5300 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLuxseg6ei8,
5301 "vluxseg6ei8.v {reg1}, ({reg2}), {reg3}{vm}",
5302 SkipV0Vm<XRegister, VRegister>()),
5303 "VLuxseg6ei8");
5304 }
5305
TEST_F(AssemblerRISCV64Test,VLuxseg6ei16)5306 TEST_F(AssemblerRISCV64Test, VLuxseg6ei16) {
5307 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLuxseg6ei16,
5308 "vluxseg6ei16.v {reg1}, ({reg2}), {reg3}{vm}",
5309 SkipV0Vm<XRegister, VRegister>()),
5310 "VLuxseg6ei16");
5311 }
5312
TEST_F(AssemblerRISCV64Test,VLuxseg6ei32)5313 TEST_F(AssemblerRISCV64Test, VLuxseg6ei32) {
5314 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLuxseg6ei32,
5315 "vluxseg6ei32.v {reg1}, ({reg2}), {reg3}{vm}",
5316 SkipV0Vm<XRegister, VRegister>()),
5317 "VLuxseg6ei32");
5318 }
5319
TEST_F(AssemblerRISCV64Test,VLuxseg6ei64)5320 TEST_F(AssemblerRISCV64Test, VLuxseg6ei64) {
5321 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLuxseg6ei64,
5322 "vluxseg6ei64.v {reg1}, ({reg2}), {reg3}{vm}",
5323 SkipV0Vm<XRegister, VRegister>()),
5324 "VLuxseg6ei64");
5325 }
5326
TEST_F(AssemblerRISCV64Test,VLuxseg7ei8)5327 TEST_F(AssemblerRISCV64Test, VLuxseg7ei8) {
5328 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLuxseg7ei8,
5329 "vluxseg7ei8.v {reg1}, ({reg2}), {reg3}{vm}",
5330 SkipV0Vm<XRegister, VRegister>()),
5331 "VLuxseg7ei8");
5332 }
5333
TEST_F(AssemblerRISCV64Test,VLuxseg7ei16)5334 TEST_F(AssemblerRISCV64Test, VLuxseg7ei16) {
5335 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLuxseg7ei16,
5336 "vluxseg7ei16.v {reg1}, ({reg2}), {reg3}{vm}",
5337 SkipV0Vm<XRegister, VRegister>()),
5338 "VLuxseg7ei16");
5339 }
5340
TEST_F(AssemblerRISCV64Test,VLuxseg7ei32)5341 TEST_F(AssemblerRISCV64Test, VLuxseg7ei32) {
5342 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLuxseg7ei32,
5343 "vluxseg7ei32.v {reg1}, ({reg2}), {reg3}{vm}",
5344 SkipV0Vm<XRegister, VRegister>()),
5345 "VLuxseg7ei32");
5346 }
5347
TEST_F(AssemblerRISCV64Test,VLuxseg7ei64)5348 TEST_F(AssemblerRISCV64Test, VLuxseg7ei64) {
5349 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLuxseg7ei64,
5350 "vluxseg7ei64.v {reg1}, ({reg2}), {reg3}{vm}",
5351 SkipV0Vm<XRegister, VRegister>()),
5352 "VLuxseg7ei64");
5353 }
5354
TEST_F(AssemblerRISCV64Test,VLuxseg8ei8)5355 TEST_F(AssemblerRISCV64Test, VLuxseg8ei8) {
5356 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLuxseg8ei8,
5357 "vluxseg8ei8.v {reg1}, ({reg2}), {reg3}{vm}",
5358 SkipV0Vm<XRegister, VRegister>()),
5359 "VLuxseg8ei8");
5360 }
5361
TEST_F(AssemblerRISCV64Test,VLuxseg8ei16)5362 TEST_F(AssemblerRISCV64Test, VLuxseg8ei16) {
5363 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLuxseg8ei16,
5364 "vluxseg8ei16.v {reg1}, ({reg2}), {reg3}{vm}",
5365 SkipV0Vm<XRegister, VRegister>()),
5366 "VLuxseg8ei16");
5367 }
5368
TEST_F(AssemblerRISCV64Test,VLuxseg8ei32)5369 TEST_F(AssemblerRISCV64Test, VLuxseg8ei32) {
5370 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLuxseg8ei32,
5371 "vluxseg8ei32.v {reg1}, ({reg2}), {reg3}{vm}",
5372 SkipV0Vm<XRegister, VRegister>()),
5373 "VLuxseg8ei32");
5374 }
5375
TEST_F(AssemblerRISCV64Test,VLuxseg8ei64)5376 TEST_F(AssemblerRISCV64Test, VLuxseg8ei64) {
5377 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLuxseg8ei64,
5378 "vluxseg8ei64.v {reg1}, ({reg2}), {reg3}{vm}",
5379 SkipV0Vm<XRegister, VRegister>()),
5380 "VLuxseg8ei64");
5381 }
5382
TEST_F(AssemblerRISCV64Test,VSuxseg2ei8)5383 TEST_F(AssemblerRISCV64Test, VSuxseg2ei8) {
5384 DriverStr(
5385 RepeatVRVVm(&Riscv64Assembler::VSuxseg2ei8, "vsuxseg2ei8.v {reg1}, ({reg2}), {reg3}{vm}"),
5386 "VSuxseg2ei8");
5387 }
5388
TEST_F(AssemblerRISCV64Test,VSuxseg2ei16)5389 TEST_F(AssemblerRISCV64Test, VSuxseg2ei16) {
5390 DriverStr(
5391 RepeatVRVVm(&Riscv64Assembler::VSuxseg2ei16, "vsuxseg2ei16.v {reg1}, ({reg2}), {reg3}{vm}"),
5392 "VSuxseg2ei16");
5393 }
5394
TEST_F(AssemblerRISCV64Test,VSuxseg2ei32)5395 TEST_F(AssemblerRISCV64Test, VSuxseg2ei32) {
5396 DriverStr(
5397 RepeatVRVVm(&Riscv64Assembler::VSuxseg2ei32, "vsuxseg2ei32.v {reg1}, ({reg2}), {reg3}{vm}"),
5398 "VSuxseg2ei32");
5399 }
5400
TEST_F(AssemblerRISCV64Test,VSuxseg2ei64)5401 TEST_F(AssemblerRISCV64Test, VSuxseg2ei64) {
5402 DriverStr(
5403 RepeatVRVVm(&Riscv64Assembler::VSuxseg2ei64, "vsuxseg2ei64.v {reg1}, ({reg2}), {reg3}{vm}"),
5404 "VSuxseg2ei64");
5405 }
5406
TEST_F(AssemblerRISCV64Test,VSuxseg3ei8)5407 TEST_F(AssemblerRISCV64Test, VSuxseg3ei8) {
5408 DriverStr(
5409 RepeatVRVVm(&Riscv64Assembler::VSuxseg3ei8, "vsuxseg3ei8.v {reg1}, ({reg2}), {reg3}{vm}"),
5410 "VSuxseg3ei8");
5411 }
5412
TEST_F(AssemblerRISCV64Test,VSuxseg3ei16)5413 TEST_F(AssemblerRISCV64Test, VSuxseg3ei16) {
5414 DriverStr(
5415 RepeatVRVVm(&Riscv64Assembler::VSuxseg3ei16, "vsuxseg3ei16.v {reg1}, ({reg2}), {reg3}{vm}"),
5416 "VSuxseg3ei16");
5417 }
5418
TEST_F(AssemblerRISCV64Test,VSuxseg3ei32)5419 TEST_F(AssemblerRISCV64Test, VSuxseg3ei32) {
5420 DriverStr(
5421 RepeatVRVVm(&Riscv64Assembler::VSuxseg3ei32, "vsuxseg3ei32.v {reg1}, ({reg2}), {reg3}{vm}"),
5422 "VSuxseg3ei32");
5423 }
5424
TEST_F(AssemblerRISCV64Test,VSuxseg3ei64)5425 TEST_F(AssemblerRISCV64Test, VSuxseg3ei64) {
5426 DriverStr(
5427 RepeatVRVVm(&Riscv64Assembler::VSuxseg3ei64, "vsuxseg3ei64.v {reg1}, ({reg2}), {reg3}{vm}"),
5428 "VSuxseg3ei64");
5429 }
5430
TEST_F(AssemblerRISCV64Test,VSuxseg4ei8)5431 TEST_F(AssemblerRISCV64Test, VSuxseg4ei8) {
5432 DriverStr(
5433 RepeatVRVVm(&Riscv64Assembler::VSuxseg4ei8, "vsuxseg4ei8.v {reg1}, ({reg2}), {reg3}{vm}"),
5434 "VSuxseg4ei8");
5435 }
5436
TEST_F(AssemblerRISCV64Test,VSuxseg4ei16)5437 TEST_F(AssemblerRISCV64Test, VSuxseg4ei16) {
5438 DriverStr(
5439 RepeatVRVVm(&Riscv64Assembler::VSuxseg4ei16, "vsuxseg4ei16.v {reg1}, ({reg2}), {reg3}{vm}"),
5440 "VSuxseg4ei16");
5441 }
5442
TEST_F(AssemblerRISCV64Test,VSuxseg4ei32)5443 TEST_F(AssemblerRISCV64Test, VSuxseg4ei32) {
5444 DriverStr(
5445 RepeatVRVVm(&Riscv64Assembler::VSuxseg4ei32, "vsuxseg4ei32.v {reg1}, ({reg2}), {reg3}{vm}"),
5446 "VSuxseg4ei32");
5447 }
5448
TEST_F(AssemblerRISCV64Test,VSuxseg4ei64)5449 TEST_F(AssemblerRISCV64Test, VSuxseg4ei64) {
5450 DriverStr(
5451 RepeatVRVVm(&Riscv64Assembler::VSuxseg4ei64, "vsuxseg4ei64.v {reg1}, ({reg2}), {reg3}{vm}"),
5452 "VSuxseg4ei64");
5453 }
5454
TEST_F(AssemblerRISCV64Test,VSuxseg5ei8)5455 TEST_F(AssemblerRISCV64Test, VSuxseg5ei8) {
5456 DriverStr(
5457 RepeatVRVVm(&Riscv64Assembler::VSuxseg5ei8, "vsuxseg5ei8.v {reg1}, ({reg2}), {reg3}{vm}"),
5458 "VSuxseg5ei8");
5459 }
5460
TEST_F(AssemblerRISCV64Test,VSuxseg5ei16)5461 TEST_F(AssemblerRISCV64Test, VSuxseg5ei16) {
5462 DriverStr(
5463 RepeatVRVVm(&Riscv64Assembler::VSuxseg5ei16, "vsuxseg5ei16.v {reg1}, ({reg2}), {reg3}{vm}"),
5464 "VSuxseg5ei16");
5465 }
5466
TEST_F(AssemblerRISCV64Test,VSuxseg5ei32)5467 TEST_F(AssemblerRISCV64Test, VSuxseg5ei32) {
5468 DriverStr(
5469 RepeatVRVVm(&Riscv64Assembler::VSuxseg5ei32, "vsuxseg5ei32.v {reg1}, ({reg2}), {reg3}{vm}"),
5470 "VSuxseg5ei32");
5471 }
5472
TEST_F(AssemblerRISCV64Test,VSuxseg5ei64)5473 TEST_F(AssemblerRISCV64Test, VSuxseg5ei64) {
5474 DriverStr(
5475 RepeatVRVVm(&Riscv64Assembler::VSuxseg5ei64, "vsuxseg5ei64.v {reg1}, ({reg2}), {reg3}{vm}"),
5476 "VSuxseg5ei64");
5477 }
5478
TEST_F(AssemblerRISCV64Test,VSuxseg6ei8)5479 TEST_F(AssemblerRISCV64Test, VSuxseg6ei8) {
5480 DriverStr(
5481 RepeatVRVVm(&Riscv64Assembler::VSuxseg6ei8, "vsuxseg6ei8.v {reg1}, ({reg2}), {reg3}{vm}"),
5482 "VSuxseg6ei8");
5483 }
5484
TEST_F(AssemblerRISCV64Test,VSuxseg6ei16)5485 TEST_F(AssemblerRISCV64Test, VSuxseg6ei16) {
5486 DriverStr(
5487 RepeatVRVVm(&Riscv64Assembler::VSuxseg6ei16, "vsuxseg6ei16.v {reg1}, ({reg2}), {reg3}{vm}"),
5488 "VSuxseg6ei16");
5489 }
5490
TEST_F(AssemblerRISCV64Test,VSuxseg6ei32)5491 TEST_F(AssemblerRISCV64Test, VSuxseg6ei32) {
5492 DriverStr(
5493 RepeatVRVVm(&Riscv64Assembler::VSuxseg6ei32, "vsuxseg6ei32.v {reg1}, ({reg2}), {reg3}{vm}"),
5494 "VSuxseg6ei32");
5495 }
5496
TEST_F(AssemblerRISCV64Test,VSuxseg6ei64)5497 TEST_F(AssemblerRISCV64Test, VSuxseg6ei64) {
5498 DriverStr(
5499 RepeatVRVVm(&Riscv64Assembler::VSuxseg6ei64, "vsuxseg6ei64.v {reg1}, ({reg2}), {reg3}{vm}"),
5500 "VSuxseg6ei64");
5501 }
5502
TEST_F(AssemblerRISCV64Test,VSuxseg7ei8)5503 TEST_F(AssemblerRISCV64Test, VSuxseg7ei8) {
5504 DriverStr(
5505 RepeatVRVVm(&Riscv64Assembler::VSuxseg7ei8, "vsuxseg7ei8.v {reg1}, ({reg2}), {reg3}{vm}"),
5506 "VSuxseg7ei8");
5507 }
5508
TEST_F(AssemblerRISCV64Test,VSuxseg7ei16)5509 TEST_F(AssemblerRISCV64Test, VSuxseg7ei16) {
5510 DriverStr(
5511 RepeatVRVVm(&Riscv64Assembler::VSuxseg7ei16, "vsuxseg7ei16.v {reg1}, ({reg2}), {reg3}{vm}"),
5512 "VSuxseg7ei16");
5513 }
5514
TEST_F(AssemblerRISCV64Test,VSuxseg7ei32)5515 TEST_F(AssemblerRISCV64Test, VSuxseg7ei32) {
5516 DriverStr(
5517 RepeatVRVVm(&Riscv64Assembler::VSuxseg7ei32, "vsuxseg7ei32.v {reg1}, ({reg2}), {reg3}{vm}"),
5518 "VSuxseg7ei32");
5519 }
5520
TEST_F(AssemblerRISCV64Test,VSuxseg7ei64)5521 TEST_F(AssemblerRISCV64Test, VSuxseg7ei64) {
5522 DriverStr(
5523 RepeatVRVVm(&Riscv64Assembler::VSuxseg7ei64, "vsuxseg7ei64.v {reg1}, ({reg2}), {reg3}{vm}"),
5524 "VSuxseg7ei64");
5525 }
5526
TEST_F(AssemblerRISCV64Test,VSuxseg8ei8)5527 TEST_F(AssemblerRISCV64Test, VSuxseg8ei8) {
5528 DriverStr(
5529 RepeatVRVVm(&Riscv64Assembler::VSuxseg8ei8, "vsuxseg8ei8.v {reg1}, ({reg2}), {reg3}{vm}"),
5530 "VSuxseg8ei8");
5531 }
5532
TEST_F(AssemblerRISCV64Test,VSuxseg8ei16)5533 TEST_F(AssemblerRISCV64Test, VSuxseg8ei16) {
5534 DriverStr(
5535 RepeatVRVVm(&Riscv64Assembler::VSuxseg8ei16, "vsuxseg8ei16.v {reg1}, ({reg2}), {reg3}{vm}"),
5536 "VSuxseg8ei16");
5537 }
5538
TEST_F(AssemblerRISCV64Test,VSuxseg8ei32)5539 TEST_F(AssemblerRISCV64Test, VSuxseg8ei32) {
5540 DriverStr(
5541 RepeatVRVVm(&Riscv64Assembler::VSuxseg8ei32, "vsuxseg8ei32.v {reg1}, ({reg2}), {reg3}{vm}"),
5542 "VSuxseg8ei32");
5543 }
5544
TEST_F(AssemblerRISCV64Test,VSuxseg8ei64)5545 TEST_F(AssemblerRISCV64Test, VSuxseg8ei64) {
5546 DriverStr(
5547 RepeatVRVVm(&Riscv64Assembler::VSuxseg8ei64, "vsuxseg8ei64.v {reg1}, ({reg2}), {reg3}{vm}"),
5548 "VSuxseg8ei64");
5549 }
5550
TEST_F(AssemblerRISCV64Test,VLoxseg2ei8)5551 TEST_F(AssemblerRISCV64Test, VLoxseg2ei8) {
5552 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLoxseg2ei8,
5553 "vloxseg2ei8.v {reg1}, ({reg2}), {reg3}{vm}",
5554 SkipV0Vm<XRegister, VRegister>()),
5555 "VLoxseg2ei8");
5556 }
5557
TEST_F(AssemblerRISCV64Test,VLoxseg2ei16)5558 TEST_F(AssemblerRISCV64Test, VLoxseg2ei16) {
5559 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLoxseg2ei16,
5560 "vloxseg2ei16.v {reg1}, ({reg2}), {reg3}{vm}",
5561 SkipV0Vm<XRegister, VRegister>()),
5562 "VLoxseg2ei16");
5563 }
5564
TEST_F(AssemblerRISCV64Test,VLoxseg2ei32)5565 TEST_F(AssemblerRISCV64Test, VLoxseg2ei32) {
5566 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLoxseg2ei32,
5567 "vloxseg2ei32.v {reg1}, ({reg2}), {reg3}{vm}",
5568 SkipV0Vm<XRegister, VRegister>()),
5569 "VLoxseg2ei32");
5570 }
5571
TEST_F(AssemblerRISCV64Test,VLoxseg2ei64)5572 TEST_F(AssemblerRISCV64Test, VLoxseg2ei64) {
5573 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLoxseg2ei64,
5574 "vloxseg2ei64.v {reg1}, ({reg2}), {reg3}{vm}",
5575 SkipV0Vm<XRegister, VRegister>()),
5576 "VLoxseg2ei64");
5577 }
5578
TEST_F(AssemblerRISCV64Test,VLoxseg3ei8)5579 TEST_F(AssemblerRISCV64Test, VLoxseg3ei8) {
5580 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLoxseg3ei8,
5581 "vloxseg3ei8.v {reg1}, ({reg2}), {reg3}{vm}",
5582 SkipV0Vm<XRegister, VRegister>()),
5583 "VLoxseg3ei8");
5584 }
5585
TEST_F(AssemblerRISCV64Test,VLoxseg3ei16)5586 TEST_F(AssemblerRISCV64Test, VLoxseg3ei16) {
5587 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLoxseg3ei16,
5588 "vloxseg3ei16.v {reg1}, ({reg2}), {reg3}{vm}",
5589 SkipV0Vm<XRegister, VRegister>()),
5590 "VLoxseg3ei16");
5591 }
5592
TEST_F(AssemblerRISCV64Test,VLoxseg3ei32)5593 TEST_F(AssemblerRISCV64Test, VLoxseg3ei32) {
5594 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLoxseg3ei32,
5595 "vloxseg3ei32.v {reg1}, ({reg2}), {reg3}{vm}",
5596 SkipV0Vm<XRegister, VRegister>()),
5597 "VLoxseg3ei32");
5598 }
5599
TEST_F(AssemblerRISCV64Test,VLoxseg3ei64)5600 TEST_F(AssemblerRISCV64Test, VLoxseg3ei64) {
5601 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLoxseg3ei64,
5602 "vloxseg3ei64.v {reg1}, ({reg2}), {reg3}{vm}",
5603 SkipV0Vm<XRegister, VRegister>()),
5604 "VLoxseg3ei64");
5605 }
5606
TEST_F(AssemblerRISCV64Test,VLoxseg4ei8)5607 TEST_F(AssemblerRISCV64Test, VLoxseg4ei8) {
5608 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLoxseg4ei8,
5609 "vloxseg4ei8.v {reg1}, ({reg2}), {reg3}{vm}",
5610 SkipV0Vm<XRegister, VRegister>()),
5611 "VLoxseg4ei8");
5612 }
5613
TEST_F(AssemblerRISCV64Test,VLoxseg4ei16)5614 TEST_F(AssemblerRISCV64Test, VLoxseg4ei16) {
5615 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLoxseg4ei16,
5616 "vloxseg4ei16.v {reg1}, ({reg2}), {reg3}{vm}",
5617 SkipV0Vm<XRegister, VRegister>()),
5618 "VLoxseg4ei16");
5619 }
5620
TEST_F(AssemblerRISCV64Test,VLoxseg4ei32)5621 TEST_F(AssemblerRISCV64Test, VLoxseg4ei32) {
5622 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLoxseg4ei32,
5623 "vloxseg4ei32.v {reg1}, ({reg2}), {reg3}{vm}",
5624 SkipV0Vm<XRegister, VRegister>()),
5625 "VLoxseg4ei32");
5626 }
5627
TEST_F(AssemblerRISCV64Test,VLoxseg4ei64)5628 TEST_F(AssemblerRISCV64Test, VLoxseg4ei64) {
5629 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLoxseg4ei64,
5630 "vloxseg4ei64.v {reg1}, ({reg2}), {reg3}{vm}",
5631 SkipV0Vm<XRegister, VRegister>()),
5632 "VLoxseg4ei64");
5633 }
5634
TEST_F(AssemblerRISCV64Test,VLoxseg5ei8)5635 TEST_F(AssemblerRISCV64Test, VLoxseg5ei8) {
5636 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLoxseg5ei8,
5637 "vloxseg5ei8.v {reg1}, ({reg2}), {reg3}{vm}",
5638 SkipV0Vm<XRegister, VRegister>()),
5639 "VLoxseg5ei8");
5640 }
5641
TEST_F(AssemblerRISCV64Test,VLoxseg5ei16)5642 TEST_F(AssemblerRISCV64Test, VLoxseg5ei16) {
5643 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLoxseg5ei16,
5644 "vloxseg5ei16.v {reg1}, ({reg2}), {reg3}{vm}",
5645 SkipV0Vm<XRegister, VRegister>()),
5646 "VLoxseg5ei16");
5647 }
5648
TEST_F(AssemblerRISCV64Test,VLoxseg5ei32)5649 TEST_F(AssemblerRISCV64Test, VLoxseg5ei32) {
5650 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLoxseg5ei32,
5651 "vloxseg5ei32.v {reg1}, ({reg2}), {reg3}{vm}",
5652 SkipV0Vm<XRegister, VRegister>()),
5653 "VLoxseg5ei32");
5654 }
5655
TEST_F(AssemblerRISCV64Test,VLoxseg5ei64)5656 TEST_F(AssemblerRISCV64Test, VLoxseg5ei64) {
5657 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLoxseg5ei64,
5658 "vloxseg5ei64.v {reg1}, ({reg2}), {reg3}{vm}",
5659 SkipV0Vm<XRegister, VRegister>()),
5660 "VLoxseg5ei64");
5661 }
5662
TEST_F(AssemblerRISCV64Test,VLoxseg6ei8)5663 TEST_F(AssemblerRISCV64Test, VLoxseg6ei8) {
5664 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLoxseg6ei8,
5665 "vloxseg6ei8.v {reg1}, ({reg2}), {reg3}{vm}",
5666 SkipV0Vm<XRegister, VRegister>()),
5667 "VLoxseg6ei8");
5668 }
5669
TEST_F(AssemblerRISCV64Test,VLoxseg6ei16)5670 TEST_F(AssemblerRISCV64Test, VLoxseg6ei16) {
5671 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLoxseg6ei16,
5672 "vloxseg6ei16.v {reg1}, ({reg2}), {reg3}{vm}",
5673 SkipV0Vm<XRegister, VRegister>()),
5674 "VLoxseg6ei16");
5675 }
5676
TEST_F(AssemblerRISCV64Test,VLoxseg6ei32)5677 TEST_F(AssemblerRISCV64Test, VLoxseg6ei32) {
5678 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLoxseg6ei32,
5679 "vloxseg6ei32.v {reg1}, ({reg2}), {reg3}{vm}",
5680 SkipV0Vm<XRegister, VRegister>()),
5681 "VLoxseg6ei32");
5682 }
5683
TEST_F(AssemblerRISCV64Test,VLoxseg6ei64)5684 TEST_F(AssemblerRISCV64Test, VLoxseg6ei64) {
5685 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLoxseg6ei64,
5686 "vloxseg6ei64.v {reg1}, ({reg2}), {reg3}{vm}",
5687 SkipV0Vm<XRegister, VRegister>()),
5688 "VLoxseg6ei64");
5689 }
5690
TEST_F(AssemblerRISCV64Test,VLoxseg7ei8)5691 TEST_F(AssemblerRISCV64Test, VLoxseg7ei8) {
5692 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLoxseg7ei8,
5693 "vloxseg7ei8.v {reg1}, ({reg2}), {reg3}{vm}",
5694 SkipV0Vm<XRegister, VRegister>()),
5695 "VLoxseg7ei8");
5696 }
5697
TEST_F(AssemblerRISCV64Test,VLoxseg7ei16)5698 TEST_F(AssemblerRISCV64Test, VLoxseg7ei16) {
5699 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLoxseg7ei16,
5700 "vloxseg7ei16.v {reg1}, ({reg2}), {reg3}{vm}",
5701 SkipV0Vm<XRegister, VRegister>()),
5702 "VLoxseg7ei16");
5703 }
5704
TEST_F(AssemblerRISCV64Test,VLoxseg7ei32)5705 TEST_F(AssemblerRISCV64Test, VLoxseg7ei32) {
5706 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLoxseg7ei32,
5707 "vloxseg7ei32.v {reg1}, ({reg2}), {reg3}{vm}",
5708 SkipV0Vm<XRegister, VRegister>()),
5709 "VLoxseg7ei32");
5710 }
5711
TEST_F(AssemblerRISCV64Test,VLoxseg7ei64)5712 TEST_F(AssemblerRISCV64Test, VLoxseg7ei64) {
5713 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLoxseg7ei64,
5714 "vloxseg7ei64.v {reg1}, ({reg2}), {reg3}{vm}",
5715 SkipV0Vm<XRegister, VRegister>()),
5716 "VLoxseg7ei64");
5717 }
5718
TEST_F(AssemblerRISCV64Test,VLoxseg8ei8)5719 TEST_F(AssemblerRISCV64Test, VLoxseg8ei8) {
5720 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLoxseg8ei8,
5721 "vloxseg8ei8.v {reg1}, ({reg2}), {reg3}{vm}",
5722 SkipV0Vm<XRegister, VRegister>()),
5723 "VLoxseg8ei8");
5724 }
5725
TEST_F(AssemblerRISCV64Test,VLoxseg8ei16)5726 TEST_F(AssemblerRISCV64Test, VLoxseg8ei16) {
5727 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLoxseg8ei16,
5728 "vloxseg8ei16.v {reg1}, ({reg2}), {reg3}{vm}",
5729 SkipV0Vm<XRegister, VRegister>()),
5730 "VLoxseg8ei16");
5731 }
5732
TEST_F(AssemblerRISCV64Test,VLoxseg8ei32)5733 TEST_F(AssemblerRISCV64Test, VLoxseg8ei32) {
5734 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLoxseg8ei32,
5735 "vloxseg8ei32.v {reg1}, ({reg2}), {reg3}{vm}",
5736 SkipV0Vm<XRegister, VRegister>()),
5737 "VLoxseg8ei32");
5738 }
5739
TEST_F(AssemblerRISCV64Test,VLoxseg8ei64)5740 TEST_F(AssemblerRISCV64Test, VLoxseg8ei64) {
5741 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VLoxseg8ei64,
5742 "vloxseg8ei64.v {reg1}, ({reg2}), {reg3}{vm}",
5743 SkipV0Vm<XRegister, VRegister>()),
5744 "VLoxseg8ei64");
5745 }
5746
TEST_F(AssemblerRISCV64Test,VSoxseg2ei8)5747 TEST_F(AssemblerRISCV64Test, VSoxseg2ei8) {
5748 DriverStr(
5749 RepeatVRVVm(&Riscv64Assembler::VSoxseg2ei8, "vsoxseg2ei8.v {reg1}, ({reg2}), {reg3}{vm}"),
5750 "VSoxseg2ei8");
5751 }
5752
TEST_F(AssemblerRISCV64Test,VSoxseg2ei16)5753 TEST_F(AssemblerRISCV64Test, VSoxseg2ei16) {
5754 DriverStr(
5755 RepeatVRVVm(&Riscv64Assembler::VSoxseg2ei16, "vsoxseg2ei16.v {reg1}, ({reg2}), {reg3}{vm}"),
5756 "VSoxseg2ei16");
5757 }
5758
TEST_F(AssemblerRISCV64Test,VSoxseg2ei32)5759 TEST_F(AssemblerRISCV64Test, VSoxseg2ei32) {
5760 DriverStr(
5761 RepeatVRVVm(&Riscv64Assembler::VSoxseg2ei32, "vsoxseg2ei32.v {reg1}, ({reg2}), {reg3}{vm}"),
5762 "VSoxseg2ei32");
5763 }
5764
TEST_F(AssemblerRISCV64Test,VSoxseg2ei64)5765 TEST_F(AssemblerRISCV64Test, VSoxseg2ei64) {
5766 DriverStr(
5767 RepeatVRVVm(&Riscv64Assembler::VSoxseg2ei64, "vsoxseg2ei64.v {reg1}, ({reg2}), {reg3}{vm}"),
5768 "VSoxseg2ei64");
5769 }
5770
TEST_F(AssemblerRISCV64Test,VSoxseg3ei8)5771 TEST_F(AssemblerRISCV64Test, VSoxseg3ei8) {
5772 DriverStr(
5773 RepeatVRVVm(&Riscv64Assembler::VSoxseg3ei8, "vsoxseg3ei8.v {reg1}, ({reg2}), {reg3}{vm}"),
5774 "VSoxseg3ei8");
5775 }
5776
TEST_F(AssemblerRISCV64Test,VSoxseg3ei16)5777 TEST_F(AssemblerRISCV64Test, VSoxseg3ei16) {
5778 DriverStr(
5779 RepeatVRVVm(&Riscv64Assembler::VSoxseg3ei16, "vsoxseg3ei16.v {reg1}, ({reg2}), {reg3}{vm}"),
5780 "VSoxseg3ei16");
5781 }
5782
TEST_F(AssemblerRISCV64Test,VSoxseg3ei32)5783 TEST_F(AssemblerRISCV64Test, VSoxseg3ei32) {
5784 DriverStr(
5785 RepeatVRVVm(&Riscv64Assembler::VSoxseg3ei32, "vsoxseg3ei32.v {reg1}, ({reg2}), {reg3}{vm}"),
5786 "VSoxseg3ei32");
5787 }
5788
TEST_F(AssemblerRISCV64Test,VSoxseg3ei64)5789 TEST_F(AssemblerRISCV64Test, VSoxseg3ei64) {
5790 DriverStr(
5791 RepeatVRVVm(&Riscv64Assembler::VSoxseg3ei64, "vsoxseg3ei64.v {reg1}, ({reg2}), {reg3}{vm}"),
5792 "VSoxseg3ei64");
5793 }
5794
TEST_F(AssemblerRISCV64Test,VSoxseg4ei8)5795 TEST_F(AssemblerRISCV64Test, VSoxseg4ei8) {
5796 DriverStr(
5797 RepeatVRVVm(&Riscv64Assembler::VSoxseg4ei8, "vsoxseg4ei8.v {reg1}, ({reg2}), {reg3}{vm}"),
5798 "VSoxseg4ei8");
5799 }
5800
TEST_F(AssemblerRISCV64Test,VSoxseg4ei16)5801 TEST_F(AssemblerRISCV64Test, VSoxseg4ei16) {
5802 DriverStr(
5803 RepeatVRVVm(&Riscv64Assembler::VSoxseg4ei16, "vsoxseg4ei16.v {reg1}, ({reg2}), {reg3}{vm}"),
5804 "VSoxseg4ei16");
5805 }
5806
TEST_F(AssemblerRISCV64Test,VSoxseg4ei32)5807 TEST_F(AssemblerRISCV64Test, VSoxseg4ei32) {
5808 DriverStr(
5809 RepeatVRVVm(&Riscv64Assembler::VSoxseg4ei32, "vsoxseg4ei32.v {reg1}, ({reg2}), {reg3}{vm}"),
5810 "VSoxseg4ei32");
5811 }
5812
TEST_F(AssemblerRISCV64Test,VSoxseg4ei64)5813 TEST_F(AssemblerRISCV64Test, VSoxseg4ei64) {
5814 DriverStr(
5815 RepeatVRVVm(&Riscv64Assembler::VSoxseg4ei64, "vsoxseg4ei64.v {reg1}, ({reg2}), {reg3}{vm}"),
5816 "VSoxseg4ei64");
5817 }
5818
TEST_F(AssemblerRISCV64Test,VSoxseg5ei8)5819 TEST_F(AssemblerRISCV64Test, VSoxseg5ei8) {
5820 DriverStr(
5821 RepeatVRVVm(&Riscv64Assembler::VSoxseg5ei8, "vsoxseg5ei8.v {reg1}, ({reg2}), {reg3}{vm}"),
5822 "VSoxseg5ei8");
5823 }
5824
TEST_F(AssemblerRISCV64Test,VSoxseg5ei16)5825 TEST_F(AssemblerRISCV64Test, VSoxseg5ei16) {
5826 DriverStr(
5827 RepeatVRVVm(&Riscv64Assembler::VSoxseg5ei16, "vsoxseg5ei16.v {reg1}, ({reg2}), {reg3}{vm}"),
5828 "VSoxseg5ei16");
5829 }
5830
TEST_F(AssemblerRISCV64Test,VSoxseg5ei32)5831 TEST_F(AssemblerRISCV64Test, VSoxseg5ei32) {
5832 DriverStr(
5833 RepeatVRVVm(&Riscv64Assembler::VSoxseg5ei32, "vsoxseg5ei32.v {reg1}, ({reg2}), {reg3}{vm}"),
5834 "VSoxseg5ei32");
5835 }
5836
TEST_F(AssemblerRISCV64Test,VSoxseg5ei64)5837 TEST_F(AssemblerRISCV64Test, VSoxseg5ei64) {
5838 DriverStr(
5839 RepeatVRVVm(&Riscv64Assembler::VSoxseg5ei64, "vsoxseg5ei64.v {reg1}, ({reg2}), {reg3}{vm}"),
5840 "VSoxseg5ei64");
5841 }
5842
TEST_F(AssemblerRISCV64Test,VSoxseg6ei8)5843 TEST_F(AssemblerRISCV64Test, VSoxseg6ei8) {
5844 DriverStr(
5845 RepeatVRVVm(&Riscv64Assembler::VSoxseg6ei8, "vsoxseg6ei8.v {reg1}, ({reg2}), {reg3}{vm}"),
5846 "VSoxseg6ei8");
5847 }
5848
TEST_F(AssemblerRISCV64Test,VSoxseg6ei16)5849 TEST_F(AssemblerRISCV64Test, VSoxseg6ei16) {
5850 DriverStr(
5851 RepeatVRVVm(&Riscv64Assembler::VSoxseg6ei16, "vsoxseg6ei16.v {reg1}, ({reg2}), {reg3}{vm}"),
5852 "VSoxseg6ei16");
5853 }
5854
TEST_F(AssemblerRISCV64Test,VSoxseg6ei32)5855 TEST_F(AssemblerRISCV64Test, VSoxseg6ei32) {
5856 DriverStr(
5857 RepeatVRVVm(&Riscv64Assembler::VSoxseg6ei32, "vsoxseg6ei32.v {reg1}, ({reg2}), {reg3}{vm}"),
5858 "VSoxseg6ei32");
5859 }
5860
TEST_F(AssemblerRISCV64Test,VSoxseg6ei64)5861 TEST_F(AssemblerRISCV64Test, VSoxseg6ei64) {
5862 DriverStr(
5863 RepeatVRVVm(&Riscv64Assembler::VSoxseg6ei64, "vsoxseg6ei64.v {reg1}, ({reg2}), {reg3}{vm}"),
5864 "VSoxseg6ei64");
5865 }
5866
TEST_F(AssemblerRISCV64Test,VSoxseg7ei8)5867 TEST_F(AssemblerRISCV64Test, VSoxseg7ei8) {
5868 DriverStr(
5869 RepeatVRVVm(&Riscv64Assembler::VSoxseg7ei8, "vsoxseg7ei8.v {reg1}, ({reg2}), {reg3}{vm}"),
5870 "VSoxseg7ei8");
5871 }
5872
TEST_F(AssemblerRISCV64Test,VSoxseg7ei16)5873 TEST_F(AssemblerRISCV64Test, VSoxseg7ei16) {
5874 DriverStr(
5875 RepeatVRVVm(&Riscv64Assembler::VSoxseg7ei16, "vsoxseg7ei16.v {reg1}, ({reg2}), {reg3}{vm}"),
5876 "VSoxseg7ei16");
5877 }
5878
TEST_F(AssemblerRISCV64Test,VSoxseg7ei32)5879 TEST_F(AssemblerRISCV64Test, VSoxseg7ei32) {
5880 DriverStr(
5881 RepeatVRVVm(&Riscv64Assembler::VSoxseg7ei32, "vsoxseg7ei32.v {reg1}, ({reg2}), {reg3}{vm}"),
5882 "VSoxseg7ei32");
5883 }
5884
TEST_F(AssemblerRISCV64Test,VSoxseg7ei64)5885 TEST_F(AssemblerRISCV64Test, VSoxseg7ei64) {
5886 DriverStr(
5887 RepeatVRVVm(&Riscv64Assembler::VSoxseg7ei64, "vsoxseg7ei64.v {reg1}, ({reg2}), {reg3}{vm}"),
5888 "VSoxseg7ei64");
5889 }
5890
TEST_F(AssemblerRISCV64Test,VSoxseg8ei8)5891 TEST_F(AssemblerRISCV64Test, VSoxseg8ei8) {
5892 DriverStr(
5893 RepeatVRVVm(&Riscv64Assembler::VSoxseg8ei8, "vsoxseg8ei8.v {reg1}, ({reg2}), {reg3}{vm}"),
5894 "VSoxseg8ei8");
5895 }
5896
TEST_F(AssemblerRISCV64Test,VSoxseg8ei16)5897 TEST_F(AssemblerRISCV64Test, VSoxseg8ei16) {
5898 DriverStr(
5899 RepeatVRVVm(&Riscv64Assembler::VSoxseg8ei16, "vsoxseg8ei16.v {reg1}, ({reg2}), {reg3}{vm}"),
5900 "VSoxseg8ei16");
5901 }
5902
TEST_F(AssemblerRISCV64Test,VSoxseg8ei32)5903 TEST_F(AssemblerRISCV64Test, VSoxseg8ei32) {
5904 DriverStr(
5905 RepeatVRVVm(&Riscv64Assembler::VSoxseg8ei32, "vsoxseg8ei32.v {reg1}, ({reg2}), {reg3}{vm}"),
5906 "VSoxseg8ei32");
5907 }
5908
TEST_F(AssemblerRISCV64Test,VSoxseg8ei64)5909 TEST_F(AssemblerRISCV64Test, VSoxseg8ei64) {
5910 DriverStr(
5911 RepeatVRVVm(&Riscv64Assembler::VSoxseg8ei64, "vsoxseg8ei64.v {reg1}, ({reg2}), {reg3}{vm}"),
5912 "VSoxseg8ei64");
5913 }
5914
TEST_F(AssemblerRISCV64Test,VL1re8)5915 TEST_F(AssemblerRISCV64Test, VL1re8) {
5916 DriverStr(
5917 RepeatVRAligned(&Riscv64Assembler::VL1re8, /*alignment=*/ 1, "vl1re8.v {reg1}, ({reg2})"),
5918 "VL1re8");
5919 }
5920
TEST_F(AssemblerRISCV64Test,VL1re16)5921 TEST_F(AssemblerRISCV64Test, VL1re16) {
5922 DriverStr(
5923 RepeatVRAligned(&Riscv64Assembler::VL1re16, /*alignment=*/ 1, "vl1re16.v {reg1}, ({reg2})"),
5924 "VL1re16");
5925 }
5926
TEST_F(AssemblerRISCV64Test,VL1re32)5927 TEST_F(AssemblerRISCV64Test, VL1re32) {
5928 DriverStr(
5929 RepeatVRAligned(&Riscv64Assembler::VL1re32, /*alignment=*/ 1, "vl1re32.v {reg1}, ({reg2})"),
5930 "VL1re32");
5931 }
5932
TEST_F(AssemblerRISCV64Test,VL1re64)5933 TEST_F(AssemblerRISCV64Test, VL1re64) {
5934 DriverStr(
5935 RepeatVRAligned(&Riscv64Assembler::VL1re64, /*alignment=*/ 1, "vl1re64.v {reg1}, ({reg2})"),
5936 "VL1re64");
5937 }
5938
TEST_F(AssemblerRISCV64Test,VL2re8)5939 TEST_F(AssemblerRISCV64Test, VL2re8) {
5940 DriverStr(
5941 RepeatVRAligned(&Riscv64Assembler::VL2re8, /*alignment=*/ 2, "vl2re8.v {reg1}, ({reg2})"),
5942 "VL2re8");
5943 }
5944
TEST_F(AssemblerRISCV64Test,VL2re16)5945 TEST_F(AssemblerRISCV64Test, VL2re16) {
5946 DriverStr(
5947 RepeatVRAligned(&Riscv64Assembler::VL2re16, /*alignment=*/ 2, "vl2re16.v {reg1}, ({reg2})"),
5948 "VL2re16");
5949 }
5950
TEST_F(AssemblerRISCV64Test,VL2re32)5951 TEST_F(AssemblerRISCV64Test, VL2re32) {
5952 DriverStr(
5953 RepeatVRAligned(&Riscv64Assembler::VL2re32, /*alignment=*/ 2, "vl2re32.v {reg1}, ({reg2})"),
5954 "VL2re32");
5955 }
5956
TEST_F(AssemblerRISCV64Test,VL2re64)5957 TEST_F(AssemblerRISCV64Test, VL2re64) {
5958 DriverStr(
5959 RepeatVRAligned(&Riscv64Assembler::VL2re64, /*alignment=*/ 2, "vl2re64.v {reg1}, ({reg2})"),
5960 "VL2re64");
5961 }
5962
TEST_F(AssemblerRISCV64Test,VL4re8)5963 TEST_F(AssemblerRISCV64Test, VL4re8) {
5964 DriverStr(
5965 RepeatVRAligned(&Riscv64Assembler::VL4re8, /*alignment=*/ 4, "vl4re8.v {reg1}, ({reg2})"),
5966 "VL4re8");
5967 }
5968
TEST_F(AssemblerRISCV64Test,VL4re16)5969 TEST_F(AssemblerRISCV64Test, VL4re16) {
5970 DriverStr(
5971 RepeatVRAligned(&Riscv64Assembler::VL4re16, /*alignment=*/ 4, "vl4re16.v {reg1}, ({reg2})"),
5972 "VL4re16");
5973 }
5974
TEST_F(AssemblerRISCV64Test,VL4re32)5975 TEST_F(AssemblerRISCV64Test, VL4re32) {
5976 DriverStr(
5977 RepeatVRAligned(&Riscv64Assembler::VL4re32, /*alignment=*/ 4, "vl4re32.v {reg1}, ({reg2})"),
5978 "VL4re32");
5979 }
5980
TEST_F(AssemblerRISCV64Test,VL4re64)5981 TEST_F(AssemblerRISCV64Test, VL4re64) {
5982 DriverStr(
5983 RepeatVRAligned(&Riscv64Assembler::VL4re64, /*alignment=*/ 4, "vl4re64.v {reg1}, ({reg2})"),
5984 "VL4re64");
5985 }
5986
TEST_F(AssemblerRISCV64Test,VL8re8)5987 TEST_F(AssemblerRISCV64Test, VL8re8) {
5988 DriverStr(
5989 RepeatVRAligned(&Riscv64Assembler::VL8re8, /*alignment=*/ 8, "vl8re8.v {reg1}, ({reg2})"),
5990 "VL8re8");
5991 }
5992
TEST_F(AssemblerRISCV64Test,VL8re16)5993 TEST_F(AssemblerRISCV64Test, VL8re16) {
5994 DriverStr(
5995 RepeatVRAligned(&Riscv64Assembler::VL8re16, /*alignment=*/ 8, "vl8re16.v {reg1}, ({reg2})"),
5996 "VL8re16");
5997 }
5998
TEST_F(AssemblerRISCV64Test,VL8re32)5999 TEST_F(AssemblerRISCV64Test, VL8re32) {
6000 DriverStr(
6001 RepeatVRAligned(&Riscv64Assembler::VL8re32, /*alignment=*/ 8, "vl8re32.v {reg1}, ({reg2})"),
6002 "VL8re32");
6003 }
6004
TEST_F(AssemblerRISCV64Test,VL8re64)6005 TEST_F(AssemblerRISCV64Test, VL8re64) {
6006 DriverStr(
6007 RepeatVRAligned(&Riscv64Assembler::VL8re64, /*alignment=*/ 8, "vl8re64.v {reg1}, ({reg2})"),
6008 "VL8re64");
6009 }
6010
TEST_F(AssemblerRISCV64Test,VL1r)6011 TEST_F(AssemblerRISCV64Test, VL1r) {
6012 DriverStr(RepeatVRAligned(&Riscv64Assembler::VL1r, /*alignment=*/ 1, "vl1r.v {reg1}, ({reg2})"),
6013 "VL1r");
6014 }
6015
TEST_F(AssemblerRISCV64Test,VL2r)6016 TEST_F(AssemblerRISCV64Test, VL2r) {
6017 DriverStr(RepeatVRAligned(&Riscv64Assembler::VL2r, /*alignment=*/ 2, "vl2r.v {reg1}, ({reg2})"),
6018 "VL2r");
6019 }
6020
TEST_F(AssemblerRISCV64Test,VL4r)6021 TEST_F(AssemblerRISCV64Test, VL4r) {
6022 DriverStr(RepeatVRAligned(&Riscv64Assembler::VL4r, /*alignment=*/ 4, "vl4r.v {reg1}, ({reg2})"),
6023 "VL4r");
6024 }
6025
TEST_F(AssemblerRISCV64Test,VL8r)6026 TEST_F(AssemblerRISCV64Test, VL8r) {
6027 DriverStr(RepeatVRAligned(&Riscv64Assembler::VL8r, /*alignment=*/ 8, "vl8r.v {reg1}, ({reg2})"),
6028 "VL8r");
6029 }
6030
TEST_F(AssemblerRISCV64Test,VS1r)6031 TEST_F(AssemblerRISCV64Test, VS1r) {
6032 DriverStr(RepeatVRAligned(&Riscv64Assembler::VS1r, /*alignment=*/ 1, "vs1r.v {reg1}, ({reg2})"),
6033 "VS1r");
6034 }
6035
TEST_F(AssemblerRISCV64Test,VS2r)6036 TEST_F(AssemblerRISCV64Test, VS2r) {
6037 DriverStr(RepeatVRAligned(&Riscv64Assembler::VS2r, /*alignment=*/ 2, "vs2r.v {reg1}, ({reg2})"),
6038 "VS2r");
6039 }
6040
TEST_F(AssemblerRISCV64Test,VS4r)6041 TEST_F(AssemblerRISCV64Test, VS4r) {
6042 DriverStr(RepeatVRAligned(&Riscv64Assembler::VS4r, /*alignment=*/ 4, "vs4r.v {reg1}, ({reg2})"),
6043 "VS4r");
6044 }
6045
TEST_F(AssemblerRISCV64Test,VS8r)6046 TEST_F(AssemblerRISCV64Test, VS8r) {
6047 DriverStr(RepeatVRAligned(&Riscv64Assembler::VS8r, /*alignment=*/ 8, "vs8r.v {reg1}, ({reg2})"),
6048 "VS8r");
6049 }
6050
TEST_F(AssemblerRISCV64Test,VAdd_vv)6051 TEST_F(AssemblerRISCV64Test, VAdd_vv) {
6052 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VAdd_vv,
6053 "vadd.vv {reg1}, {reg2}, {reg3}{vm}",
6054 SkipV0Vm<VRegister, VRegister>()),
6055 "VAdd_vv");
6056 }
6057
TEST_F(AssemblerRISCV64Test,VAdd_vx)6058 TEST_F(AssemblerRISCV64Test, VAdd_vx) {
6059 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VAdd_vx,
6060 "vadd.vx {reg1}, {reg2}, {reg3}{vm}",
6061 SkipV0Vm<VRegister, XRegister>()),
6062 "VAdd_vx");
6063 }
6064
TEST_F(AssemblerRISCV64Test,VAdd_vi)6065 TEST_F(AssemblerRISCV64Test, VAdd_vi) {
6066 DriverStr(RepeatVVIbVmFiltered(&Riscv64Assembler::VAdd_vi,
6067 /*imm_bits=*/ -5,
6068 "vadd.vi {reg1}, {reg2}, {imm}{vm}",
6069 SkipV0Vm<VRegister, int32_t>()),
6070 "VAdd_vi");
6071 }
6072
TEST_F(AssemblerRISCV64Test,VSub_vv)6073 TEST_F(AssemblerRISCV64Test, VSub_vv) {
6074 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VSub_vv,
6075 "vsub.vv {reg1}, {reg2}, {reg3}{vm}",
6076 SkipV0Vm<VRegister, VRegister>()),
6077 "VSub_vv");
6078 }
6079
TEST_F(AssemblerRISCV64Test,VSub_vx)6080 TEST_F(AssemblerRISCV64Test, VSub_vx) {
6081 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VSub_vx,
6082 "vsub.vx {reg1}, {reg2}, {reg3}{vm}",
6083 SkipV0Vm<VRegister, XRegister>()),
6084 "VSub_vx");
6085 }
6086
TEST_F(AssemblerRISCV64Test,VRsub_vx)6087 TEST_F(AssemblerRISCV64Test, VRsub_vx) {
6088 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VRsub_vx,
6089 "vrsub.vx {reg1}, {reg2}, {reg3}{vm}",
6090 SkipV0Vm<VRegister, XRegister>()),
6091 "VRsub_vx");
6092 }
6093
TEST_F(AssemblerRISCV64Test,VRsub_vi)6094 TEST_F(AssemblerRISCV64Test, VRsub_vi) {
6095 DriverStr(RepeatVVIbVmFiltered(&Riscv64Assembler::VRsub_vi,
6096 /*imm_bits=*/ -5,
6097 "vrsub.vi {reg1}, {reg2}, {imm}{vm}",
6098 SkipV0Vm<VRegister, int32_t>()),
6099 "VRsub_vi");
6100 }
6101
TEST_F(AssemblerRISCV64Test,VNeg_v)6102 TEST_F(AssemblerRISCV64Test, VNeg_v) {
6103 DriverStr(RepeatVV(&Riscv64Assembler::VNeg_v, "vneg.v {reg1}, {reg2}"), "VNeg_v");
6104 }
6105
TEST_F(AssemblerRISCV64Test,VMinu_vv)6106 TEST_F(AssemblerRISCV64Test, VMinu_vv) {
6107 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VMinu_vv,
6108 "vminu.vv {reg1}, {reg2}, {reg3}{vm}",
6109 SkipV0Vm<VRegister, VRegister>()),
6110 "VMinu_vv");
6111 }
6112
TEST_F(AssemblerRISCV64Test,VMinu_vx)6113 TEST_F(AssemblerRISCV64Test, VMinu_vx) {
6114 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VMinu_vx,
6115 "vminu.vx {reg1}, {reg2}, {reg3}{vm}",
6116 SkipV0Vm<VRegister, XRegister>()),
6117 "VMinu_vx");
6118 }
6119
TEST_F(AssemblerRISCV64Test,VMin_vv)6120 TEST_F(AssemblerRISCV64Test, VMin_vv) {
6121 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VMin_vv,
6122 "vmin.vv {reg1}, {reg2}, {reg3}{vm}",
6123 SkipV0Vm<VRegister, VRegister>()),
6124 "VMin_vv");
6125 }
6126
TEST_F(AssemblerRISCV64Test,VMin_vx)6127 TEST_F(AssemblerRISCV64Test, VMin_vx) {
6128 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VMin_vx,
6129 "vmin.vx {reg1}, {reg2}, {reg3}{vm}",
6130 SkipV0Vm<VRegister, XRegister>()),
6131 "VMin_vx");
6132 }
6133
TEST_F(AssemblerRISCV64Test,VMaxu_vv)6134 TEST_F(AssemblerRISCV64Test, VMaxu_vv) {
6135 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VMaxu_vv,
6136 "vmaxu.vv {reg1}, {reg2}, {reg3}{vm}",
6137 SkipV0Vm<VRegister, VRegister>()),
6138 "VMaxu_vv");
6139 }
6140
TEST_F(AssemblerRISCV64Test,VMaxu_vx)6141 TEST_F(AssemblerRISCV64Test, VMaxu_vx) {
6142 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VMaxu_vx,
6143 "vmaxu.vx {reg1}, {reg2}, {reg3}{vm}",
6144 SkipV0Vm<VRegister, XRegister>()),
6145 "VMaxu_vx");
6146 }
6147
TEST_F(AssemblerRISCV64Test,VMax_vv)6148 TEST_F(AssemblerRISCV64Test, VMax_vv) {
6149 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VMax_vv,
6150 "vmax.vv {reg1}, {reg2}, {reg3}{vm}",
6151 SkipV0Vm<VRegister, VRegister>()),
6152 "VMax_vv");
6153 }
6154
TEST_F(AssemblerRISCV64Test,VMax_vx)6155 TEST_F(AssemblerRISCV64Test, VMax_vx) {
6156 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VMax_vx,
6157 "vmax.vx {reg1}, {reg2}, {reg3}{vm}",
6158 SkipV0Vm<VRegister, XRegister>()),
6159 "VMax_vx");
6160 }
6161
TEST_F(AssemblerRISCV64Test,VAnd_vv)6162 TEST_F(AssemblerRISCV64Test, VAnd_vv) {
6163 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VAnd_vv,
6164 "vand.vv {reg1}, {reg2}, {reg3}{vm}",
6165 SkipV0Vm<VRegister, VRegister>()),
6166 "VAnd_vv");
6167 }
6168
TEST_F(AssemblerRISCV64Test,VAnd_vx)6169 TEST_F(AssemblerRISCV64Test, VAnd_vx) {
6170 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VAnd_vx,
6171 "vand.vx {reg1}, {reg2}, {reg3}{vm}",
6172 SkipV0Vm<VRegister, XRegister>()),
6173 "VAnd_vx");
6174 }
6175
TEST_F(AssemblerRISCV64Test,VAnd_vi)6176 TEST_F(AssemblerRISCV64Test, VAnd_vi) {
6177 DriverStr(RepeatVVIbVmFiltered(&Riscv64Assembler::VAnd_vi,
6178 /*imm_bits=*/ -5,
6179 "vand.vi {reg1}, {reg2}, {imm}{vm}",
6180 SkipV0Vm<VRegister, int32_t>()),
6181 "VAnd_vi");
6182 }
6183
TEST_F(AssemblerRISCV64Test,VOr_vv)6184 TEST_F(AssemblerRISCV64Test, VOr_vv) {
6185 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VOr_vv,
6186 "vor.vv {reg1}, {reg2}, {reg3}{vm}",
6187 SkipV0Vm<VRegister, VRegister>()),
6188 "VOr_vv");
6189 }
6190
TEST_F(AssemblerRISCV64Test,VOr_vx)6191 TEST_F(AssemblerRISCV64Test, VOr_vx) {
6192 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VOr_vx,
6193 "vor.vx {reg1}, {reg2}, {reg3}{vm}",
6194 SkipV0Vm<VRegister, XRegister>()),
6195 "VOr_vx");
6196 }
6197
TEST_F(AssemblerRISCV64Test,VOr_vi)6198 TEST_F(AssemblerRISCV64Test, VOr_vi) {
6199 DriverStr(RepeatVVIbVmFiltered(&Riscv64Assembler::VOr_vi,
6200 /*imm_bits=*/ -5,
6201 "vor.vi {reg1}, {reg2}, {imm}{vm}",
6202 SkipV0Vm<VRegister, int32_t>()),
6203 "VOr_vi");
6204 }
6205
TEST_F(AssemblerRISCV64Test,VXor_vv)6206 TEST_F(AssemblerRISCV64Test, VXor_vv) {
6207 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VXor_vv,
6208 "vxor.vv {reg1}, {reg2}, {reg3}{vm}",
6209 SkipV0Vm<VRegister, VRegister>()),
6210 "VXor_vv");
6211 }
6212
TEST_F(AssemblerRISCV64Test,VXor_vx)6213 TEST_F(AssemblerRISCV64Test, VXor_vx) {
6214 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VXor_vx,
6215 "vxor.vx {reg1}, {reg2}, {reg3}{vm}",
6216 SkipV0Vm<VRegister, XRegister>()),
6217 "VXor_vx");
6218 }
6219
TEST_F(AssemblerRISCV64Test,VXor_vi)6220 TEST_F(AssemblerRISCV64Test, VXor_vi) {
6221 DriverStr(RepeatVVIbVmFiltered(&Riscv64Assembler::VXor_vi,
6222 /*imm_bits=*/ -5,
6223 "vxor.vi {reg1}, {reg2}, {imm}{vm}",
6224 SkipV0Vm<VRegister, int32_t>()),
6225 "VXor_vi");
6226 }
6227
TEST_F(AssemblerRISCV64Test,VNot_v)6228 TEST_F(AssemblerRISCV64Test, VNot_v) {
6229 DriverStr(RepeatVVVmFiltered(
6230 &Riscv64Assembler::VNot_v, "vnot.v {reg1}, {reg2}{vm}", SkipV0Vm<VRegister>()),
6231 "VNot_v");
6232 }
6233
TEST_F(AssemblerRISCV64Test,VRgather_vv)6234 TEST_F(AssemblerRISCV64Test, VRgather_vv) {
6235 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VRgather_vv,
6236 "vrgather.vv {reg1}, {reg2}, {reg3}{vm}",
6237 VXVVmSkipV0VmAndNoR1R2R3Overlap()),
6238 "VRgather_vv");
6239 }
6240
TEST_F(AssemblerRISCV64Test,VRgather_vx)6241 TEST_F(AssemblerRISCV64Test, VRgather_vx) {
6242 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VRgather_vx,
6243 "vrgather.vx {reg1}, {reg2}, {reg3}{vm}",
6244 VXVVmSkipV0VmAndNoR1R2Overlap<XRegister>()),
6245 "VRgather_vx");
6246 }
6247
TEST_F(AssemblerRISCV64Test,VRgather_vi)6248 TEST_F(AssemblerRISCV64Test, VRgather_vi) {
6249 DriverStr(RepeatVVIbVmFiltered(&Riscv64Assembler::VRgather_vi,
6250 /*imm_bits=*/ 5,
6251 "vrgather.vi {reg1}, {reg2}, {imm}{vm}",
6252 VXVVmSkipV0VmAndNoR1R2Overlap<uint32_t>()),
6253 "VRgather_vi");
6254 }
6255
TEST_F(AssemblerRISCV64Test,VSlideup_vx)6256 TEST_F(AssemblerRISCV64Test, VSlideup_vx) {
6257 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VSlideup_vx,
6258 "vslideup.vx {reg1}, {reg2}, {reg3}{vm}",
6259 VXVVmSkipV0VmAndNoR1R2Overlap<XRegister>()),
6260 "VSlideup_vx");
6261 }
6262
TEST_F(AssemblerRISCV64Test,VSlideup_vi)6263 TEST_F(AssemblerRISCV64Test, VSlideup_vi) {
6264 DriverStr(RepeatVVIbVmFiltered(&Riscv64Assembler::VSlideup_vi,
6265 /*imm_bits=*/ 5,
6266 "vslideup.vi {reg1}, {reg2}, {imm}{vm}",
6267 VXVVmSkipV0VmAndNoR1R2Overlap<uint32_t>()),
6268 "VSlideup_vi");
6269 }
6270
TEST_F(AssemblerRISCV64Test,VRgatherei16_vv)6271 TEST_F(AssemblerRISCV64Test, VRgatherei16_vv) {
6272 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VRgatherei16_vv,
6273 "vrgatherei16.vv {reg1}, {reg2}, {reg3}{vm}",
6274 VXVVmSkipV0VmAndNoR1R2R3Overlap()),
6275 "VRgatherei16_vv");
6276 }
6277
TEST_F(AssemblerRISCV64Test,VSlidedown_vx)6278 TEST_F(AssemblerRISCV64Test, VSlidedown_vx) {
6279 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VSlidedown_vx,
6280 "vslidedown.vx {reg1}, {reg2}, {reg3}{vm}",
6281 VXVVmSkipV0VmAndNoR1R2Overlap<XRegister>()),
6282 "VSlidedown_vx");
6283 }
6284
TEST_F(AssemblerRISCV64Test,VSlidedown_vi)6285 TEST_F(AssemblerRISCV64Test, VSlidedown_vi) {
6286 DriverStr(RepeatVVIbVmFiltered(&Riscv64Assembler::VSlidedown_vi,
6287 /*imm_bits=*/ 5,
6288 "vslidedown.vi {reg1}, {reg2}, {imm}{vm}",
6289 SkipV0Vm<VRegister, uint32_t>()),
6290 "VSlidedown_vi");
6291 }
6292
TEST_F(AssemblerRISCV64Test,VAdc_vvm)6293 TEST_F(AssemblerRISCV64Test, VAdc_vvm) {
6294 DriverStr(RepeatVVVFiltered(&Riscv64Assembler::VAdc_vvm,
6295 "vadc.vvm {reg1}, {reg2}, {reg3}, v0",
6296 SkipV0<VRegister, VRegister>()),
6297 "VAdc_vvm");
6298 }
6299
TEST_F(AssemblerRISCV64Test,VAdc_vxm)6300 TEST_F(AssemblerRISCV64Test, VAdc_vxm) {
6301 DriverStr(RepeatVVRFiltered(&Riscv64Assembler::VAdc_vxm,
6302 "vadc.vxm {reg1}, {reg2}, {reg3}, v0",
6303 SkipV0<VRegister, XRegister>()),
6304 "VAdc_vxm");
6305 }
6306
TEST_F(AssemblerRISCV64Test,VAdc_vim)6307 TEST_F(AssemblerRISCV64Test, VAdc_vim) {
6308 DriverStr(RepeatVVIFiltered(&Riscv64Assembler::VAdc_vim,
6309 /*imm_bits=*/ -5,
6310 "vadc.vim {reg1}, {reg2}, {imm}, v0",
6311 SkipV0<VRegister, int32_t>()),
6312 "VAdc_vim");
6313 }
6314
TEST_F(AssemblerRISCV64Test,VMadc_vvm)6315 TEST_F(AssemblerRISCV64Test, VMadc_vvm) {
6316 DriverStr(RepeatVVV(&Riscv64Assembler::VMadc_vvm, "vmadc.vvm {reg1}, {reg2}, {reg3}, v0"),
6317 "VMadc_vvm");
6318 }
6319
TEST_F(AssemblerRISCV64Test,VMadc_vxm)6320 TEST_F(AssemblerRISCV64Test, VMadc_vxm) {
6321 DriverStr(RepeatVVR(&Riscv64Assembler::VMadc_vxm, "vmadc.vxm {reg1}, {reg2}, {reg3}, v0"),
6322 "VMadc_vxm");
6323 }
6324
TEST_F(AssemblerRISCV64Test,VMadc_vim)6325 TEST_F(AssemblerRISCV64Test, VMadc_vim) {
6326 DriverStr(RepeatVVIb(&Riscv64Assembler::VMadc_vim,
6327 /*imm_bits=*/ -5,
6328 "vmadc.vim {reg1}, {reg2}, {imm}, v0"),
6329 "VMadc_vim");
6330 }
6331
TEST_F(AssemblerRISCV64Test,VMadc_vv)6332 TEST_F(AssemblerRISCV64Test, VMadc_vv) {
6333 DriverStr(RepeatVVV(&Riscv64Assembler::VMadc_vv, "vmadc.vv {reg1}, {reg2}, {reg3}"), "VMadc_vv");
6334 }
6335
TEST_F(AssemblerRISCV64Test,VMadc_vx)6336 TEST_F(AssemblerRISCV64Test, VMadc_vx) {
6337 DriverStr(RepeatVVR(&Riscv64Assembler::VMadc_vx, "vmadc.vx {reg1}, {reg2}, {reg3}"), "VMadc_vx");
6338 }
6339
TEST_F(AssemblerRISCV64Test,VMadc_vi)6340 TEST_F(AssemblerRISCV64Test, VMadc_vi) {
6341 DriverStr(RepeatVVIb(&Riscv64Assembler::VMadc_vi,
6342 /*imm_bits=*/ -5,
6343 "vmadc.vi {reg1}, {reg2}, {imm}"),
6344 "VMadc_vi");
6345 }
6346
TEST_F(AssemblerRISCV64Test,VSbc_vvm)6347 TEST_F(AssemblerRISCV64Test, VSbc_vvm) {
6348 DriverStr(RepeatVVVFiltered(&Riscv64Assembler::VSbc_vvm,
6349 "vsbc.vvm {reg1}, {reg2}, {reg3}, v0",
6350 SkipV0<VRegister, VRegister>()),
6351 "VSbc_vvm");
6352 }
6353
TEST_F(AssemblerRISCV64Test,VSbc_vxm)6354 TEST_F(AssemblerRISCV64Test, VSbc_vxm) {
6355 DriverStr(RepeatVVRFiltered(&Riscv64Assembler::VSbc_vxm,
6356 "vsbc.vxm {reg1}, {reg2}, {reg3}, v0",
6357 SkipV0<VRegister, XRegister>()),
6358 "VSbc_vxm");
6359 }
6360
TEST_F(AssemblerRISCV64Test,VMsbc_vvm)6361 TEST_F(AssemblerRISCV64Test, VMsbc_vvm) {
6362 DriverStr(RepeatVVV(&Riscv64Assembler::VMsbc_vvm, "vmsbc.vvm {reg1}, {reg2}, {reg3}, v0"),
6363 "VMsbc_vvm");
6364 }
6365
TEST_F(AssemblerRISCV64Test,VMsbc_vxm)6366 TEST_F(AssemblerRISCV64Test, VMsbc_vxm) {
6367 DriverStr(RepeatVVR(&Riscv64Assembler::VMsbc_vxm, "vmsbc.vxm {reg1}, {reg2}, {reg3}, v0"),
6368 "VMsbc_vxm");
6369 }
6370
TEST_F(AssemblerRISCV64Test,VMsbc_vv)6371 TEST_F(AssemblerRISCV64Test, VMsbc_vv) {
6372 DriverStr(RepeatVVV(&Riscv64Assembler::VMsbc_vv, "vmsbc.vv {reg1}, {reg2}, {reg3}"), "VMsbc_vvm");
6373 }
6374
TEST_F(AssemblerRISCV64Test,VMsbc_vx)6375 TEST_F(AssemblerRISCV64Test, VMsbc_vx) {
6376 DriverStr(RepeatVVR(&Riscv64Assembler::VMsbc_vx, "vmsbc.vx {reg1}, {reg2}, {reg3}"), "VMsbc_vxm");
6377 }
6378
TEST_F(AssemblerRISCV64Test,VMerge_vvm)6379 TEST_F(AssemblerRISCV64Test, VMerge_vvm) {
6380 DriverStr(RepeatVVVFiltered(&Riscv64Assembler::VMerge_vvm,
6381 "vmerge.vvm {reg1}, {reg2}, {reg3}, v0",
6382 SkipV0<VRegister, VRegister>()),
6383 "VMerge_vvm");
6384 }
6385
TEST_F(AssemblerRISCV64Test,VMerge_vxm)6386 TEST_F(AssemblerRISCV64Test, VMerge_vxm) {
6387 DriverStr(RepeatVVRFiltered(&Riscv64Assembler::VMerge_vxm,
6388 "vmerge.vxm {reg1}, {reg2}, {reg3}, v0",
6389 SkipV0<VRegister, XRegister>()),
6390 "VMerge_vxm");
6391 }
6392
TEST_F(AssemblerRISCV64Test,VMerge_vim)6393 TEST_F(AssemblerRISCV64Test, VMerge_vim) {
6394 DriverStr(RepeatVVIFiltered(&Riscv64Assembler::VMerge_vim,
6395 /*imm_bits=*/ -5,
6396 "vmerge.vim {reg1}, {reg2}, {imm}, v0",
6397 SkipV0<VRegister, int32_t>()),
6398 "VMerge_vim");
6399 }
6400
TEST_F(AssemblerRISCV64Test,VMv_vv)6401 TEST_F(AssemblerRISCV64Test, VMv_vv) {
6402 DriverStr(RepeatVV(&Riscv64Assembler::VMv_vv, "vmv.v.v {reg1}, {reg2}"), "VMmv_vv");
6403 }
6404
TEST_F(AssemblerRISCV64Test,VMv_vx)6405 TEST_F(AssemblerRISCV64Test, VMv_vx) {
6406 DriverStr(RepeatVR(&Riscv64Assembler::VMv_vx, "vmv.v.x {reg1}, {reg2}"), "VMv_vx");
6407 }
6408
TEST_F(AssemblerRISCV64Test,VMv_vi)6409 TEST_F(AssemblerRISCV64Test, VMv_vi) {
6410 DriverStr(RepeatVIb(&Riscv64Assembler::VMv_vi, /*imm_bits=*/ -5, "vmv.v.i {reg}, {imm}"),
6411 "VMv_vi");
6412 }
6413
TEST_F(AssemblerRISCV64Test,VMseq_vv)6414 TEST_F(AssemblerRISCV64Test, VMseq_vv) {
6415 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VMseq_vv,
6416 "vmseq.vv {reg1}, {reg2}, {reg3}{vm}",
6417 SkipV0Vm<VRegister, VRegister>()),
6418 "VMseq_vv");
6419 }
6420
TEST_F(AssemblerRISCV64Test,VMseq_vx)6421 TEST_F(AssemblerRISCV64Test, VMseq_vx) {
6422 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VMseq_vx,
6423 "vmseq.vx {reg1}, {reg2}, {reg3}{vm}",
6424 SkipV0Vm<VRegister, XRegister>()),
6425 "VMseq_vx");
6426 }
6427
TEST_F(AssemblerRISCV64Test,VMseq_vi)6428 TEST_F(AssemblerRISCV64Test, VMseq_vi) {
6429 DriverStr(RepeatVVIbVmFiltered(&Riscv64Assembler::VMseq_vi,
6430 /*imm_bits=*/ -5,
6431 "vmseq.vi {reg1}, {reg2}, {imm}{vm}",
6432 SkipV0Vm<VRegister, int32_t>()),
6433 "VMseq_vi");
6434 }
6435
TEST_F(AssemblerRISCV64Test,VMsne_vv)6436 TEST_F(AssemblerRISCV64Test, VMsne_vv) {
6437 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VMsne_vv,
6438 "vmsne.vv {reg1}, {reg2}, {reg3}{vm}",
6439 SkipV0Vm<VRegister, VRegister>()),
6440 "VMsne_vv");
6441 }
6442
TEST_F(AssemblerRISCV64Test,VMsne_vx)6443 TEST_F(AssemblerRISCV64Test, VMsne_vx) {
6444 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VMsne_vx,
6445 "vmsne.vx {reg1}, {reg2}, {reg3}{vm}",
6446 SkipV0Vm<VRegister, XRegister>()),
6447 "VMsne_vx");
6448 }
6449
TEST_F(AssemblerRISCV64Test,VMsne_vi)6450 TEST_F(AssemblerRISCV64Test, VMsne_vi) {
6451 DriverStr(RepeatVVIbVmFiltered(&Riscv64Assembler::VMsne_vi,
6452 /*imm_bits=*/ -5,
6453 "vmsne.vi {reg1}, {reg2}, {imm}{vm}",
6454 SkipV0Vm<VRegister, int32_t>()),
6455 "VMsne_vi");
6456 }
6457
TEST_F(AssemblerRISCV64Test,VMsltu_vv)6458 TEST_F(AssemblerRISCV64Test, VMsltu_vv) {
6459 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VMsltu_vv,
6460 "vmsltu.vv {reg1}, {reg2}, {reg3}{vm}",
6461 SkipV0Vm<VRegister, VRegister>()),
6462 "VMsltu_vv");
6463 }
6464
TEST_F(AssemblerRISCV64Test,VMsltu_vx)6465 TEST_F(AssemblerRISCV64Test, VMsltu_vx) {
6466 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VMsltu_vx,
6467 "vmsltu.vx {reg1}, {reg2}, {reg3}{vm}",
6468 SkipV0Vm<VRegister, XRegister>()),
6469 "VMsltu_vx");
6470 }
6471
TEST_F(AssemblerRISCV64Test,VMsgtu_vv)6472 TEST_F(AssemblerRISCV64Test, VMsgtu_vv) {
6473 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VMsgtu_vv,
6474 "vmsgtu.vv {reg1}, {reg2}, {reg3}{vm}",
6475 SkipV0Vm<VRegister, VRegister>()),
6476 "VMsgtu_vv");
6477 }
6478
TEST_F(AssemblerRISCV64Test,VMslt_vv)6479 TEST_F(AssemblerRISCV64Test, VMslt_vv) {
6480 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VMslt_vv,
6481 "vmslt.vv {reg1}, {reg2}, {reg3}{vm}",
6482 SkipV0Vm<VRegister, VRegister>()),
6483 "VMslt_vv");
6484 }
6485
TEST_F(AssemblerRISCV64Test,VMslt_vx)6486 TEST_F(AssemblerRISCV64Test, VMslt_vx) {
6487 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VMslt_vx,
6488 "vmslt.vx {reg1}, {reg2}, {reg3}{vm}",
6489 SkipV0Vm<VRegister, XRegister>()),
6490 "VMslt_vx");
6491 }
6492
TEST_F(AssemblerRISCV64Test,VMsgt_vv)6493 TEST_F(AssemblerRISCV64Test, VMsgt_vv) {
6494 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VMsgt_vv,
6495 "vmsgt.vv {reg1}, {reg2}, {reg3}{vm}",
6496 SkipV0Vm<VRegister, VRegister>()),
6497 "VMsgt_vv");
6498 }
6499
TEST_F(AssemblerRISCV64Test,VMsleu_vv)6500 TEST_F(AssemblerRISCV64Test, VMsleu_vv) {
6501 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VMsleu_vv,
6502 "vmsleu.vv {reg1}, {reg2}, {reg3}{vm}",
6503 SkipV0Vm<VRegister, VRegister>()),
6504 "VMsleu_vv");
6505 }
6506
TEST_F(AssemblerRISCV64Test,VMsleu_vx)6507 TEST_F(AssemblerRISCV64Test, VMsleu_vx) {
6508 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VMsleu_vx,
6509 "vmsleu.vx {reg1}, {reg2}, {reg3}{vm}",
6510 SkipV0Vm<VRegister, XRegister>()),
6511 "VMsleu_vx");
6512 }
6513
TEST_F(AssemblerRISCV64Test,VMsleu_vi)6514 TEST_F(AssemblerRISCV64Test, VMsleu_vi) {
6515 DriverStr(RepeatVVIbVmFiltered(&Riscv64Assembler::VMsleu_vi,
6516 /*imm_bits=*/ -5,
6517 "vmsleu.vi {reg1}, {reg2}, {imm}{vm}",
6518 SkipV0Vm<VRegister, int32_t>()),
6519 "VMsleu_vi");
6520 }
6521
TEST_F(AssemblerRISCV64Test,VMsgeu_vv)6522 TEST_F(AssemblerRISCV64Test, VMsgeu_vv) {
6523 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VMsgeu_vv,
6524 "vmsgeu.vv {reg1}, {reg2}, {reg3}{vm}",
6525 SkipV0Vm<VRegister, VRegister>()),
6526 "VMsgeu_vv");
6527 }
6528
TEST_F(AssemblerRISCV64Test,VMsltu_vi)6529 TEST_F(AssemblerRISCV64Test, VMsltu_vi) {
6530 DriverStr(RepeatVVIbVmFiltered(&Riscv64Assembler::VMsltu_vi,
6531 /*imm_bits=*/ 4,
6532 "vmsltu.vi {reg1}, {reg2}, {imm}{vm}",
6533 SkipV0Vm<VRegister, uint32_t>(),
6534 /*bias=*/ 1),
6535 "VMsltu_vi");
6536 }
6537
TEST_F(AssemblerRISCV64Test,VMsle_vv)6538 TEST_F(AssemblerRISCV64Test, VMsle_vv) {
6539 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VMsle_vv,
6540 "vmsle.vv {reg1}, {reg2}, {reg3}{vm}",
6541 SkipV0Vm<VRegister, VRegister>()),
6542 "VMsle_vv");
6543 }
6544
TEST_F(AssemblerRISCV64Test,VMsle_vx)6545 TEST_F(AssemblerRISCV64Test, VMsle_vx) {
6546 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VMsle_vx,
6547 "vmsle.vx {reg1}, {reg2}, {reg3}{vm}",
6548 SkipV0Vm<VRegister, XRegister>()),
6549 "VMsle_vx");
6550 }
6551
TEST_F(AssemblerRISCV64Test,VMsle_vi)6552 TEST_F(AssemblerRISCV64Test, VMsle_vi) {
6553 DriverStr(RepeatVVIbVmFiltered(&Riscv64Assembler::VMsle_vi,
6554 /*imm_bits=*/ -5,
6555 "vmsle.vi {reg1}, {reg2}, {imm}{vm}",
6556 SkipV0Vm<VRegister, int32_t>()),
6557 "VMsle_vi");
6558 }
6559
TEST_F(AssemblerRISCV64Test,VMsge_vv)6560 TEST_F(AssemblerRISCV64Test, VMsge_vv) {
6561 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VMsge_vv,
6562 "vmsge.vv {reg1}, {reg2}, {reg3}{vm}",
6563 SkipV0Vm<VRegister, VRegister>()),
6564 "VMsge_vv");
6565 }
6566
TEST_F(AssemblerRISCV64Test,VMslt_vi)6567 TEST_F(AssemblerRISCV64Test, VMslt_vi) {
6568 DriverStr(RepeatVVIbVmFiltered(&Riscv64Assembler::VMslt_vi,
6569 /*imm_bits=*/ -5,
6570 "vmslt.vi {reg1}, {reg2}, {imm}{vm}",
6571 SkipV0Vm<VRegister, int32_t>(),
6572 /*bias=*/ 1),
6573 "VMslt_vi");
6574 }
6575
TEST_F(AssemblerRISCV64Test,VMsgtu_vx)6576 TEST_F(AssemblerRISCV64Test, VMsgtu_vx) {
6577 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VMsgtu_vx,
6578 "vmsgtu.vx {reg1}, {reg2}, {reg3}{vm}",
6579 SkipV0Vm<VRegister, XRegister>()),
6580 "VMsgtu_vx");
6581 }
6582
TEST_F(AssemblerRISCV64Test,VMsgtu_vi)6583 TEST_F(AssemblerRISCV64Test, VMsgtu_vi) {
6584 DriverStr(RepeatVVIbVmFiltered(&Riscv64Assembler::VMsgtu_vi,
6585 /*imm_bits=*/ -5,
6586 "vmsgtu.vi {reg1}, {reg2}, {imm}{vm}",
6587 SkipV0Vm<VRegister, int32_t>()),
6588 "VMsgtu_vi");
6589 }
6590
TEST_F(AssemblerRISCV64Test,VMsgeu_vi)6591 TEST_F(AssemblerRISCV64Test, VMsgeu_vi) {
6592 DriverStr(RepeatVVIbVmFiltered(&Riscv64Assembler::VMsgeu_vi,
6593 /*imm_bits=*/ 4,
6594 "vmsgeu.vi {reg1}, {reg2}, {imm}{vm}",
6595 SkipV0Vm<VRegister, uint32_t>(),
6596 /*bias=*/ 1),
6597 "VMsgeu_vi");
6598 }
6599
TEST_F(AssemblerRISCV64Test,VMsgt_vx)6600 TEST_F(AssemblerRISCV64Test, VMsgt_vx) {
6601 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VMsgt_vx,
6602 "vmsgt.vx {reg1}, {reg2}, {reg3}{vm}",
6603 SkipV0Vm<VRegister, XRegister>()),
6604 "VMsgt_vx");
6605 }
6606
TEST_F(AssemblerRISCV64Test,VMsgt_vi)6607 TEST_F(AssemblerRISCV64Test, VMsgt_vi) {
6608 DriverStr(RepeatVVIbVmFiltered(&Riscv64Assembler::VMsgt_vi,
6609 /*imm_bits=*/ -5,
6610 "vmsgt.vi {reg1}, {reg2}, {imm}{vm}",
6611 SkipV0Vm<VRegister, int32_t>()),
6612 "VMsgt_vi");
6613 }
6614
TEST_F(AssemblerRISCV64Test,VMsge_vi)6615 TEST_F(AssemblerRISCV64Test, VMsge_vi) {
6616 DriverStr(RepeatVVIbVmFiltered(&Riscv64Assembler::VMsge_vi,
6617 /*imm_bits=*/ -5,
6618 "vmsge.vi {reg1}, {reg2}, {imm}{vm}",
6619 SkipV0Vm<VRegister, int32_t>(),
6620 /*bias=*/ 1),
6621 "VMsge_vi");
6622 }
6623
TEST_F(AssemblerRISCV64Test,VSaddu_vv)6624 TEST_F(AssemblerRISCV64Test, VSaddu_vv) {
6625 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VSaddu_vv,
6626 "vsaddu.vv {reg1}, {reg2}, {reg3}{vm}",
6627 SkipV0Vm<VRegister, VRegister>()),
6628 "VSaddu_vv");
6629 }
6630
TEST_F(AssemblerRISCV64Test,VSaddu_vx)6631 TEST_F(AssemblerRISCV64Test, VSaddu_vx) {
6632 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VSaddu_vx,
6633 "vsaddu.vx {reg1}, {reg2}, {reg3}{vm}",
6634 SkipV0Vm<VRegister, XRegister>()),
6635 "VSaddu_vx");
6636 }
6637
TEST_F(AssemblerRISCV64Test,VSaddu_vi)6638 TEST_F(AssemblerRISCV64Test, VSaddu_vi) {
6639 DriverStr(RepeatVVIbVmFiltered(&Riscv64Assembler::VSaddu_vi,
6640 /*imm_bits=*/ -5,
6641 "vsaddu.vi {reg1}, {reg2}, {imm}{vm}",
6642 SkipV0Vm<VRegister, int32_t>()),
6643 "VSaddu_vi");
6644 }
6645
TEST_F(AssemblerRISCV64Test,VSadd_vv)6646 TEST_F(AssemblerRISCV64Test, VSadd_vv) {
6647 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VSadd_vv,
6648 "vsadd.vv {reg1}, {reg2}, {reg3}{vm}",
6649 SkipV0Vm<VRegister, VRegister>()),
6650 "VSadd_vv");
6651 }
6652
TEST_F(AssemblerRISCV64Test,VSadd_vx)6653 TEST_F(AssemblerRISCV64Test, VSadd_vx) {
6654 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VSadd_vx,
6655 "vsadd.vx {reg1}, {reg2}, {reg3}{vm}",
6656 SkipV0Vm<VRegister, XRegister>()),
6657 "VSadd_vx");
6658 }
6659
TEST_F(AssemblerRISCV64Test,VSadd_vi)6660 TEST_F(AssemblerRISCV64Test, VSadd_vi) {
6661 DriverStr(RepeatVVIbVmFiltered(&Riscv64Assembler::VSadd_vi,
6662 /*imm_bits=*/ -5,
6663 "vsadd.vi {reg1}, {reg2}, {imm}{vm}",
6664 SkipV0Vm<VRegister, int32_t>()),
6665 "VSadd_vi");
6666 }
6667
TEST_F(AssemblerRISCV64Test,VSsubu_vv)6668 TEST_F(AssemblerRISCV64Test, VSsubu_vv) {
6669 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VSsubu_vv,
6670 "vssubu.vv {reg1}, {reg2}, {reg3}{vm}",
6671 SkipV0Vm<VRegister, VRegister>()),
6672 "VSsubu_vv");
6673 }
6674
TEST_F(AssemblerRISCV64Test,VSsubu_vx)6675 TEST_F(AssemblerRISCV64Test, VSsubu_vx) {
6676 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VSsubu_vx,
6677 "vssubu.vx {reg1}, {reg2}, {reg3}{vm}",
6678 SkipV0Vm<VRegister, XRegister>()),
6679 "VSsubu_vx");
6680 }
6681
TEST_F(AssemblerRISCV64Test,VSsub_vv)6682 TEST_F(AssemblerRISCV64Test, VSsub_vv) {
6683 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VSsub_vv,
6684 "vssub.vv {reg1}, {reg2}, {reg3}{vm}",
6685 SkipV0Vm<VRegister, VRegister>()),
6686 "VSsub_vv");
6687 }
6688
TEST_F(AssemblerRISCV64Test,VSsub_vx)6689 TEST_F(AssemblerRISCV64Test, VSsub_vx) {
6690 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VSsub_vx,
6691 "vssub.vx {reg1}, {reg2}, {reg3}{vm}",
6692 SkipV0Vm<VRegister, XRegister>()),
6693 "VSsub_vx");
6694 }
6695
TEST_F(AssemblerRISCV64Test,VSll_vv)6696 TEST_F(AssemblerRISCV64Test, VSll_vv) {
6697 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VSll_vv,
6698 "vsll.vv {reg1}, {reg2}, {reg3}{vm}",
6699 SkipV0Vm<VRegister, VRegister>()),
6700 "VSll_vv");
6701 }
6702
TEST_F(AssemblerRISCV64Test,VSll_vx)6703 TEST_F(AssemblerRISCV64Test, VSll_vx) {
6704 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VSll_vx,
6705 "vsll.vx {reg1}, {reg2}, {reg3}{vm}",
6706 SkipV0Vm<VRegister, XRegister>()),
6707 "VSll_vx");
6708 }
6709
TEST_F(AssemblerRISCV64Test,VSll_vi)6710 TEST_F(AssemblerRISCV64Test, VSll_vi) {
6711 DriverStr(RepeatVVIbVmFiltered(&Riscv64Assembler::VSll_vi,
6712 /*imm_bits=*/ 5,
6713 "vsll.vi {reg1}, {reg2}, {imm}{vm}",
6714 SkipV0Vm<VRegister, uint32_t>()),
6715 "VSll_vi");
6716 }
6717
TEST_F(AssemblerRISCV64Test,VSmul_vv)6718 TEST_F(AssemblerRISCV64Test, VSmul_vv) {
6719 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VSmul_vv,
6720 "vsmul.vv {reg1}, {reg2}, {reg3}{vm}",
6721 SkipV0Vm<VRegister, VRegister>()),
6722 "VSmul_vv");
6723 }
6724
TEST_F(AssemblerRISCV64Test,VSmul_vx)6725 TEST_F(AssemblerRISCV64Test, VSmul_vx) {
6726 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VSmul_vx,
6727 "vsmul.vx {reg1}, {reg2}, {reg3}{vm}",
6728 SkipV0Vm<VRegister, XRegister>()),
6729 "VSmul_vx");
6730 }
6731
TEST_F(AssemblerRISCV64Test,Vmv1r_v)6732 TEST_F(AssemblerRISCV64Test, Vmv1r_v) {
6733 DriverStr(RepeatVVAligned(&Riscv64Assembler::Vmv1r_v, /*alignment=*/ 1, "vmv1r.v {reg1}, {reg2}"),
6734 "Vmv1r_v");
6735 }
6736
TEST_F(AssemblerRISCV64Test,Vmv2r_v)6737 TEST_F(AssemblerRISCV64Test, Vmv2r_v) {
6738 DriverStr(RepeatVVAligned(&Riscv64Assembler::Vmv2r_v, /*alignment=*/ 2, "vmv2r.v {reg1}, {reg2}"),
6739 "Vmv2r_v");
6740 }
6741
TEST_F(AssemblerRISCV64Test,Vmv4r_v)6742 TEST_F(AssemblerRISCV64Test, Vmv4r_v) {
6743 DriverStr(RepeatVVAligned(&Riscv64Assembler::Vmv4r_v, /*alignment=*/ 4, "vmv4r.v {reg1}, {reg2}"),
6744 "Vmv4r_v");
6745 }
6746
TEST_F(AssemblerRISCV64Test,Vmv8r_v)6747 TEST_F(AssemblerRISCV64Test, Vmv8r_v) {
6748 DriverStr(RepeatVVAligned(&Riscv64Assembler::Vmv8r_v, /*alignment=*/ 8, "vmv8r.v {reg1}, {reg2}"),
6749 "Vmv8r_v");
6750 }
6751
TEST_F(AssemblerRISCV64Test,VSrl_vv)6752 TEST_F(AssemblerRISCV64Test, VSrl_vv) {
6753 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VSrl_vv,
6754 "vsrl.vv {reg1}, {reg2}, {reg3}{vm}",
6755 SkipV0Vm<VRegister, VRegister>()),
6756 "VSrl_vv");
6757 }
6758
TEST_F(AssemblerRISCV64Test,VSrl_vx)6759 TEST_F(AssemblerRISCV64Test, VSrl_vx) {
6760 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VSrl_vx,
6761 "vsrl.vx {reg1}, {reg2}, {reg3}{vm}",
6762 SkipV0Vm<VRegister, XRegister>()),
6763 "VSrl_vx");
6764 }
6765
TEST_F(AssemblerRISCV64Test,VSrl_vi)6766 TEST_F(AssemblerRISCV64Test, VSrl_vi) {
6767 DriverStr(RepeatVVIbVmFiltered(&Riscv64Assembler::VSrl_vi,
6768 /*imm_bits=*/ 5,
6769 "vsrl.vi {reg1}, {reg2}, {imm}{vm}",
6770 SkipV0Vm<VRegister, uint32_t>()),
6771 "VSrl_vi");
6772 }
6773
TEST_F(AssemblerRISCV64Test,VSra_vv)6774 TEST_F(AssemblerRISCV64Test, VSra_vv) {
6775 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VSra_vv,
6776 "vsra.vv {reg1}, {reg2}, {reg3}{vm}",
6777 SkipV0Vm<VRegister, VRegister>()),
6778 "VSra_vv");
6779 }
6780
TEST_F(AssemblerRISCV64Test,VSra_vx)6781 TEST_F(AssemblerRISCV64Test, VSra_vx) {
6782 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VSra_vx,
6783 "vsra.vx {reg1}, {reg2}, {reg3}{vm}",
6784 SkipV0Vm<VRegister, XRegister>()),
6785 "VSra_vx");
6786 }
6787
TEST_F(AssemblerRISCV64Test,VSra_vi)6788 TEST_F(AssemblerRISCV64Test, VSra_vi) {
6789 DriverStr(RepeatVVIbVmFiltered(&Riscv64Assembler::VSra_vi,
6790 /*imm_bits=*/ 5,
6791 "vsra.vi {reg1}, {reg2}, {imm}{vm}",
6792 SkipV0Vm<VRegister, uint32_t>()),
6793 "VSra_vi");
6794 }
6795
TEST_F(AssemblerRISCV64Test,VSsrl_vv)6796 TEST_F(AssemblerRISCV64Test, VSsrl_vv) {
6797 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VSsrl_vv,
6798 "vssrl.vv {reg1}, {reg2}, {reg3}{vm}",
6799 SkipV0Vm<VRegister, VRegister>()),
6800 "VSsrl_vv");
6801 }
6802
TEST_F(AssemblerRISCV64Test,VSsrl_vx)6803 TEST_F(AssemblerRISCV64Test, VSsrl_vx) {
6804 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VSsrl_vx,
6805 "vssrl.vx {reg1}, {reg2}, {reg3}{vm}",
6806 SkipV0Vm<VRegister, XRegister>()),
6807 "VSsrl_vx");
6808 }
6809
TEST_F(AssemblerRISCV64Test,VSsrl_vi)6810 TEST_F(AssemblerRISCV64Test, VSsrl_vi) {
6811 DriverStr(RepeatVVIbVmFiltered(&Riscv64Assembler::VSsrl_vi,
6812 /*imm_bits=*/ 5,
6813 "vssrl.vi {reg1}, {reg2}, {imm}{vm}",
6814 SkipV0Vm<VRegister, uint32_t>()),
6815 "VSsrl_vi");
6816 }
6817
TEST_F(AssemblerRISCV64Test,VSsra_vv)6818 TEST_F(AssemblerRISCV64Test, VSsra_vv) {
6819 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VSsra_vv,
6820 "vssra.vv {reg1}, {reg2}, {reg3}{vm}",
6821 SkipV0Vm<VRegister, VRegister>()),
6822 "VSsra_vv");
6823 }
6824
TEST_F(AssemblerRISCV64Test,VSsra_vx)6825 TEST_F(AssemblerRISCV64Test, VSsra_vx) {
6826 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VSsra_vx,
6827 "vssra.vx {reg1}, {reg2}, {reg3}{vm}",
6828 SkipV0Vm<VRegister, XRegister>()),
6829 "VSsra_vx");
6830 }
6831
TEST_F(AssemblerRISCV64Test,VSsra_vi)6832 TEST_F(AssemblerRISCV64Test, VSsra_vi) {
6833 DriverStr(RepeatVVIbVmFiltered(&Riscv64Assembler::VSsra_vi,
6834 /*imm_bits=*/ 5,
6835 "vssra.vi {reg1}, {reg2}, {imm}{vm}",
6836 SkipV0Vm<VRegister, uint32_t>()),
6837 "VSsra_vi");
6838 }
6839
TEST_F(AssemblerRISCV64Test,VNsrl_wv)6840 TEST_F(AssemblerRISCV64Test, VNsrl_wv) {
6841 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VNsrl_wv,
6842 "vnsrl.wv {reg1}, {reg2}, {reg3}{vm}",
6843 SkipV0Vm<VRegister, VRegister>()),
6844 "VNsrl_wv");
6845 }
6846
TEST_F(AssemblerRISCV64Test,VNsrl_wx)6847 TEST_F(AssemblerRISCV64Test, VNsrl_wx) {
6848 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VNsrl_wx,
6849 "vnsrl.wx {reg1}, {reg2}, {reg3}{vm}",
6850 SkipV0Vm<VRegister, XRegister>()),
6851 "VNsrl_wx");
6852 }
6853
TEST_F(AssemblerRISCV64Test,VNsrl_wi)6854 TEST_F(AssemblerRISCV64Test, VNsrl_wi) {
6855 DriverStr(RepeatVVIbVmFiltered(&Riscv64Assembler::VNsrl_wi,
6856 /*imm_bits=*/ 5,
6857 "vnsrl.wi {reg1}, {reg2}, {imm}{vm}",
6858 SkipV0Vm<VRegister, uint32_t>()),
6859 "VNsrl_wi");
6860 }
6861
TEST_F(AssemblerRISCV64Test,VNcvt_x_x_w)6862 TEST_F(AssemblerRISCV64Test, VNcvt_x_x_w) {
6863 DriverStr(
6864 RepeatVVVmFiltered(
6865 &Riscv64Assembler::VNcvt_x_x_w, "vncvt.x.x.w {reg1}, {reg2}{vm}", SkipV0Vm<VRegister>()),
6866 "VNcvt_x_x_w");
6867 }
6868
TEST_F(AssemblerRISCV64Test,VNsra_wv)6869 TEST_F(AssemblerRISCV64Test, VNsra_wv) {
6870 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VNsra_wv,
6871 "vnsra.wv {reg1}, {reg2}, {reg3}{vm}",
6872 SkipV0Vm<VRegister, VRegister>()),
6873 "VNsra_wv");
6874 }
6875
TEST_F(AssemblerRISCV64Test,VNsra_wx)6876 TEST_F(AssemblerRISCV64Test, VNsra_wx) {
6877 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VNsra_wx,
6878 "vnsra.wx {reg1}, {reg2}, {reg3}{vm}",
6879 SkipV0Vm<VRegister, XRegister>()),
6880 "VNsra_wx");
6881 }
6882
TEST_F(AssemblerRISCV64Test,VNsra_wi)6883 TEST_F(AssemblerRISCV64Test, VNsra_wi) {
6884 DriverStr(RepeatVVIbVmFiltered(&Riscv64Assembler::VNsra_wi,
6885 /*imm_bits=*/ 5,
6886 "vnsra.wi {reg1}, {reg2}, {imm}{vm}",
6887 SkipV0Vm<VRegister, uint32_t>()),
6888 "VNsra_wi");
6889 }
6890
TEST_F(AssemblerRISCV64Test,VNclipu_wv)6891 TEST_F(AssemblerRISCV64Test, VNclipu_wv) {
6892 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VNclipu_wv,
6893 "vnclipu.wv {reg1}, {reg2}, {reg3}{vm}",
6894 SkipV0Vm<VRegister, VRegister>()),
6895 "VNclipu_wv");
6896 }
6897
TEST_F(AssemblerRISCV64Test,VNclipu_wx)6898 TEST_F(AssemblerRISCV64Test, VNclipu_wx) {
6899 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VNclipu_wx,
6900 "vnclipu.wx {reg1}, {reg2}, {reg3}{vm}",
6901 SkipV0Vm<VRegister, XRegister>()),
6902 "VNclipu_wx");
6903 }
6904
TEST_F(AssemblerRISCV64Test,VNclipu_wi)6905 TEST_F(AssemblerRISCV64Test, VNclipu_wi) {
6906 DriverStr(RepeatVVIbVmFiltered(&Riscv64Assembler::VNclipu_wi,
6907 /*imm_bits=*/ 5,
6908 "vnclipu.wi {reg1}, {reg2}, {imm}{vm}",
6909 SkipV0Vm<VRegister, uint32_t>()),
6910 "VNclipu_wi");
6911 }
6912
TEST_F(AssemblerRISCV64Test,VNclip_wv)6913 TEST_F(AssemblerRISCV64Test, VNclip_wv) {
6914 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VNclip_wv,
6915 "vnclip.wv {reg1}, {reg2}, {reg3}{vm}",
6916 SkipV0Vm<VRegister, VRegister>()),
6917 "VNclip_wv");
6918 }
6919
TEST_F(AssemblerRISCV64Test,VNclip_wx)6920 TEST_F(AssemblerRISCV64Test, VNclip_wx) {
6921 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VNclip_wx,
6922 "vnclip.wx {reg1}, {reg2}, {reg3}{vm}",
6923 SkipV0Vm<VRegister, XRegister>()),
6924 "VNclip_wx");
6925 }
6926
TEST_F(AssemblerRISCV64Test,VNclip_wi)6927 TEST_F(AssemblerRISCV64Test, VNclip_wi) {
6928 DriverStr(RepeatVVIbVmFiltered(&Riscv64Assembler::VNclip_wi,
6929 /*imm_bits=*/ 5,
6930 "vnclip.wi {reg1}, {reg2}, {imm}{vm}",
6931 SkipV0Vm<VRegister, uint32_t>()),
6932 "VNclip_wi");
6933 }
6934
TEST_F(AssemblerRISCV64Test,VWredsumu_vs)6935 TEST_F(AssemblerRISCV64Test, VWredsumu_vs) {
6936 DriverStr(RepeatVVVVm(&Riscv64Assembler::VWredsumu_vs, "vwredsumu.vs {reg1}, {reg2}, {reg3}{vm}"),
6937 "VWredsumu_vs");
6938 }
6939
TEST_F(AssemblerRISCV64Test,VWredsum_vs)6940 TEST_F(AssemblerRISCV64Test, VWredsum_vs) {
6941 DriverStr(RepeatVVVVm(&Riscv64Assembler::VWredsum_vs, "vwredsum.vs {reg1}, {reg2}, {reg3}{vm}"),
6942 "VWredsum_vs");
6943 }
6944
TEST_F(AssemblerRISCV64Test,VRedsum_vs)6945 TEST_F(AssemblerRISCV64Test, VRedsum_vs) {
6946 DriverStr(RepeatVVVVm(&Riscv64Assembler::VRedsum_vs, "vredsum.vs {reg1}, {reg2}, {reg3}{vm}"),
6947 "VRedsum_vs");
6948 }
6949
TEST_F(AssemblerRISCV64Test,VRedand_vs)6950 TEST_F(AssemblerRISCV64Test, VRedand_vs) {
6951 DriverStr(RepeatVVVVm(&Riscv64Assembler::VRedand_vs, "vredand.vs {reg1}, {reg2}, {reg3}{vm}"),
6952 "VRedand_vs");
6953 }
6954
TEST_F(AssemblerRISCV64Test,VRedor_vs)6955 TEST_F(AssemblerRISCV64Test, VRedor_vs) {
6956 DriverStr(RepeatVVVVm(&Riscv64Assembler::VRedor_vs, "vredor.vs {reg1}, {reg2}, {reg3}{vm}"),
6957 "VRedor_vs");
6958 }
6959
TEST_F(AssemblerRISCV64Test,VRedxor_vs)6960 TEST_F(AssemblerRISCV64Test, VRedxor_vs) {
6961 DriverStr(RepeatVVVVm(&Riscv64Assembler::VRedxor_vs, "vredxor.vs {reg1}, {reg2}, {reg3}{vm}"),
6962 "VRedxor_vs");
6963 }
6964
TEST_F(AssemblerRISCV64Test,VRedminu_vs)6965 TEST_F(AssemblerRISCV64Test, VRedminu_vs) {
6966 DriverStr(RepeatVVVVm(&Riscv64Assembler::VRedminu_vs, "vredminu.vs {reg1}, {reg2}, {reg3}{vm}"),
6967 "VRedminu_vs");
6968 }
6969
TEST_F(AssemblerRISCV64Test,VRedmin_vs)6970 TEST_F(AssemblerRISCV64Test, VRedmin_vs) {
6971 DriverStr(RepeatVVVVm(&Riscv64Assembler::VRedmin_vs, "vredmin.vs {reg1}, {reg2}, {reg3}{vm}"),
6972 "VRedmin_vs");
6973 }
6974
TEST_F(AssemblerRISCV64Test,VRedmaxu_vs)6975 TEST_F(AssemblerRISCV64Test, VRedmaxu_vs) {
6976 DriverStr(RepeatVVVVm(&Riscv64Assembler::VRedmaxu_vs, "vredmaxu.vs {reg1}, {reg2}, {reg3}{vm}"),
6977 "VRedmaxu_vs");
6978 }
6979
TEST_F(AssemblerRISCV64Test,VRedmax_vs)6980 TEST_F(AssemblerRISCV64Test, VRedmax_vs) {
6981 DriverStr(RepeatVVVVm(&Riscv64Assembler::VRedmax_vs, "vredmax.vs {reg1}, {reg2}, {reg3}{vm}"),
6982 "VRedmax_vs");
6983 }
6984
TEST_F(AssemblerRISCV64Test,VAaddu_vv)6985 TEST_F(AssemblerRISCV64Test, VAaddu_vv) {
6986 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VAaddu_vv,
6987 "vaaddu.vv {reg1}, {reg2}, {reg3}{vm}",
6988 SkipV0Vm<VRegister, VRegister>()),
6989 "VAaddu_vv");
6990 }
6991
TEST_F(AssemblerRISCV64Test,VAaddu_vx)6992 TEST_F(AssemblerRISCV64Test, VAaddu_vx) {
6993 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VAaddu_vx,
6994 "vaaddu.vx {reg1}, {reg2}, {reg3}{vm}",
6995 SkipV0Vm<VRegister, XRegister>()),
6996 "VAaddu_vx");
6997 }
6998
TEST_F(AssemblerRISCV64Test,VAadd_vv)6999 TEST_F(AssemblerRISCV64Test, VAadd_vv) {
7000 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VAadd_vv,
7001 "vaadd.vv {reg1}, {reg2}, {reg3}{vm}",
7002 SkipV0Vm<VRegister, VRegister>()),
7003 "VAadd_vv");
7004 }
7005
TEST_F(AssemblerRISCV64Test,VAadd_vx)7006 TEST_F(AssemblerRISCV64Test, VAadd_vx) {
7007 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VAadd_vx,
7008 "vaadd.vx {reg1}, {reg2}, {reg3}{vm}",
7009 SkipV0Vm<VRegister, XRegister>()),
7010 "VAadd_vx");
7011 }
7012
TEST_F(AssemblerRISCV64Test,VAsubu_vv)7013 TEST_F(AssemblerRISCV64Test, VAsubu_vv) {
7014 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VAsubu_vv,
7015 "vasubu.vv {reg1}, {reg2}, {reg3}{vm}",
7016 SkipV0Vm<VRegister, VRegister>()),
7017 "VAsubu_vv");
7018 }
7019
TEST_F(AssemblerRISCV64Test,VAsubu_vx)7020 TEST_F(AssemblerRISCV64Test, VAsubu_vx) {
7021 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VAsubu_vx,
7022 "vasubu.vx {reg1}, {reg2}, {reg3}{vm}",
7023 SkipV0Vm<VRegister, XRegister>()),
7024 "VAsubu_vx");
7025 }
7026
TEST_F(AssemblerRISCV64Test,VAsub_vv)7027 TEST_F(AssemblerRISCV64Test, VAsub_vv) {
7028 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VAsub_vv,
7029 "vasub.vv {reg1}, {reg2}, {reg3}{vm}",
7030 SkipV0Vm<VRegister, VRegister>()),
7031 "VAsub_vv");
7032 }
7033
TEST_F(AssemblerRISCV64Test,VAsub_vx)7034 TEST_F(AssemblerRISCV64Test, VAsub_vx) {
7035 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VAsub_vx,
7036 "vasub.vx {reg1}, {reg2}, {reg3}{vm}",
7037 SkipV0Vm<VRegister, XRegister>()),
7038 "VAsub_vx");
7039 }
7040
TEST_F(AssemblerRISCV64Test,VSlide1up_vx)7041 TEST_F(AssemblerRISCV64Test, VSlide1up_vx) {
7042 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VSlide1up_vx,
7043 "vslide1up.vx {reg1}, {reg2}, {reg3}{vm}",
7044 VXVVmSkipV0VmAndNoR1R2Overlap<XRegister>()),
7045 "VSlide1up_vx");
7046 }
7047
TEST_F(AssemblerRISCV64Test,VSlide1down_vx)7048 TEST_F(AssemblerRISCV64Test, VSlide1down_vx) {
7049 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VSlide1down_vx,
7050 "vslide1down.vx {reg1}, {reg2}, {reg3}{vm}",
7051 SkipV0Vm<VRegister, XRegister>()),
7052 "VSlide1down_vx");
7053 }
7054
TEST_F(AssemblerRISCV64Test,VCompress_vm)7055 TEST_F(AssemblerRISCV64Test, VCompress_vm) {
7056 DriverStr(RepeatVVVFiltered(&Riscv64Assembler::VCompress_vm,
7057 "vcompress.vm {reg1}, {reg2}, {reg3}",
7058 VVVNoR1R2R3Overlap()),
7059 "VCompress_vm");
7060 }
7061
TEST_F(AssemblerRISCV64Test,VMandn_mm)7062 TEST_F(AssemblerRISCV64Test, VMandn_mm) {
7063 DriverStr(RepeatVVV(&Riscv64Assembler::VMandn_mm, "vmandn.mm {reg1}, {reg2}, {reg3}"),
7064 "VMandn_mm");
7065 }
7066
TEST_F(AssemblerRISCV64Test,VMand_mm)7067 TEST_F(AssemblerRISCV64Test, VMand_mm) {
7068 DriverStr(RepeatVVV(&Riscv64Assembler::VMand_mm, "vmand.mm {reg1}, {reg2}, {reg3}"), "VMand_mm");
7069 }
7070
TEST_F(AssemblerRISCV64Test,VMmv_m)7071 TEST_F(AssemblerRISCV64Test, VMmv_m) {
7072 DriverStr(RepeatVV(&Riscv64Assembler::VMmv_m, "vmmv.m {reg1}, {reg2}"), "VMmv_m");
7073 }
7074
TEST_F(AssemblerRISCV64Test,VMor_mm)7075 TEST_F(AssemblerRISCV64Test, VMor_mm) {
7076 DriverStr(RepeatVVV(&Riscv64Assembler::VMor_mm, "vmor.mm {reg1}, {reg2}, {reg3}"), "VMor_mm");
7077 }
7078
TEST_F(AssemblerRISCV64Test,VMxor_mm)7079 TEST_F(AssemblerRISCV64Test, VMxor_mm) {
7080 DriverStr(RepeatVVV(&Riscv64Assembler::VMxor_mm, "vmxor.mm {reg1}, {reg2}, {reg3}"), "VMxor_mm");
7081 }
7082
TEST_F(AssemblerRISCV64Test,VMclr_m)7083 TEST_F(AssemblerRISCV64Test, VMclr_m) {
7084 DriverStr(RepeatV(&Riscv64Assembler::VMclr_m, "vmclr.m {reg}"), "VMclr_m");
7085 }
7086
TEST_F(AssemblerRISCV64Test,VMorn_mm)7087 TEST_F(AssemblerRISCV64Test, VMorn_mm) {
7088 DriverStr(RepeatVVV(&Riscv64Assembler::VMorn_mm, "vmorn.mm {reg1}, {reg2}, {reg3}"), "VMorn_mm");
7089 }
7090
TEST_F(AssemblerRISCV64Test,VMnand_mm)7091 TEST_F(AssemblerRISCV64Test, VMnand_mm) {
7092 DriverStr(RepeatVVV(&Riscv64Assembler::VMnand_mm, "vmnand.mm {reg1}, {reg2}, {reg3}"),
7093 "VMnand_m");
7094 }
7095
TEST_F(AssemblerRISCV64Test,VMnot_m)7096 TEST_F(AssemblerRISCV64Test, VMnot_m) {
7097 DriverStr(RepeatVV(&Riscv64Assembler::VMnot_m, "vmnot.m {reg1}, {reg2}"), "VMnot_m");
7098 }
7099
TEST_F(AssemblerRISCV64Test,VMnor_mm)7100 TEST_F(AssemblerRISCV64Test, VMnor_mm) {
7101 DriverStr(RepeatVVV(&Riscv64Assembler::VMnor_mm, "vmnor.mm {reg1}, {reg2}, {reg3}"), "VMnor_mm");
7102 }
7103
TEST_F(AssemblerRISCV64Test,VMxnor_mm)7104 TEST_F(AssemblerRISCV64Test, VMxnor_mm) {
7105 DriverStr(RepeatVVV(&Riscv64Assembler::VMxnor_mm, "vmxnor.mm {reg1}, {reg2}, {reg3}"),
7106 "VMxnor_mm");
7107 }
7108
TEST_F(AssemblerRISCV64Test,VMset_m)7109 TEST_F(AssemblerRISCV64Test, VMset_m) {
7110 DriverStr(RepeatV(&Riscv64Assembler::VMset_m, "vmset.m {reg}"), "VMset_m");
7111 }
7112
TEST_F(AssemblerRISCV64Test,VDivu_vv)7113 TEST_F(AssemblerRISCV64Test, VDivu_vv) {
7114 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VDivu_vv,
7115 "vdivu.vv {reg1}, {reg2}, {reg3}{vm}",
7116 SkipV0Vm<VRegister, VRegister>()),
7117 "VDivu_vv");
7118 }
7119
TEST_F(AssemblerRISCV64Test,VDivu_vx)7120 TEST_F(AssemblerRISCV64Test, VDivu_vx) {
7121 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VDivu_vx,
7122 "vdivu.vx {reg1}, {reg2}, {reg3}{vm}",
7123 SkipV0Vm<VRegister, XRegister>()),
7124 "VDivu_vx");
7125 }
7126
TEST_F(AssemblerRISCV64Test,VDiv_vv)7127 TEST_F(AssemblerRISCV64Test, VDiv_vv) {
7128 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VDiv_vv,
7129 "vdiv.vv {reg1}, {reg2}, {reg3}{vm}",
7130 SkipV0Vm<VRegister, VRegister>()),
7131 "VDiv_vv");
7132 }
7133
TEST_F(AssemblerRISCV64Test,VDiv_vx)7134 TEST_F(AssemblerRISCV64Test, VDiv_vx) {
7135 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VDiv_vx,
7136 "vdiv.vx {reg1}, {reg2}, {reg3}{vm}",
7137 SkipV0Vm<VRegister, XRegister>()),
7138 "VDiv_vx");
7139 }
7140
TEST_F(AssemblerRISCV64Test,VRemu_vv)7141 TEST_F(AssemblerRISCV64Test, VRemu_vv) {
7142 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VRemu_vv,
7143 "vremu.vv {reg1}, {reg2}, {reg3}{vm}",
7144 SkipV0Vm<VRegister, VRegister>()),
7145 "VRemu_vv");
7146 }
7147
TEST_F(AssemblerRISCV64Test,VRemu_vx)7148 TEST_F(AssemblerRISCV64Test, VRemu_vx) {
7149 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VRemu_vx,
7150 "vremu.vx {reg1}, {reg2}, {reg3}{vm}",
7151 SkipV0Vm<VRegister, XRegister>()),
7152 "VRemu_vx");
7153 }
7154
TEST_F(AssemblerRISCV64Test,VRem_vv)7155 TEST_F(AssemblerRISCV64Test, VRem_vv) {
7156 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VRem_vv,
7157 "vrem.vv {reg1}, {reg2}, {reg3}{vm}",
7158 SkipV0Vm<VRegister, VRegister>()),
7159 "VRem_vv");
7160 }
7161
TEST_F(AssemblerRISCV64Test,VRem_vx)7162 TEST_F(AssemblerRISCV64Test, VRem_vx) {
7163 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VRem_vx,
7164 "vrem.vx {reg1}, {reg2}, {reg3}{vm}",
7165 SkipV0Vm<VRegister, XRegister>()),
7166 "VRem_vx");
7167 }
7168
TEST_F(AssemblerRISCV64Test,VMulhu_vv)7169 TEST_F(AssemblerRISCV64Test, VMulhu_vv) {
7170 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VMulhu_vv,
7171 "vmulhu.vv {reg1}, {reg2}, {reg3}{vm}",
7172 SkipV0Vm<VRegister, VRegister>()),
7173 "VMulhu_vv");
7174 }
7175
TEST_F(AssemblerRISCV64Test,VMulhu_vx)7176 TEST_F(AssemblerRISCV64Test, VMulhu_vx) {
7177 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VMulhu_vx,
7178 "vmulhu.vx {reg1}, {reg2}, {reg3}{vm}",
7179 SkipV0Vm<VRegister, XRegister>()),
7180 "VMulhu_vx");
7181 }
7182
TEST_F(AssemblerRISCV64Test,VMul_vv)7183 TEST_F(AssemblerRISCV64Test, VMul_vv) {
7184 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VMul_vv,
7185 "vmul.vv {reg1}, {reg2}, {reg3}{vm}",
7186 SkipV0Vm<VRegister, VRegister>()),
7187 "VMul_vv");
7188 }
7189
TEST_F(AssemblerRISCV64Test,VMul_vx)7190 TEST_F(AssemblerRISCV64Test, VMul_vx) {
7191 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VMul_vx,
7192 "vmul.vx {reg1}, {reg2}, {reg3}{vm}",
7193 SkipV0Vm<VRegister, XRegister>()),
7194 "VMul_vx");
7195 }
7196
TEST_F(AssemblerRISCV64Test,VMulhsu_vv)7197 TEST_F(AssemblerRISCV64Test, VMulhsu_vv) {
7198 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VMulhsu_vv,
7199 "vmulhsu.vv {reg1}, {reg2}, {reg3}{vm}",
7200 SkipV0Vm<VRegister, VRegister>()),
7201 "VMulhsu_vv");
7202 }
7203
TEST_F(AssemblerRISCV64Test,VMulhsu_vx)7204 TEST_F(AssemblerRISCV64Test, VMulhsu_vx) {
7205 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VMulhsu_vx,
7206 "vmulhsu.vx {reg1}, {reg2}, {reg3}{vm}",
7207 SkipV0Vm<VRegister, XRegister>()),
7208 "VMulhsu_vx");
7209 }
7210
TEST_F(AssemblerRISCV64Test,VMulh_vv)7211 TEST_F(AssemblerRISCV64Test, VMulh_vv) {
7212 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VMulh_vv,
7213 "vmulh.vv {reg1}, {reg2}, {reg3}{vm}",
7214 SkipV0Vm<VRegister, VRegister>()),
7215 "VMulh_vv");
7216 }
7217
TEST_F(AssemblerRISCV64Test,VMulh_vx)7218 TEST_F(AssemblerRISCV64Test, VMulh_vx) {
7219 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VMulh_vx,
7220 "vmulh.vx {reg1}, {reg2}, {reg3}{vm}",
7221 SkipV0Vm<VRegister, XRegister>()),
7222 "VMulh_vx");
7223 }
7224
TEST_F(AssemblerRISCV64Test,VMadd_vv)7225 TEST_F(AssemblerRISCV64Test, VMadd_vv) {
7226 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VMadd_vv,
7227 "vmadd.vv {reg1}, {reg2}, {reg3}{vm}",
7228 SkipV0Vm<VRegister, VRegister>()),
7229 "VMadd_vv");
7230 }
7231
TEST_F(AssemblerRISCV64Test,VMadd_vx)7232 TEST_F(AssemblerRISCV64Test, VMadd_vx) {
7233 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VMadd_vx,
7234 "vmadd.vx {reg1}, {reg2}, {reg3}{vm}",
7235 SkipV0Vm<XRegister, VRegister>()),
7236 "VMadd_vx");
7237 }
7238
TEST_F(AssemblerRISCV64Test,VNmsub_vv)7239 TEST_F(AssemblerRISCV64Test, VNmsub_vv) {
7240 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VNmsub_vv,
7241 "vnmsub.vv {reg1}, {reg2}, {reg3}{vm}",
7242 SkipV0Vm<VRegister, VRegister>()),
7243 "VNmsub_vv");
7244 }
7245
TEST_F(AssemblerRISCV64Test,VNmsub_vx)7246 TEST_F(AssemblerRISCV64Test, VNmsub_vx) {
7247 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VNmsub_vx,
7248 "vnmsub.vx {reg1}, {reg2}, {reg3}{vm}",
7249 SkipV0Vm<XRegister, VRegister>()),
7250 "VNmsub_vx");
7251 }
7252
TEST_F(AssemblerRISCV64Test,VMacc_vv)7253 TEST_F(AssemblerRISCV64Test, VMacc_vv) {
7254 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VMacc_vv,
7255 "vmacc.vv {reg1}, {reg2}, {reg3}{vm}",
7256 SkipV0Vm<VRegister, VRegister>()),
7257 "VMacc_vv");
7258 }
7259
TEST_F(AssemblerRISCV64Test,VMacc_vx)7260 TEST_F(AssemblerRISCV64Test, VMacc_vx) {
7261 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VMacc_vx,
7262 "vmacc.vx {reg1}, {reg2}, {reg3}{vm}",
7263 SkipV0Vm<XRegister, VRegister>()),
7264 "VMacc_vx");
7265 }
7266
TEST_F(AssemblerRISCV64Test,VNmsac_vv)7267 TEST_F(AssemblerRISCV64Test, VNmsac_vv) {
7268 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VNmsac_vv,
7269 "vnmsac.vv {reg1}, {reg2}, {reg3}{vm}",
7270 VXVVmSkipV0VmAndNoR1R2R3Overlap()),
7271 "VNmsac_vv");
7272 }
7273
TEST_F(AssemblerRISCV64Test,VNmsac_vx)7274 TEST_F(AssemblerRISCV64Test, VNmsac_vx) {
7275 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VNmsac_vx,
7276 "vnmsac.vx {reg1}, {reg2}, {reg3}{vm}",
7277 SkipV0Vm<XRegister, VRegister>()),
7278 "VNmsac_vx");
7279 }
7280
TEST_F(AssemblerRISCV64Test,VWaddu_vv)7281 TEST_F(AssemblerRISCV64Test, VWaddu_vv) {
7282 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VWaddu_vv,
7283 "vwaddu.vv {reg1}, {reg2}, {reg3}{vm}",
7284 VXVVmSkipV0VmAndNoR1R2R3Overlap()),
7285 "VWaddu_vv");
7286 }
7287
TEST_F(AssemblerRISCV64Test,VWaddu_vx)7288 TEST_F(AssemblerRISCV64Test, VWaddu_vx) {
7289 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VWaddu_vx,
7290 "vwaddu.vx {reg1}, {reg2}, {reg3}{vm}",
7291 VXVVmSkipV0VmAndNoR1R2Overlap<XRegister>()),
7292 "VWaddu_vx");
7293 }
7294
TEST_F(AssemblerRISCV64Test,VWcvtu_x_x_v)7295 TEST_F(AssemblerRISCV64Test, VWcvtu_x_x_v) {
7296 DriverStr(RepeatVVVmFiltered(&Riscv64Assembler::VWcvtu_x_x_v,
7297 "vwcvtu.x.x.v {reg1}, {reg2}{vm}",
7298 VVVmSkipV0VmAndNoR1R2Overlap()),
7299 "VWcvtu_x_x_v");
7300 }
7301
TEST_F(AssemblerRISCV64Test,VWadd_vv)7302 TEST_F(AssemblerRISCV64Test, VWadd_vv) {
7303 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VWadd_vv,
7304 "vwadd.vv {reg1}, {reg2}, {reg3}{vm}",
7305 VXVVmSkipV0VmAndNoR1R2R3Overlap()),
7306 "VWadd_vv");
7307 }
7308
TEST_F(AssemblerRISCV64Test,VWadd_vx)7309 TEST_F(AssemblerRISCV64Test, VWadd_vx) {
7310 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VWadd_vx,
7311 "vwadd.vx {reg1}, {reg2}, {reg3}{vm}",
7312 VXVVmSkipV0VmAndNoR1R2Overlap<XRegister>()),
7313 "VWadd_vx");
7314 }
7315
TEST_F(AssemblerRISCV64Test,VWcvt_x_x_v)7316 TEST_F(AssemblerRISCV64Test, VWcvt_x_x_v) {
7317 DriverStr(RepeatVVVmFiltered(&Riscv64Assembler::VWcvt_x_x_v,
7318 "vwcvt.x.x.v {reg1}, {reg2}{vm}",
7319 VVVmSkipV0VmAndNoR1R2Overlap()),
7320 "VWcvt_x_x_v");
7321 }
7322
TEST_F(AssemblerRISCV64Test,VWsubu_vv)7323 TEST_F(AssemblerRISCV64Test, VWsubu_vv) {
7324 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VWsubu_vv,
7325 "vwsubu.vv {reg1}, {reg2}, {reg3}{vm}",
7326 VXVVmSkipV0VmAndNoR1R2R3Overlap()),
7327 "VWsubu_vv");
7328 }
7329
TEST_F(AssemblerRISCV64Test,VWsubu_vx)7330 TEST_F(AssemblerRISCV64Test, VWsubu_vx) {
7331 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VWsubu_vx,
7332 "vwsubu.vx {reg1}, {reg2}, {reg3}{vm}",
7333 VXVVmSkipV0VmAndNoR1R2Overlap<XRegister>()),
7334 "VWsubu_vx");
7335 }
7336
TEST_F(AssemblerRISCV64Test,VWsub_vv)7337 TEST_F(AssemblerRISCV64Test, VWsub_vv) {
7338 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VWsub_vv,
7339 "vwsub.vv {reg1}, {reg2}, {reg3}{vm}",
7340 VXVVmSkipV0VmAndNoR1R2R3Overlap()),
7341 "VWsub_vv");
7342 }
7343
TEST_F(AssemblerRISCV64Test,VWsub_vx)7344 TEST_F(AssemblerRISCV64Test, VWsub_vx) {
7345 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VWsub_vx,
7346 "vwsub.vx {reg1}, {reg2}, {reg3}{vm}",
7347 VXVVmSkipV0VmAndNoR1R2Overlap<XRegister>()),
7348 "VWsub_vx");
7349 }
7350
TEST_F(AssemblerRISCV64Test,VWaddu_wv)7351 TEST_F(AssemblerRISCV64Test, VWaddu_wv) {
7352 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VWaddu_wv,
7353 "vwaddu.wv {reg1}, {reg2}, {reg3}{vm}",
7354 VXVVmSkipV0VmAndNoR1R3Overlap<VRegister>()),
7355 "VWaddu_wv");
7356 }
7357
TEST_F(AssemblerRISCV64Test,VWaddu_wx)7358 TEST_F(AssemblerRISCV64Test, VWaddu_wx) {
7359 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VWaddu_wx,
7360 "vwaddu.wx {reg1}, {reg2}, {reg3}{vm}",
7361 SkipV0Vm<VRegister, XRegister>()),
7362 "VWaddu_wx");
7363 }
7364
TEST_F(AssemblerRISCV64Test,VWadd_wv)7365 TEST_F(AssemblerRISCV64Test, VWadd_wv) {
7366 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VWadd_wv,
7367 "vwadd.wv {reg1}, {reg2}, {reg3}{vm}",
7368 VXVVmSkipV0VmAndNoR1R3Overlap<VRegister>()),
7369 "VWadd_wv");
7370 }
7371
TEST_F(AssemblerRISCV64Test,VWadd_wx)7372 TEST_F(AssemblerRISCV64Test, VWadd_wx) {
7373 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VWadd_wx,
7374 "vwadd.wx {reg1}, {reg2}, {reg3}{vm}",
7375 SkipV0Vm<VRegister, XRegister>()),
7376 "VWadd_wx");
7377 }
7378
TEST_F(AssemblerRISCV64Test,VWsubu_wv)7379 TEST_F(AssemblerRISCV64Test, VWsubu_wv) {
7380 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VWsubu_wv,
7381 "vwsubu.wv {reg1}, {reg2}, {reg3}{vm}",
7382 VXVVmSkipV0VmAndNoR1R3Overlap<VRegister>()),
7383 "VWsubu_wv");
7384 }
7385
TEST_F(AssemblerRISCV64Test,VWsubu_wx)7386 TEST_F(AssemblerRISCV64Test, VWsubu_wx) {
7387 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VWsubu_wx,
7388 "vwsubu.wx {reg1}, {reg2}, {reg3}{vm}",
7389 SkipV0Vm<VRegister, XRegister>()),
7390 "VWsubu_wx");
7391 }
7392
TEST_F(AssemblerRISCV64Test,VWsub_wv)7393 TEST_F(AssemblerRISCV64Test, VWsub_wv) {
7394 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VWsub_wv,
7395 "vwsub.wv {reg1}, {reg2}, {reg3}{vm}",
7396 VXVVmSkipV0VmAndNoR1R3Overlap<VRegister>()),
7397 "VWsub_wv");
7398 }
7399
TEST_F(AssemblerRISCV64Test,VWsub_wx)7400 TEST_F(AssemblerRISCV64Test, VWsub_wx) {
7401 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VWsub_wx,
7402 "vwsub.wx {reg1}, {reg2}, {reg3}{vm}",
7403 SkipV0Vm<VRegister, XRegister>()),
7404 "VWsub_wx");
7405 }
7406
TEST_F(AssemblerRISCV64Test,VWmulu_vv)7407 TEST_F(AssemblerRISCV64Test, VWmulu_vv) {
7408 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VWmulu_vv,
7409 "vwmulu.vv {reg1}, {reg2}, {reg3}{vm}",
7410 VXVVmSkipV0VmAndNoR1R2R3Overlap()),
7411 "VWmulu_vv");
7412 }
7413
TEST_F(AssemblerRISCV64Test,VWmulu_vx)7414 TEST_F(AssemblerRISCV64Test, VWmulu_vx) {
7415 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VWmulu_vx,
7416 "vwmulu.vx {reg1}, {reg2}, {reg3}{vm}",
7417 VXVVmSkipV0VmAndNoR1R2Overlap<XRegister>()),
7418 "VWmulu_vx");
7419 }
7420
TEST_F(AssemblerRISCV64Test,VWmulsu_vv)7421 TEST_F(AssemblerRISCV64Test, VWmulsu_vv) {
7422 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VWmulsu_vv,
7423 "vwmulsu.vv {reg1}, {reg2}, {reg3}{vm}",
7424 VXVVmSkipV0VmAndNoR1R2R3Overlap()),
7425 "VWmulsu_vv");
7426 }
7427
TEST_F(AssemblerRISCV64Test,VWmulsu_vx)7428 TEST_F(AssemblerRISCV64Test, VWmulsu_vx) {
7429 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VWmulsu_vx,
7430 "vwmulsu.vx {reg1}, {reg2}, {reg3}{vm}",
7431 VXVVmSkipV0VmAndNoR1R2Overlap<XRegister>()),
7432 "VWmulsu_vx");
7433 }
7434
TEST_F(AssemblerRISCV64Test,VWmul_vv)7435 TEST_F(AssemblerRISCV64Test, VWmul_vv) {
7436 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VWmul_vv,
7437 "vwmul.vv {reg1}, {reg2}, {reg3}{vm}",
7438 VXVVmSkipV0VmAndNoR1R2R3Overlap()),
7439 "VWmul_vv");
7440 }
7441
TEST_F(AssemblerRISCV64Test,VWmul_vx)7442 TEST_F(AssemblerRISCV64Test, VWmul_vx) {
7443 DriverStr(RepeatVVRVmFiltered(&Riscv64Assembler::VWmul_vx,
7444 "vwmul.vx {reg1}, {reg2}, {reg3}{vm}",
7445 VXVVmSkipV0VmAndNoR1R2Overlap<XRegister>()),
7446 "VWmul_vx");
7447 }
7448
TEST_F(AssemblerRISCV64Test,VWmaccu_vv)7449 TEST_F(AssemblerRISCV64Test, VWmaccu_vv) {
7450 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VWmaccu_vv,
7451 "vwmaccu.vv {reg1}, {reg2}, {reg3}{vm}",
7452 VXVVmSkipV0VmAndNoR1R2R3Overlap()),
7453 "VWmaccu_vv");
7454 }
7455
TEST_F(AssemblerRISCV64Test,VWmaccu_vx)7456 TEST_F(AssemblerRISCV64Test, VWmaccu_vx) {
7457 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VWmaccu_vx,
7458 "vwmaccu.vx {reg1}, {reg2}, {reg3}{vm}",
7459 VXVVmSkipV0VmAndNoR1R3Overlap<XRegister>()),
7460 "VWmaccu_vx");
7461 }
7462
TEST_F(AssemblerRISCV64Test,VWmacc_vv)7463 TEST_F(AssemblerRISCV64Test, VWmacc_vv) {
7464 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VWmacc_vv,
7465 "vwmacc.vv {reg1}, {reg2}, {reg3}{vm}",
7466 VXVVmSkipV0VmAndNoR1R2R3Overlap()),
7467 "VWmacc_vv");
7468 }
7469
TEST_F(AssemblerRISCV64Test,VWmacc_vx)7470 TEST_F(AssemblerRISCV64Test, VWmacc_vx) {
7471 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VWmacc_vx,
7472 "vwmacc.vx {reg1}, {reg2}, {reg3}{vm}",
7473 VXVVmSkipV0VmAndNoR1R3Overlap<XRegister>()),
7474 "VWmacc_vx");
7475 }
7476
TEST_F(AssemblerRISCV64Test,VWmaccus_vx)7477 TEST_F(AssemblerRISCV64Test, VWmaccus_vx) {
7478 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VWmaccus_vx,
7479 "vwmaccus.vx {reg1}, {reg2}, {reg3}{vm}",
7480 VXVVmSkipV0VmAndNoR1R3Overlap<XRegister>()),
7481 "VWmaccus_vx");
7482 }
7483
TEST_F(AssemblerRISCV64Test,VWmaccsu_vv)7484 TEST_F(AssemblerRISCV64Test, VWmaccsu_vv) {
7485 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VWmaccsu_vv,
7486 "vwmaccsu.vv {reg1}, {reg2}, {reg3}{vm}",
7487 VXVVmSkipV0VmAndNoR1R2R3Overlap()),
7488 "VWmaccsu_vv");
7489 }
7490
TEST_F(AssemblerRISCV64Test,VWmaccsu_vx)7491 TEST_F(AssemblerRISCV64Test, VWmaccsu_vx) {
7492 DriverStr(RepeatVRVVmFiltered(&Riscv64Assembler::VWmaccsu_vx,
7493 "vwmaccsu.vx {reg1}, {reg2}, {reg3}{vm}",
7494 VXVVmSkipV0VmAndNoR1R3Overlap<XRegister>()),
7495 "VWmaccsu_vx");
7496 }
7497
TEST_F(AssemblerRISCV64Test,VFadd_vv)7498 TEST_F(AssemblerRISCV64Test, VFadd_vv) {
7499 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VFadd_vv,
7500 "vfadd.vv {reg1}, {reg2}, {reg3}{vm}",
7501 SkipV0Vm<VRegister, VRegister>()),
7502 "VFadd_vv");
7503 }
7504
TEST_F(AssemblerRISCV64Test,VFadd_vf)7505 TEST_F(AssemblerRISCV64Test, VFadd_vf) {
7506 DriverStr(RepeatVVFVmFiltered(&Riscv64Assembler::VFadd_vf,
7507 "vfadd.vf {reg1}, {reg2}, {reg3}{vm}",
7508 SkipV0Vm<VRegister, FRegister>()),
7509 "VFadd_vf");
7510 }
7511
TEST_F(AssemblerRISCV64Test,VFredusum_vs)7512 TEST_F(AssemblerRISCV64Test, VFredusum_vs) {
7513 DriverStr(RepeatVVVVm(&Riscv64Assembler::VFredusum_vs, "vfredusum.vs {reg1}, {reg2}, {reg3}{vm}"),
7514 "VFredusum_vs");
7515 }
7516
TEST_F(AssemblerRISCV64Test,VFsub_vv)7517 TEST_F(AssemblerRISCV64Test, VFsub_vv) {
7518 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VFsub_vv,
7519 "vfsub.vv {reg1}, {reg2}, {reg3}{vm}",
7520 SkipV0Vm<VRegister, VRegister>()),
7521 "VFsub_vv");
7522 }
7523
TEST_F(AssemblerRISCV64Test,VFsub_vf)7524 TEST_F(AssemblerRISCV64Test, VFsub_vf) {
7525 DriverStr(RepeatVVFVmFiltered(&Riscv64Assembler::VFsub_vf,
7526 "vfsub.vf {reg1}, {reg2}, {reg3}{vm}",
7527 SkipV0Vm<VRegister, FRegister>()),
7528 "VFsub_vf");
7529 }
7530
TEST_F(AssemblerRISCV64Test,VFredosum_vs)7531 TEST_F(AssemblerRISCV64Test, VFredosum_vs) {
7532 DriverStr(RepeatVVVVm(&Riscv64Assembler::VFredosum_vs, "vfredosum.vs {reg1}, {reg2}, {reg3}{vm}"),
7533 "VFredosum_vs");
7534 }
7535
TEST_F(AssemblerRISCV64Test,VFmin_vv)7536 TEST_F(AssemblerRISCV64Test, VFmin_vv) {
7537 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VFmin_vv,
7538 "vfmin.vv {reg1}, {reg2}, {reg3}{vm}",
7539 SkipV0Vm<VRegister, VRegister>()),
7540 "VFmin_vv");
7541 }
7542
TEST_F(AssemblerRISCV64Test,VFmin_vf)7543 TEST_F(AssemblerRISCV64Test, VFmin_vf) {
7544 DriverStr(RepeatVVFVmFiltered(&Riscv64Assembler::VFmin_vf,
7545 "vfmin.vf {reg1}, {reg2}, {reg3}{vm}",
7546 SkipV0Vm<VRegister, FRegister>()),
7547 "VFmin_vf");
7548 }
7549
TEST_F(AssemblerRISCV64Test,VFredmin_vs)7550 TEST_F(AssemblerRISCV64Test, VFredmin_vs) {
7551 DriverStr(RepeatVVVVm(&Riscv64Assembler::VFredmin_vs, "vfredmin.vs {reg1}, {reg2}, {reg3}{vm}"),
7552 "VFredmin_vs");
7553 }
7554
TEST_F(AssemblerRISCV64Test,VFmax_vv)7555 TEST_F(AssemblerRISCV64Test, VFmax_vv) {
7556 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VFmax_vv,
7557 "vfmax.vv {reg1}, {reg2}, {reg3}{vm}",
7558 SkipV0Vm<VRegister, VRegister>()),
7559 "VFmax_vv");
7560 }
7561
TEST_F(AssemblerRISCV64Test,VFmax_vf)7562 TEST_F(AssemblerRISCV64Test, VFmax_vf) {
7563 DriverStr(RepeatVVFVmFiltered(&Riscv64Assembler::VFmax_vf,
7564 "vfmax.vf {reg1}, {reg2}, {reg3}{vm}",
7565 SkipV0Vm<VRegister, FRegister>()),
7566 "VFmax_vf");
7567 }
7568
TEST_F(AssemblerRISCV64Test,VFredmax_vs)7569 TEST_F(AssemblerRISCV64Test, VFredmax_vs) {
7570 DriverStr(RepeatVVVVm(&Riscv64Assembler::VFredmax_vs, "vfredmax.vs {reg1}, {reg2}, {reg3}{vm}"),
7571 "VFredmax_vs");
7572 }
7573
TEST_F(AssemblerRISCV64Test,VFsgnj_vv)7574 TEST_F(AssemblerRISCV64Test, VFsgnj_vv) {
7575 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VFsgnj_vv,
7576 "vfsgnj.vv {reg1}, {reg2}, {reg3}{vm}",
7577 SkipV0Vm<VRegister, VRegister>()),
7578 "VFsgnj_vv");
7579 }
7580
TEST_F(AssemblerRISCV64Test,VFsgnj_vf)7581 TEST_F(AssemblerRISCV64Test, VFsgnj_vf) {
7582 DriverStr(RepeatVVFVmFiltered(&Riscv64Assembler::VFsgnj_vf,
7583 "vfsgnj.vf {reg1}, {reg2}, {reg3}{vm}",
7584 SkipV0Vm<VRegister, FRegister>()),
7585 "VFsgnj_vf");
7586 }
7587
TEST_F(AssemblerRISCV64Test,VFsgnjn_vv)7588 TEST_F(AssemblerRISCV64Test, VFsgnjn_vv) {
7589 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VFsgnjn_vv,
7590 "vfsgnjn.vv {reg1}, {reg2}, {reg3}{vm}",
7591 SkipV0Vm<VRegister, VRegister>()),
7592 "VFsgnjn_vv");
7593 }
7594
TEST_F(AssemblerRISCV64Test,VFsgnjn_vf)7595 TEST_F(AssemblerRISCV64Test, VFsgnjn_vf) {
7596 DriverStr(RepeatVVFVmFiltered(&Riscv64Assembler::VFsgnjn_vf,
7597 "vfsgnjn.vf {reg1}, {reg2}, {reg3}{vm}",
7598 SkipV0Vm<VRegister, FRegister>()),
7599 "VFsgnjn_vf");
7600 }
7601
TEST_F(AssemblerRISCV64Test,VFneg_v)7602 TEST_F(AssemblerRISCV64Test, VFneg_v) {
7603 DriverStr(RepeatVV(&Riscv64Assembler::VFneg_v, "vfneg.v {reg1}, {reg2}"), "VFneg_v");
7604 }
7605
TEST_F(AssemblerRISCV64Test,VFsgnjx_vv)7606 TEST_F(AssemblerRISCV64Test, VFsgnjx_vv) {
7607 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VFsgnjx_vv,
7608 "vfsgnjx.vv {reg1}, {reg2}, {reg3}{vm}",
7609 SkipV0Vm<VRegister, VRegister>()),
7610 "VFsgnjx_vv");
7611 }
7612
TEST_F(AssemblerRISCV64Test,VFsgnjx_vf)7613 TEST_F(AssemblerRISCV64Test, VFsgnjx_vf) {
7614 DriverStr(RepeatVVFVmFiltered(&Riscv64Assembler::VFsgnjx_vf,
7615 "vfsgnjx.vf {reg1}, {reg2}, {reg3}{vm}",
7616 SkipV0Vm<VRegister, FRegister>()),
7617 "VFsgnjx_vf");
7618 }
7619
TEST_F(AssemblerRISCV64Test,VFabs_v)7620 TEST_F(AssemblerRISCV64Test, VFabs_v) {
7621 DriverStr(RepeatVV(&Riscv64Assembler::VFabs_v, "vfabs.v {reg1}, {reg2}"), "VFabs_v");
7622 }
7623
TEST_F(AssemblerRISCV64Test,VFslide1up_vf)7624 TEST_F(AssemblerRISCV64Test, VFslide1up_vf) {
7625 DriverStr(RepeatVVFVmFiltered(&Riscv64Assembler::VFslide1up_vf,
7626 "vfslide1up.vf {reg1}, {reg2}, {reg3}{vm}",
7627 VXVVmSkipV0VmAndNoR1R2Overlap<FRegister>()),
7628 "VFslide1up_vf");
7629 }
7630
TEST_F(AssemblerRISCV64Test,VFslide1down_vf)7631 TEST_F(AssemblerRISCV64Test, VFslide1down_vf) {
7632 DriverStr(RepeatVVFVmFiltered(&Riscv64Assembler::VFslide1down_vf,
7633 "vfslide1down.vf {reg1}, {reg2}, {reg3}{vm}",
7634 SkipV0Vm<VRegister, FRegister>()),
7635 "VFslide1down_vf");
7636 }
7637
TEST_F(AssemblerRISCV64Test,VFmerge_vfm)7638 TEST_F(AssemblerRISCV64Test, VFmerge_vfm) {
7639 DriverStr(RepeatVVFFiltered(&Riscv64Assembler::VFmerge_vfm,
7640 "vfmerge.vfm {reg1}, {reg2}, {reg3}, v0",
7641 SkipV0<VRegister, FRegister>()),
7642 "VFmerge_vfm");
7643 }
7644
TEST_F(AssemblerRISCV64Test,VFmv_v_f)7645 TEST_F(AssemblerRISCV64Test, VFmv_v_f) {
7646 DriverStr(RepeatVF(&Riscv64Assembler::VFmv_v_f, "vfmv.v.f {reg1}, {reg2}"), "VFmv_v_f");
7647 }
7648
TEST_F(AssemblerRISCV64Test,VMfeq_vv)7649 TEST_F(AssemblerRISCV64Test, VMfeq_vv) {
7650 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VMfeq_vv,
7651 "vmfeq.vv {reg1}, {reg2}, {reg3}{vm}",
7652 SkipV0Vm<VRegister, VRegister>()),
7653 "VMfeq_vv");
7654 }
7655
TEST_F(AssemblerRISCV64Test,VMfeq_vf)7656 TEST_F(AssemblerRISCV64Test, VMfeq_vf) {
7657 DriverStr(RepeatVVFVmFiltered(&Riscv64Assembler::VMfeq_vf,
7658 "vmfeq.vf {reg1}, {reg2}, {reg3}{vm}",
7659 SkipV0Vm<VRegister, FRegister>()),
7660 "VMfeq_vf");
7661 }
7662
TEST_F(AssemblerRISCV64Test,VMfle_vv)7663 TEST_F(AssemblerRISCV64Test, VMfle_vv) {
7664 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VMfle_vv,
7665 "vmfle.vv {reg1}, {reg2}, {reg3}{vm}",
7666 SkipV0Vm<VRegister, VRegister>()),
7667 "VMfle_vv");
7668 }
7669
TEST_F(AssemblerRISCV64Test,VMfle_vf)7670 TEST_F(AssemblerRISCV64Test, VMfle_vf) {
7671 DriverStr(RepeatVVFVmFiltered(&Riscv64Assembler::VMfle_vf,
7672 "vmfle.vf {reg1}, {reg2}, {reg3}{vm}",
7673 SkipV0Vm<VRegister, FRegister>()),
7674 "VMfle_vf");
7675 }
7676
TEST_F(AssemblerRISCV64Test,VMfge_vv)7677 TEST_F(AssemblerRISCV64Test, VMfge_vv) {
7678 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VMfge_vv,
7679 "vmfge.vv {reg1}, {reg2}, {reg3}{vm}",
7680 SkipV0Vm<VRegister, VRegister>()),
7681 "VMfge_vv");
7682 }
7683
TEST_F(AssemblerRISCV64Test,VMflt_vv)7684 TEST_F(AssemblerRISCV64Test, VMflt_vv) {
7685 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VMflt_vv,
7686 "vmflt.vv {reg1}, {reg2}, {reg3}{vm}",
7687 SkipV0Vm<VRegister, VRegister>()),
7688 "VMflt_vv");
7689 }
7690
TEST_F(AssemblerRISCV64Test,VMflt_vf)7691 TEST_F(AssemblerRISCV64Test, VMflt_vf) {
7692 DriverStr(RepeatVVFVmFiltered(&Riscv64Assembler::VMflt_vf,
7693 "vmflt.vf {reg1}, {reg2}, {reg3}{vm}",
7694 SkipV0Vm<VRegister, FRegister>()),
7695 "VMflt_vf");
7696 }
7697
TEST_F(AssemblerRISCV64Test,VMfgt_vv)7698 TEST_F(AssemblerRISCV64Test, VMfgt_vv) {
7699 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VMfgt_vv,
7700 "vmfgt.vv {reg1}, {reg2}, {reg3}{vm}",
7701 SkipV0Vm<VRegister, VRegister>()),
7702 "VMfgt_vv");
7703 }
7704
TEST_F(AssemblerRISCV64Test,VMfne_vv)7705 TEST_F(AssemblerRISCV64Test, VMfne_vv) {
7706 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VMfne_vv,
7707 "vmfne.vv {reg1}, {reg2}, {reg3}{vm}",
7708 SkipV0Vm<VRegister, VRegister>()),
7709 "VMfne_vv");
7710 }
7711
TEST_F(AssemblerRISCV64Test,VMfne_vf)7712 TEST_F(AssemblerRISCV64Test, VMfne_vf) {
7713 DriverStr(RepeatVVFVmFiltered(&Riscv64Assembler::VMfne_vf,
7714 "vmfne.vf {reg1}, {reg2}, {reg3}{vm}",
7715 SkipV0Vm<VRegister, FRegister>()),
7716 "VMfne_vf");
7717 }
7718
TEST_F(AssemblerRISCV64Test,VMfgt_vf)7719 TEST_F(AssemblerRISCV64Test, VMfgt_vf) {
7720 DriverStr(RepeatVVFVmFiltered(&Riscv64Assembler::VMfgt_vf,
7721 "vmfgt.vf {reg1}, {reg2}, {reg3}{vm}",
7722 SkipV0Vm<VRegister, FRegister>()),
7723 "VMfgt_vf");
7724 }
7725
TEST_F(AssemblerRISCV64Test,VMfge_vf)7726 TEST_F(AssemblerRISCV64Test, VMfge_vf) {
7727 DriverStr(RepeatVVFVmFiltered(&Riscv64Assembler::VMfge_vf,
7728 "vmfge.vf {reg1}, {reg2}, {reg3}{vm}",
7729 SkipV0Vm<VRegister, FRegister>()),
7730 "VMfge_vf");
7731 }
7732
TEST_F(AssemblerRISCV64Test,VFdiv_vv)7733 TEST_F(AssemblerRISCV64Test, VFdiv_vv) {
7734 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VFdiv_vv,
7735 "vfdiv.vv {reg1}, {reg2}, {reg3}{vm}",
7736 SkipV0Vm<VRegister, VRegister>()),
7737 "VFdiv_vv");
7738 }
7739
TEST_F(AssemblerRISCV64Test,VFdiv_vf)7740 TEST_F(AssemblerRISCV64Test, VFdiv_vf) {
7741 DriverStr(RepeatVVFVmFiltered(&Riscv64Assembler::VFdiv_vf,
7742 "vfdiv.vf {reg1}, {reg2}, {reg3}{vm}",
7743 SkipV0Vm<VRegister, FRegister>()),
7744 "VFdiv_vf");
7745 }
7746
TEST_F(AssemblerRISCV64Test,VFrdiv_vf)7747 TEST_F(AssemblerRISCV64Test, VFrdiv_vf) {
7748 DriverStr(RepeatVVFVmFiltered(&Riscv64Assembler::VFrdiv_vf,
7749 "vfrdiv.vf {reg1}, {reg2}, {reg3}{vm}",
7750 SkipV0Vm<VRegister, FRegister>()),
7751 "VFrdiv_vf");
7752 }
7753
TEST_F(AssemblerRISCV64Test,VFmul_vv)7754 TEST_F(AssemblerRISCV64Test, VFmul_vv) {
7755 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VFmul_vv,
7756 "vfmul.vv {reg1}, {reg2}, {reg3}{vm}",
7757 SkipV0Vm<VRegister, VRegister>()),
7758 "VFmul_vv");
7759 }
7760
TEST_F(AssemblerRISCV64Test,VFmul_vf)7761 TEST_F(AssemblerRISCV64Test, VFmul_vf) {
7762 DriverStr(RepeatVVFVmFiltered(&Riscv64Assembler::VFmul_vf,
7763 "vfmul.vf {reg1}, {reg2}, {reg3}{vm}",
7764 SkipV0Vm<VRegister, FRegister>()),
7765 "VFmul_vf");
7766 }
7767
TEST_F(AssemblerRISCV64Test,VFrsub_vf)7768 TEST_F(AssemblerRISCV64Test, VFrsub_vf) {
7769 DriverStr(RepeatVVFVmFiltered(&Riscv64Assembler::VFrsub_vf,
7770 "vfrsub.vf {reg1}, {reg2}, {reg3}{vm}",
7771 SkipV0Vm<VRegister, FRegister>()),
7772 "VFrsub_vf");
7773 }
7774
TEST_F(AssemblerRISCV64Test,VFmadd_vv)7775 TEST_F(AssemblerRISCV64Test, VFmadd_vv) {
7776 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VFmadd_vv,
7777 "vfmadd.vv {reg1}, {reg2}, {reg3}{vm}",
7778 SkipV0Vm<VRegister, VRegister>()),
7779 "VFmadd_vv");
7780 }
7781
TEST_F(AssemblerRISCV64Test,VFmadd_vf)7782 TEST_F(AssemblerRISCV64Test, VFmadd_vf) {
7783 DriverStr(RepeatVFVVmFiltered(&Riscv64Assembler::VFmadd_vf,
7784 "vfmadd.vf {reg1}, {reg2}, {reg3}{vm}",
7785 SkipV0Vm<FRegister, VRegister>()),
7786 "VFmadd_vf");
7787 }
7788
TEST_F(AssemblerRISCV64Test,VFnmadd_vv)7789 TEST_F(AssemblerRISCV64Test, VFnmadd_vv) {
7790 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VFnmadd_vv,
7791 "vfnmadd.vv {reg1}, {reg2}, {reg3}{vm}",
7792 SkipV0Vm<VRegister, VRegister>()),
7793 "VFnmadd_vv");
7794 }
7795
TEST_F(AssemblerRISCV64Test,VFnmadd_vf)7796 TEST_F(AssemblerRISCV64Test, VFnmadd_vf) {
7797 DriverStr(RepeatVFVVmFiltered(&Riscv64Assembler::VFnmadd_vf,
7798 "vfnmadd.vf {reg1}, {reg2}, {reg3}{vm}",
7799 SkipV0Vm<FRegister, VRegister>()),
7800 "VFnmadd_vf");
7801 }
7802
TEST_F(AssemblerRISCV64Test,VFmsub_vv)7803 TEST_F(AssemblerRISCV64Test, VFmsub_vv) {
7804 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VFmsub_vv,
7805 "vfmsub.vv {reg1}, {reg2}, {reg3}{vm}",
7806 SkipV0Vm<VRegister, VRegister>()),
7807 "VFmsub_vv");
7808 }
7809
TEST_F(AssemblerRISCV64Test,VFmsub_vf)7810 TEST_F(AssemblerRISCV64Test, VFmsub_vf) {
7811 DriverStr(RepeatVFVVmFiltered(&Riscv64Assembler::VFmsub_vf,
7812 "vfmsub.vf {reg1}, {reg2}, {reg3}{vm}",
7813 SkipV0Vm<FRegister, VRegister>()),
7814 "VFmsub_vf");
7815 }
7816
TEST_F(AssemblerRISCV64Test,VFnmsub_vv)7817 TEST_F(AssemblerRISCV64Test, VFnmsub_vv) {
7818 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VFnmsub_vv,
7819 "vfnmsub.vv {reg1}, {reg2}, {reg3}{vm}",
7820 SkipV0Vm<VRegister, VRegister>()),
7821 "VFnmsub_vv");
7822 }
7823
TEST_F(AssemblerRISCV64Test,VFnmsub_vf)7824 TEST_F(AssemblerRISCV64Test, VFnmsub_vf) {
7825 DriverStr(RepeatVFVVmFiltered(&Riscv64Assembler::VFnmsub_vf,
7826 "vfnmsub.vf {reg1}, {reg2}, {reg3}{vm}",
7827 SkipV0Vm<FRegister, VRegister>()),
7828 "VFnmsub_vf");
7829 }
7830
TEST_F(AssemblerRISCV64Test,VFmacc_vv)7831 TEST_F(AssemblerRISCV64Test, VFmacc_vv) {
7832 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VFmacc_vv,
7833 "vfmacc.vv {reg1}, {reg2}, {reg3}{vm}",
7834 SkipV0Vm<VRegister, VRegister>()),
7835 "VFmacc_vv");
7836 }
7837
TEST_F(AssemblerRISCV64Test,VFmacc_vf)7838 TEST_F(AssemblerRISCV64Test, VFmacc_vf) {
7839 DriverStr(RepeatVFVVmFiltered(&Riscv64Assembler::VFmacc_vf,
7840 "vfmacc.vf {reg1}, {reg2}, {reg3}{vm}",
7841 SkipV0Vm<FRegister, VRegister>()),
7842 "VFmacc_vf");
7843 }
7844
TEST_F(AssemblerRISCV64Test,VFnmacc_vv)7845 TEST_F(AssemblerRISCV64Test, VFnmacc_vv) {
7846 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VFnmacc_vv,
7847 "vfnmacc.vv {reg1}, {reg2}, {reg3}{vm}",
7848 SkipV0Vm<VRegister, VRegister>()),
7849 "VFnmacc_vv");
7850 }
7851
TEST_F(AssemblerRISCV64Test,VFnmacc_vf)7852 TEST_F(AssemblerRISCV64Test, VFnmacc_vf) {
7853 DriverStr(RepeatVFVVmFiltered(&Riscv64Assembler::VFnmacc_vf,
7854 "vfnmacc.vf {reg1}, {reg2}, {reg3}{vm}",
7855 SkipV0Vm<FRegister, VRegister>()),
7856 "VFnmacc_vf");
7857 }
7858
TEST_F(AssemblerRISCV64Test,VFmsac_vv)7859 TEST_F(AssemblerRISCV64Test, VFmsac_vv) {
7860 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VFmsac_vv,
7861 "vfmsac.vv {reg1}, {reg2}, {reg3}{vm}",
7862 SkipV0Vm<VRegister, VRegister>()),
7863 "VFmsac_vv");
7864 }
7865
TEST_F(AssemblerRISCV64Test,VFmsac_vf)7866 TEST_F(AssemblerRISCV64Test, VFmsac_vf) {
7867 DriverStr(RepeatVFVVmFiltered(&Riscv64Assembler::VFmsac_vf,
7868 "vfmsac.vf {reg1}, {reg2}, {reg3}{vm}",
7869 SkipV0Vm<FRegister, VRegister>()),
7870 "VFmsac_vf");
7871 }
7872
TEST_F(AssemblerRISCV64Test,VFnmsac_vv)7873 TEST_F(AssemblerRISCV64Test, VFnmsac_vv) {
7874 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VFnmsac_vv,
7875 "vfnmsac.vv {reg1}, {reg2}, {reg3}{vm}",
7876 SkipV0Vm<VRegister, VRegister>()),
7877 "VFnmsac_vv");
7878 }
7879
TEST_F(AssemblerRISCV64Test,VFnmsac_vf)7880 TEST_F(AssemblerRISCV64Test, VFnmsac_vf) {
7881 DriverStr(RepeatVFVVmFiltered(&Riscv64Assembler::VFnmsac_vf,
7882 "vfnmsac.vf {reg1}, {reg2}, {reg3}{vm}",
7883 SkipV0Vm<FRegister, VRegister>()),
7884 "VFnmsac_vf");
7885 }
7886
TEST_F(AssemblerRISCV64Test,VFwadd_vv)7887 TEST_F(AssemblerRISCV64Test, VFwadd_vv) {
7888 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VFwadd_vv,
7889 "vfwadd.vv {reg1}, {reg2}, {reg3}{vm}",
7890 VXVVmSkipV0VmAndNoR1R2R3Overlap()),
7891 "VFwadd_vv");
7892 }
7893
TEST_F(AssemblerRISCV64Test,VFwadd_vf)7894 TEST_F(AssemblerRISCV64Test, VFwadd_vf) {
7895 DriverStr(RepeatVVFVmFiltered(&Riscv64Assembler::VFwadd_vf,
7896 "vfwadd.vf {reg1}, {reg2}, {reg3}{vm}",
7897 VXVVmSkipV0VmAndNoR1R2Overlap<FRegister>()),
7898 "VFwadd_vf");
7899 }
7900
TEST_F(AssemblerRISCV64Test,VFwredusum_vs)7901 TEST_F(AssemblerRISCV64Test, VFwredusum_vs) {
7902 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VFwredusum_vs,
7903 "vfwredusum.vs {reg1}, {reg2}, {reg3}{vm}",
7904 SkipV0Vm<VRegister, VRegister>()),
7905 "VFwredusum_vs");
7906 }
7907
TEST_F(AssemblerRISCV64Test,VFwsub_vv)7908 TEST_F(AssemblerRISCV64Test, VFwsub_vv) {
7909 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VFwsub_vv,
7910 "vfwsub.vv {reg1}, {reg2}, {reg3}{vm}",
7911 VXVVmSkipV0VmAndNoR1R2R3Overlap()),
7912 "VFwsub_vv");
7913 }
7914
TEST_F(AssemblerRISCV64Test,VFwsub_vf)7915 TEST_F(AssemblerRISCV64Test, VFwsub_vf) {
7916 DriverStr(RepeatVVFVmFiltered(&Riscv64Assembler::VFwsub_vf,
7917 "vfwsub.vf {reg1}, {reg2}, {reg3}{vm}",
7918 VXVVmSkipV0VmAndNoR1R2Overlap<FRegister>()),
7919 "VFwsub_vf");
7920 }
7921
TEST_F(AssemblerRISCV64Test,VFwredosum_vs)7922 TEST_F(AssemblerRISCV64Test, VFwredosum_vs) {
7923 DriverStr(
7924 RepeatVVVVm(&Riscv64Assembler::VFwredosum_vs, "vfwredosum.vs {reg1}, {reg2}, {reg3}{vm}"),
7925 "VFwredosum_vs");
7926 }
7927
TEST_F(AssemblerRISCV64Test,VFwadd_wv)7928 TEST_F(AssemblerRISCV64Test, VFwadd_wv) {
7929 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VFwadd_wv,
7930 "vfwadd.wv {reg1}, {reg2}, {reg3}{vm}",
7931 VXVVmSkipV0VmAndNoR1R3Overlap<VRegister>()),
7932 "VFwadd_wv");
7933 }
7934
TEST_F(AssemblerRISCV64Test,VFwadd_wf)7935 TEST_F(AssemblerRISCV64Test, VFwadd_wf) {
7936 DriverStr(RepeatVVFVmFiltered(&Riscv64Assembler::VFwadd_wf,
7937 "vfwadd.wf {reg1}, {reg2}, {reg3}{vm}",
7938 SkipV0Vm<VRegister, FRegister>()),
7939 "VFwadd_wf");
7940 }
7941
TEST_F(AssemblerRISCV64Test,VFwsub_wv)7942 TEST_F(AssemblerRISCV64Test, VFwsub_wv) {
7943 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VFwsub_wv,
7944 "vfwsub.wv {reg1}, {reg2}, {reg3}{vm}",
7945 VXVVmSkipV0VmAndNoR1R3Overlap<VRegister>()),
7946 "VFwsub_wv");
7947 }
7948
TEST_F(AssemblerRISCV64Test,VFwsub_wf)7949 TEST_F(AssemblerRISCV64Test, VFwsub_wf) {
7950 DriverStr(RepeatVVFVmFiltered(&Riscv64Assembler::VFwsub_wf,
7951 "vfwsub.wf {reg1}, {reg2}, {reg3}{vm}",
7952 SkipV0Vm<VRegister, FRegister>()),
7953 "VFwsub_wf");
7954 }
7955
TEST_F(AssemblerRISCV64Test,VFwmul_vv)7956 TEST_F(AssemblerRISCV64Test, VFwmul_vv) {
7957 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VFwmul_vv,
7958 "vfwmul.vv {reg1}, {reg2}, {reg3}{vm}",
7959 VXVVmSkipV0VmAndNoR1R2R3Overlap()),
7960 "VFwmul_vv");
7961 }
7962
TEST_F(AssemblerRISCV64Test,VFwmul_vf)7963 TEST_F(AssemblerRISCV64Test, VFwmul_vf) {
7964 DriverStr(RepeatVVFVmFiltered(&Riscv64Assembler::VFwmul_vf,
7965 "vfwmul.vf {reg1}, {reg2}, {reg3}{vm}",
7966 VXVVmSkipV0VmAndNoR1R2Overlap<FRegister>()),
7967 "VFwmul_vf");
7968 }
7969
TEST_F(AssemblerRISCV64Test,VFwmacc_vv)7970 TEST_F(AssemblerRISCV64Test, VFwmacc_vv) {
7971 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VFwmacc_vv,
7972 "vfwmacc.vv {reg1}, {reg2}, {reg3}{vm}",
7973 VXVVmSkipV0VmAndNoR1R2R3Overlap()),
7974 "VFwmacc_vv");
7975 }
7976
TEST_F(AssemblerRISCV64Test,VFwmacc_vf)7977 TEST_F(AssemblerRISCV64Test, VFwmacc_vf) {
7978 DriverStr(RepeatVFVVmFiltered(&Riscv64Assembler::VFwmacc_vf,
7979 "vfwmacc.vf {reg1}, {reg2}, {reg3}{vm}",
7980 VXVVmSkipV0VmAndNoR1R3Overlap<FRegister>()),
7981 "VFwmacc_vf");
7982 }
7983
TEST_F(AssemblerRISCV64Test,VFwnmacc_vv)7984 TEST_F(AssemblerRISCV64Test, VFwnmacc_vv) {
7985 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VFwnmacc_vv,
7986 "vfwnmacc.vv {reg1}, {reg2}, {reg3}{vm}",
7987 VXVVmSkipV0VmAndNoR1R2R3Overlap()),
7988 "VFwnmacc_vv");
7989 }
7990
TEST_F(AssemblerRISCV64Test,VFwnmacc_vf)7991 TEST_F(AssemblerRISCV64Test, VFwnmacc_vf) {
7992 DriverStr(RepeatVFVVmFiltered(&Riscv64Assembler::VFwnmacc_vf,
7993 "vfwnmacc.vf {reg1}, {reg2}, {reg3}{vm}",
7994 VXVVmSkipV0VmAndNoR1R3Overlap<FRegister>()),
7995 "VFwnmacc_vf");
7996 }
7997
TEST_F(AssemblerRISCV64Test,VFwmsac_vv)7998 TEST_F(AssemblerRISCV64Test, VFwmsac_vv) {
7999 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VFwmsac_vv,
8000 "vfwmsac.vv {reg1}, {reg2}, {reg3}{vm}",
8001 VXVVmSkipV0VmAndNoR1R2R3Overlap()),
8002 "VFwmsac_vv");
8003 }
8004
TEST_F(AssemblerRISCV64Test,VFwmsac_vf)8005 TEST_F(AssemblerRISCV64Test, VFwmsac_vf) {
8006 DriverStr(RepeatVFVVmFiltered(&Riscv64Assembler::VFwmsac_vf,
8007 "vfwmsac.vf {reg1}, {reg2}, {reg3}{vm}",
8008 VXVVmSkipV0VmAndNoR1R3Overlap<FRegister>()),
8009 "VFwmsac_vf");
8010 }
8011
TEST_F(AssemblerRISCV64Test,VFwnmsac_vv)8012 TEST_F(AssemblerRISCV64Test, VFwnmsac_vv) {
8013 DriverStr(RepeatVVVVmFiltered(&Riscv64Assembler::VFwnmsac_vv,
8014 "vfwnmsac.vv {reg1}, {reg2}, {reg3}{vm}",
8015 VXVVmSkipV0VmAndNoR1R2R3Overlap()),
8016 "VFwnmsac_vv");
8017 }
8018
TEST_F(AssemblerRISCV64Test,VFwnmsac_vf)8019 TEST_F(AssemblerRISCV64Test, VFwnmsac_vf) {
8020 DriverStr(RepeatVFVVmFiltered(&Riscv64Assembler::VFwnmsac_vf,
8021 "vfwnmsac.vf {reg1}, {reg2}, {reg3}{vm}",
8022 VXVVmSkipV0VmAndNoR1R3Overlap<FRegister>()),
8023 "VFwnmsac_vf");
8024 }
8025
TEST_F(AssemblerRISCV64Test,VMv_s_x)8026 TEST_F(AssemblerRISCV64Test, VMv_s_x) {
8027 DriverStr(RepeatVR(&Riscv64Assembler::VMv_s_x, "vmv.s.x {reg1}, {reg2}"), "VMv_s_x");
8028 }
8029
TEST_F(AssemblerRISCV64Test,VMv_x_s)8030 TEST_F(AssemblerRISCV64Test, VMv_x_s) {
8031 DriverStr(RepeatRV(&Riscv64Assembler::VMv_x_s, "vmv.x.s {reg1}, {reg2}"), "VMv_x_s");
8032 }
8033
TEST_F(AssemblerRISCV64Test,VCpop_m)8034 TEST_F(AssemblerRISCV64Test, VCpop_m) {
8035 DriverStr(RepeatRVVm(&Riscv64Assembler::VCpop_m, "vcpop.m {reg1}, {reg2}{vm}"), "VCpop_m");
8036 }
8037
TEST_F(AssemblerRISCV64Test,VFirst_m)8038 TEST_F(AssemblerRISCV64Test, VFirst_m) {
8039 DriverStr(RepeatRVVm(&Riscv64Assembler::VFirst_m, "vfirst.m {reg1}, {reg2}{vm}"), "VFirst_m");
8040 }
8041
TEST_F(AssemblerRISCV64Test,VZext_vf8)8042 TEST_F(AssemblerRISCV64Test, VZext_vf8) {
8043 DriverStr(
8044 RepeatVVVmFiltered(
8045 &Riscv64Assembler::VZext_vf8, "vzext.vf8 {reg1}, {reg2}{vm}", SkipV0Vm<VRegister>()),
8046 "VZext_vf8");
8047 }
8048
TEST_F(AssemblerRISCV64Test,VSext_vf8)8049 TEST_F(AssemblerRISCV64Test, VSext_vf8) {
8050 DriverStr(
8051 RepeatVVVmFiltered(
8052 &Riscv64Assembler::VSext_vf8, "vsext.vf8 {reg1}, {reg2}{vm}", SkipV0Vm<VRegister>()),
8053 "VSext_vf8");
8054 }
8055
TEST_F(AssemblerRISCV64Test,VZext_vf4)8056 TEST_F(AssemblerRISCV64Test, VZext_vf4) {
8057 DriverStr(
8058 RepeatVVVmFiltered(
8059 &Riscv64Assembler::VZext_vf4, "vzext.vf4 {reg1}, {reg2}{vm}", SkipV0Vm<VRegister>()),
8060 "VZext_vf4");
8061 }
8062
TEST_F(AssemblerRISCV64Test,VSext_vf4)8063 TEST_F(AssemblerRISCV64Test, VSext_vf4) {
8064 DriverStr(
8065 RepeatVVVmFiltered(
8066 &Riscv64Assembler::VSext_vf4, "vsext.vf4 {reg1}, {reg2}{vm}", SkipV0Vm<VRegister>()),
8067 "VSext_vf4");
8068 }
8069
TEST_F(AssemblerRISCV64Test,VZext_vf2)8070 TEST_F(AssemblerRISCV64Test, VZext_vf2) {
8071 DriverStr(
8072 RepeatVVVmFiltered(
8073 &Riscv64Assembler::VZext_vf2, "vzext.vf2 {reg1}, {reg2}{vm}", SkipV0Vm<VRegister>()),
8074 "VZext_vf2");
8075 }
8076
TEST_F(AssemblerRISCV64Test,VSext_vf2)8077 TEST_F(AssemblerRISCV64Test, VSext_vf2) {
8078 DriverStr(
8079 RepeatVVVmFiltered(
8080 &Riscv64Assembler::VSext_vf2, "vsext.vf2 {reg1}, {reg2}{vm}", SkipV0Vm<VRegister>()),
8081 "VSext_vf2");
8082 }
8083
TEST_F(AssemblerRISCV64Test,VFmv_s_f)8084 TEST_F(AssemblerRISCV64Test, VFmv_s_f) {
8085 DriverStr(RepeatVF(&Riscv64Assembler::VFmv_s_f, "vfmv.s.f {reg1}, {reg2}"), "VFmv_s_f");
8086 }
8087
TEST_F(AssemblerRISCV64Test,VFmv_f_s)8088 TEST_F(AssemblerRISCV64Test, VFmv_f_s) {
8089 DriverStr(RepeatFV(&Riscv64Assembler::VFmv_f_s, "vfmv.f.s {reg1}, {reg2}"), "VFmv_f_s");
8090 }
8091
TEST_F(AssemblerRISCV64Test,VFcvt_xu_f_v)8092 TEST_F(AssemblerRISCV64Test, VFcvt_xu_f_v) {
8093 DriverStr(RepeatVVVmFiltered(&Riscv64Assembler::VFcvt_xu_f_v,
8094 "vfcvt.xu.f.v {reg1}, {reg2}{vm}",
8095 SkipV0Vm<VRegister>()),
8096 "VFcvt_xu_f_v");
8097 }
8098
TEST_F(AssemblerRISCV64Test,VFcvt_x_f_v)8099 TEST_F(AssemblerRISCV64Test, VFcvt_x_f_v) {
8100 DriverStr(
8101 RepeatVVVmFiltered(
8102 &Riscv64Assembler::VFcvt_x_f_v, "vfcvt.x.f.v {reg1}, {reg2}{vm}", SkipV0Vm<VRegister>()),
8103 "VFcvt_x_f_v");
8104 }
8105
TEST_F(AssemblerRISCV64Test,VFcvt_f_xu_v)8106 TEST_F(AssemblerRISCV64Test, VFcvt_f_xu_v) {
8107 DriverStr(RepeatVVVmFiltered(&Riscv64Assembler::VFcvt_f_xu_v,
8108 "vfcvt.f.xu.v {reg1}, {reg2}{vm}",
8109 SkipV0Vm<VRegister>()),
8110 "VFcvt_f_xu_v");
8111 }
8112
TEST_F(AssemblerRISCV64Test,VFcvt_f_x_v)8113 TEST_F(AssemblerRISCV64Test, VFcvt_f_x_v) {
8114 DriverStr(
8115 RepeatVVVmFiltered(
8116 &Riscv64Assembler::VFcvt_f_x_v, "vfcvt.f.x.v {reg1}, {reg2}{vm}", SkipV0Vm<VRegister>()),
8117 "VFcvt_f_x_v");
8118 }
8119
TEST_F(AssemblerRISCV64Test,VFcvt_rtz_xu_f_v)8120 TEST_F(AssemblerRISCV64Test, VFcvt_rtz_xu_f_v) {
8121 DriverStr(RepeatVVVmFiltered(&Riscv64Assembler::VFcvt_rtz_xu_f_v,
8122 "vfcvt.rtz.xu.f.v {reg1}, {reg2}{vm}",
8123 SkipV0Vm<VRegister>()),
8124 "VFcvt_rtz_xu_f_v");
8125 }
8126
TEST_F(AssemblerRISCV64Test,VFcvt_rtz_x_f_v)8127 TEST_F(AssemblerRISCV64Test, VFcvt_rtz_x_f_v) {
8128 DriverStr(RepeatVVVmFiltered(&Riscv64Assembler::VFcvt_rtz_x_f_v,
8129 "vfcvt.rtz.x.f.v {reg1}, {reg2}{vm}",
8130 SkipV0Vm<VRegister>()),
8131 "VFcvt_rtz_x_f_v");
8132 }
8133
TEST_F(AssemblerRISCV64Test,VFwcvt_xu_f_v)8134 TEST_F(AssemblerRISCV64Test, VFwcvt_xu_f_v) {
8135 DriverStr(RepeatVVVmFiltered(&Riscv64Assembler::VFwcvt_xu_f_v,
8136 "vfwcvt.xu.f.v {reg1}, {reg2}{vm}",
8137 VVVmSkipV0VmAndNoR1R2Overlap()),
8138 "VFwcvt_xu_f_v");
8139 }
8140
TEST_F(AssemblerRISCV64Test,VFwcvt_x_f_v)8141 TEST_F(AssemblerRISCV64Test, VFwcvt_x_f_v) {
8142 DriverStr(RepeatVVVmFiltered(&Riscv64Assembler::VFwcvt_x_f_v,
8143 "vfwcvt.x.f.v {reg1}, {reg2}{vm}",
8144 VVVmSkipV0VmAndNoR1R2Overlap()),
8145 "VFwcvt_x_f_v");
8146 }
8147
TEST_F(AssemblerRISCV64Test,VFwcvt_f_xu_v)8148 TEST_F(AssemblerRISCV64Test, VFwcvt_f_xu_v) {
8149 DriverStr(RepeatVVVmFiltered(&Riscv64Assembler::VFwcvt_f_xu_v,
8150 "vfwcvt.f.xu.v {reg1}, {reg2}{vm}",
8151 VVVmSkipV0VmAndNoR1R2Overlap()),
8152 "VFwcvt_f_xu_v");
8153 }
8154
TEST_F(AssemblerRISCV64Test,VFwcvt_f_x_v)8155 TEST_F(AssemblerRISCV64Test, VFwcvt_f_x_v) {
8156 DriverStr(RepeatVVVmFiltered(&Riscv64Assembler::VFwcvt_f_x_v,
8157 "vfwcvt.f.x.v {reg1}, {reg2}{vm}",
8158 VVVmSkipV0VmAndNoR1R2Overlap()),
8159 "VFwcvt_f_x_v");
8160 }
8161
TEST_F(AssemblerRISCV64Test,VFwcvt_f_f_v)8162 TEST_F(AssemblerRISCV64Test, VFwcvt_f_f_v) {
8163 DriverStr(RepeatVVVmFiltered(&Riscv64Assembler::VFwcvt_f_f_v,
8164 "vfwcvt.f.f.v {reg1}, {reg2}{vm}",
8165 VVVmSkipV0VmAndNoR1R2Overlap()),
8166 "VFwcvt_f_f_v");
8167 }
8168
TEST_F(AssemblerRISCV64Test,VFwcvt_rtz_xu_f_v)8169 TEST_F(AssemblerRISCV64Test, VFwcvt_rtz_xu_f_v) {
8170 DriverStr(RepeatVVVmFiltered(&Riscv64Assembler::VFwcvt_rtz_xu_f_v,
8171 "vfwcvt.rtz.xu.f.v {reg1}, {reg2}{vm}",
8172 VVVmSkipV0VmAndNoR1R2Overlap()),
8173 "VFwcvt_rtz_xu_f_v");
8174 }
8175
TEST_F(AssemblerRISCV64Test,VFwcvt_rtz_x_f_v)8176 TEST_F(AssemblerRISCV64Test, VFwcvt_rtz_x_f_v) {
8177 DriverStr(RepeatVVVmFiltered(&Riscv64Assembler::VFwcvt_rtz_x_f_v,
8178 "vfwcvt.rtz.x.f.v {reg1}, {reg2}{vm}",
8179 VVVmSkipV0VmAndNoR1R2Overlap()),
8180 "VFwcvt_rtz_x_f_v");
8181 }
8182
TEST_F(AssemblerRISCV64Test,VFncvt_xu_f_w)8183 TEST_F(AssemblerRISCV64Test, VFncvt_xu_f_w) {
8184 DriverStr(RepeatVVVmFiltered(&Riscv64Assembler::VFncvt_xu_f_w,
8185 "vfncvt.xu.f.w {reg1}, {reg2}{vm}",
8186 SkipV0Vm<VRegister>()),
8187 "VFncvt_xu_f_w");
8188 }
8189
TEST_F(AssemblerRISCV64Test,VFncvt_x_f_w)8190 TEST_F(AssemblerRISCV64Test, VFncvt_x_f_w) {
8191 DriverStr(RepeatVVVmFiltered(&Riscv64Assembler::VFncvt_x_f_w,
8192 "vfncvt.x.f.w {reg1}, {reg2}{vm}",
8193 SkipV0Vm<VRegister>()),
8194 "VFncvt_x_f_w");
8195 }
8196
TEST_F(AssemblerRISCV64Test,VFncvt_f_xu_w)8197 TEST_F(AssemblerRISCV64Test, VFncvt_f_xu_w) {
8198 DriverStr(RepeatVVVmFiltered(&Riscv64Assembler::VFncvt_f_xu_w,
8199 "vfncvt.f.xu.w {reg1}, {reg2}{vm}",
8200 SkipV0Vm<VRegister>()),
8201 "VFncvt_f_xu_w");
8202 }
8203
TEST_F(AssemblerRISCV64Test,VFncvt_f_x_w)8204 TEST_F(AssemblerRISCV64Test, VFncvt_f_x_w) {
8205 DriverStr(RepeatVVVmFiltered(&Riscv64Assembler::VFncvt_f_x_w,
8206 "vfncvt.f.x.w {reg1}, {reg2}{vm}",
8207 SkipV0Vm<VRegister>()),
8208 "VFncvt_f_x_w");
8209 }
8210
TEST_F(AssemblerRISCV64Test,VFncvt_f_f_w)8211 TEST_F(AssemblerRISCV64Test, VFncvt_f_f_w) {
8212 DriverStr(RepeatVVVmFiltered(&Riscv64Assembler::VFncvt_f_f_w,
8213 "vfncvt.f.f.w {reg1}, {reg2}{vm}",
8214 SkipV0Vm<VRegister>()),
8215 "VFncvt_f_f_w");
8216 }
8217
TEST_F(AssemblerRISCV64Test,VFncvt_rod_f_f_w)8218 TEST_F(AssemblerRISCV64Test, VFncvt_rod_f_f_w) {
8219 DriverStr(RepeatVVVmFiltered(&Riscv64Assembler::VFncvt_rod_f_f_w,
8220 "vfncvt.rod.f.f.w {reg1}, {reg2}{vm}",
8221 SkipV0Vm<VRegister>()),
8222 "VFncvt_rod_f_f_w");
8223 }
8224
TEST_F(AssemblerRISCV64Test,VFncvt_rtz_xu_f_w)8225 TEST_F(AssemblerRISCV64Test, VFncvt_rtz_xu_f_w) {
8226 DriverStr(RepeatVVVmFiltered(&Riscv64Assembler::VFncvt_rtz_xu_f_w,
8227 "vfncvt.rtz.xu.f.w {reg1}, {reg2}{vm}",
8228 SkipV0Vm<VRegister>()),
8229 "VFncvt_rtz_xu_f_w");
8230 }
8231
TEST_F(AssemblerRISCV64Test,VFncvt_rtz_x_f_w)8232 TEST_F(AssemblerRISCV64Test, VFncvt_rtz_x_f_w) {
8233 DriverStr(RepeatVVVmFiltered(&Riscv64Assembler::VFncvt_rtz_x_f_w,
8234 "vfncvt.rtz.x.f.w {reg1}, {reg2}{vm}",
8235 SkipV0Vm<VRegister>()),
8236 "VFncvt_rtz_x_f_w");
8237 }
8238
TEST_F(AssemblerRISCV64Test,VFsqrt_v)8239 TEST_F(AssemblerRISCV64Test, VFsqrt_v) {
8240 DriverStr(RepeatVVVmFiltered(
8241 &Riscv64Assembler::VFsqrt_v, "vfsqrt.v {reg1}, {reg2}{vm}", SkipV0Vm<VRegister>()),
8242 "VFsqrt_v");
8243 }
8244
TEST_F(AssemblerRISCV64Test,VFrsqrt7_v)8245 TEST_F(AssemblerRISCV64Test, VFrsqrt7_v) {
8246 DriverStr(
8247 RepeatVVVmFiltered(
8248 &Riscv64Assembler::VFrsqrt7_v, "vfrsqrt7.v {reg1}, {reg2}{vm}", SkipV0Vm<VRegister>()),
8249 "VFrsqrt7_v");
8250 }
8251
TEST_F(AssemblerRISCV64Test,VFrec7_v)8252 TEST_F(AssemblerRISCV64Test, VFrec7_v) {
8253 DriverStr(RepeatVVVmFiltered(
8254 &Riscv64Assembler::VFrec7_v, "vfrec7.v {reg1}, {reg2}{vm}", SkipV0Vm<VRegister>()),
8255 "VFrec7_v");
8256 }
8257
TEST_F(AssemblerRISCV64Test,VFclass_v)8258 TEST_F(AssemblerRISCV64Test, VFclass_v) {
8259 DriverStr(
8260 RepeatVVVmFiltered(
8261 &Riscv64Assembler::VFclass_v, "vfclass.v {reg1}, {reg2}{vm}", SkipV0Vm<VRegister>()),
8262 "VFclass_v");
8263 }
8264
TEST_F(AssemblerRISCV64Test,VMsbf_m)8265 TEST_F(AssemblerRISCV64Test, VMsbf_m) {
8266 DriverStr(
8267 RepeatVVVmFiltered(
8268 &Riscv64Assembler::VMsbf_m, "vmsbf.m {reg1}, {reg2}{vm}", VVVmSkipV0VmAndNoR1R2Overlap()),
8269 "VMsbf_m");
8270 }
8271
TEST_F(AssemblerRISCV64Test,VMsof_m)8272 TEST_F(AssemblerRISCV64Test, VMsof_m) {
8273 DriverStr(
8274 RepeatVVVmFiltered(
8275 &Riscv64Assembler::VMsof_m, "vmsof.m {reg1}, {reg2}{vm}", VVVmSkipV0VmAndNoR1R2Overlap()),
8276 "VMsof_m");
8277 }
8278
TEST_F(AssemblerRISCV64Test,VMsif_m)8279 TEST_F(AssemblerRISCV64Test, VMsif_m) {
8280 DriverStr(
8281 RepeatVVVmFiltered(
8282 &Riscv64Assembler::VMsif_m, "vmsif.m {reg1}, {reg2}{vm}", VVVmSkipV0VmAndNoR1R2Overlap()),
8283 "VMsif_m");
8284 }
8285
TEST_F(AssemblerRISCV64Test,VIota_m)8286 TEST_F(AssemblerRISCV64Test, VIota_m) {
8287 DriverStr(
8288 RepeatVVVmFiltered(
8289 &Riscv64Assembler::VIota_m, "viota.m {reg1}, {reg2}{vm}", VVVmSkipV0VmAndNoR1R2Overlap()),
8290 "VIota_m");
8291 }
8292
TEST_F(AssemblerRISCV64Test,VId_v)8293 TEST_F(AssemblerRISCV64Test, VId_v) {
8294 DriverStr(RepeatVVmFiltered(&Riscv64Assembler::VId_v, "vid.v {reg} {vm}", SkipV0Vm()), "VId_v");
8295 }
8296
TEST_F(AssemblerRISCV64Test,Nop)8297 TEST_F(AssemblerRISCV64Test, Nop) {
8298 __ Nop();
8299 DriverStr("nop", "Nop");
8300 }
8301
8302 // Pseudo instructions.
TEST_F(AssemblerRISCV64Test,Nop_WithoutC)8303 TEST_F(AssemblerRISCV64Test, Nop_WithoutC) {
8304 ScopedCSuppression scs(this);
8305 __ Nop();
8306 DriverStr("nop", "Nop_WithoutC");
8307 }
8308
8309 // TODO(riscv64): Investigate whether new clang assembler produces some shorter sequences and
8310 // implement them.
TEST_F(AssemblerRISCV64Test,DISABLED_Li)8311 TEST_F(AssemblerRISCV64Test, DISABLED_Li) {
8312 ScopedZbaZbbAndCSuppression scs(this);
8313 TestLoadConst64("Li",
8314 /*can_use_tmp=*/ false,
8315 [&](XRegister rd, int64_t value) { __ Li(rd, value); });
8316 }
8317
TEST_F(AssemblerRISCV64Test,Mv)8318 TEST_F(AssemblerRISCV64Test, Mv) {
8319 ScopedCSuppression scs(this);
8320 DriverStr(RepeatRR(&Riscv64Assembler::Mv, "addi {reg1}, {reg2}, 0"), "Mv");
8321 }
8322
TEST_F(AssemblerRISCV64Test,Not)8323 TEST_F(AssemblerRISCV64Test, Not) {
8324 DriverStr(RepeatRR(&Riscv64Assembler::Not, "not {reg1}, {reg2}"), "Not");
8325 }
8326
TEST_F(AssemblerRISCV64Test,Not_WithoutC)8327 TEST_F(AssemblerRISCV64Test, Not_WithoutC) {
8328 ScopedCSuppression scs(this);
8329 DriverStr(RepeatRR(&Riscv64Assembler::Not, "not {reg1}, {reg2}"), "Not_WithoutC");
8330 }
8331
TEST_F(AssemblerRISCV64Test,Neg)8332 TEST_F(AssemblerRISCV64Test, Neg) {
8333 DriverStr(RepeatRR(&Riscv64Assembler::Neg, "sub {reg1}, x0, {reg2}"), "Neg");
8334 }
8335
TEST_F(AssemblerRISCV64Test,NegW)8336 TEST_F(AssemblerRISCV64Test, NegW) {
8337 DriverStr(RepeatRR(&Riscv64Assembler::NegW, "subw {reg1}, x0, {reg2}"), "Neg");
8338 }
8339
TEST_F(AssemblerRISCV64Test,SextB)8340 TEST_F(AssemblerRISCV64Test, SextB) {
8341 DriverStr(RepeatRR(&Riscv64Assembler::SextB, "sext.b {reg1}, {reg2}\n"), "SextB");
8342 }
8343
TEST_F(AssemblerRISCV64Test,SextB_WithoutZbb)8344 TEST_F(AssemblerRISCV64Test, SextB_WithoutZbb) {
8345 ScopedZbbSuppression scs(this);
8346 DriverStr(RepeatRR(&Riscv64Assembler::SextB, "sext.b {reg1}, {reg2}\n"), "SextB_WithoutZbb");
8347 }
8348
TEST_F(AssemblerRISCV64Test,SextB_WithoutC)8349 TEST_F(AssemblerRISCV64Test, SextB_WithoutC) {
8350 ScopedCSuppression scs(this);
8351 DriverStr(RepeatRR(&Riscv64Assembler::SextB, "sext.b {reg1}, {reg2}\n"), "SextB_WithoutC");
8352 }
8353
TEST_F(AssemblerRISCV64Test,SextB_WithoutZbbAndC)8354 TEST_F(AssemblerRISCV64Test, SextB_WithoutZbbAndC) {
8355 ScopedZbbAndCSuppression scs(this);
8356 DriverStr(RepeatRR(&Riscv64Assembler::SextB, "sext.b {reg1}, {reg2}\n"), "SextB_WithoutZbbAndC");
8357 }
8358
TEST_F(AssemblerRISCV64Test,SextH)8359 TEST_F(AssemblerRISCV64Test, SextH) {
8360 DriverStr(RepeatRR(&Riscv64Assembler::SextH, "sext.h {reg1}, {reg2}\n"), "SextH");
8361 }
8362
TEST_F(AssemblerRISCV64Test,SextH_WithoutZbb)8363 TEST_F(AssemblerRISCV64Test, SextH_WithoutZbb) {
8364 ScopedZbbSuppression scs(this);
8365 DriverStr(RepeatRR(&Riscv64Assembler::SextH, "sext.h {reg1}, {reg2}\n"), "SextH_WithoutZbb");
8366 }
8367
TEST_F(AssemblerRISCV64Test,SextH_WithoutC)8368 TEST_F(AssemblerRISCV64Test, SextH_WithoutC) {
8369 ScopedCSuppression scs(this);
8370 DriverStr(RepeatRR(&Riscv64Assembler::SextH, "sext.h {reg1}, {reg2}\n"), "SextH_WithoutC");
8371 }
8372
TEST_F(AssemblerRISCV64Test,SextH_WithoutZbbAndC)8373 TEST_F(AssemblerRISCV64Test, SextH_WithoutZbbAndC) {
8374 ScopedZbbAndCSuppression scs(this);
8375 DriverStr(RepeatRR(&Riscv64Assembler::SextH, "sext.h {reg1}, {reg2}\n"), "SextH_WithoutZbbAndC");
8376 }
8377
TEST_F(AssemblerRISCV64Test,SextW)8378 TEST_F(AssemblerRISCV64Test, SextW) {
8379 DriverStr(RepeatRR(&Riscv64Assembler::SextW, "sext.w {reg1}, {reg2}\n"), "SextW");
8380 }
8381
TEST_F(AssemblerRISCV64Test,SextW_WithoutC)8382 TEST_F(AssemblerRISCV64Test, SextW_WithoutC) {
8383 ScopedCSuppression scs(this);
8384 DriverStr(RepeatRR(&Riscv64Assembler::SextW, "sext.w {reg1}, {reg2}\n"), "SextW_WithoutC");
8385 }
8386
TEST_F(AssemblerRISCV64Test,ZextB)8387 TEST_F(AssemblerRISCV64Test, ZextB) {
8388 DriverStr(RepeatRR(&Riscv64Assembler::ZextB, "zext.b {reg1}, {reg2}"), "ZextB");
8389 }
8390
TEST_F(AssemblerRISCV64Test,ZextB_WithoutC)8391 TEST_F(AssemblerRISCV64Test, ZextB_WithoutC) {
8392 ScopedCSuppression scs(this);
8393 DriverStr(RepeatRR(&Riscv64Assembler::ZextB, "zext.b {reg1}, {reg2}"), "ZextB_WithoutC");
8394 }
8395
TEST_F(AssemblerRISCV64Test,ZextH)8396 TEST_F(AssemblerRISCV64Test, ZextH) {
8397 DriverStr(RepeatRR(&Riscv64Assembler::ZextH, "zext.h {reg1}, {reg2}\n"), "ZextH");
8398 }
8399
TEST_F(AssemblerRISCV64Test,ZextH_WithoutZbb)8400 TEST_F(AssemblerRISCV64Test, ZextH_WithoutZbb) {
8401 ScopedZbbSuppression scs(this);
8402 DriverStr(RepeatRR(&Riscv64Assembler::ZextH, "zext.h {reg1}, {reg2}\n"), "ZextH_WithoutZbb");
8403 }
8404
TEST_F(AssemblerRISCV64Test,ZextH_WithoutC)8405 TEST_F(AssemblerRISCV64Test, ZextH_WithoutC) {
8406 ScopedCSuppression scs(this);
8407 DriverStr(RepeatRR(&Riscv64Assembler::ZextH, "zext.h {reg1}, {reg2}\n"), "ZextH_WithoutC");
8408 }
8409
TEST_F(AssemblerRISCV64Test,ZextH_WithoutZbbAndC)8410 TEST_F(AssemblerRISCV64Test, ZextH_WithoutZbbAndC) {
8411 ScopedZbbAndCSuppression scs(this);
8412 DriverStr(RepeatRR(&Riscv64Assembler::ZextH, "zext.h {reg1}, {reg2}\n"), "ZextH_WithoutZbbAndC");
8413 }
8414
TEST_F(AssemblerRISCV64Test,ZextW)8415 TEST_F(AssemblerRISCV64Test, ZextW) {
8416 DriverStr(RepeatRR(&Riscv64Assembler::ZextW, "zext.w {reg1}, {reg2}\n"), "ZextW");
8417 }
8418
TEST_F(AssemblerRISCV64Test,ZextW_WithoutZba)8419 TEST_F(AssemblerRISCV64Test, ZextW_WithoutZba) {
8420 ScopedZbaSuppression scs(this);
8421 DriverStr(RepeatRR(&Riscv64Assembler::ZextW, "zext.w {reg1}, {reg2}\n"), "ZextW_WithoutZba");
8422 }
8423
TEST_F(AssemblerRISCV64Test,ZextW_WithoutC)8424 TEST_F(AssemblerRISCV64Test, ZextW_WithoutC) {
8425 ScopedCSuppression scs(this);
8426 DriverStr(RepeatRR(&Riscv64Assembler::ZextW, "zext.w {reg1}, {reg2}\n"), "ZextW_WithoutC");
8427 }
8428
TEST_F(AssemblerRISCV64Test,ZextW_WithoutZbaAndC)8429 TEST_F(AssemblerRISCV64Test, ZextW_WithoutZbaAndC) {
8430 ScopedZbaAndCSuppression scs(this);
8431 DriverStr(RepeatRR(&Riscv64Assembler::ZextW, "zext.w {reg1}, {reg2}\n"), "ZextW_WithoutZbaAndC");
8432 }
8433
TEST_F(AssemblerRISCV64Test,Seqz)8434 TEST_F(AssemblerRISCV64Test, Seqz) {
8435 DriverStr(RepeatRR(&Riscv64Assembler::Seqz, "sltiu {reg1}, {reg2}, 1\n"), "Seqz");
8436 }
8437
TEST_F(AssemblerRISCV64Test,Snez)8438 TEST_F(AssemblerRISCV64Test, Snez) {
8439 DriverStr(RepeatRR(&Riscv64Assembler::Snez, "sltu {reg1}, zero, {reg2}\n"), "Snez");
8440 }
8441
TEST_F(AssemblerRISCV64Test,Sltz)8442 TEST_F(AssemblerRISCV64Test, Sltz) {
8443 DriverStr(RepeatRR(&Riscv64Assembler::Sltz, "slt {reg1}, {reg2}, zero\n"), "Sltz");
8444 }
8445
TEST_F(AssemblerRISCV64Test,Sgtz)8446 TEST_F(AssemblerRISCV64Test, Sgtz) {
8447 DriverStr(RepeatRR(&Riscv64Assembler::Sgtz, "slt {reg1}, zero, {reg2}\n"), "Sgtz");
8448 }
8449
TEST_F(AssemblerRISCV64Test,FMvS)8450 TEST_F(AssemblerRISCV64Test, FMvS) {
8451 DriverStr(RepeatFF(&Riscv64Assembler::FMvS, "fsgnj.s {reg1}, {reg2}, {reg2}\n"), "FMvS");
8452 }
8453
TEST_F(AssemblerRISCV64Test,FAbsS)8454 TEST_F(AssemblerRISCV64Test, FAbsS) {
8455 DriverStr(RepeatFF(&Riscv64Assembler::FAbsS, "fsgnjx.s {reg1}, {reg2}, {reg2}\n"), "FAbsS");
8456 }
8457
TEST_F(AssemblerRISCV64Test,FNegS)8458 TEST_F(AssemblerRISCV64Test, FNegS) {
8459 DriverStr(RepeatFF(&Riscv64Assembler::FNegS, "fsgnjn.s {reg1}, {reg2}, {reg2}\n"), "FNegS");
8460 }
8461
TEST_F(AssemblerRISCV64Test,FMvD)8462 TEST_F(AssemblerRISCV64Test, FMvD) {
8463 DriverStr(RepeatFF(&Riscv64Assembler::FMvD, "fsgnj.d {reg1}, {reg2}, {reg2}\n"), "FMvD");
8464 }
8465
TEST_F(AssemblerRISCV64Test,FAbsD)8466 TEST_F(AssemblerRISCV64Test, FAbsD) {
8467 DriverStr(RepeatFF(&Riscv64Assembler::FAbsD, "fsgnjx.d {reg1}, {reg2}, {reg2}\n"), "FAbsD");
8468 }
8469
TEST_F(AssemblerRISCV64Test,FNegD)8470 TEST_F(AssemblerRISCV64Test, FNegD) {
8471 DriverStr(RepeatFF(&Riscv64Assembler::FNegD, "fsgnjn.d {reg1}, {reg2}, {reg2}\n"), "FNegD");
8472 }
8473
TEST_F(AssemblerRISCV64Test,Beqz)8474 TEST_F(AssemblerRISCV64Test, Beqz) {
8475 DriverStr(
8476 RepeatRIbS(
8477 &Riscv64Assembler::Beqz, /*imm_bits=*/-12, /*shift=*/1, "beq {reg}, zero, {imm}\n"),
8478 "Beqz");
8479 }
8480
TEST_F(AssemblerRISCV64Test,Beqz_WithoutC)8481 TEST_F(AssemblerRISCV64Test, Beqz_WithoutC) {
8482 ScopedCSuppression scs(this);
8483 DriverStr(
8484 RepeatRIbS(
8485 &Riscv64Assembler::Beqz, /*imm_bits=*/-11, /*shift=*/2, "beq {reg}, zero, {imm}\n"),
8486 "Beqz_WithoutC");
8487 }
8488
TEST_F(AssemblerRISCV64Test,Bnez)8489 TEST_F(AssemblerRISCV64Test, Bnez) {
8490 DriverStr(
8491 RepeatRIbS(
8492 &Riscv64Assembler::Bnez, /*imm_bits=*/-12, /*shift=*/1, "bne {reg}, zero, {imm}\n"),
8493 "Bnez");
8494 }
8495
TEST_F(AssemblerRISCV64Test,Bnez_WithoutC)8496 TEST_F(AssemblerRISCV64Test, Bnez_WithoutC) {
8497 ScopedCSuppression scs(this);
8498 DriverStr(
8499 RepeatRIbS(
8500 &Riscv64Assembler::Bnez, /*imm_bits=*/-11, /*shift=*/2, "bne {reg}, zero, {imm}\n"),
8501 "Bnez_WithoutC");
8502 }
8503
TEST_F(AssemblerRISCV64Test,Blez)8504 TEST_F(AssemblerRISCV64Test, Blez) {
8505 DriverStr(
8506 RepeatRIbS(
8507 &Riscv64Assembler::Blez, /*imm_bits=*/-12, /*shift=*/1, "bge zero, {reg}, {imm}\n"),
8508 "Blez");
8509 }
8510
TEST_F(AssemblerRISCV64Test,Bgez)8511 TEST_F(AssemblerRISCV64Test, Bgez) {
8512 DriverStr(
8513 RepeatRIbS(
8514 &Riscv64Assembler::Bgez, /*imm_bits=*/-12, /*shift=*/1, "bge {reg}, zero, {imm}\n"),
8515 "Bgez");
8516 }
8517
TEST_F(AssemblerRISCV64Test,Bltz)8518 TEST_F(AssemblerRISCV64Test, Bltz) {
8519 DriverStr(
8520 RepeatRIbS(
8521 &Riscv64Assembler::Bltz, /*imm_bits=*/-12, /*shift=*/1, "blt {reg}, zero, {imm}\n"),
8522 "Bltz");
8523 }
8524
TEST_F(AssemblerRISCV64Test,Bgtz)8525 TEST_F(AssemblerRISCV64Test, Bgtz) {
8526 DriverStr(
8527 RepeatRIbS(
8528 &Riscv64Assembler::Bgtz, /*imm_bits=*/-12, /*shift=*/1, "blt zero, {reg}, {imm}\n"),
8529 "Bgtz");
8530 }
8531
TEST_F(AssemblerRISCV64Test,Bgt)8532 TEST_F(AssemblerRISCV64Test, Bgt) {
8533 DriverStr(
8534 RepeatRRIbS(
8535 &Riscv64Assembler::Bgt, /*imm_bits=*/-12, /*shift=*/1, "blt {reg2}, {reg1}, {imm}\n"),
8536 "Bgt");
8537 }
8538
TEST_F(AssemblerRISCV64Test,Ble)8539 TEST_F(AssemblerRISCV64Test, Ble) {
8540 DriverStr(
8541 RepeatRRIbS(
8542 &Riscv64Assembler::Ble, /*imm_bits=*/-12, /*shift=*/1, "bge {reg2}, {reg1}, {imm}\n"),
8543 "Bge");
8544 }
8545
TEST_F(AssemblerRISCV64Test,Bgtu)8546 TEST_F(AssemblerRISCV64Test, Bgtu) {
8547 DriverStr(
8548 RepeatRRIbS(
8549 &Riscv64Assembler::Bgtu, /*imm_bits=*/-12, /*shift=*/1, "bltu {reg2}, {reg1}, {imm}\n"),
8550 "Bgtu");
8551 }
8552
TEST_F(AssemblerRISCV64Test,Bleu)8553 TEST_F(AssemblerRISCV64Test, Bleu) {
8554 DriverStr(
8555 RepeatRRIbS(
8556 &Riscv64Assembler::Bleu, /*imm_bits=*/-12, /*shift=*/1, "bgeu {reg2}, {reg1}, {imm}\n"),
8557 "Bgeu");
8558 }
8559
TEST_F(AssemblerRISCV64Test,J)8560 TEST_F(AssemblerRISCV64Test, J) {
8561 DriverStr(RepeatIbS<int32_t>(&Riscv64Assembler::J, /*imm_bits=*/-20, /*shift=*/1, "j {imm}\n"),
8562 "J");
8563 }
8564
TEST_F(AssemblerRISCV64Test,J_WithoutC)8565 TEST_F(AssemblerRISCV64Test, J_WithoutC) {
8566 ScopedCSuppression scs(this);
8567 DriverStr(RepeatIbS<int32_t>(&Riscv64Assembler::J, /*imm_bits=*/-19, /*shift=*/2, "j {imm}\n"),
8568 "J_WithoutC");
8569 }
8570
TEST_F(AssemblerRISCV64Test,JalRA)8571 TEST_F(AssemblerRISCV64Test, JalRA) {
8572 DriverStr(
8573 RepeatIbS<int32_t>(&Riscv64Assembler::Jal, /*imm_bits=*/-20, /*shift=*/1, "jal {imm}\n"),
8574 "JalRA");
8575 }
8576
TEST_F(AssemblerRISCV64Test,JalRA_WithoutC)8577 TEST_F(AssemblerRISCV64Test, JalRA_WithoutC) {
8578 ScopedCSuppression scs(this);
8579 DriverStr(
8580 RepeatIbS<int32_t>(&Riscv64Assembler::Jal, /*imm_bits=*/-19, /*shift=*/2, "jal {imm}\n"),
8581 "JalRA_WithoutC");
8582 }
8583
TEST_F(AssemblerRISCV64Test,Jr)8584 TEST_F(AssemblerRISCV64Test, Jr) {
8585 DriverStr(RepeatR(&Riscv64Assembler::Jr, "jr {reg}\n"), "Jr");
8586 }
8587
TEST_F(AssemblerRISCV64Test,Jr_WithoutC)8588 TEST_F(AssemblerRISCV64Test, Jr_WithoutC) {
8589 ScopedCSuppression scs(this);
8590 DriverStr(RepeatR(&Riscv64Assembler::Jr, "jr {reg}\n"), "Jr_WithoutC");
8591 }
8592
TEST_F(AssemblerRISCV64Test,JalrRA)8593 TEST_F(AssemblerRISCV64Test, JalrRA) {
8594 DriverStr(RepeatR(&Riscv64Assembler::Jalr, "jalr {reg}\n"), "JalrRA");
8595 }
8596
8597 // Note: `c.jal` is RV32-only but we test `Jalr(XRegister)` with and without "C" anyway.
TEST_F(AssemblerRISCV64Test,JalrRA_WithoutC)8598 TEST_F(AssemblerRISCV64Test, JalrRA_WithoutC) {
8599 ScopedCSuppression scs(this);
8600 DriverStr(RepeatR(&Riscv64Assembler::Jalr, "jalr {reg}\n"), "JalrRA_WithoutC");
8601 }
8602
TEST_F(AssemblerRISCV64Test,Jalr0)8603 TEST_F(AssemblerRISCV64Test, Jalr0) {
8604 DriverStr(RepeatRR(&Riscv64Assembler::Jalr, "jalr {reg1}, {reg2}\n"), "Jalr0");
8605 }
8606
TEST_F(AssemblerRISCV64Test,Jalr0_WithoutC)8607 TEST_F(AssemblerRISCV64Test, Jalr0_WithoutC) {
8608 ScopedCSuppression scs(this);
8609 DriverStr(RepeatRR(&Riscv64Assembler::Jalr, "jalr {reg1}, {reg2}\n"), "Jalr0_WithoutC");
8610 }
8611
TEST_F(AssemblerRISCV64Test,Ret)8612 TEST_F(AssemblerRISCV64Test, Ret) {
8613 __ Ret();
8614 DriverStr("ret\n", "Ret");
8615 }
8616
TEST_F(AssemblerRISCV64Test,Ret_WithoutC)8617 TEST_F(AssemblerRISCV64Test, Ret_WithoutC) {
8618 ScopedCSuppression scs(this);
8619 __ Ret();
8620 DriverStr("ret\n", "Ret_WithoutC");
8621 }
8622
TEST_F(AssemblerRISCV64Test,RdCycle)8623 TEST_F(AssemblerRISCV64Test, RdCycle) {
8624 DriverStr(RepeatR(&Riscv64Assembler::RdCycle, "rdcycle {reg}\n"), "RdCycle");
8625 }
8626
TEST_F(AssemblerRISCV64Test,RdTime)8627 TEST_F(AssemblerRISCV64Test, RdTime) {
8628 DriverStr(RepeatR(&Riscv64Assembler::RdTime, "rdtime {reg}\n"), "RdTime");
8629 }
8630
TEST_F(AssemblerRISCV64Test,RdInstret)8631 TEST_F(AssemblerRISCV64Test, RdInstret) {
8632 DriverStr(RepeatR(&Riscv64Assembler::RdInstret, "rdinstret {reg}\n"), "RdInstret");
8633 }
8634
TEST_F(AssemblerRISCV64Test,Csrr)8635 TEST_F(AssemblerRISCV64Test, Csrr) {
8636 TestCsrrXMacro(
8637 "Csrr", "csrr {reg}, {csr}", [&](uint32_t csr, XRegister rd) { __ Csrr(rd, csr); });
8638 }
8639
TEST_F(AssemblerRISCV64Test,Csrw)8640 TEST_F(AssemblerRISCV64Test, Csrw) {
8641 TestCsrrXMacro(
8642 "Csrw", "csrw {csr}, {reg}", [&](uint32_t csr, XRegister rs) { __ Csrw(csr, rs); });
8643 }
8644
TEST_F(AssemblerRISCV64Test,Csrs)8645 TEST_F(AssemblerRISCV64Test, Csrs) {
8646 TestCsrrXMacro(
8647 "Csrs", "csrs {csr}, {reg}", [&](uint32_t csr, XRegister rs) { __ Csrs(csr, rs); });
8648 }
8649
TEST_F(AssemblerRISCV64Test,Csrc)8650 TEST_F(AssemblerRISCV64Test, Csrc) {
8651 TestCsrrXMacro(
8652 "Csrc", "csrc {csr}, {reg}", [&](uint32_t csr, XRegister rs) { __ Csrc(csr, rs); });
8653 }
8654
TEST_F(AssemblerRISCV64Test,Csrwi)8655 TEST_F(AssemblerRISCV64Test, Csrwi) {
8656 TestCsrrXiMacro(
8657 "Csrwi", "csrwi {csr}, {uimm}", [&](uint32_t csr, uint32_t uimm) { __ Csrwi(csr, uimm); });
8658 }
8659
TEST_F(AssemblerRISCV64Test,Csrsi)8660 TEST_F(AssemblerRISCV64Test, Csrsi) {
8661 TestCsrrXiMacro(
8662 "Csrsi", "csrsi {csr}, {uimm}", [&](uint32_t csr, uint32_t uimm) { __ Csrsi(csr, uimm); });
8663 }
8664
TEST_F(AssemblerRISCV64Test,Csrci)8665 TEST_F(AssemblerRISCV64Test, Csrci) {
8666 TestCsrrXiMacro(
8667 "Csrci", "csrci {csr}, {uimm}", [&](uint32_t csr, uint32_t uimm) { __ Csrci(csr, uimm); });
8668 }
8669
TEST_F(AssemblerRISCV64Test,LoadConst32)8670 TEST_F(AssemblerRISCV64Test, LoadConst32) {
8671 ScopedCSuppression scs(this);
8672 // `LoadConst32()` emits the same code sequences as `Li()` for 32-bit values.
8673 ScratchRegisterScope srs(GetAssembler());
8674 srs.ExcludeXRegister(TMP);
8675 srs.ExcludeXRegister(TMP2);
8676 DriverStr(RepeatRIb(&Riscv64Assembler::LoadConst32, /*imm_bits=*/-32, "li {reg}, {imm}"), "LoadConst32");
8677 }
8678
8679 // TODO(riscv64): Investigate whether new clang assembler produces some shorter sequences and
8680 // implement them.
TEST_F(AssemblerRISCV64Test,DISABLED_LoadConst64)8681 TEST_F(AssemblerRISCV64Test, DISABLED_LoadConst64) {
8682 ScopedZbaZbbAndCSuppression scs(this);
8683 TestLoadConst64("LoadConst64",
8684 /*can_use_tmp=*/ true,
8685 [&](XRegister rd, int64_t value) { __ LoadConst64(rd, value); });
8686 }
8687
TEST_F(AssemblerRISCV64Test,AddConst32)8688 TEST_F(AssemblerRISCV64Test, AddConst32) {
8689 ScopedCSuppression scs(this);
8690 auto emit_op = [&](XRegister rd, XRegister rs1, int64_t value) {
8691 __ AddConst32(rd, rs1, dchecked_integral_cast<int32_t>(value));
8692 };
8693 TestAddConst("AddConst32", /*bits=*/32, /*suffix=*/ "w", emit_op);
8694 }
8695
TEST_F(AssemblerRISCV64Test,AddConst64)8696 TEST_F(AssemblerRISCV64Test, AddConst64) {
8697 ScopedZbaZbbAndCSuppression scs(this);
8698 auto emit_op = [&](XRegister rd, XRegister rs1, int64_t value) {
8699 __ AddConst64(rd, rs1, value);
8700 };
8701 TestAddConst("AddConst64", /*bits=*/64, /*suffix=*/ "", emit_op);
8702 }
8703
TEST_F(AssemblerRISCV64Test,BcondForward128B)8704 TEST_F(AssemblerRISCV64Test, BcondForward128B) {
8705 TestBcondForward("BcondForward128B", 128, "1", GetPrintBcond());
8706 }
8707
TEST_F(AssemblerRISCV64Test,BcondForward128B_WithoutC)8708 TEST_F(AssemblerRISCV64Test, BcondForward128B_WithoutC) {
8709 ScopedCSuppression scs(this);
8710 TestBcondForward("BcondForward128B_WithoutC", 128, "1", GetPrintBcond());
8711 }
8712
TEST_F(AssemblerRISCV64Test,BcondForward128BBare)8713 TEST_F(AssemblerRISCV64Test, BcondForward128BBare) {
8714 TestBcondForward("BcondForward128BBare", 128, "1", GetPrintBcond(), /*is_bare=*/ true);
8715 }
8716
TEST_F(AssemblerRISCV64Test,BcondForward128BBare_WithoutC)8717 TEST_F(AssemblerRISCV64Test, BcondForward128BBare_WithoutC) {
8718 ScopedCSuppression scs(this);
8719 TestBcondForward(
8720 "BcondForward128BBare_WithoutC", 128, "1", GetPrintBcond(), /*is_bare=*/ true);
8721 }
8722
TEST_F(AssemblerRISCV64Test,BcondBackward128B)8723 TEST_F(AssemblerRISCV64Test, BcondBackward128B) {
8724 TestBcondBackward("BcondBackward128B", 128, "1", GetPrintBcond());
8725 }
8726
TEST_F(AssemblerRISCV64Test,BcondBackward128B_WithoutC)8727 TEST_F(AssemblerRISCV64Test, BcondBackward128B_WithoutC) {
8728 ScopedCSuppression scs(this);
8729 TestBcondBackward("BcondBackward128B_WithoutC", 128, "1", GetPrintBcond());
8730 }
8731
TEST_F(AssemblerRISCV64Test,BcondBackward128BBare)8732 TEST_F(AssemblerRISCV64Test, BcondBackward128BBare) {
8733 TestBcondBackward("BcondBackward128BBare", 128, "1", GetPrintBcond(), /*is_bare=*/ true);
8734 }
8735
TEST_F(AssemblerRISCV64Test,BcondBackward128BBare_WithoutC)8736 TEST_F(AssemblerRISCV64Test, BcondBackward128BBare_WithoutC) {
8737 ScopedCSuppression scs(this);
8738 TestBcondBackward("BcondBackward128Bare_WithoutC", 128, "1", GetPrintBcond(), /*is_bare=*/ true);
8739 }
8740
TEST_F(AssemblerRISCV64Test,BcondForward3KiB)8741 TEST_F(AssemblerRISCV64Test, BcondForward3KiB) {
8742 TestBcondForward("BcondForward3KiB", 3 * KB, "1", GetPrintBcond());
8743 }
8744
TEST_F(AssemblerRISCV64Test,BcondForward3KiB_WithoutC)8745 TEST_F(AssemblerRISCV64Test, BcondForward3KiB_WithoutC) {
8746 ScopedCSuppression scs(this);
8747 TestBcondForward("BcondForward3KiB_WithoutC", 3 * KB, "1", GetPrintBcond());
8748 }
8749
TEST_F(AssemblerRISCV64Test,BcondForward3KiBBare_WithoutC)8750 TEST_F(AssemblerRISCV64Test, BcondForward3KiBBare_WithoutC) {
8751 ScopedCSuppression scs(this);
8752 TestBcondForward(
8753 "BcondForward3KiBBare_WithoutC", 3 * KB, "1", GetPrintBcond(), /*is_bare=*/ true);
8754 }
8755
TEST_F(AssemblerRISCV64Test,BcondBackward3KiB)8756 TEST_F(AssemblerRISCV64Test, BcondBackward3KiB) {
8757 TestBcondBackward("BcondBackward3KiB", 3 * KB, "1", GetPrintBcond());
8758 }
8759
TEST_F(AssemblerRISCV64Test,BcondBackward3KiB_WithoutC)8760 TEST_F(AssemblerRISCV64Test, BcondBackward3KiB_WithoutC) {
8761 ScopedCSuppression scs(this);
8762 TestBcondBackward("BcondBackward3KiB_WithoutC", 3 * KB, "1", GetPrintBcond());
8763 }
8764
TEST_F(AssemblerRISCV64Test,BcondBackward3KiBBare_WithoutC)8765 TEST_F(AssemblerRISCV64Test, BcondBackward3KiBBare_WithoutC) {
8766 ScopedCSuppression scs(this);
8767 TestBcondBackward(
8768 "BcondBackward3KiBare_WithoutC", 3 * KB, "1", GetPrintBcond(), /*is_bare=*/ true);
8769 }
8770
TEST_F(AssemblerRISCV64Test,BcondForward5KiB)8771 TEST_F(AssemblerRISCV64Test, BcondForward5KiB) {
8772 TestBcondForward("BcondForward5KiB", 5 * KB, "1", GetPrintBcondOppositeAndJ("2"));
8773 }
8774
TEST_F(AssemblerRISCV64Test,BcondForward5KiB_WithoutC)8775 TEST_F(AssemblerRISCV64Test, BcondForward5KiB_WithoutC) {
8776 ScopedCSuppression scs(this);
8777 TestBcondForward("BcondForward5KiB_WithoutC", 5 * KB, "1", GetPrintBcondOppositeAndJ("2"));
8778 }
8779
TEST_F(AssemblerRISCV64Test,BcondBackward5KiB)8780 TEST_F(AssemblerRISCV64Test, BcondBackward5KiB) {
8781 TestBcondBackward("BcondBackward5KiB", 5 * KB, "1", GetPrintBcondOppositeAndJ("2"));
8782 }
8783
TEST_F(AssemblerRISCV64Test,BcondBackward5KiB_WithoutC)8784 TEST_F(AssemblerRISCV64Test, BcondBackward5KiB_WithoutC) {
8785 ScopedCSuppression scs(this);
8786 TestBcondBackward("BcondBackward5KiB_WithoutC", 5 * KB, "1", GetPrintBcondOppositeAndJ("2"));
8787 }
8788
TEST_F(AssemblerRISCV64Test,BcondForward2MiB)8789 TEST_F(AssemblerRISCV64Test, BcondForward2MiB) {
8790 TestBcondForward("BcondForward2MiB", 2 * MB, "1", GetPrintBcondOppositeAndTail("2", "3"));
8791 }
8792
TEST_F(AssemblerRISCV64Test,BcondForward2MiB_WithoutC)8793 TEST_F(AssemblerRISCV64Test, BcondForward2MiB_WithoutC) {
8794 ScopedCSuppression scs(this);
8795 TestBcondForward(
8796 "BcondForward2MiB_WithoutC", 2 * MB, "1", GetPrintBcondOppositeAndTail("2", "3"));
8797 }
8798
TEST_F(AssemblerRISCV64Test,BcondBackward2MiB)8799 TEST_F(AssemblerRISCV64Test, BcondBackward2MiB) {
8800 TestBcondBackward("BcondBackward2MiB", 2 * MB, "1", GetPrintBcondOppositeAndTail("2", "3"));
8801 }
8802
TEST_F(AssemblerRISCV64Test,BcondBackward2MiB_WithoutC)8803 TEST_F(AssemblerRISCV64Test, BcondBackward2MiB_WithoutC) {
8804 ScopedCSuppression scs(this);
8805 TestBcondBackward(
8806 "BcondBackward2MiB_WithoutC", 2 * MB, "1", GetPrintBcondOppositeAndTail("2", "3"));
8807 }
8808
TEST_F(AssemblerRISCV64Test,BeqA0ZeroMaxOffset9Forward)8809 TEST_F(AssemblerRISCV64Test, BeqA0ZeroMaxOffset9Forward) {
8810 TestBeqzA0Forward("BeqA0ZeroMaxOffset9Forward",
8811 MaxOffset9ForwardDistance() - /*C.BEQZ*/ 2u,
8812 GetPrintCBcond(),
8813 "1");
8814 }
8815
TEST_F(AssemblerRISCV64Test,BeqA0ZeroMaxOffset9ForwardBare)8816 TEST_F(AssemblerRISCV64Test, BeqA0ZeroMaxOffset9ForwardBare) {
8817 TestBeqzA0Forward("BeqA0ZeroMaxOffset9ForwardBare",
8818 MaxOffset9ForwardDistance() - /*C.BEQZ*/ 2u,
8819 GetPrintCBcond(),
8820 "1",
8821 /*is_bare=*/ true);
8822 }
8823
TEST_F(AssemblerRISCV64Test,BneA0ZeroMaxOffset9Forward)8824 TEST_F(AssemblerRISCV64Test, BneA0ZeroMaxOffset9Forward) {
8825 TestBnezA0Forward("BneA0ZeroMaxOffset9Forward",
8826 MaxOffset9ForwardDistance() - /*C.BNEZ*/ 2u,
8827 GetPrintCBcond(),
8828 "1");
8829 }
8830
TEST_F(AssemblerRISCV64Test,BneA0ZeroMaxOffset9ForwardBare)8831 TEST_F(AssemblerRISCV64Test, BneA0ZeroMaxOffset9ForwardBare) {
8832 TestBnezA0Forward("BneA0ZeroMaxOffset9ForwardBare",
8833 MaxOffset9ForwardDistance() - /*C.BNEZ*/ 2u,
8834 GetPrintCBcond(),
8835 "1",
8836 /*is_bare=*/ true);
8837 }
8838
TEST_F(AssemblerRISCV64Test,BeqA0ZeroMaxOffset9Backward)8839 TEST_F(AssemblerRISCV64Test, BeqA0ZeroMaxOffset9Backward) {
8840 TestBeqzA0Backward("BeqA0ZeroMaxOffset9Backward",
8841 MaxOffset9BackwardDistance(),
8842 GetPrintCBcond(),
8843 "1");
8844 }
8845
TEST_F(AssemblerRISCV64Test,BeqA0ZeroMaxOffset9BackwardBare)8846 TEST_F(AssemblerRISCV64Test, BeqA0ZeroMaxOffset9BackwardBare) {
8847 TestBeqzA0Backward("BeqA0ZeroMaxOffset9BackwardBare",
8848 MaxOffset9BackwardDistance(),
8849 GetPrintCBcond(),
8850 "1",
8851 /*is_bare=*/ true);
8852 }
8853
TEST_F(AssemblerRISCV64Test,BneA0ZeroMaxOffset9Backward)8854 TEST_F(AssemblerRISCV64Test, BneA0ZeroMaxOffset9Backward) {
8855 TestBnezA0Backward("BneA0ZeroMaxOffset9Backward",
8856 MaxOffset9BackwardDistance(),
8857 GetPrintCBcond(),
8858 "1");
8859 }
8860
TEST_F(AssemblerRISCV64Test,BneA0ZeroMaxOffset9BackwardBare)8861 TEST_F(AssemblerRISCV64Test, BneA0ZeroMaxOffset9BackwardBare) {
8862 TestBnezA0Backward("BneA0ZeroMaxOffset9BackwardBare",
8863 MaxOffset9BackwardDistance(),
8864 GetPrintCBcond(),
8865 "1",
8866 /*is_bare=*/ true);
8867 }
8868
TEST_F(AssemblerRISCV64Test,BeqA0ZeroOverMaxOffset9Forward)8869 TEST_F(AssemblerRISCV64Test, BeqA0ZeroOverMaxOffset9Forward) {
8870 TestBeqzA0Forward("BeqA0ZeroOverMaxOffset9Forward",
8871 MaxOffset9ForwardDistance() - /*C.BEQZ*/ 2u + /*Exceed max*/ 2u,
8872 GetPrintBcond(),
8873 "1");
8874 }
8875
TEST_F(AssemblerRISCV64Test,BneA0ZeroOverMaxOffset9Forward)8876 TEST_F(AssemblerRISCV64Test, BneA0ZeroOverMaxOffset9Forward) {
8877 TestBnezA0Forward("BneA0ZeroOverMaxOffset9Forward",
8878 MaxOffset9ForwardDistance() - /*C.BNEZ*/ 2u + /*Exceed max*/ 2u,
8879 GetPrintBcond(),
8880 "1");
8881 }
8882
TEST_F(AssemblerRISCV64Test,BeqA0ZeroOverMaxOffset9Backward)8883 TEST_F(AssemblerRISCV64Test, BeqA0ZeroOverMaxOffset9Backward) {
8884 TestBeqzA0Backward("BeqA0ZeroOverMaxOffset9Backward",
8885 MaxOffset9BackwardDistance() + /*Exceed max*/ 2u,
8886 GetPrintBcond(),
8887 "1");
8888 }
8889
TEST_F(AssemblerRISCV64Test,BneA0ZeroOverMaxOffset9Backward)8890 TEST_F(AssemblerRISCV64Test, BneA0ZeroOverMaxOffset9Backward) {
8891 TestBnezA0Backward("BneA0ZeroOverMaxOffset9Backward",
8892 MaxOffset9BackwardDistance() + /*Exceed max*/ 2u,
8893 GetPrintBcond(),
8894 "1");
8895 }
8896
TEST_F(AssemblerRISCV64Test,BeqA0ZeroMaxOffset13Forward)8897 TEST_F(AssemblerRISCV64Test, BeqA0ZeroMaxOffset13Forward) {
8898 TestBeqzA0Forward("BeqA0ZeroMaxOffset13Forward",
8899 MaxOffset13ForwardDistance() - /*C.BEQZ*/ 2u,
8900 GetPrintBcond(),
8901 "1");
8902 }
8903
TEST_F(AssemblerRISCV64Test,BeqA0ZeroMaxOffset13Forward_WithoutC)8904 TEST_F(AssemblerRISCV64Test, BeqA0ZeroMaxOffset13Forward_WithoutC) {
8905 ScopedCSuppression scs(this);
8906 TestBeqzA0Forward("BeqA0ZeroMaxOffset13Forward_WithoutC",
8907 MaxOffset13ForwardDistance_WithoutC() - /*BEQ*/ 4u,
8908 GetPrintBcond(),
8909 "1");
8910 }
8911
TEST_F(AssemblerRISCV64Test,BeqA0ZeroMaxOffset13ForwardBare_WithoutC)8912 TEST_F(AssemblerRISCV64Test, BeqA0ZeroMaxOffset13ForwardBare_WithoutC) {
8913 ScopedCSuppression scs(this);
8914 TestBeqzA0Forward("BeqA0ZeroMaxOffset13ForwardBare_WithoutC",
8915 MaxOffset13ForwardDistance_WithoutC() - /*BEQ*/ 4u,
8916 GetPrintBcond(),
8917 "1",
8918 /*is_bare=*/ true);
8919 }
8920
TEST_F(AssemblerRISCV64Test,BneA0ZeroMaxOffset13Forward)8921 TEST_F(AssemblerRISCV64Test, BneA0ZeroMaxOffset13Forward) {
8922 TestBnezA0Forward("BneA0ZeroMaxOffset13Forward",
8923 MaxOffset13ForwardDistance() - /*C.BNEZ*/ 2u,
8924 GetPrintBcond(),
8925 "1");
8926 }
8927
TEST_F(AssemblerRISCV64Test,BneA0ZeroMaxOffset13Forward_WithoutC)8928 TEST_F(AssemblerRISCV64Test, BneA0ZeroMaxOffset13Forward_WithoutC) {
8929 ScopedCSuppression scs(this);
8930 TestBnezA0Forward("BneA0ZeroMaxOffset13Forward_WithoutC",
8931 MaxOffset13ForwardDistance_WithoutC() - /*BNE*/ 4u,
8932 GetPrintBcond(),
8933 "1");
8934 }
8935
TEST_F(AssemblerRISCV64Test,BneA0ZeroMaxOffset13ForwardBare_WithoutC)8936 TEST_F(AssemblerRISCV64Test, BneA0ZeroMaxOffset13ForwardBare_WithoutC) {
8937 ScopedCSuppression scs(this);
8938 TestBnezA0Forward("BneA0ZeroMaxOffset13ForwardBare_WithoutC",
8939 MaxOffset13ForwardDistance_WithoutC() - /*BNE*/ 4u,
8940 GetPrintBcond(),
8941 "1",
8942 /*is_bare=*/ true);
8943 }
8944
TEST_F(AssemblerRISCV64Test,BeqA0A1MaxOffset13Forward)8945 TEST_F(AssemblerRISCV64Test, BeqA0A1MaxOffset13Forward) {
8946 TestBeqA0A1Forward("BeqA0A1MaxOffset13Forward",
8947 MaxOffset13ForwardDistance() - /*BEQ*/ 4u,
8948 GetPrintBcond(),
8949 "1");
8950 }
8951
TEST_F(AssemblerRISCV64Test,BeqA0A1MaxOffset13Forward_WithoutC)8952 TEST_F(AssemblerRISCV64Test, BeqA0A1MaxOffset13Forward_WithoutC) {
8953 ScopedCSuppression scs(this);
8954 TestBeqA0A1Forward("BeqA0A1MaxOffset13Forward_WithoutC",
8955 MaxOffset13ForwardDistance_WithoutC() - /*BEQ*/ 4u,
8956 GetPrintBcond(),
8957 "1");
8958 }
8959
TEST_F(AssemblerRISCV64Test,BeqA0A1MaxOffset13ForwardBare)8960 TEST_F(AssemblerRISCV64Test, BeqA0A1MaxOffset13ForwardBare) {
8961 TestBeqA0A1Forward("BeqA0A1MaxOffset13ForwardBare",
8962 MaxOffset13ForwardDistance() - /*BEQ*/ 4u,
8963 GetPrintBcond(),
8964 "1",
8965 /*is_bare=*/true);
8966 }
8967
TEST_F(AssemblerRISCV64Test,BeqA0A1MaxOffset13ForwardBare_WithoutC)8968 TEST_F(AssemblerRISCV64Test, BeqA0A1MaxOffset13ForwardBare_WithoutC) {
8969 ScopedCSuppression scs(this);
8970 TestBeqA0A1Forward("BeqA0A1MaxOffset13ForwardBare_WithoutC",
8971 MaxOffset13ForwardDistance_WithoutC() - /*BEQ*/ 4u,
8972 GetPrintBcond(),
8973 "1",
8974 /*is_bare=*/true);
8975 }
8976
TEST_F(AssemblerRISCV64Test,BeqA0ZeroMaxOffset13Backward)8977 TEST_F(AssemblerRISCV64Test, BeqA0ZeroMaxOffset13Backward) {
8978 TestBeqzA0Backward("BeqA0ZeroMaxOffset13Backward",
8979 MaxOffset13BackwardDistance(),
8980 GetPrintBcond(),
8981 "1");
8982 }
8983
TEST_F(AssemblerRISCV64Test,BeqA0ZeroMaxOffset13Backward_WithoutC)8984 TEST_F(AssemblerRISCV64Test, BeqA0ZeroMaxOffset13Backward_WithoutC) {
8985 ScopedCSuppression scs(this);
8986 TestBeqzA0Backward("BeqA0ZeroMaxOffset13Backward_WithoutC",
8987 MaxOffset13BackwardDistance_WithoutC(),
8988 GetPrintBcond(),
8989 "1");
8990 }
8991
TEST_F(AssemblerRISCV64Test,BeqA0ZeroMaxOffset13BackwardBare_WithoutC)8992 TEST_F(AssemblerRISCV64Test, BeqA0ZeroMaxOffset13BackwardBare_WithoutC) {
8993 ScopedCSuppression scs(this);
8994 TestBeqzA0Backward("BeqA0ZeroMaxOffset13BackwardBare_WithoutC",
8995 MaxOffset13BackwardDistance_WithoutC(),
8996 GetPrintBcond(),
8997 "1",
8998 /*is_bare=*/ true);
8999 }
9000
TEST_F(AssemblerRISCV64Test,BneA0ZeroMaxOffset13Backward)9001 TEST_F(AssemblerRISCV64Test, BneA0ZeroMaxOffset13Backward) {
9002 TestBnezA0Backward("BneA0ZeroMaxOffset13Backward",
9003 MaxOffset13BackwardDistance(),
9004 GetPrintBcond(),
9005 "1");
9006 }
9007
TEST_F(AssemblerRISCV64Test,BneA0ZeroMaxOffset13Backward_WithoutC)9008 TEST_F(AssemblerRISCV64Test, BneA0ZeroMaxOffset13Backward_WithoutC) {
9009 ScopedCSuppression scs(this);
9010 TestBnezA0Backward("BneA0ZeroMaxOffset13Backward_WithoutC",
9011 MaxOffset13BackwardDistance_WithoutC(),
9012 GetPrintBcond(),
9013 "1");
9014 }
9015
TEST_F(AssemblerRISCV64Test,BneA0ZeroMaxOffset13BackwardBare_WithoutC)9016 TEST_F(AssemblerRISCV64Test, BneA0ZeroMaxOffset13BackwardBare_WithoutC) {
9017 ScopedCSuppression scs(this);
9018 TestBnezA0Backward("BneA0ZeroMaxOffset13BackwardBare_WithoutC",
9019 MaxOffset13BackwardDistance_WithoutC(),
9020 GetPrintBcond(),
9021 "1",
9022 /*is_bare=*/ true);
9023 }
9024
TEST_F(AssemblerRISCV64Test,BeqA0A1MaxOffset13Backward)9025 TEST_F(AssemblerRISCV64Test, BeqA0A1MaxOffset13Backward) {
9026 TestBeqA0A1Backward("BeqA0A1MaxOffset13Backward",
9027 MaxOffset13BackwardDistance(),
9028 GetPrintBcond(),
9029 "1");
9030 }
9031
TEST_F(AssemblerRISCV64Test,BeqA0A1MaxOffset13Backward_WithoutC)9032 TEST_F(AssemblerRISCV64Test, BeqA0A1MaxOffset13Backward_WithoutC) {
9033 ScopedCSuppression scs(this);
9034 TestBeqA0A1Backward("BeqA0A1MaxOffset13Backward_WithoutC",
9035 MaxOffset13BackwardDistance_WithoutC(),
9036 GetPrintBcond(),
9037 "1");
9038 }
9039
TEST_F(AssemblerRISCV64Test,BeqA0A1MaxOffset13BackwardBare)9040 TEST_F(AssemblerRISCV64Test, BeqA0A1MaxOffset13BackwardBare) {
9041 TestBeqA0A1Backward("BeqA0A1MaxOffset13BackwardBare",
9042 MaxOffset13BackwardDistance(),
9043 GetPrintBcond(),
9044 "1",
9045 /*is_bare=*/true);
9046 }
9047
TEST_F(AssemblerRISCV64Test,BeqA0A1MaxOffset13BackwardBare_WithoutC)9048 TEST_F(AssemblerRISCV64Test, BeqA0A1MaxOffset13BackwardBare_WithoutC) {
9049 ScopedCSuppression scs(this);
9050 TestBeqA0A1Backward("BeqA0A1MaxOffset13BackwardBare_WithoutC",
9051 MaxOffset13BackwardDistance_WithoutC(),
9052 GetPrintBcond(),
9053 "1",
9054 /*is_bare=*/true);
9055 }
9056
TEST_F(AssemblerRISCV64Test,BeqA0ZeroOverMaxOffset13Forward)9057 TEST_F(AssemblerRISCV64Test, BeqA0ZeroOverMaxOffset13Forward) {
9058 TestBeqzA0Forward("BeqA0ZeroOverMaxOffset13Forward",
9059 MaxOffset13ForwardDistance() - /*BEQ*/ 4u + /*Exceed max*/ 2u,
9060 GetPrintCBcondOppositeAndJ("2"),
9061 "1");
9062 }
9063
TEST_F(AssemblerRISCV64Test,BeqA0ZeroOverMaxOffset13Forward_WithoutC)9064 TEST_F(AssemblerRISCV64Test, BeqA0ZeroOverMaxOffset13Forward_WithoutC) {
9065 ScopedCSuppression scs(this);
9066 TestBeqzA0Forward("BeqA0ZeroOverMaxOffset13Forward_WithoutC",
9067 MaxOffset13ForwardDistance_WithoutC() - /*BEQ*/ 4u + /*Exceed max*/ 4u,
9068 GetPrintBcondOppositeAndJ("2"),
9069 "1");
9070 }
9071
TEST_F(AssemblerRISCV64Test,BneA0ZeroOverMaxOffset13Forward)9072 TEST_F(AssemblerRISCV64Test, BneA0ZeroOverMaxOffset13Forward) {
9073 TestBnezA0Forward("BneA0ZeroOverMaxOffset13Forward",
9074 MaxOffset13ForwardDistance() - /*BNE*/ 4u + /*Exceed max*/ 2u,
9075 GetPrintCBcondOppositeAndJ("2"),
9076 "1");
9077 }
9078
TEST_F(AssemblerRISCV64Test,BneA0ZeroOverMaxOffset13Forward_WithoutC)9079 TEST_F(AssemblerRISCV64Test, BneA0ZeroOverMaxOffset13Forward_WithoutC) {
9080 ScopedCSuppression scs(this);
9081 TestBnezA0Forward("BneA0ZeroOverMaxOffset13Forward_WithoutC",
9082 MaxOffset13ForwardDistance_WithoutC() - /*BNE*/ 4u + /*Exceed max*/ 4u,
9083 GetPrintBcondOppositeAndJ("2"),
9084 "1");
9085 }
9086
TEST_F(AssemblerRISCV64Test,BeqA0A1OverMaxOffset13Forward)9087 TEST_F(AssemblerRISCV64Test, BeqA0A1OverMaxOffset13Forward) {
9088 TestBeqA0A1Forward("BeqA0A1OverMaxOffset13Forward",
9089 MaxOffset13ForwardDistance() - /*BEQ*/ 4u + /*Exceed max*/ 2u,
9090 GetPrintBcondOppositeAndJ("2"),
9091 "1");
9092 }
9093
TEST_F(AssemblerRISCV64Test,BeqA0A1OverMaxOffset13Forward_WithoutC)9094 TEST_F(AssemblerRISCV64Test, BeqA0A1OverMaxOffset13Forward_WithoutC) {
9095 ScopedCSuppression scs(this);
9096 TestBeqA0A1Forward("BeqA0A1OverMaxOffset13Forward_WithoutC",
9097 MaxOffset13ForwardDistance_WithoutC() - /*BEQ*/ 4u + /*Exceed max*/ 4u,
9098 GetPrintBcondOppositeAndJ("2"),
9099 "1");
9100 }
9101
TEST_F(AssemblerRISCV64Test,BeqA0ZeroOverMaxOffset13Backward)9102 TEST_F(AssemblerRISCV64Test, BeqA0ZeroOverMaxOffset13Backward) {
9103 TestBeqzA0Backward("BeqA0ZeroOverMaxOffset13Backward",
9104 MaxOffset13BackwardDistance() + /*Exceed max*/ 2u,
9105 GetPrintCBcondOppositeAndJ("2"),
9106 "1");
9107 }
9108
TEST_F(AssemblerRISCV64Test,BeqA0ZeroOverMaxOffset13Backward_WithoutC)9109 TEST_F(AssemblerRISCV64Test, BeqA0ZeroOverMaxOffset13Backward_WithoutC) {
9110 ScopedCSuppression scs(this);
9111 TestBeqzA0Backward("BeqA0ZeroOverMaxOffset13Backward_WithoutC",
9112 MaxOffset13BackwardDistance_WithoutC() + /*Exceed max*/ 4u,
9113 GetPrintBcondOppositeAndJ("2"),
9114 "1");
9115 }
9116
TEST_F(AssemblerRISCV64Test,BneA0ZeroOverMaxOffset13Backward)9117 TEST_F(AssemblerRISCV64Test, BneA0ZeroOverMaxOffset13Backward) {
9118 TestBnezA0Backward("BneA0ZeroOverMaxOffset13Backward",
9119 MaxOffset13BackwardDistance() + /*Exceed max*/ 2u,
9120 GetPrintCBcondOppositeAndJ("2"),
9121 "1");
9122 }
9123
TEST_F(AssemblerRISCV64Test,BneA0ZeroOverMaxOffset13Backward_WithoutC)9124 TEST_F(AssemblerRISCV64Test, BneA0ZeroOverMaxOffset13Backward_WithoutC) {
9125 ScopedCSuppression scs(this);
9126 TestBnezA0Backward("BneA0ZeroOverMaxOffset13Backward_WithoutC",
9127 MaxOffset13BackwardDistance_WithoutC() + /*Exceed max*/ 4u,
9128 GetPrintBcondOppositeAndJ("2"),
9129 "1");
9130 }
9131
TEST_F(AssemblerRISCV64Test,BeqA0A1OverMaxOffset13Backward)9132 TEST_F(AssemblerRISCV64Test, BeqA0A1OverMaxOffset13Backward) {
9133 TestBeqA0A1Backward("BeqA0A1OverMaxOffset13Backward",
9134 MaxOffset13BackwardDistance() + /*Exceed max*/ 2u,
9135 GetPrintBcondOppositeAndJ("2"),
9136 "1");
9137 }
9138
TEST_F(AssemblerRISCV64Test,BeqA0A1OverMaxOffset13Backward_WithoutC)9139 TEST_F(AssemblerRISCV64Test, BeqA0A1OverMaxOffset13Backward_WithoutC) {
9140 ScopedCSuppression scs(this);
9141 TestBeqA0A1Backward("BeqA0A1OverMaxOffset13Backward_WithoutC",
9142 MaxOffset13BackwardDistance_WithoutC() + /*Exceed max*/ 4u,
9143 GetPrintBcondOppositeAndJ("2"),
9144 "1");
9145 }
9146
TEST_F(AssemblerRISCV64Test,BeqA0ZeroMaxOffset21Forward)9147 TEST_F(AssemblerRISCV64Test, BeqA0ZeroMaxOffset21Forward) {
9148 TestBeqzA0Forward("BeqA0ZeroMaxOffset21Forward",
9149 MaxOffset21ForwardDistance() - /*J*/ 4u,
9150 GetPrintCBcondOppositeAndJ("2"),
9151 "1");
9152 }
9153
TEST_F(AssemblerRISCV64Test,BeqA0ZeroMaxOffset21Forward_WithoutC)9154 TEST_F(AssemblerRISCV64Test, BeqA0ZeroMaxOffset21Forward_WithoutC) {
9155 ScopedCSuppression scs(this);
9156 TestBeqzA0Forward("BeqA0ZeroMaxOffset21Forward_WithoutC",
9157 MaxOffset21ForwardDistance_WithoutC() - /*J*/ 4u,
9158 GetPrintBcondOppositeAndJ("2"),
9159 "1");
9160 }
9161
TEST_F(AssemblerRISCV64Test,BneA0ZeroMaxOffset21Forward)9162 TEST_F(AssemblerRISCV64Test, BneA0ZeroMaxOffset21Forward) {
9163 TestBnezA0Forward("BneA0ZeroMaxOffset21Forward",
9164 MaxOffset21ForwardDistance() - /*J*/ 4u,
9165 GetPrintCBcondOppositeAndJ("2"),
9166 "1");
9167 }
9168
TEST_F(AssemblerRISCV64Test,BneA0ZeroMaxOffset21Forward_WithoutC)9169 TEST_F(AssemblerRISCV64Test, BneA0ZeroMaxOffset21Forward_WithoutC) {
9170 ScopedCSuppression scs(this);
9171 TestBnezA0Forward("BneA0ZeroMaxOffset21Forward_WithoutC",
9172 MaxOffset21ForwardDistance_WithoutC() - /*J*/ 4u,
9173 GetPrintBcondOppositeAndJ("2"),
9174 "1");
9175 }
9176
TEST_F(AssemblerRISCV64Test,BeqA0A1MaxOffset21Forward)9177 TEST_F(AssemblerRISCV64Test, BeqA0A1MaxOffset21Forward) {
9178 TestBeqA0A1Forward("BeqA0A1MaxOffset21Forward",
9179 MaxOffset21ForwardDistance() - /*J*/ 4u,
9180 GetPrintBcondOppositeAndJ("2"),
9181 "1");
9182 }
9183
TEST_F(AssemblerRISCV64Test,BeqA0A1MaxOffset21Forward_WithoutC)9184 TEST_F(AssemblerRISCV64Test, BeqA0A1MaxOffset21Forward_WithoutC) {
9185 ScopedCSuppression scs(this);
9186 TestBeqA0A1Forward("BeqA0A1MaxOffset21Forward_WithoutC",
9187 MaxOffset21ForwardDistance_WithoutC() - /*J*/ 4u,
9188 GetPrintBcondOppositeAndJ("2"),
9189 "1");
9190 }
9191
TEST_F(AssemblerRISCV64Test,BeqA0ZeroMaxOffset21Backward)9192 TEST_F(AssemblerRISCV64Test, BeqA0ZeroMaxOffset21Backward) {
9193 TestBeqzA0Backward("BeqA0ZeroMaxOffset21Backward",
9194 MaxOffset21BackwardDistance() - /*C.BNEZ*/ 2u,
9195 GetPrintCBcondOppositeAndJ("2"),
9196 "1");
9197 }
9198
TEST_F(AssemblerRISCV64Test,BeqA0ZeroMaxOffset21Backward_WithoutC)9199 TEST_F(AssemblerRISCV64Test, BeqA0ZeroMaxOffset21Backward_WithoutC) {
9200 ScopedCSuppression scs(this);
9201 TestBeqzA0Backward("BeqA0ZeroMaxOffset21Backward_WithoutC",
9202 MaxOffset21BackwardDistance_WithoutC() - /*BNE*/ 4u,
9203 GetPrintBcondOppositeAndJ("2"),
9204 "1");
9205 }
9206
TEST_F(AssemblerRISCV64Test,BneA0ZeroMaxOffset21Backward)9207 TEST_F(AssemblerRISCV64Test, BneA0ZeroMaxOffset21Backward) {
9208 TestBnezA0Backward("BneA0ZeroMaxOffset21Backward",
9209 MaxOffset21BackwardDistance() - /*C.BEQZ*/ 2u,
9210 GetPrintCBcondOppositeAndJ("2"),
9211 "1");
9212 }
9213
TEST_F(AssemblerRISCV64Test,BneA0ZeroMaxOffset21Backward_WithoutC)9214 TEST_F(AssemblerRISCV64Test, BneA0ZeroMaxOffset21Backward_WithoutC) {
9215 ScopedCSuppression scs(this);
9216 TestBnezA0Backward("BneA0ZeroMaxOffset21Backward_WithoutC",
9217 MaxOffset21BackwardDistance_WithoutC() - /*BEQ*/ 4u,
9218 GetPrintBcondOppositeAndJ("2"),
9219 "1");
9220 }
9221
TEST_F(AssemblerRISCV64Test,BeqA0A1MaxOffset21Backward)9222 TEST_F(AssemblerRISCV64Test, BeqA0A1MaxOffset21Backward) {
9223 TestBeqA0A1Backward("BeqA0A1MaxOffset21Backward",
9224 MaxOffset21BackwardDistance() - /*BNE*/ 4u,
9225 GetPrintBcondOppositeAndJ("2"),
9226 "1");
9227 }
9228
TEST_F(AssemblerRISCV64Test,BeqA0A1MaxOffset21Backward_WithoutC)9229 TEST_F(AssemblerRISCV64Test, BeqA0A1MaxOffset21Backward_WithoutC) {
9230 ScopedCSuppression scs(this);
9231 TestBeqA0A1Backward("BeqA0A1MaxOffset21Backward_WithoutC",
9232 MaxOffset21BackwardDistance_WithoutC() - /*BNE*/ 4u,
9233 GetPrintBcondOppositeAndJ("2"),
9234 "1");
9235 }
9236
TEST_F(AssemblerRISCV64Test,BeqA0ZeroOverMaxOffset21Forward)9237 TEST_F(AssemblerRISCV64Test, BeqA0ZeroOverMaxOffset21Forward) {
9238 TestBeqzA0Forward("BeqA0ZeroOverMaxOffset21Forward",
9239 MaxOffset21ForwardDistance() - /*J*/ 4u + /*Exceed max*/ 2u,
9240 GetPrintBcondOppositeAndTail("2", "3"),
9241 "1");
9242 }
9243
TEST_F(AssemblerRISCV64Test,BeqA0ZeroOverMaxOffset21Forward_WithoutC)9244 TEST_F(AssemblerRISCV64Test, BeqA0ZeroOverMaxOffset21Forward_WithoutC) {
9245 ScopedCSuppression scs(this);
9246 TestBeqzA0Forward("BeqA0ZeroOverMaxOffset21Forward_WithoutC",
9247 MaxOffset21ForwardDistance_WithoutC() - /*J*/ 4u + /*Exceed max*/ 4u,
9248 GetPrintBcondOppositeAndTail("2", "3"),
9249 "1");
9250 }
9251
TEST_F(AssemblerRISCV64Test,BneA0ZeroOverMaxOffset21Forward)9252 TEST_F(AssemblerRISCV64Test, BneA0ZeroOverMaxOffset21Forward) {
9253 TestBnezA0Forward("BneA0ZeroOverMaxOffset21Forward",
9254 MaxOffset21ForwardDistance() - /*J*/ 4u + /*Exceed max*/ 2u,
9255 GetPrintBcondOppositeAndTail("2", "3"),
9256 "1");
9257 }
9258
TEST_F(AssemblerRISCV64Test,BneA0ZeroOverMaxOffset21Forward_WithoutC)9259 TEST_F(AssemblerRISCV64Test, BneA0ZeroOverMaxOffset21Forward_WithoutC) {
9260 ScopedCSuppression scs(this);
9261 TestBnezA0Forward("BneA0ZeroOverMaxOffset21Forward_WithoutC",
9262 MaxOffset21ForwardDistance_WithoutC() - /*J*/ 4u + /*Exceed max*/ 4u,
9263 GetPrintBcondOppositeAndTail("2", "3"),
9264 "1");
9265 }
9266
TEST_F(AssemblerRISCV64Test,BeqA0A1OverMaxOffset21Forward)9267 TEST_F(AssemblerRISCV64Test, BeqA0A1OverMaxOffset21Forward) {
9268 TestBeqA0A1Forward("BeqA0A1OverMaxOffset21Forward",
9269 MaxOffset21ForwardDistance() - /*J*/ 4u + /*Exceed max*/ 2u,
9270 GetPrintBcondOppositeAndTail("2", "3"),
9271 "1");
9272 }
9273
TEST_F(AssemblerRISCV64Test,BeqA0A1OverMaxOffset21Forward_WithoutC)9274 TEST_F(AssemblerRISCV64Test, BeqA0A1OverMaxOffset21Forward_WithoutC) {
9275 ScopedCSuppression scs(this);
9276 TestBeqA0A1Forward("BeqA0A1OverMaxOffset21Forward_WithoutC",
9277 MaxOffset21ForwardDistance_WithoutC() - /*J*/ 4u + /*Exceed max*/ 4u,
9278 GetPrintBcondOppositeAndTail("2", "3"),
9279 "1");
9280 }
9281
TEST_F(AssemblerRISCV64Test,BeqA0ZeroOverMaxOffset21Backward)9282 TEST_F(AssemblerRISCV64Test, BeqA0ZeroOverMaxOffset21Backward) {
9283 TestBeqzA0Backward("BeqA0ZeroOverMaxOffset21Backward",
9284 MaxOffset21BackwardDistance() - /*C.BNEZ*/ 2u + /*Exceed max*/ 2u,
9285 GetPrintBcondOppositeAndTail("2", "3"),
9286 "1");
9287 }
9288
TEST_F(AssemblerRISCV64Test,BeqA0ZeroOverMaxOffset21Backward_WithoutC)9289 TEST_F(AssemblerRISCV64Test, BeqA0ZeroOverMaxOffset21Backward_WithoutC) {
9290 ScopedCSuppression scs(this);
9291 TestBeqzA0Backward("BeqA0ZeroOverMaxOffset21Backward_WithoutC",
9292 MaxOffset21BackwardDistance_WithoutC() - /*BNE*/ 4u + /*Exceed max*/ 4u,
9293 GetPrintBcondOppositeAndTail("2", "3"),
9294 "1");
9295 }
9296
TEST_F(AssemblerRISCV64Test,BneA0ZeroOverMaxOffset21Backward)9297 TEST_F(AssemblerRISCV64Test, BneA0ZeroOverMaxOffset21Backward) {
9298 TestBnezA0Backward("BneA0ZeroOverMaxOffset21Backward",
9299 MaxOffset21BackwardDistance() - /*C.BEQZ*/ 2u + /*Exceed max*/ 2u,
9300 GetPrintBcondOppositeAndTail("2", "3"),
9301 "1");
9302 }
9303
TEST_F(AssemblerRISCV64Test,BneA0ZeroOverMaxOffset21Backward_WithoutC)9304 TEST_F(AssemblerRISCV64Test, BneA0ZeroOverMaxOffset21Backward_WithoutC) {
9305 ScopedCSuppression scs(this);
9306 TestBnezA0Backward("BneA0ZeroOverMaxOffset21Backward_WithoutC",
9307 MaxOffset21BackwardDistance_WithoutC() - /*BEQ*/ 4u + /*Exceed max*/ 4u,
9308 GetPrintBcondOppositeAndTail("2", "3"),
9309 "1");
9310 }
9311
TEST_F(AssemblerRISCV64Test,BeqA0A1OverMaxOffset21Backward)9312 TEST_F(AssemblerRISCV64Test, BeqA0A1OverMaxOffset21Backward) {
9313 TestBeqA0A1Backward("BeqA0A1OverMaxOffset21Backward",
9314 MaxOffset21BackwardDistance() - /*BNE*/ 4u + /*Exceed max*/ 2u,
9315 GetPrintBcondOppositeAndTail("2", "3"),
9316 "1");
9317 }
9318
TEST_F(AssemblerRISCV64Test,BeqA0A1OverMaxOffset21Backward_WithoutC)9319 TEST_F(AssemblerRISCV64Test, BeqA0A1OverMaxOffset21Backward_WithoutC) {
9320 ScopedCSuppression scs(this);
9321 TestBeqA0A1Backward("BeqA0A1OverMaxOffset21Backward_WithoutC",
9322 MaxOffset21BackwardDistance_WithoutC() - /*BNE*/ 4u + /*Exceed max*/ 4u,
9323 GetPrintBcondOppositeAndTail("2", "3"),
9324 "1");
9325 }
9326
TEST_F(AssemblerRISCV64Test,BeqA0A1AlmostCascade)9327 TEST_F(AssemblerRISCV64Test, BeqA0A1AlmostCascade) {
9328 TestBeqA0A1MaybeCascade("BeqA0A1AlmostCascade", /*cascade=*/false, GetPrintBcond());
9329 }
9330
TEST_F(AssemblerRISCV64Test,BeqA0A1AlmostCascade_WithoutC)9331 TEST_F(AssemblerRISCV64Test, BeqA0A1AlmostCascade_WithoutC) {
9332 ScopedCSuppression scs(this);
9333 TestBeqA0A1MaybeCascade("BeqA0A1AlmostCascade_WithoutC", /*cascade=*/false, GetPrintBcond());
9334 }
9335
TEST_F(AssemblerRISCV64Test,BeqA0A1Cascade)9336 TEST_F(AssemblerRISCV64Test, BeqA0A1Cascade) {
9337 TestBeqA0A1MaybeCascade("BeqA0A1Cascade", /*cascade=*/true, GetPrintBcondOppositeAndJ("1"));
9338 }
9339
TEST_F(AssemblerRISCV64Test,BeqA0A1Cascade_WithoutC)9340 TEST_F(AssemblerRISCV64Test, BeqA0A1Cascade_WithoutC) {
9341 ScopedCSuppression scs(this);
9342 TestBeqA0A1MaybeCascade(
9343 "BeqA0A1Cascade_WithoutC", /*cascade=*/true, GetPrintBcondOppositeAndJ("1"));
9344 }
9345
TEST_F(AssemblerRISCV64Test,BcondElimination)9346 TEST_F(AssemblerRISCV64Test, BcondElimination) {
9347 TestBcondElimination("BcondElimination", "c.nop");
9348 }
9349
TEST_F(AssemblerRISCV64Test,BcondElimination_WithoutC)9350 TEST_F(AssemblerRISCV64Test, BcondElimination_WithoutC) {
9351 ScopedCSuppression scs(this);
9352 TestBcondElimination("BcondElimination_WithoutC", "nop");
9353 }
9354
TEST_F(AssemblerRISCV64Test,BcondUnconditional)9355 TEST_F(AssemblerRISCV64Test, BcondUnconditional) {
9356 TestBcondUnconditional("BcondUnconditional", "c.j");
9357 }
9358
TEST_F(AssemblerRISCV64Test,BcondUnconditional_WithoutC)9359 TEST_F(AssemblerRISCV64Test, BcondUnconditional_WithoutC) {
9360 ScopedCSuppression scs(this);
9361 TestBcondUnconditional("BcondUnconditional_WithoutC", "j");
9362 }
9363
TEST_F(AssemblerRISCV64Test,JalRdForward1KiB)9364 TEST_F(AssemblerRISCV64Test, JalRdForward1KiB) {
9365 TestJalRdForward("JalRdForward1KiB", 1 * KB, "1", GetPrintJalRd());
9366 }
9367
TEST_F(AssemblerRISCV64Test,JalRdForward1KiB_WithoutC)9368 TEST_F(AssemblerRISCV64Test, JalRdForward1KiB_WithoutC) {
9369 ScopedCSuppression scs(this);
9370 TestJalRdForward("JalRdForward1KiB_WithoutC", 1 * KB, "1", GetPrintJalRd());
9371 }
9372
TEST_F(AssemblerRISCV64Test,JalRdForward1KiBBare)9373 TEST_F(AssemblerRISCV64Test, JalRdForward1KiBBare) {
9374 TestJalRdForward("JalRdForward1KiBBare", 1 * KB, "1", GetPrintJalRd(), /*is_bare=*/true);
9375 }
9376
TEST_F(AssemblerRISCV64Test,JalRdForward1KiBBare_WithoutC)9377 TEST_F(AssemblerRISCV64Test, JalRdForward1KiBBare_WithoutC) {
9378 ScopedCSuppression scs(this);
9379 TestJalRdForward("JalRdForward1KiBBare_WithoutC", 1 * KB, "1", GetPrintJalRd(), /*is_bare=*/true);
9380 }
9381
TEST_F(AssemblerRISCV64Test,JalRdBackward1KiB)9382 TEST_F(AssemblerRISCV64Test, JalRdBackward1KiB) {
9383 TestJalRdBackward("JalRdBackward1KiB", 1 * KB, "1", GetPrintJalRd());
9384 }
9385
TEST_F(AssemblerRISCV64Test,JalRdBackward1KiB_WithoutC)9386 TEST_F(AssemblerRISCV64Test, JalRdBackward1KiB_WithoutC) {
9387 ScopedCSuppression scs(this);
9388 TestJalRdBackward("JalRdBackward1KiB_WithoutC", 1 * KB, "1", GetPrintJalRd());
9389 }
9390
TEST_F(AssemblerRISCV64Test,JalRdBackward1KiBBare)9391 TEST_F(AssemblerRISCV64Test, JalRdBackward1KiBBare) {
9392 TestJalRdBackward("JalRdBackward1KiBBare", 1 * KB, "1", GetPrintJalRd(), /*is_bare=*/true);
9393 }
9394
TEST_F(AssemblerRISCV64Test,JalRdBackward1KiBBare_WithoutC)9395 TEST_F(AssemblerRISCV64Test, JalRdBackward1KiBBare_WithoutC) {
9396 ScopedCSuppression scs(this);
9397 TestJalRdBackward(
9398 "JalRdBackward1KiBBare_WithoutC", 1 * KB, "1", GetPrintJalRd(), /*is_bare=*/true);
9399 }
9400
TEST_F(AssemblerRISCV64Test,JalRdForward3KiB)9401 TEST_F(AssemblerRISCV64Test, JalRdForward3KiB) {
9402 TestJalRdForward("JalRdForward3KiB", 3 * KB, "1", GetPrintJalRd());
9403 }
9404
TEST_F(AssemblerRISCV64Test,JalRdForward3KiB_WithoutC)9405 TEST_F(AssemblerRISCV64Test, JalRdForward3KiB_WithoutC) {
9406 ScopedCSuppression scs(this);
9407 TestJalRdForward("JalRdForward3KiB_WithoutC", 3 * KB, "1", GetPrintJalRd());
9408 }
9409
TEST_F(AssemblerRISCV64Test,JalRdForward3KiBBare_WithoutC)9410 TEST_F(AssemblerRISCV64Test, JalRdForward3KiBBare_WithoutC) {
9411 ScopedCSuppression scs(this);
9412 TestJalRdForward("JalRdForward3KiBBare_WithoutC", 3 * KB, "1", GetPrintJalRd(), /*is_bare=*/true);
9413 }
9414
TEST_F(AssemblerRISCV64Test,JalRdBackward3KiB)9415 TEST_F(AssemblerRISCV64Test, JalRdBackward3KiB) {
9416 TestJalRdBackward("JalRdBackward3KiB", 3 * KB, "1", GetPrintJalRd());
9417 }
9418
TEST_F(AssemblerRISCV64Test,JalRdBackward3KiB_WithoutC)9419 TEST_F(AssemblerRISCV64Test, JalRdBackward3KiB_WithoutC) {
9420 ScopedCSuppression scs(this);
9421 TestJalRdBackward("JalRdBackward3KiB_WithoutC", 3 * KB, "1", GetPrintJalRd());
9422 }
9423
TEST_F(AssemblerRISCV64Test,JalRdBackward3KiBBare_WithoutC)9424 TEST_F(AssemblerRISCV64Test, JalRdBackward3KiBBare_WithoutC) {
9425 ScopedCSuppression scs(this);
9426 TestJalRdBackward(
9427 "JalRdBackward3KiBBare_WithoutC", 3 * KB, "1", GetPrintJalRd(), /*is_bare=*/true);
9428 }
9429
TEST_F(AssemblerRISCV64Test,JalRdForward2MiB)9430 TEST_F(AssemblerRISCV64Test, JalRdForward2MiB) {
9431 TestJalRdForward("JalRdForward2MiB", 2 * MB, "1", GetPrintCallRd("2"));
9432 }
9433
TEST_F(AssemblerRISCV64Test,JalRdForward2MiB_WithoutC)9434 TEST_F(AssemblerRISCV64Test, JalRdForward2MiB_WithoutC) {
9435 ScopedCSuppression scs(this);
9436 TestJalRdForward("JalRdForward2MiB_WithoutC", 2 * MB, "1", GetPrintCallRd("2"));
9437 }
9438
TEST_F(AssemblerRISCV64Test,JalRdBackward2MiB)9439 TEST_F(AssemblerRISCV64Test, JalRdBackward2MiB) {
9440 TestJalRdBackward("JalRdBackward2MiB", 2 * MB, "1", GetPrintCallRd("2"));
9441 }
9442
TEST_F(AssemblerRISCV64Test,JalRdBackward2MiB_WithoutC)9443 TEST_F(AssemblerRISCV64Test, JalRdBackward2MiB_WithoutC) {
9444 ScopedCSuppression scs(this);
9445 TestJalRdBackward("JalRdBackward2MiB_WithoutC", 2 * MB, "1", GetPrintCallRd("2"));
9446 }
9447
TEST_F(AssemblerRISCV64Test,JForward1KiB)9448 TEST_F(AssemblerRISCV64Test, JForward1KiB) {
9449 TestBuncondForward("JForward1KiB", 1 * KB, "1", GetEmitJ(), GetPrintCJ());
9450 }
9451
TEST_F(AssemblerRISCV64Test,JForward1KiB_WithoutC)9452 TEST_F(AssemblerRISCV64Test, JForward1KiB_WithoutC) {
9453 ScopedCSuppression scs(this);
9454 TestBuncondForward("JForward1KiB_WithoutC", 1 * KB, "1", GetEmitJ(), GetPrintJ());
9455 }
9456
TEST_F(AssemblerRISCV64Test,JForward1KiBBare)9457 TEST_F(AssemblerRISCV64Test, JForward1KiBBare) {
9458 TestBuncondForward("JForward1KiBBare", 1 * KB, "1", GetEmitJ(/*is_bare=*/true), GetPrintCJ());
9459 }
9460
TEST_F(AssemblerRISCV64Test,JForward1KiBBare_WithoutC)9461 TEST_F(AssemblerRISCV64Test, JForward1KiBBare_WithoutC) {
9462 ScopedCSuppression scs(this);
9463 TestBuncondForward(
9464 "JForward1KiBBare_WithoutC", 1 * KB, "1", GetEmitJ(/*is_bare=*/true), GetPrintJ());
9465 }
9466
TEST_F(AssemblerRISCV64Test,JBackward1KiB)9467 TEST_F(AssemblerRISCV64Test, JBackward1KiB) {
9468 TestBuncondBackward("JBackward1KiB", 1 * KB, "1", GetEmitJ(), GetPrintCJ());
9469 }
9470
TEST_F(AssemblerRISCV64Test,JBackward1KiB_WithoutC)9471 TEST_F(AssemblerRISCV64Test, JBackward1KiB_WithoutC) {
9472 ScopedCSuppression scs(this);
9473 TestBuncondBackward("JBackward1KiB_WithoutC", 1 * KB, "1", GetEmitJ(), GetPrintJ());
9474 }
9475
TEST_F(AssemblerRISCV64Test,JBackward1KiBBare)9476 TEST_F(AssemblerRISCV64Test, JBackward1KiBBare) {
9477 TestBuncondBackward("JBackward1KiBBare", 1 * KB, "1", GetEmitJ(/*is_bare=*/true), GetPrintCJ());
9478 }
9479
TEST_F(AssemblerRISCV64Test,JBackward1KiBBare_WithoutC)9480 TEST_F(AssemblerRISCV64Test, JBackward1KiBBare_WithoutC) {
9481 ScopedCSuppression scs(this);
9482 TestBuncondBackward(
9483 "JBackward1KiBBare_WithoutC", 1 * KB, "1", GetEmitJ(/*is_bare=*/true), GetPrintJ());
9484 }
9485
TEST_F(AssemblerRISCV64Test,JForward3KiB)9486 TEST_F(AssemblerRISCV64Test, JForward3KiB) {
9487 TestBuncondForward("JForward3KiB", 3 * KB, "1", GetEmitJ(), GetPrintJ());
9488 }
9489
TEST_F(AssemblerRISCV64Test,JForward3KiB_WithoutC)9490 TEST_F(AssemblerRISCV64Test, JForward3KiB_WithoutC) {
9491 ScopedCSuppression scs(this);
9492 TestBuncondForward("JForward3KiB_WithoutC", 3 * KB, "1", GetEmitJ(), GetPrintJ());
9493 }
9494
TEST_F(AssemblerRISCV64Test,JForward3KiBBare_WithoutC)9495 TEST_F(AssemblerRISCV64Test, JForward3KiBBare_WithoutC) {
9496 ScopedCSuppression scs(this);
9497 TestBuncondForward(
9498 "JForward3KiBBare_WithoutC", 3 * KB, "1", GetEmitJ(/*is_bare=*/true), GetPrintJ());
9499 }
9500
TEST_F(AssemblerRISCV64Test,JBackward3KiB)9501 TEST_F(AssemblerRISCV64Test, JBackward3KiB) {
9502 TestBuncondBackward("JBackward3KiB", 3 * KB, "1", GetEmitJ(), GetPrintJ());
9503 }
9504
TEST_F(AssemblerRISCV64Test,JBackward3KiB_WithoutC)9505 TEST_F(AssemblerRISCV64Test, JBackward3KiB_WithoutC) {
9506 ScopedCSuppression scs(this);
9507 TestBuncondBackward("JBackward3KiB_WithoutC", 3 * KB, "1", GetEmitJ(), GetPrintJ());
9508 }
9509
TEST_F(AssemblerRISCV64Test,JBackward3KiBBare_WithoutC)9510 TEST_F(AssemblerRISCV64Test, JBackward3KiBBare_WithoutC) {
9511 ScopedCSuppression scs(this);
9512 TestBuncondBackward(
9513 "JBackward3KiBBare_WithoutC", 3 * KB, "1", GetEmitJ(/*is_bare=*/true), GetPrintJ());
9514 }
9515
TEST_F(AssemblerRISCV64Test,JForward2MiB)9516 TEST_F(AssemblerRISCV64Test, JForward2MiB) {
9517 TestBuncondForward("JForward2MiB", 2 * MB, "1", GetEmitJ(), GetPrintTail("2"));
9518 }
9519
TEST_F(AssemblerRISCV64Test,JForward2MiB_WithoutC)9520 TEST_F(AssemblerRISCV64Test, JForward2MiB_WithoutC) {
9521 ScopedCSuppression scs(this);
9522 TestBuncondForward("JForward2MiB_WithoutC", 2 * MB, "1", GetEmitJ(), GetPrintTail("2"));
9523 }
9524
TEST_F(AssemblerRISCV64Test,JBackward2MiB)9525 TEST_F(AssemblerRISCV64Test, JBackward2MiB) {
9526 TestBuncondBackward("JBackward2MiB", 2 * MB, "1", GetEmitJ(), GetPrintTail("2"));
9527 }
9528
TEST_F(AssemblerRISCV64Test,JBackward2MiB_WithoutC)9529 TEST_F(AssemblerRISCV64Test, JBackward2MiB_WithoutC) {
9530 ScopedCSuppression scs(this);
9531 TestBuncondBackward("JBackward2MiB_WithoutC", 2 * MB, "1", GetEmitJ(), GetPrintTail("2"));
9532 }
9533
TEST_F(AssemblerRISCV64Test,JMaxOffset12Forward)9534 TEST_F(AssemblerRISCV64Test, JMaxOffset12Forward) {
9535 TestBuncondForward("JMaxOffset12Forward",
9536 MaxOffset12ForwardDistance() - /*C.J*/ 2u,
9537 "1",
9538 GetEmitJ(),
9539 GetPrintCJ());
9540 }
9541
TEST_F(AssemblerRISCV64Test,JMaxOffset12ForwardBare)9542 TEST_F(AssemblerRISCV64Test, JMaxOffset12ForwardBare) {
9543 TestBuncondForward("JMaxOffset12ForwardBare",
9544 MaxOffset12ForwardDistance() - /*C.J*/ 2u,
9545 "1",
9546 GetEmitJ(/*is_bare=*/true),
9547 GetPrintCJ());
9548 }
9549
TEST_F(AssemblerRISCV64Test,JMaxOffset12Backward)9550 TEST_F(AssemblerRISCV64Test, JMaxOffset12Backward) {
9551 TestBuncondBackward("JMaxOffset12Backward",
9552 MaxOffset12BackwardDistance(),
9553 "1",
9554 GetEmitJ(),
9555 GetPrintCJ());
9556 }
9557
TEST_F(AssemblerRISCV64Test,JMaxOffset12BackwardBare)9558 TEST_F(AssemblerRISCV64Test, JMaxOffset12BackwardBare) {
9559 TestBuncondBackward("JMaxOffset12BackwardBare",
9560 MaxOffset12BackwardDistance(),
9561 "1",
9562 GetEmitJ(/*is_bare=*/true),
9563 GetPrintCJ());
9564 }
9565
TEST_F(AssemblerRISCV64Test,JOverMaxOffset12Forward)9566 TEST_F(AssemblerRISCV64Test, JOverMaxOffset12Forward) {
9567 TestBuncondForward("JOverMaxOffset12Forward",
9568 MaxOffset12ForwardDistance() - /*C.J*/ 2u + /*Exceed max*/ 2u,
9569 "1",
9570 GetEmitJ(),
9571 GetPrintJ());
9572 }
9573
TEST_F(AssemblerRISCV64Test,JOverMaxOffset12Backward)9574 TEST_F(AssemblerRISCV64Test, JOverMaxOffset12Backward) {
9575 TestBuncondBackward("JMaxOffset12Backward",
9576 MaxOffset12BackwardDistance() + /*Exceed max*/ 2u,
9577 "1",
9578 GetEmitJ(),
9579 GetPrintJ());
9580 }
9581
TEST_F(AssemblerRISCV64Test,JMaxOffset21Forward)9582 TEST_F(AssemblerRISCV64Test, JMaxOffset21Forward) {
9583 TestBuncondForward("JMaxOffset21Forward",
9584 MaxOffset21ForwardDistance() - /*J*/ 4u,
9585 "1",
9586 GetEmitJ(),
9587 GetPrintJ());
9588 }
9589
TEST_F(AssemblerRISCV64Test,JMaxOffset21Forward_WithoutC)9590 TEST_F(AssemblerRISCV64Test, JMaxOffset21Forward_WithoutC) {
9591 ScopedCSuppression scs(this);
9592 TestBuncondForward("JMaxOffset21Forward_WithoutC",
9593 MaxOffset21ForwardDistance_WithoutC() - /*J*/ 4u,
9594 "1",
9595 GetEmitJ(),
9596 GetPrintJ());
9597 }
9598
TEST_F(AssemblerRISCV64Test,JMaxOffset21ForwardBare_WithoutC)9599 TEST_F(AssemblerRISCV64Test, JMaxOffset21ForwardBare_WithoutC) {
9600 ScopedCSuppression scs(this);
9601 TestBuncondForward("JMaxOffset21ForwardBare_WithoutC",
9602 MaxOffset21ForwardDistance_WithoutC() - /*J*/ 4u,
9603 "1",
9604 GetEmitJ(/*is_bare=*/true),
9605 GetPrintJ());
9606 }
9607
TEST_F(AssemblerRISCV64Test,JMaxOffset21Backward)9608 TEST_F(AssemblerRISCV64Test, JMaxOffset21Backward) {
9609 TestBuncondBackward("JMaxOffset21Backward",
9610 MaxOffset21BackwardDistance(),
9611 "1",
9612 GetEmitJ(),
9613 GetPrintJ());
9614 }
9615
TEST_F(AssemblerRISCV64Test,JMaxOffset21Backward_WithoutC)9616 TEST_F(AssemblerRISCV64Test, JMaxOffset21Backward_WithoutC) {
9617 ScopedCSuppression scs(this);
9618 TestBuncondBackward("JMaxOffset21Backward_WithoutC",
9619 MaxOffset21BackwardDistance_WithoutC(),
9620 "1",
9621 GetEmitJ(),
9622 GetPrintJ());
9623 }
9624
TEST_F(AssemblerRISCV64Test,JMaxOffset21BackwardBare_WithoutC)9625 TEST_F(AssemblerRISCV64Test, JMaxOffset21BackwardBare_WithoutC) {
9626 ScopedCSuppression scs(this);
9627 TestBuncondBackward("JMaxOffset21BackwardBare_WithoutC",
9628 MaxOffset21BackwardDistance_WithoutC(),
9629 "1",
9630 GetEmitJ(/*is_bare=*/true),
9631 GetPrintJ());
9632 }
9633
TEST_F(AssemblerRISCV64Test,JOverMaxOffset21Forward)9634 TEST_F(AssemblerRISCV64Test, JOverMaxOffset21Forward) {
9635 TestBuncondForward("JOverMaxOffset21Forward",
9636 MaxOffset21ForwardDistance() - /*J*/ 4u + /*Exceed max*/ 2u,
9637 "1",
9638 GetEmitJ(),
9639 GetPrintTail("2"));
9640 }
9641
TEST_F(AssemblerRISCV64Test,JOverMaxOffset21Forward_WithoutC)9642 TEST_F(AssemblerRISCV64Test, JOverMaxOffset21Forward_WithoutC) {
9643 ScopedCSuppression scs(this);
9644 TestBuncondForward("JOverMaxOffset21Forward_WithoutC",
9645 MaxOffset21ForwardDistance_WithoutC() - /*J*/ 4u + /*Exceed max*/ 4u,
9646 "1",
9647 GetEmitJ(),
9648 GetPrintTail("2"));
9649 }
9650
TEST_F(AssemblerRISCV64Test,JOverMaxOffset21Backward)9651 TEST_F(AssemblerRISCV64Test, JOverMaxOffset21Backward) {
9652 TestBuncondBackward("JMaxOffset21Backward",
9653 MaxOffset21BackwardDistance() + /*Exceed max*/ 2u,
9654 "1",
9655 GetEmitJ(),
9656 GetPrintTail("2"));
9657 }
9658
TEST_F(AssemblerRISCV64Test,JOverMaxOffset21Backward_WithoutC)9659 TEST_F(AssemblerRISCV64Test, JOverMaxOffset21Backward_WithoutC) {
9660 ScopedCSuppression scs(this);
9661 TestBuncondBackward("JMaxOffset21Backward_WithoutC",
9662 MaxOffset21BackwardDistance_WithoutC() + /*Exceed max*/ 4u,
9663 "1",
9664 GetEmitJ(),
9665 GetPrintTail("2"));
9666 }
9667
TEST_F(AssemblerRISCV64Test,CallForward3KiB_WithoutC)9668 TEST_F(AssemblerRISCV64Test, CallForward3KiB_WithoutC) {
9669 ScopedCSuppression scs(this);
9670 TestBuncondForward("CallForward3KiB_WithoutC", 3 * KB, "1", GetEmitJal(), GetPrintJal());
9671 }
9672
TEST_F(AssemblerRISCV64Test,CallBackward3KiB_WithoutC)9673 TEST_F(AssemblerRISCV64Test, CallBackward3KiB_WithoutC) {
9674 ScopedCSuppression scs(this);
9675 TestBuncondBackward("CallBackward3KiB_WithoutC", 3 * KB, "1", GetEmitJal(), GetPrintJal());
9676 }
9677
TEST_F(AssemblerRISCV64Test,CallForward2MiB_WithoutC)9678 TEST_F(AssemblerRISCV64Test, CallForward2MiB_WithoutC) {
9679 ScopedCSuppression scs(this);
9680 TestBuncondForward("CallForward2MiB_WithoutC", 2 * MB, "1", GetEmitJal(), GetPrintCall("2"));
9681 }
9682
TEST_F(AssemblerRISCV64Test,CallBackward2MiB_WithoutC)9683 TEST_F(AssemblerRISCV64Test, CallBackward2MiB_WithoutC) {
9684 ScopedCSuppression scs(this);
9685 TestBuncondBackward("CallBackward2MiB_WithoutC", 2 * MB, "1", GetEmitJal(), GetPrintCall("2"));
9686 }
9687
TEST_F(AssemblerRISCV64Test,CallMaxOffset21Forward_WithoutC)9688 TEST_F(AssemblerRISCV64Test, CallMaxOffset21Forward_WithoutC) {
9689 ScopedCSuppression scs(this);
9690 TestBuncondForward("CallMaxOffset21Forward_WithoutC",
9691 MaxOffset21ForwardDistance_WithoutC() - /*J*/ 4u,
9692 "1",
9693 GetEmitJal(),
9694 GetPrintJal());
9695 }
9696
TEST_F(AssemblerRISCV64Test,CallMaxOffset21Backward_WithoutC)9697 TEST_F(AssemblerRISCV64Test, CallMaxOffset21Backward_WithoutC) {
9698 ScopedCSuppression scs(this);
9699 TestBuncondBackward("CallMaxOffset21Backward_WithoutC",
9700 MaxOffset21BackwardDistance_WithoutC(),
9701 "1",
9702 GetEmitJal(),
9703 GetPrintJal());
9704 }
9705
TEST_F(AssemblerRISCV64Test,CallOverMaxOffset21Forward_WithoutC)9706 TEST_F(AssemblerRISCV64Test, CallOverMaxOffset21Forward_WithoutC) {
9707 ScopedCSuppression scs(this);
9708 TestBuncondForward("CallOverMaxOffset21Forward_WithoutC",
9709 MaxOffset21ForwardDistance_WithoutC() - /*J*/ 4u + /*Exceed max*/ 4u,
9710 "1",
9711 GetEmitJal(),
9712 GetPrintCall("2"));
9713 }
9714
TEST_F(AssemblerRISCV64Test,CallOverMaxOffset21Backward_WithoutC)9715 TEST_F(AssemblerRISCV64Test, CallOverMaxOffset21Backward_WithoutC) {
9716 ScopedCSuppression scs(this);
9717 TestBuncondBackward("CallMaxOffset21Backward_WithoutC",
9718 MaxOffset21BackwardDistance_WithoutC() + /*Exceed max*/ 4u,
9719 "1",
9720 GetEmitJal(),
9721 GetPrintCall("2"));
9722 }
9723
TEST_F(AssemblerRISCV64Test,Loadb)9724 TEST_F(AssemblerRISCV64Test, Loadb) {
9725 ScopedCSuppression scs(this); // Suppress 16-bit instructions for address formation.
9726 TestLoadStoreArbitraryOffset("Loadb", "lb", &Riscv64Assembler::Loadb, /*is_store=*/ false);
9727 }
9728
TEST_F(AssemblerRISCV64Test,Loadh)9729 TEST_F(AssemblerRISCV64Test, Loadh) {
9730 ScopedCSuppression scs(this);
9731 TestLoadStoreArbitraryOffset("Loadh", "lh", &Riscv64Assembler::Loadh, /*is_store=*/ false);
9732 }
9733
TEST_F(AssemblerRISCV64Test,Loadw)9734 TEST_F(AssemblerRISCV64Test, Loadw) {
9735 ScopedCSuppression scs(this);
9736 TestLoadStoreArbitraryOffset("Loadw", "lw", &Riscv64Assembler::Loadw, /*is_store=*/ false);
9737 }
9738
TEST_F(AssemblerRISCV64Test,Loadd)9739 TEST_F(AssemblerRISCV64Test, Loadd) {
9740 ScopedCSuppression scs(this);
9741 TestLoadStoreArbitraryOffset("Loadd", "ld", &Riscv64Assembler::Loadd, /*is_store=*/ false);
9742 }
9743
TEST_F(AssemblerRISCV64Test,Loadbu)9744 TEST_F(AssemblerRISCV64Test, Loadbu) {
9745 ScopedCSuppression scs(this);
9746 TestLoadStoreArbitraryOffset("Loadbu", "lbu", &Riscv64Assembler::Loadbu, /*is_store=*/ false);
9747 }
9748
TEST_F(AssemblerRISCV64Test,Loadhu)9749 TEST_F(AssemblerRISCV64Test, Loadhu) {
9750 ScopedCSuppression scs(this);
9751 TestLoadStoreArbitraryOffset("Loadhu", "lhu", &Riscv64Assembler::Loadhu, /*is_store=*/ false);
9752 }
9753
TEST_F(AssemblerRISCV64Test,Loadwu)9754 TEST_F(AssemblerRISCV64Test, Loadwu) {
9755 ScopedCSuppression scs(this); // Suppress 16-bit instructions for address formation.
9756 TestLoadStoreArbitraryOffset("Loadwu", "lwu", &Riscv64Assembler::Loadwu, /*is_store=*/ false);
9757 }
9758
TEST_F(AssemblerRISCV64Test,Storeb)9759 TEST_F(AssemblerRISCV64Test, Storeb) {
9760 ScopedCSuppression scs(this);
9761 TestLoadStoreArbitraryOffset("Storeb", "sb", &Riscv64Assembler::Storeb, /*is_store=*/ true);
9762 }
9763
TEST_F(AssemblerRISCV64Test,Storeh)9764 TEST_F(AssemblerRISCV64Test, Storeh) {
9765 ScopedCSuppression scs(this);
9766 TestLoadStoreArbitraryOffset("Storeh", "sh", &Riscv64Assembler::Storeh, /*is_store=*/ true);
9767 }
9768
TEST_F(AssemblerRISCV64Test,Storew)9769 TEST_F(AssemblerRISCV64Test, Storew) {
9770 ScopedCSuppression scs(this);
9771 TestLoadStoreArbitraryOffset("Storew", "sw", &Riscv64Assembler::Storew, /*is_store=*/ true);
9772 }
9773
TEST_F(AssemblerRISCV64Test,Stored)9774 TEST_F(AssemblerRISCV64Test, Stored) {
9775 ScopedCSuppression scs(this);
9776 TestLoadStoreArbitraryOffset("Stored", "sd", &Riscv64Assembler::Stored, /*is_store=*/ true);
9777 }
9778
TEST_F(AssemblerRISCV64Test,FLoadw)9779 TEST_F(AssemblerRISCV64Test, FLoadw) {
9780 ScopedCSuppression scs(this); // Suppress 16-bit instructions for address formation.
9781 TestFPLoadStoreArbitraryOffset("FLoadw", "flw", &Riscv64Assembler::FLoadw);
9782 }
9783
TEST_F(AssemblerRISCV64Test,FLoadd)9784 TEST_F(AssemblerRISCV64Test, FLoadd) {
9785 ScopedCSuppression scs(this);
9786 TestFPLoadStoreArbitraryOffset("FLoadd", "fld", &Riscv64Assembler::FLoadd);
9787 }
9788
TEST_F(AssemblerRISCV64Test,FStorew)9789 TEST_F(AssemblerRISCV64Test, FStorew) {
9790 ScopedCSuppression scs(this); // Suppress 16-bit instructions for address formation.
9791 TestFPLoadStoreArbitraryOffset("FStorew", "fsw", &Riscv64Assembler::FStorew);
9792 }
9793
TEST_F(AssemblerRISCV64Test,FStored)9794 TEST_F(AssemblerRISCV64Test, FStored) {
9795 ScopedCSuppression scs(this);
9796 TestFPLoadStoreArbitraryOffset("FStored", "fsd", &Riscv64Assembler::FStored);
9797 }
9798
TEST_F(AssemblerRISCV64Test,Unimp)9799 TEST_F(AssemblerRISCV64Test, Unimp) {
9800 __ Unimp();
9801 DriverStr("unimp\n", "Unimp");
9802 }
9803
TEST_F(AssemblerRISCV64Test,Unimp_WithoutC)9804 TEST_F(AssemblerRISCV64Test, Unimp_WithoutC) {
9805 ScopedCSuppression scs(this);
9806 __ Unimp();
9807 DriverStr("unimp\n", "Unimp_WithoutC");
9808 }
9809
TEST_F(AssemblerRISCV64Test,LoadLabelAddress)9810 TEST_F(AssemblerRISCV64Test, LoadLabelAddress) {
9811 std::string expected;
9812 constexpr size_t kNumLoadsForward = 4 * KB;
9813 constexpr size_t kNumLoadsBackward = 4 * KB;
9814 Riscv64Label label;
9815 auto emit_batch = [&](size_t num_loads, const std::string& target_label) {
9816 for (size_t i = 0; i != num_loads; ++i) {
9817 // Cycle through non-Zero registers.
9818 XRegister rd = enum_cast<XRegister>((i % (kNumberOfXRegisters - 1)) + 1);
9819 DCHECK_NE(rd, Zero);
9820 std::string rd_name = GetRegisterName(rd);
9821 __ LoadLabelAddress(rd, &label);
9822 expected += "1:\n";
9823 expected += ART_FORMAT("auipc {}, %pcrel_hi({})\n", rd_name, target_label);
9824 expected += ART_FORMAT("addi {}, {}, %pcrel_lo(1b)\n", rd_name, rd_name);
9825 }
9826 };
9827 emit_batch(kNumLoadsForward, "2f");
9828 __ Bind(&label);
9829 expected += "2:\n";
9830 emit_batch(kNumLoadsBackward, "2b");
9831 DriverStr(expected, "LoadLabelAddress");
9832 }
9833
TEST_F(AssemblerRISCV64Test,LoadLiteralWithPaddingForLong)9834 TEST_F(AssemblerRISCV64Test, LoadLiteralWithPaddingForLong) {
9835 ScopedCSuppression scs(this);
9836 TestLoadLiteral("LoadLiteralWithPaddingForLong", /*with_padding_for_long=*/ true);
9837 }
9838
TEST_F(AssemblerRISCV64Test,LoadLiteralWithoutPaddingForLong)9839 TEST_F(AssemblerRISCV64Test, LoadLiteralWithoutPaddingForLong) {
9840 ScopedCSuppression scs(this);
9841 TestLoadLiteral("LoadLiteralWithoutPaddingForLong", /*with_padding_for_long=*/ false);
9842 }
9843
TEST_F(AssemblerRISCV64Test,JumpTable)9844 TEST_F(AssemblerRISCV64Test, JumpTable) {
9845 ScopedCSuppression scs(this);
9846 std::string expected;
9847 expected += EmitNops(sizeof(uint32_t));
9848 Riscv64Label targets[4];
9849 uint32_t target_locations[4];
9850 JumpTable* jump_table = __ CreateJumpTable(ArenaVector<Riscv64Label*>(
9851 {&targets[0], &targets[1], &targets[2], &targets[3]}, __ GetAllocator()->Adapter()));
9852 for (size_t i : {0, 1, 2, 3}) {
9853 target_locations[i] = __ CodeSize();
9854 __ Bind(&targets[i]);
9855 expected += std::to_string(i) + ":\n";
9856 expected += EmitNops(sizeof(uint32_t));
9857 }
9858 __ LoadLabelAddress(A0, jump_table->GetLabel());
9859 expected += "4:\n"
9860 "auipc a0, %pcrel_hi(5f)\n"
9861 "addi a0, a0, %pcrel_lo(4b)\n";
9862 expected += EmitNops(sizeof(uint32_t));
9863 uint32_t label5_location = __ CodeSize();
9864 auto target_offset = [&](size_t i) {
9865 // Even with `-mno-relax`, clang assembler does not fully resolve `.4byte 0b - 5b`
9866 // and emits a relocation, so we need to calculate target offsets ourselves.
9867 return std::to_string(static_cast<int64_t>(target_locations[i] - label5_location));
9868 };
9869 expected += "5:\n"
9870 ".4byte " + target_offset(0) + "\n"
9871 ".4byte " + target_offset(1) + "\n"
9872 ".4byte " + target_offset(2) + "\n"
9873 ".4byte " + target_offset(3) + "\n";
9874 DriverStr(expected, "JumpTable");
9875 }
9876
TEST_F(AssemblerRISCV64Test,ScratchRegisters)9877 TEST_F(AssemblerRISCV64Test, ScratchRegisters) {
9878 ScratchRegisterScope srs(GetAssembler());
9879 ASSERT_EQ(2u, srs.AvailableXRegisters()); // Default: TMP(T6) and TMP2(T5).
9880 ASSERT_EQ(1u, srs.AvailableFRegisters()); // Default: FTMP(FT11).
9881
9882 XRegister tmp = srs.AllocateXRegister();
9883 EXPECT_EQ(TMP, tmp);
9884 XRegister tmp2 = srs.AllocateXRegister();
9885 EXPECT_EQ(TMP2, tmp2);
9886 ASSERT_EQ(0u, srs.AvailableXRegisters());
9887
9888 FRegister ftmp = srs.AllocateFRegister();
9889 EXPECT_EQ(FTMP, ftmp);
9890 ASSERT_EQ(0u, srs.AvailableFRegisters());
9891
9892 // Test nesting.
9893 srs.FreeXRegister(A0);
9894 srs.FreeXRegister(A1);
9895 srs.FreeFRegister(FA0);
9896 srs.FreeFRegister(FA1);
9897 ASSERT_EQ(2u, srs.AvailableXRegisters());
9898 ASSERT_EQ(2u, srs.AvailableFRegisters());
9899 {
9900 ScratchRegisterScope srs2(GetAssembler());
9901 ASSERT_EQ(2u, srs2.AvailableXRegisters());
9902 ASSERT_EQ(2u, srs2.AvailableFRegisters());
9903 XRegister a1 = srs2.AllocateXRegister();
9904 EXPECT_EQ(A1, a1);
9905 XRegister a0 = srs2.AllocateXRegister();
9906 EXPECT_EQ(A0, a0);
9907 ASSERT_EQ(0u, srs2.AvailableXRegisters());
9908 FRegister fa1 = srs2.AllocateFRegister();
9909 EXPECT_EQ(FA1, fa1);
9910 FRegister fa0 = srs2.AllocateFRegister();
9911 EXPECT_EQ(FA0, fa0);
9912 ASSERT_EQ(0u, srs2.AvailableFRegisters());
9913 }
9914 ASSERT_EQ(2u, srs.AvailableXRegisters());
9915 ASSERT_EQ(2u, srs.AvailableFRegisters());
9916
9917 srs.IncludeXRegister(A0); // No-op as the register was already available.
9918 ASSERT_EQ(2u, srs.AvailableXRegisters());
9919 srs.IncludeFRegister(FA0); // No-op as the register was already available.
9920 ASSERT_EQ(2u, srs.AvailableFRegisters());
9921 srs.IncludeXRegister(S0);
9922 ASSERT_EQ(3u, srs.AvailableXRegisters());
9923 srs.IncludeFRegister(FS0);
9924 ASSERT_EQ(3u, srs.AvailableFRegisters());
9925
9926 srs.ExcludeXRegister(S1); // No-op as the register was not available.
9927 ASSERT_EQ(3u, srs.AvailableXRegisters());
9928 srs.ExcludeFRegister(FS1); // No-op as the register was not available.
9929 ASSERT_EQ(3u, srs.AvailableFRegisters());
9930 srs.ExcludeXRegister(A0);
9931 ASSERT_EQ(2u, srs.AvailableXRegisters());
9932 srs.ExcludeFRegister(FA0);
9933 ASSERT_EQ(2u, srs.AvailableFRegisters());
9934 }
9935
9936 #undef __
9937
9938 } // namespace riscv64
9939 } // namespace art
9940