1 /*
2 * Copyright (C) 2024 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 "gtest/gtest.h"
18
19 #include <cstdint>
20 #include <cstdlib>
21 #include <cstring>
22 #include <iomanip>
23 #include <iostream>
24 #include <tuple>
25 #include <utility>
26
27 namespace berberis {
28
29 namespace {
30
31 template <typename T>
BitUtilLog2(T x)32 constexpr T BitUtilLog2(T x) {
33 return __builtin_ctz(x);
34 }
35
36 using UInt8x16Tuple = std::tuple<uint8_t,
37 uint8_t,
38 uint8_t,
39 uint8_t,
40 uint8_t,
41 uint8_t,
42 uint8_t,
43 uint8_t,
44 uint8_t,
45 uint8_t,
46 uint8_t,
47 uint8_t,
48 uint8_t,
49 uint8_t,
50 uint8_t,
51 uint8_t>;
52 using UInt16x8Tuple =
53 std::tuple<uint16_t, uint16_t, uint16_t, uint16_t, uint16_t, uint16_t, uint16_t, uint16_t>;
54 using UInt32x4Tuple = std::tuple<uint32_t, uint32_t, uint32_t, uint32_t>;
55 using UInt64x2Tuple = std::tuple<uint64_t, uint64_t>;
56
57 enum PrintModeEndianess { kLittleEndian, kBigEndian };
58
59 // A wrapper around __uint128 which can be constructed from a pair of uint64_t literals.
60 class SIMD128Register {
61 public:
SIMD128Register()62 SIMD128Register() {};
63
SIMD128Register(UInt8x16Tuple u8)64 constexpr SIMD128Register(UInt8x16Tuple u8) : uint8_{u8} {};
SIMD128Register(UInt16x8Tuple u16)65 constexpr SIMD128Register(UInt16x8Tuple u16) : uint16_{u16} {};
SIMD128Register(UInt32x4Tuple u32)66 constexpr SIMD128Register(UInt32x4Tuple u32) : uint32_{u32} {};
SIMD128Register(UInt64x2Tuple u64)67 constexpr SIMD128Register(UInt64x2Tuple u64) : uint64_{u64} {};
SIMD128Register(__int128_t i128)68 constexpr SIMD128Register(__int128_t i128) : i128_{i128} {};
SIMD128Register(uint8_t u128)69 constexpr SIMD128Register(uint8_t u128) : u128_{u128} {};
SIMD128Register(uint16_t u128)70 constexpr SIMD128Register(uint16_t u128) : u128_{u128} {};
SIMD128Register(uint32_t u128)71 constexpr SIMD128Register(uint32_t u128) : u128_{u128} {};
SIMD128Register(uint64_t u128)72 constexpr SIMD128Register(uint64_t u128) : u128_{u128} {};
SIMD128Register(__uint128_t u128)73 constexpr SIMD128Register(__uint128_t u128) : u128_{u128} {};
74
Get() const75 [[nodiscard]] constexpr __uint128_t Get() const { return u128_; }
76
operator =(const SIMD128Register & other)77 constexpr SIMD128Register& operator=(const SIMD128Register& other) {
78 u128_ = other.u128_;
79 return *this;
80 };
operator &=(const SIMD128Register & other)81 constexpr SIMD128Register& operator&=(const SIMD128Register& other) {
82 u128_ &= other.u128_;
83 return *this;
84 }
operator |=(const SIMD128Register & other)85 constexpr SIMD128Register& operator|=(const SIMD128Register& other) {
86 u128_ |= other.u128_;
87 return *this;
88 }
89
operator ==(const SIMD128Register & other) const90 constexpr bool operator==(const SIMD128Register& other) const { return u128_ == other.u128_; }
operator !=(const SIMD128Register & other) const91 constexpr bool operator!=(const SIMD128Register& other) const { return u128_ != other.u128_; }
operator >>(size_t shift_amount) const92 constexpr SIMD128Register operator>>(size_t shift_amount) const { return u128_ >> shift_amount; }
operator <<(size_t shift_amount) const93 constexpr SIMD128Register operator<<(size_t shift_amount) const { return u128_ << shift_amount; }
operator &(SIMD128Register other) const94 constexpr SIMD128Register operator&(SIMD128Register other) const { return u128_ & other.u128_; }
operator |(SIMD128Register other) const95 constexpr SIMD128Register operator|(SIMD128Register other) const { return u128_ | other.u128_; }
operator ^(SIMD128Register other) const96 constexpr SIMD128Register operator^(SIMD128Register other) const { return u128_ ^ other.u128_; }
operator ~() const97 constexpr SIMD128Register operator~() const { return ~u128_; }
98 friend std::ostream& operator<<(std::ostream& os, const SIMD128Register& simd);
99
100 template <size_t N>
Print(std::ostream & os) const101 std::ostream& Print(std::ostream& os) const {
102 if constexpr (kSimd128PrintMode == kBigEndian) {
103 os << std::uppercase << std::hex << std::setw(4) << std::setfill('0') << std::get<N>(uint16_);
104 if constexpr (N > 0) {
105 os << '\'';
106 }
107 } else {
108 os << std::uppercase << std::hex << std::setw(2) << std::setfill('0')
109 << static_cast<int>(std::get<N * 2>(uint8_));
110 os << std::uppercase << std::hex << std::setw(2) << std::setfill('0')
111 << static_cast<int>(std::get<N * 2 + 1>(uint8_));
112 if constexpr (N < 7) {
113 os << '\'';
114 }
115 }
116 return os;
117 }
118
119 template <size_t... N>
PrintEach(std::ostream & os,std::index_sequence<N...>) const120 std::ostream& PrintEach(std::ostream& os, std::index_sequence<N...>) const {
121 os << "0x";
122 if constexpr (kSimd128PrintMode == kBigEndian) {
123 (Print<7 - N>(os), ...);
124 } else {
125 (Print<N>(os), ...);
126 }
127 return os;
128 }
129
130 private:
131 union {
132 #ifdef __GNUC__
133 [[gnu::may_alias]] UInt8x16Tuple uint8_;
134 [[gnu::may_alias]] UInt16x8Tuple uint16_;
135 [[gnu::may_alias]] UInt32x4Tuple uint32_;
136 [[gnu::may_alias]] UInt64x2Tuple uint64_;
137 [[gnu::may_alias]] __int128_t i128_;
138 [[gnu::may_alias]] __uint128_t u128_;
139 #endif
140 };
141
142 // Support for BIG_ENDIAN or LITTLE_ENDIAN printing of SIMD128Register values. Change this value
143 // if you want to see failure results in LITTLE_ENDIAN.
144 static constexpr const PrintModeEndianess kSimd128PrintMode = kBigEndian;
145 };
146
147 // Helps produce easy to read output on failed tests.
operator <<(std::ostream & os,const SIMD128Register & simd)148 std::ostream& operator<<(std::ostream& os, const SIMD128Register& simd) {
149 return simd.PrintEach(os, std::make_index_sequence<8>());
150 }
151
152 const SIMD128Register kVectorCalculationsSourceLegacy[16] = {
153 {{0x8706'8504'8302'8100, 0x8f0e'8d0c'8b0a'8908}},
154 {{0x9716'9514'9312'9110, 0x9f1e'9d1c'9b1a'9918}},
155 {{0xa726'a524'a322'a120, 0xaf2e'ad2c'ab2a'a928}},
156 {{0xb736'b534'b332'b130, 0xbf3e'bd3c'bb3a'b938}},
157 {{0xc746'c544'c342'c140, 0xcf4e'cd4c'cb4a'c948}},
158 {{0xd756'd554'd352'd150, 0xdf5e'dd5c'db5a'd958}},
159 {{0xe766'e564'e362'e160, 0xef6e'ed6c'eb6a'e968}},
160 {{0xf776'f574'f372'f170, 0xff7e'fd7c'fb7a'f978}},
161
162 {{0x0e0c'0a09'0604'0200, 0x1e1c'1a18'1614'1211}},
163 {{0x2e2c'2a29'2624'2220, 0x3e3c'3a38'3634'3231}},
164 {{0x4e4c'4a49'4644'4240, 0x5e5c'5a58'5654'5251}},
165 {{0x6e6c'6a69'6664'6260, 0x7e7c'7a78'7674'7271}},
166 {{0x8e8c'8a89'8684'8280, 0x9e9c'9a98'9694'9291}},
167 {{0xaeac'aaa9'a6a4'a2a0, 0xbebc'bab8'b6b4'b2b1}},
168 {{0xcecc'cac9'c6c4'c2c0, 0xdedc'dad8'd6d4'd2d1}},
169 {{0xeeec'eae9'e6e4'e2e0, 0xfefc'faf8'f6f4'f2f1}},
170 };
171
172 const SIMD128Register kVectorCalculationsSource[16] = {
173 {{0x8706'8504'8302'8100, 0x8f0e'8d0c'8b0a'8908}},
174 {{0x9716'9514'9312'9110, 0x9f1e'9d1c'9b1a'9918}},
175 {{0xa726'a524'a322'a120, 0xaf2e'ad2c'ab2a'a928}},
176 {{0xb736'b534'b332'b130, 0xbf3e'bd3c'bb3a'b938}},
177 {{0xc746'c544'c342'c140, 0xcf4e'cd4c'cb4a'c948}},
178 {{0xd756'd554'd352'd150, 0xdf5e'dd5c'db5a'd958}},
179 {{0xe766'e564'e362'e160, 0xef6e'ed6c'eb6a'e968}},
180 {{0xf776'f574'f372'f170, 0xff7e'fd7c'fb7a'f978}},
181
182 {{0x9e0c'9a09'9604'9200, 0x8e1c'8a18'8614'8211}},
183 {{0xbe2c'ba29'b624'b220, 0xae3c'aa38'a634'a231}},
184 {{0xde4c'da49'd644'd240, 0xce5c'ca58'c654'c251}},
185 {{0xfe6c'fa69'f664'f260, 0xee7c'ea78'e674'e271}},
186 {{0x1e8c'1a89'1684'1280, 0x0e9c'0a98'0694'0291}},
187 {{0x3eac'3aa9'36a4'32a0, 0x2ebc'2ab8'26b4'22b1}},
188 {{0x5ecc'5ac9'56c4'52c0, 0x4edc'4ad8'46d4'42d1}},
189 {{0x7eec'7ae9'76e4'72e0, 0x6efc'6af8'66f4'62f1}},
190 };
191
192 const SIMD128Register kVectorComparisonSource[16] = {
193 {{0xf005'f005'f005'f005, 0xffff'ffff'4040'4040}},
194 {{0xffff'ffff'40b4'40b4, 0xffff'ffff'40b4'0000}},
195 {{0x4016'4016'4016'4016, 0x4016'8000'0000'0000}},
196 {{0xaaaa'aaaa'aaaa'aaaa, 0x1111'1111'1111'1111}},
197 {{0xfff4'fff4'fff4'fff4, 0xfff6'fff6'fff6'fff6}},
198 {{0xfff8'fff8'fff4'fff4, 0xfff5'fff5'fff5'fff5}},
199 {{0xa9bb'bbbb'a9bb'bbbb, 0xa9bb'bbbb'a9bb'bbbb}},
200 {{0xa9a9'a9a9'a9a9'a9a9, 0xa9a9'a9a9'a9a9'a9a9}},
201
202 {{0xf005'f005'f005'f005, 0xffff'ffff'4040'4040}},
203 {{0x1111'1111'1111'1111, 0x1111'1111'1111'1111}},
204 {{0xfff1'fff1'fff1'fff1, 0xfff1'fff1'fff1'fff1}},
205 {{0x6e6c'6a69'6664'6260, 0x7e7c'7a78'7674'7271}},
206 {{0x8e8c'8a89'8684'8280, 0x9e9c'9a98'9694'9291}},
207 {{0xaeac'aaa9'a6a4'a2a0, 0xbebc'bab8'b6b4'b2b1}},
208 {{0xcecc'cac9'c6c4'c2c0, 0xdedc'dad8'd6d4'd2d1}},
209 {{0xeeec'eae9'e6e4'e2e0, 0xfefc'faf8'f6f4'f2f1}},
210 };
211
212 namespace VXRMFlags {
213
214 inline constexpr uint64_t RNU = 0b00;
215 inline constexpr uint64_t RNE = 0b01;
216 inline constexpr uint64_t RDN = 0b10;
217 inline constexpr uint64_t ROD = 0b11;
218
219 } // namespace VXRMFlags
220
221 // Easily recognizable bit pattern for target register.
222 const SIMD128Register kUndisturbedResult{{0x5555'5555'5555'5555, 0x5555'5555'5555'5555}};
223
GetAgnosticResult()224 SIMD128Register GetAgnosticResult() {
225 static const bool kRvvAgnosticIsUndisturbed = getenv("RVV_AGNOSTIC_IS_UNDISTURBED") != nullptr;
226 if (kRvvAgnosticIsUndisturbed) {
227 return kUndisturbedResult;
228 }
229 return {{~uint64_t{0U}, ~uint64_t{0U}}};
230 }
231
232 const SIMD128Register kAgnosticResult = GetAgnosticResult();
233
234 // Mask in form suitable for storing in v0 and use in v0.t form.
235 const SIMD128Register kMask{{0xd5ad'd6b5'ad6b'b5ad, 0x6af7'57bb'deed'7bb5}};
236 // Mask used with vsew = 0 (8bit) elements.
237 const SIMD128Register kMaskInt8[8] = {
238 {{255, 0, 255, 255, 0, 255, 0, 255, 255, 0, 255, 0, 255, 255, 0, 255}},
239 {{255, 255, 0, 255, 0, 255, 255, 0, 255, 0, 255, 255, 0, 255, 0, 255}},
240 {{255, 0, 255, 0, 255, 255, 0, 255, 0, 255, 255, 0, 255, 0, 255, 255}},
241 {{255, 0, 255, 255, 0, 255, 0, 255, 255, 0, 255, 0, 255, 0, 255, 255}},
242 {{255, 0, 255, 0, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 255, 0}},
243 {{255, 0, 255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 255, 0, 255, 255}},
244 {{255, 255, 0, 255, 255, 255, 0, 255, 255, 255, 255, 0, 255, 0, 255, 0}},
245 {{255, 255, 255, 0, 255, 255, 255, 255, 0, 255, 0, 255, 0, 255, 255, 0}},
246 };
247 // Mask used with vsew = 1 (16bit) elements.
248 const SIMD128Register kMaskInt16[8] = {
249 {{0xffff, 0x0000, 0xffff, 0xffff, 0x0000, 0xffff, 0x0000, 0xffff}},
250 {{0xffff, 0x0000, 0xffff, 0x0000, 0xffff, 0xffff, 0x0000, 0xffff}},
251 {{0xffff, 0xffff, 0x0000, 0xffff, 0x0000, 0xffff, 0xffff, 0x0000}},
252 {{0xffff, 0x0000, 0xffff, 0xffff, 0x0000, 0xffff, 0x0000, 0xffff}},
253 {{0xffff, 0x0000, 0xffff, 0x0000, 0xffff, 0xffff, 0x0000, 0xffff}},
254 {{0x0000, 0xffff, 0xffff, 0x0000, 0xffff, 0x0000, 0xffff, 0xffff}},
255 {{0xffff, 0x0000, 0xffff, 0xffff, 0x0000, 0xffff, 0x0000, 0xffff}},
256 {{0xffff, 0x0000, 0xffff, 0x0000, 0xffff, 0x0000, 0xffff, 0xffff}},
257 };
258 // Mask used with vsew = 2 (32bit) elements.
259 const SIMD128Register kMaskInt32[8] = {
260 {{0xffff'ffff, 0x0000'0000, 0xffff'ffff, 0xffff'ffff}},
261 {{0x0000'0000, 0xffff'ffff, 0x0000'0000, 0xffff'ffff}},
262 {{0xffff'ffff, 0x0000'0000, 0xffff'ffff, 0x0000'0000}},
263 {{0xffff'ffff, 0xffff'ffff, 0x0000'0000, 0xffff'ffff}},
264 {{0xffff'ffff, 0xffff'ffff, 0x0000'0000, 0xffff'ffff}},
265 {{0x0000'0000, 0xffff'ffff, 0xffff'ffff, 0x0000'0000}},
266 {{0xffff'ffff, 0x0000'0000, 0xffff'ffff, 0xffff'ffff}},
267 {{0x0000'0000, 0xffff'ffff, 0x0000'0000, 0xffff'ffff}},
268 };
269 // Mask used with vsew = 3 (64bit) elements.
270 const SIMD128Register kMaskInt64[8] = {
271 {{0xffff'ffff'ffff'ffff, 0x0000'0000'0000'0000}},
272 {{0xffff'ffff'ffff'ffff, 0xffff'ffff'ffff'ffff}},
273 {{0x0000'0000'0000'0000, 0xffff'ffff'ffff'ffff}},
274 {{0x0000'0000'0000'0000, 0xffff'ffff'ffff'ffff}},
275 {{0xffff'ffff'ffff'ffff, 0x0000'0000'0000'0000}},
276 {{0xffff'ffff'ffff'ffff, 0x0000'0000'0000'0000}},
277 {{0xffff'ffff'ffff'ffff, 0xffff'ffff'ffff'ffff}},
278 {{0x0000'0000'0000'0000, 0xffff'ffff'ffff'ffff}},
279 };
280 // To verify operations without masking.
281 const SIMD128Register kNoMask[8] = {
282 {{0xffff'ffff'ffff'ffff, 0xffff'ffff'ffff'ffff}},
283 {{0xffff'ffff'ffff'ffff, 0xffff'ffff'ffff'ffff}},
284 {{0xffff'ffff'ffff'ffff, 0xffff'ffff'ffff'ffff}},
285 {{0xffff'ffff'ffff'ffff, 0xffff'ffff'ffff'ffff}},
286 {{0xffff'ffff'ffff'ffff, 0xffff'ffff'ffff'ffff}},
287 {{0xffff'ffff'ffff'ffff, 0xffff'ffff'ffff'ffff}},
288 {{0xffff'ffff'ffff'ffff, 0xffff'ffff'ffff'ffff}},
289 {{0xffff'ffff'ffff'ffff, 0xffff'ffff'ffff'ffff}},
290 };
291
292 // Half of sub-register lmul.
293 const SIMD128Register kFractionMaskInt8[5] = {
294 {{255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}, // Half of 1/8 reg = 1/16
295 {{255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}, // Half of 1/4 reg = 1/8
296 {{255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}, // Half of 1/2 reg = 1/4
297 {{255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0}}, // Half of full reg = 1/2
298 {{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}}, // Full reg
299 };
300
MakeBitmaskFromVl(size_t vl)301 SIMD128Register MakeBitmaskFromVl(size_t vl) {
302 if (vl == 128) {
303 return {__uint128_t(0)};
304 } else {
305 return {(~__int128(0)) << vl};
306 }
307 }
308
309 template <typename ElementType>
MaskForElem()310 auto MaskForElem() {
311 if constexpr (std::is_same_v<ElementType, uint8_t>) {
312 return kMaskInt8;
313 } else if constexpr (std::is_same_v<ElementType, uint16_t>) {
314 return kMaskInt16;
315 } else if constexpr (std::is_same_v<ElementType, uint32_t>) {
316 return kMaskInt32;
317 } else if constexpr (std::is_same_v<ElementType, uint64_t>) {
318 return kMaskInt64;
319 } else {
320 static_assert(false);
321 }
322 }
323
324 template <bool kIsMasked, typename ElementType>
MaskForElemIfMasked()325 auto MaskForElemIfMasked() {
326 if constexpr (!kIsMasked) {
327 return kNoMask;
328 } else {
329 return MaskForElem<ElementType>();
330 }
331 }
332
333 using ExecInsnFunc = void (*)();
334
RunTwoVectorArgsOneRes(ExecInsnFunc exec_insn,const SIMD128Register * src,SIMD128Register * res,uint64_t vtype,uint64_t vlmax)335 void RunTwoVectorArgsOneRes(ExecInsnFunc exec_insn,
336 const SIMD128Register* src,
337 SIMD128Register* res,
338 uint64_t vtype,
339 uint64_t vlmax) {
340 uint64_t vstart, vl;
341 // Mask register is, unconditionally, v0, and we need 8, 16, or 24 to handle full 8-registers
342 // inputs thus we use v8..v15 for destination and place sources into v16..v23 and v24..v31.
343 asm( // Load arguments and undisturbed result.
344 "vsetvli t0, zero, e64, m8, ta, ma\n\t"
345 "vle64.v v8, (%[res])\n\t"
346 "vle64.v v16, (%[src])\n\t"
347 "addi t0, %[src], 128\n\t"
348 "vle64.v v24, (t0)\n\t"
349 // Load mask.
350 "vsetvli t0, zero, e64, m1, ta, ma\n\t"
351 "vle64.v v0, (%[mask])\n\t"
352 // Execute tested instruction.
353 "vsetvl t0, zero, %[vtype]\n\t"
354 "jalr %[exec_insn]\n\t"
355 // Save vstart and vl just after insn execution for checks.
356 "csrr %[vstart], vstart\n\t"
357 "csrr %[vl], vl\n\t"
358 // Store the result.
359 "vsetvli t0, zero, e64, m8, ta, ma\n\t"
360 "vse64.v v8, (%[res])\n\t"
361 : [vstart] "=&r"(vstart), [vl] "=&r"(vl)
362 : [exec_insn] "r"(exec_insn),
363 [src] "r"(src),
364 [res] "r"(res),
365 [vtype] "r"(vtype),
366 [mask] "r"(&kMask)
367 : "t0",
368 "ra",
369 "v0",
370 "v8",
371 "v9",
372 "v10",
373 "v11",
374 "v12",
375 "v13",
376 "v14",
377 "v15",
378 "v16",
379 "v17",
380 "v18",
381 "v19",
382 "v20",
383 "v21",
384 "v22",
385 "v23",
386 "v24",
387 "v25",
388 "v26",
389 "v27",
390 "v28",
391 "v29",
392 "v30",
393 "v31",
394 "memory");
395 // Every vector instruction must set vstart to 0, but shouldn't touch vl.
396 EXPECT_EQ(vstart, 0);
397 EXPECT_EQ(vl, vlmax);
398 }
399
400 // Supports ExecInsnFuncs that fit the following [inputs...] -> output formats:
401 // vector -> vector
402 // vector, vector -> vector
403 // vector, scalar -> vector
404 // vector, float -> vector
405 // Vectors will be used in v16 first, then v24
406 // scalar and float will be filled from scalar_src, and will use t0 and ft0,
407 // respectively.
RunCommonVectorFunc(ExecInsnFunc exec_insn,const SIMD128Register * src,SIMD128Register * res,uint64_t * scalar_int_res,uint64_t * scalar_float_res,uint64_t scalar_src,uint64_t vstart,uint64_t vtype,uint64_t vlin)408 void RunCommonVectorFunc(ExecInsnFunc exec_insn,
409 const SIMD128Register* src,
410 SIMD128Register* res,
411 uint64_t* scalar_int_res,
412 uint64_t* scalar_float_res,
413 uint64_t scalar_src,
414 uint64_t vstart,
415 uint64_t vtype,
416 uint64_t vlin) {
417 uint64_t unused_local;
418 if (!scalar_int_res) {
419 scalar_int_res = &unused_local;
420 }
421 if (!scalar_float_res) {
422 scalar_float_res = &unused_local;
423 }
424 SIMD128Register unused_simd_local[8];
425 if (!res) {
426 res = &unused_simd_local[0];
427 }
428
429 uint64_t vl = vlin;
430 // Mask register is, unconditionally, v0, and we need 8 or 24 to handle full 8-registers
431 // inputs thus we use v8..v15 for destination and place sources into v24..v31.
432 asm( // Load arguments and undisturbed result.
433 "vsetvli t0, zero, e64, m8, ta, ma\n\t"
434 "vle64.v v8, (%[res])\n\t"
435 "vle64.v v16, (%[src])\n\t"
436 "addi t0, %[src], 128\n\t"
437 "vle64.v v24, (t0)\n\t"
438 // Load mask.
439 "vsetvli t0, zero, e64, m1, ta, ma\n\t"
440 "vle64.v v0, (%[mask])\n\t"
441 // Execute tested instruction.
442 "vsetvl t0, %[vl], %[vtype]\n\t"
443 "csrw vstart, %[vstart]\n\t"
444 "mv t0, %[scalar_src]\n\t"
445 "fmv.d.x ft0, %[scalar_src]\n\t"
446 "jalr %[exec_insn]\n\t"
447 // Save t0, ft0 just after insn execution for return.
448 "sd t0, %[scalar_int]\n\t"
449 "fsd ft0, %[scalar_float]\n\t"
450 // Save vstart and vl just after insn execution for checks.
451 "csrr %[vstart], vstart\n\t"
452 "csrr %[vl], vl\n\t"
453 // Store the result.
454 "vsetvli t0, zero, e64, m8, ta, ma\n\t"
455 "vse64.v v8, (%[res])\n\t"
456 : [vstart] "=r"(vstart), [vl] "=r"(vl)
457 : [exec_insn] "r"(exec_insn),
458 [src] "r"(src),
459 [res] "r"(res),
460 [vtype] "r"(vtype),
461 "0"(vstart),
462 "1"(vl),
463 [mask] "r"(&kMask),
464 [scalar_src] "r"(scalar_src),
465 [scalar_float] "m"(*scalar_float_res),
466 [scalar_int] "m"(*scalar_int_res)
467 : "t0",
468 "ra",
469 "ft0",
470 "v0",
471 "v8",
472 "v9",
473 "v10",
474 "v11",
475 "v12",
476 "v13",
477 "v14",
478 "v15",
479 "v16",
480 "v17",
481 "v18",
482 "v19",
483 "v20",
484 "v21",
485 "v22",
486 "v23",
487 "v24",
488 "v25",
489 "v26",
490 "v27",
491 "v28",
492 "v29",
493 "v30",
494 "v31",
495 "memory");
496 // Every vector instruction must set vstart to 0, but shouldn't touch vl.
497 EXPECT_EQ(vstart, 0);
498 EXPECT_EQ(vl, vlin);
499 }
500
501 enum class TestVectorInstructionKind { kInteger, kFloat };
502 enum class TestVectorInstructionMode { kDefault, kWidening, kNarrowing, kVMerge };
503
504 template <TestVectorInstructionKind kTestVectorInstructionKind,
505 TestVectorInstructionMode kTestVectorInstructionMode,
506 typename... ExpectedResultType,
507 size_t... kResultsCount>
TestVectorInstructionInternal(ExecInsnFunc exec_insn,ExecInsnFunc exec_masked_insn,const SIMD128Register dst_result,const SIMD128Register (& source)[16],const ExpectedResultType (&...expected_result)[kResultsCount])508 void TestVectorInstructionInternal(ExecInsnFunc exec_insn,
509 ExecInsnFunc exec_masked_insn,
510 const SIMD128Register dst_result,
511 const SIMD128Register (&source)[16],
512 const ExpectedResultType (&... expected_result)[kResultsCount]) {
513 auto Verify = [&source, dst_result](ExecInsnFunc exec_insn,
514 uint8_t vsew,
515 const auto& expected_result,
516 const auto& mask) {
517 uint64_t scalar_src = 0;
518 if constexpr (kTestVectorInstructionKind == TestVectorInstructionKind::kInteger) {
519 // Set t0 for vx instructions.
520 scalar_src = 0xaaaa'aaaa'aaaa'aaaa;
521 } else {
522 // We only support Float32/Float64 for float instructions, but there are conversion
523 // instructions that work with double width floats.
524 // These instructions never use float registers though and thus we don't need to store
525 // anything into ft0 register, if they are used.
526 // For Float32/Float64 case we load 5.625 of the appropriate type into ft0.
527 ASSERT_LE(vsew, 3);
528 if (vsew == 2) {
529 scalar_src = 0xffff'ffff'40b4'0000; // float 5.625
530 } else if (vsew == 3) {
531 scalar_src = 0x4016'8000'0000'0000; // double 5.625
532 }
533 }
534 for (uint8_t vlmul = 0; vlmul < 8; ++vlmul) {
535 if constexpr (kTestVectorInstructionMode == TestVectorInstructionMode::kNarrowing ||
536 kTestVectorInstructionMode == TestVectorInstructionMode::kWidening) {
537 // Incompatible vlmul for narrowing.
538 if (vlmul == 3) {
539 continue;
540 }
541 }
542 for (uint8_t vta = 0; vta < 2; ++vta) {
543 for (uint8_t vma = 0; vma < 2; ++vma) {
544 uint64_t vtype = (vma << 7) | (vta << 6) | (vsew << 3) | vlmul;
545 uint64_t vlmax = 0;
546 asm("vsetvl %0, zero, %1" : "=r"(vlmax) : "r"(vtype));
547 // Incompatible vsew and vlmax. Skip it.
548 if (vlmax == 0) {
549 continue;
550 }
551 uint8_t emul =
552 (vlmul + (kTestVectorInstructionMode == TestVectorInstructionMode::kWidening)) &
553 0b111;
554
555 // To make tests quick enough we don't test vstart and vl change with small register
556 // sets. Only with vlmul == 2 (4 registers) we set vstart and vl to skip half of first
557 // register, last register and half of next-to last register.
558 // Don't use vlmul == 3 because that one may not be supported if instruction widens the
559 // result.
560 uint64_t vstart;
561 uint64_t vl;
562 if (emul == 2) {
563 vstart = vlmax / 8;
564 vl = (vlmax * 5) / 8;
565 } else {
566 vstart = 0;
567 vl = vlmax;
568 }
569
570 SIMD128Register result[8];
571 // Set expected_result vector registers into 0b01010101… pattern.
572 // Set undisturbed result vector registers.
573 std::fill_n(result, 8, dst_result);
574
575 RunCommonVectorFunc(
576 exec_insn, &source[0], &result[0], nullptr, nullptr, scalar_src, vstart, vtype, vl);
577
578 // Values for inactive elements (i.e. corresponding mask bit is 0).
579 SIMD128Register expected_inactive[8];
580 if constexpr (kTestVectorInstructionMode == TestVectorInstructionMode::kVMerge) {
581 // vs2 is the start of the source vector register group.
582 // Note: copy_n input/output args are backwards compared to fill_n below.
583 std::copy_n(source, 8, expected_inactive);
584 } else {
585 // For most instructions, follow basic inactive processing rules based on vma flag.
586 std::fill_n(expected_inactive, 8, (vma ? kAgnosticResult : dst_result));
587 }
588
589 if (emul < 4) {
590 for (size_t index = 0; index < 1 << emul; ++index) {
591 if (index == 0 && emul == 2) {
592 EXPECT_EQ(result[index],
593 ((dst_result & kFractionMaskInt8[3]) |
594 (SIMD128Register{expected_result[index]} & mask[index] &
595 ~kFractionMaskInt8[3]) |
596 (expected_inactive[index] & ~mask[index] & ~kFractionMaskInt8[3])));
597 } else if (index == 2 && emul == 2) {
598 EXPECT_EQ(result[index],
599 ((SIMD128Register{expected_result[index]} & mask[index] &
600 kFractionMaskInt8[3]) |
601 (expected_inactive[index] & ~mask[index] & kFractionMaskInt8[3]) |
602 ((vta ? kAgnosticResult : dst_result) & ~kFractionMaskInt8[3])));
603 } else if (index == 3 && emul == 2 && vta) {
604 EXPECT_EQ(result[index], kAgnosticResult);
605 } else if (index == 3 && emul == 2) {
606 EXPECT_EQ(result[index], dst_result);
607 } else {
608 EXPECT_EQ(result[index],
609 ((SIMD128Register{expected_result[index]} & mask[index]) |
610 ((expected_inactive[index] & ~mask[index]))));
611 }
612 }
613 } else {
614 EXPECT_EQ(
615 result[0],
616 ((SIMD128Register{expected_result[0]} & mask[0] & kFractionMaskInt8[emul - 4]) |
617 (expected_inactive[0] & ~mask[0] & kFractionMaskInt8[emul - 4]) |
618 ((vta ? kAgnosticResult : dst_result) & ~kFractionMaskInt8[emul - 4])));
619 }
620 }
621 }
622 }
623 };
624
625 ((Verify(exec_insn,
626 BitUtilLog2(sizeof(std::tuple_element_t<0, ExpectedResultType>)) -
627 (kTestVectorInstructionMode == TestVectorInstructionMode::kWidening),
628 expected_result,
629 kNoMask),
630 Verify(exec_masked_insn,
631 BitUtilLog2(sizeof(std::tuple_element_t<0, ExpectedResultType>)) -
632 (kTestVectorInstructionMode == TestVectorInstructionMode::kWidening),
633 expected_result,
634 MaskForElem<std::tuple_element_t<0, ExpectedResultType>>())),
635 ...);
636 }
637
638 template <TestVectorInstructionKind kTestVectorInstructionKind,
639 TestVectorInstructionMode kTestVectorInstructionMode,
640 typename... ExpectedResultType,
641 size_t... kResultsCount>
TestVectorInstruction(ExecInsnFunc exec_insn,ExecInsnFunc exec_masked_insn,const SIMD128Register (& source)[16],const ExpectedResultType (&...expected_result)[kResultsCount])642 void TestVectorInstruction(ExecInsnFunc exec_insn,
643 ExecInsnFunc exec_masked_insn,
644 const SIMD128Register (&source)[16],
645 const ExpectedResultType (&... expected_result)[kResultsCount]) {
646 TestVectorInstructionInternal<kTestVectorInstructionKind, kTestVectorInstructionMode>(
647 exec_insn, exec_masked_insn, kUndisturbedResult, source, expected_result...);
648 }
649
TestVectorInstruction(ExecInsnFunc exec_insn,ExecInsnFunc exec_masked_insn,const UInt8x16Tuple (& expected_result_int8)[8],const UInt16x8Tuple (& expected_result_int16)[8],const UInt32x4Tuple (& expected_result_int32)[8],const UInt64x2Tuple (& expected_result_int64)[8],const SIMD128Register (& source)[16])650 void TestVectorInstruction(ExecInsnFunc exec_insn,
651 ExecInsnFunc exec_masked_insn,
652 const UInt8x16Tuple (&expected_result_int8)[8],
653 const UInt16x8Tuple (&expected_result_int16)[8],
654 const UInt32x4Tuple (&expected_result_int32)[8],
655 const UInt64x2Tuple (&expected_result_int64)[8],
656 const SIMD128Register (&source)[16]) {
657 TestVectorInstruction<TestVectorInstructionKind::kInteger, TestVectorInstructionMode::kDefault>(
658 exec_insn,
659 exec_masked_insn,
660 source,
661 expected_result_int8,
662 expected_result_int16,
663 expected_result_int32,
664 expected_result_int64);
665 }
666
TestVectorFloatInstruction(ExecInsnFunc exec_insn,ExecInsnFunc exec_masked_insn,const UInt32x4Tuple (& expected_result_int32)[8],const UInt64x2Tuple (& expected_result_int64)[8],const SIMD128Register (& source)[16])667 void TestVectorFloatInstruction(ExecInsnFunc exec_insn,
668 ExecInsnFunc exec_masked_insn,
669 const UInt32x4Tuple (&expected_result_int32)[8],
670 const UInt64x2Tuple (&expected_result_int64)[8],
671 const SIMD128Register (&source)[16]) {
672 TestVectorInstruction<TestVectorInstructionKind::kFloat, TestVectorInstructionMode::kDefault>(
673 exec_insn, exec_masked_insn, source, expected_result_int32, expected_result_int64);
674 }
675
TestNarrowingVectorInstruction(ExecInsnFunc exec_insn,ExecInsnFunc exec_masked_insn,const UInt8x16Tuple (& expected_result_int8)[4],const UInt16x8Tuple (& expected_result_int16)[4],const UInt32x4Tuple (& expected_result_int32)[4],const SIMD128Register (& source)[16])676 void TestNarrowingVectorInstruction(ExecInsnFunc exec_insn,
677 ExecInsnFunc exec_masked_insn,
678 const UInt8x16Tuple (&expected_result_int8)[4],
679 const UInt16x8Tuple (&expected_result_int16)[4],
680 const UInt32x4Tuple (&expected_result_int32)[4],
681 const SIMD128Register (&source)[16]) {
682 TestVectorInstruction<TestVectorInstructionKind::kInteger, TestVectorInstructionMode::kNarrowing>(
683 exec_insn,
684 exec_masked_insn,
685 source,
686 expected_result_int8,
687 expected_result_int16,
688 expected_result_int32);
689 }
690
TestNarrowingVectorFloatInstruction(ExecInsnFunc exec_insn,ExecInsnFunc exec_masked_insn,const UInt32x4Tuple (& expected_result_int32)[4],const SIMD128Register (& source)[16])691 void TestNarrowingVectorFloatInstruction(ExecInsnFunc exec_insn,
692 ExecInsnFunc exec_masked_insn,
693 const UInt32x4Tuple (&expected_result_int32)[4],
694 const SIMD128Register (&source)[16]) {
695 TestVectorInstruction<TestVectorInstructionKind::kFloat, TestVectorInstructionMode::kNarrowing>(
696 exec_insn, exec_masked_insn, source, expected_result_int32);
697 }
698
TestNarrowingVectorFloatInstruction(ExecInsnFunc exec_insn,ExecInsnFunc exec_masked_insn,const UInt16x8Tuple (& expected_result_int16)[4],const UInt32x4Tuple (& expected_result_int32)[4],const SIMD128Register (& source)[16])699 void TestNarrowingVectorFloatInstruction(ExecInsnFunc exec_insn,
700 ExecInsnFunc exec_masked_insn,
701 const UInt16x8Tuple (&expected_result_int16)[4],
702 const UInt32x4Tuple (&expected_result_int32)[4],
703 const SIMD128Register (&source)[16]) {
704 TestVectorInstruction<TestVectorInstructionKind::kFloat, TestVectorInstructionMode::kNarrowing>(
705 exec_insn, exec_masked_insn, source, expected_result_int16, expected_result_int32);
706 }
707
TestWideningVectorFloatInstruction(ExecInsnFunc exec_insn,ExecInsnFunc exec_masked_insn,const UInt64x2Tuple (& expected_result_int64)[8],const SIMD128Register (& source)[16],SIMD128Register dst_result=kUndisturbedResult)708 void TestWideningVectorFloatInstruction(ExecInsnFunc exec_insn,
709 ExecInsnFunc exec_masked_insn,
710 const UInt64x2Tuple (&expected_result_int64)[8],
711 const SIMD128Register (&source)[16],
712 SIMD128Register dst_result = kUndisturbedResult) {
713 TestVectorInstructionInternal<TestVectorInstructionKind::kFloat,
714 TestVectorInstructionMode::kWidening>(
715 exec_insn, exec_masked_insn, dst_result, source, expected_result_int64);
716 }
717
TestWideningVectorFloatInstruction(ExecInsnFunc exec_insn,ExecInsnFunc exec_masked_insn,const UInt32x4Tuple (& expected_result_int32)[8],const UInt64x2Tuple (& expected_result_int64)[8],const SIMD128Register (& source)[16])718 void TestWideningVectorFloatInstruction(ExecInsnFunc exec_insn,
719 ExecInsnFunc exec_masked_insn,
720 const UInt32x4Tuple (&expected_result_int32)[8],
721 const UInt64x2Tuple (&expected_result_int64)[8],
722 const SIMD128Register (&source)[16]) {
723 TestVectorInstruction<TestVectorInstructionKind::kFloat, TestVectorInstructionMode::kWidening>(
724 exec_insn, exec_masked_insn, source, expected_result_int32, expected_result_int64);
725 }
726
TestWideningVectorInstruction(ExecInsnFunc exec_insn,ExecInsnFunc exec_masked_insn,const UInt16x8Tuple (& expected_result_int16)[8],const UInt32x4Tuple (& expected_result_int32)[8],const UInt64x2Tuple (& expected_result_int64)[8],const SIMD128Register (& source)[16])727 void TestWideningVectorInstruction(ExecInsnFunc exec_insn,
728 ExecInsnFunc exec_masked_insn,
729 const UInt16x8Tuple (&expected_result_int16)[8],
730 const UInt32x4Tuple (&expected_result_int32)[8],
731 const UInt64x2Tuple (&expected_result_int64)[8],
732 const SIMD128Register (&source)[16]) {
733 TestVectorInstruction<TestVectorInstructionKind::kInteger, TestVectorInstructionMode::kWidening>(
734 exec_insn,
735 exec_masked_insn,
736 source,
737 expected_result_int16,
738 expected_result_int32,
739 expected_result_int64);
740 }
741
742 template <TestVectorInstructionMode kTestVectorInstructionMode, typename... ExpectedResultType>
TestVectorReductionInstruction(ExecInsnFunc exec_insn,ExecInsnFunc exec_masked_insn,const SIMD128Register (& source)[16],std::tuple<const ExpectedResultType (&)[8],const ExpectedResultType (&)[8]>...expected_result)743 void TestVectorReductionInstruction(
744 ExecInsnFunc exec_insn,
745 ExecInsnFunc exec_masked_insn,
746 const SIMD128Register (&source)[16],
747 std::tuple<const ExpectedResultType (&)[8],
748 const ExpectedResultType (&)[8]>... expected_result) {
749 // Each expected_result input to this function is the vd[0] value of the reduction, for each
750 // of the possible vlmul, i.e. expected_result_vd0_int8[n] = vd[0], int8, no mask, vlmul=n.
751 //
752 // As vlmul=4 is reserved, expected_result_vd0_*[4] is ignored.
753 auto Verify =
754 [&source](ExecInsnFunc exec_insn, uint8_t vsew, uint8_t vlmul, const auto& expected_result) {
755 for (uint8_t vta = 0; vta < 2; ++vta) {
756 for (uint8_t vma = 0; vma < 2; ++vma) {
757 uint64_t vtype = (vma << 7) | (vta << 6) | (vsew << 3) | vlmul;
758 uint64_t vlmax = 0;
759 asm("vsetvl %0, zero, %1" : "=r"(vlmax) : "r"(vtype));
760 if (vlmax == 0) {
761 continue;
762 }
763
764 SIMD128Register result[8];
765 // Set undisturbed result vector registers.
766 for (size_t index = 0; index < 8; ++index) {
767 result[index] = kUndisturbedResult;
768 }
769
770 // Exectations for reductions are for swapped source arguments.
771 SIMD128Register two_sources[16]{};
772 memcpy(&two_sources[0], &source[8], sizeof(two_sources[0]) * 8);
773 memcpy(&two_sources[8], &source[0], sizeof(two_sources[0]) * 8);
774
775 RunTwoVectorArgsOneRes(exec_insn, &two_sources[0], &result[0], vtype, vlmax);
776
777 // Reduction instructions are unique in that they produce a scalar
778 // output to a single vector register as opposed to a register group.
779 // This allows us to take some short-cuts when validating:
780 //
781 // - The mask setting is only useful during computation, as the body
782 // of the destination is always only element 0, which will always be
783 // written to, regardless of mask setting.
784 // - The tail is guaranteed to be 1..VLEN/SEW, so the vlmul setting
785 // does not affect the elements that the tail policy applies to in the
786 // destination register.
787
788 // Verify that the destination register holds the reduction in the
789 // first element and the tail policy applies to the remaining.
790 SIMD128Register expected_result_register = vta ? kAgnosticResult : kUndisturbedResult;
791 size_t result_bits = 8 << vsew;
792 if constexpr (kTestVectorInstructionMode == TestVectorInstructionMode::kWidening) {
793 result_bits *= 2;
794 }
795 expected_result_register &= ~SIMD128Register{(__int128_t{1} << result_bits) - 1};
796 expected_result_register |= SIMD128Register{expected_result};
797 EXPECT_EQ(result[0], expected_result_register) << " vtype=" << vtype;
798
799 // Verify all non-destination registers are undisturbed.
800 for (size_t index = 1; index < 8; ++index) {
801 EXPECT_EQ(result[index], kUndisturbedResult)
802 << " index=" << index << " vtype=" << vtype;
803 }
804 }
805 }
806 };
807
808 auto GetVsew = [](size_t result_size) -> uint8_t {
809 size_t sew = result_size;
810 if constexpr (kTestVectorInstructionMode == TestVectorInstructionMode::kWidening) {
811 sew /= 2;
812 }
813 return BitUtilLog2(sew);
814 };
815
816 for (int vlmul = 0; vlmul < 8; vlmul++) {
817 ((Verify(exec_insn,
818 GetVsew(sizeof(ExpectedResultType)),
819 vlmul,
820 std::get<0>(expected_result)[vlmul]),
821 Verify(exec_masked_insn,
822 GetVsew(sizeof(ExpectedResultType)),
823 vlmul,
824 std::get<1>(expected_result)[vlmul])),
825 ...);
826 }
827 }
828
TestVectorReductionInstruction(ExecInsnFunc exec_insn,ExecInsnFunc exec_masked_insn,const uint32_t (& expected_result_vd0_int32)[8],const uint64_t (& expected_result_vd0_int64)[8],const uint32_t (& expected_result_vd0_with_mask_int32)[8],const uint64_t (& expected_result_vd0_with_mask_int64)[8],const SIMD128Register (& source)[16])829 void TestVectorReductionInstruction(ExecInsnFunc exec_insn,
830 ExecInsnFunc exec_masked_insn,
831 const uint32_t (&expected_result_vd0_int32)[8],
832 const uint64_t (&expected_result_vd0_int64)[8],
833 const uint32_t (&expected_result_vd0_with_mask_int32)[8],
834 const uint64_t (&expected_result_vd0_with_mask_int64)[8],
835 const SIMD128Register (&source)[16]) {
836 TestVectorReductionInstruction<TestVectorInstructionMode::kDefault>(
837 exec_insn,
838 exec_masked_insn,
839 source,
840 std::tuple<const uint32_t(&)[8], const uint32_t(&)[8]>{expected_result_vd0_int32,
841 expected_result_vd0_with_mask_int32},
842 std::tuple<const uint64_t(&)[8], const uint64_t(&)[8]>{expected_result_vd0_int64,
843 expected_result_vd0_with_mask_int64});
844 }
845
TestVectorReductionInstruction(ExecInsnFunc exec_insn,ExecInsnFunc exec_masked_insn,const uint8_t (& expected_result_vd0_int8)[8],const uint16_t (& expected_result_vd0_int16)[8],const uint32_t (& expected_result_vd0_int32)[8],const uint64_t (& expected_result_vd0_int64)[8],const uint8_t (& expected_result_vd0_with_mask_int8)[8],const uint16_t (& expected_result_vd0_with_mask_int16)[8],const uint32_t (& expected_result_vd0_with_mask_int32)[8],const uint64_t (& expected_result_vd0_with_mask_int64)[8],const SIMD128Register (& source)[16])846 void TestVectorReductionInstruction(ExecInsnFunc exec_insn,
847 ExecInsnFunc exec_masked_insn,
848 const uint8_t (&expected_result_vd0_int8)[8],
849 const uint16_t (&expected_result_vd0_int16)[8],
850 const uint32_t (&expected_result_vd0_int32)[8],
851 const uint64_t (&expected_result_vd0_int64)[8],
852 const uint8_t (&expected_result_vd0_with_mask_int8)[8],
853 const uint16_t (&expected_result_vd0_with_mask_int16)[8],
854 const uint32_t (&expected_result_vd0_with_mask_int32)[8],
855 const uint64_t (&expected_result_vd0_with_mask_int64)[8],
856 const SIMD128Register (&source)[16]) {
857 TestVectorReductionInstruction<TestVectorInstructionMode::kDefault>(
858 exec_insn,
859 exec_masked_insn,
860 source,
861 std::tuple<const uint8_t(&)[8], const uint8_t(&)[8]>{expected_result_vd0_int8,
862 expected_result_vd0_with_mask_int8},
863 std::tuple<const uint16_t(&)[8], const uint16_t(&)[8]>{expected_result_vd0_int16,
864 expected_result_vd0_with_mask_int16},
865 std::tuple<const uint32_t(&)[8], const uint32_t(&)[8]>{expected_result_vd0_int32,
866 expected_result_vd0_with_mask_int32},
867 std::tuple<const uint64_t(&)[8], const uint64_t(&)[8]>{expected_result_vd0_int64,
868 expected_result_vd0_with_mask_int64});
869 }
870
TestWideningVectorReductionInstruction(ExecInsnFunc exec_insn,ExecInsnFunc exec_masked_insn,const uint64_t (& expected_result_vd0_int64)[8],const uint64_t (& expected_result_vd0_with_mask_int64)[8],const SIMD128Register (& source)[16])871 void TestWideningVectorReductionInstruction(
872 ExecInsnFunc exec_insn,
873 ExecInsnFunc exec_masked_insn,
874 const uint64_t (&expected_result_vd0_int64)[8],
875 const uint64_t (&expected_result_vd0_with_mask_int64)[8],
876 const SIMD128Register (&source)[16]) {
877 TestVectorReductionInstruction<TestVectorInstructionMode::kWidening>(
878 exec_insn,
879 exec_masked_insn,
880 source,
881 std::tuple<const uint64_t(&)[8], const uint64_t(&)[8]>{expected_result_vd0_int64,
882 expected_result_vd0_with_mask_int64});
883 }
884
TestWideningVectorReductionInstruction(ExecInsnFunc exec_insn,ExecInsnFunc exec_masked_insn,const uint16_t (& expected_result_vd0_int16)[8],const uint32_t (& expected_result_vd0_int32)[8],const uint64_t (& expected_result_vd0_int64)[8],const uint16_t (& expected_result_vd0_with_mask_int16)[8],const uint32_t (& expected_result_vd0_with_mask_int32)[8],const uint64_t (& expected_result_vd0_with_mask_int64)[8],const SIMD128Register (& source)[16])885 void TestWideningVectorReductionInstruction(
886 ExecInsnFunc exec_insn,
887 ExecInsnFunc exec_masked_insn,
888 const uint16_t (&expected_result_vd0_int16)[8],
889 const uint32_t (&expected_result_vd0_int32)[8],
890 const uint64_t (&expected_result_vd0_int64)[8],
891 const uint16_t (&expected_result_vd0_with_mask_int16)[8],
892 const uint32_t (&expected_result_vd0_with_mask_int32)[8],
893 const uint64_t (&expected_result_vd0_with_mask_int64)[8],
894 const SIMD128Register (&source)[16]) {
895 TestVectorReductionInstruction<TestVectorInstructionMode::kWidening>(
896 exec_insn,
897 exec_masked_insn,
898 source,
899 std::tuple<const uint16_t(&)[8], const uint16_t(&)[8]>{expected_result_vd0_int16,
900 expected_result_vd0_with_mask_int16},
901 std::tuple<const uint32_t(&)[8], const uint32_t(&)[8]>{expected_result_vd0_int32,
902 expected_result_vd0_with_mask_int32},
903 std::tuple<const uint64_t(&)[8], const uint64_t(&)[8]>{expected_result_vd0_int64,
904 expected_result_vd0_with_mask_int64});
905 }
906
907 template <bool kIsMasked, typename... ExpectedResultType, size_t... kResultsCount>
TestVectorIota(ExecInsnFunc exec_insn,const SIMD128Register (& source)[16],const ExpectedResultType (&...expected_result)[kResultsCount])908 void TestVectorIota(ExecInsnFunc exec_insn,
909 const SIMD128Register (&source)[16],
910 const ExpectedResultType (&... expected_result)[kResultsCount]) {
911 auto Verify = [&source](ExecInsnFunc exec_insn,
912 uint8_t vsew,
913 const auto& expected_result,
914 auto elem_mask) {
915 for (uint8_t vlmul = 0; vlmul < 8; ++vlmul) {
916 for (uint8_t vta = 0; vta < 2; ++vta) {
917 for (uint8_t vma = 0; vma < 2; ++vma) {
918 uint64_t vtype = (vma << 7) | (vta << 6) | (vsew << 3) | vlmul;
919 uint64_t vlmax = 0;
920 asm("vsetvl %0, zero, %1" : "=r"(vlmax) : "r"(vtype));
921 if (vlmax == 0) {
922 continue;
923 }
924
925 for (uint8_t vl = 0; vl < vlmax; vl += vlmax) {
926 // To make tests quick enough we don't test vl change with small register sets. Only
927 // with vlmul == 2 (4 registers) we set vl to skip last register and half of next-to
928 // last register.
929 uint64_t vlin;
930 if (vlmul == 2 && vl == vlmax) {
931 vlin = 5 * vlmax / 8;
932 } else {
933 vlin = vl;
934 }
935
936 SIMD128Register result[8];
937 // Set expected_result vector registers into 0b01010101… pattern.
938 // Set undisturbed result vector registers.
939 std::fill_n(result, 8, kUndisturbedResult);
940
941 RunCommonVectorFunc(
942 exec_insn, &source[0], &result[0], nullptr, nullptr, 0, 0, vtype, vlin);
943
944 SIMD128Register expected_inactive[8];
945 std::fill_n(expected_inactive, 8, (vma ? kAgnosticResult : kUndisturbedResult));
946
947 // vl of 0 should never change dst registers
948 if (vl == 0) {
949 for (size_t index = 0; index < 8; ++index) {
950 EXPECT_EQ(result[index], kUndisturbedResult);
951 }
952 } else if (vlmul < 4) {
953 for (size_t index = 0; index < 1 << vlmul; ++index) {
954 for (size_t index = 0; index < 1 << vlmul; ++index) {
955 if (index == 2 && vlmul == 2) {
956 EXPECT_EQ(
957 result[index],
958 ((SIMD128Register{expected_result[index]} & elem_mask[index] &
959 kFractionMaskInt8[3]) |
960 (expected_inactive[index] & ~elem_mask[index] & kFractionMaskInt8[3]) |
961 ((vta ? kAgnosticResult : kUndisturbedResult) & ~kFractionMaskInt8[3])));
962 } else if (index == 3 && vlmul == 2) {
963 EXPECT_EQ(result[index], vta ? kAgnosticResult : kUndisturbedResult);
964 } else {
965 EXPECT_EQ(result[index],
966 ((SIMD128Register{expected_result[index]} & elem_mask[index]) |
967 (expected_inactive[index] & ~elem_mask[index])));
968 }
969 }
970 }
971 } else {
972 // vlmul >= 4 only uses 1 register
973 EXPECT_EQ(
974 result[0],
975 ((SIMD128Register{expected_result[0]} & elem_mask[0] &
976 kFractionMaskInt8[vlmul - 4]) |
977 (expected_inactive[0] & ~elem_mask[0] & kFractionMaskInt8[vlmul - 4]) |
978 ((vta ? kAgnosticResult : kUndisturbedResult) & ~kFractionMaskInt8[vlmul - 4])));
979 }
980 }
981 }
982 }
983 }
984 };
985
986 (Verify(exec_insn,
987 BitUtilLog2(sizeof(std::tuple_element_t<0, ExpectedResultType>)),
988 expected_result,
989 MaskForElemIfMasked<kIsMasked, std::tuple_element_t<0, ExpectedResultType>>()),
990 ...);
991 }
992
993 template <bool kIsMasked>
TestVectorIota(ExecInsnFunc exec_insn,const UInt8x16Tuple (& expected_result_int8)[8],const UInt16x8Tuple (& expected_result_int16)[8],const UInt32x4Tuple (& expected_result_int32)[8],const UInt64x2Tuple (& expected_result_int64)[8],const SIMD128Register (& source)[16])994 void TestVectorIota(ExecInsnFunc exec_insn,
995 const UInt8x16Tuple (&expected_result_int8)[8],
996 const UInt16x8Tuple (&expected_result_int16)[8],
997 const UInt32x4Tuple (&expected_result_int32)[8],
998 const UInt64x2Tuple (&expected_result_int64)[8],
999 const SIMD128Register (&source)[16]) {
1000 TestVectorIota<kIsMasked>(exec_insn,
1001 source,
1002 expected_result_int8,
1003 expected_result_int16,
1004 expected_result_int32,
1005 expected_result_int64);
1006 }
1007
TestExtendingVectorInstruction(ExecInsnFunc exec_insn,ExecInsnFunc exec_masked_insn,const UInt16x8Tuple (& expected_result_int16)[8],const UInt32x4Tuple (& expected_result_int32)[8],const UInt64x2Tuple (& expected_result_int64)[8],const SIMD128Register (& source)[16],const uint8_t factor)1008 void TestExtendingVectorInstruction(ExecInsnFunc exec_insn,
1009 ExecInsnFunc exec_masked_insn,
1010 const UInt16x8Tuple (&expected_result_int16)[8],
1011 const UInt32x4Tuple (&expected_result_int32)[8],
1012 const UInt64x2Tuple (&expected_result_int64)[8],
1013 const SIMD128Register (&source)[16],
1014 const uint8_t factor) {
1015 auto Verify = [&source, &factor](ExecInsnFunc exec_insn,
1016 uint8_t vsew,
1017 uint8_t vlmul_max,
1018 const auto& expected_result,
1019 auto mask) {
1020 EXPECT_TRUE((factor == 2) || (factor == 4) || (factor == 8));
1021 for (uint8_t vlmul = 0; vlmul < vlmul_max; ++vlmul) {
1022 if (vlmul == 3) {
1023 continue;
1024 }
1025 for (uint8_t vta = 0; vta < 2; ++vta) {
1026 for (uint8_t vma = 0; vma < 2; ++vma) {
1027 uint64_t vtype = (vma << 7) | (vta << 6) | (vsew << 3) | vlmul;
1028 uint64_t vlmax = 0;
1029 asm("vsetvl %0, zero, %1" : "=r"(vlmax) : "r"(vtype));
1030 // Incompatible vsew and vlmax. Skip it.
1031 if (vlmax == 0) {
1032 continue;
1033 }
1034 // To make tests quick enough we don't test vstart and vl change with small register
1035 // sets. Only with vlmul == 2 (4 registers) we set vstart and vl to skip half of
1036 // first
1037 // register and half of last register.
1038 // Don't use vlmul == 3 because that one may not be supported if instruction widens
1039 // the result.
1040 uint64_t vstart;
1041 uint64_t vl;
1042 if (vlmul == 2) {
1043 vstart = vlmax / 8;
1044 vl = (vlmax * 5) / 8;
1045 } else {
1046 vstart = 0;
1047 vl = vlmax;
1048 }
1049
1050 SIMD128Register result[8];
1051 // Set expected_result vector registers into 0b01010101… pattern.
1052 // Set undisturbed result vector registers.
1053 std::fill_n(result, 8, kUndisturbedResult);
1054
1055 RunCommonVectorFunc(
1056 exec_insn, &source[0], &result[0], nullptr, nullptr, 0, vstart, vtype, vl);
1057
1058 // Values for inactive elements (i.e. corresponding mask bit is 0).
1059 const size_t n = std::size(source) * 2;
1060 SIMD128Register expected_inactive[n];
1061 // For most instructions, follow basic inactive processing rules based on vma flag.
1062 std::fill_n(expected_inactive, n, (vma ? kAgnosticResult : kUndisturbedResult));
1063
1064 if (vlmul < 4) {
1065 for (size_t index = 0; index < 1 << vlmul; ++index) {
1066 if (index == 0 && vlmul == 2) {
1067 EXPECT_EQ(result[index],
1068 (kUndisturbedResult & kFractionMaskInt8[3]) |
1069 (SIMD128Register{expected_result[index]} & mask[index] &
1070 ~kFractionMaskInt8[3]) |
1071 (expected_inactive[index] & ~mask[index] & ~kFractionMaskInt8[3]));
1072 } else if (index == 2 && vlmul == 2) {
1073 EXPECT_EQ(
1074 result[index],
1075 (SIMD128Register{expected_result[index]} & mask[index] & kFractionMaskInt8[3]) |
1076 (expected_inactive[index] & ~mask[index] & kFractionMaskInt8[3]) |
1077 ((vta ? kAgnosticResult : kUndisturbedResult) & ~kFractionMaskInt8[3]));
1078 } else if (index == 3 && vlmul == 2 && vta) {
1079 EXPECT_EQ(result[index], kAgnosticResult);
1080 } else if (index == 3 && vlmul == 2) {
1081 EXPECT_EQ(result[index], kUndisturbedResult);
1082 } else {
1083 EXPECT_EQ(result[index],
1084 (SIMD128Register{expected_result[index]} & mask[index]) |
1085 (expected_inactive[index] & ~mask[index]));
1086 }
1087 }
1088 } else {
1089 EXPECT_EQ(
1090 result[0],
1091 (SIMD128Register{expected_result[0]} & mask[0] & kFractionMaskInt8[vlmul - 4]) |
1092 (expected_inactive[0] & ~mask[0] & kFractionMaskInt8[vlmul - 4]) |
1093 ((vta ? kAgnosticResult : kUndisturbedResult) & ~kFractionMaskInt8[vlmul - 4]));
1094 }
1095 }
1096 }
1097 }
1098 };
1099
1100 if (factor == 2) {
1101 Verify(exec_masked_insn, 1, 8, expected_result_int16, kMaskInt16);
1102 Verify(exec_insn, 1, 8, expected_result_int16, kNoMask);
1103 }
1104 if (factor == 2 || factor == 4) {
1105 Verify(exec_masked_insn, 2, 8, expected_result_int32, kMaskInt32);
1106 Verify(exec_insn, 2, 8, expected_result_int32, kNoMask);
1107 }
1108 Verify(exec_masked_insn, 3, 8, expected_result_int64, kMaskInt64);
1109 Verify(exec_insn, 3, 8, expected_result_int64, kNoMask);
1110 }
1111
1112 // Unlike regular arithmetic instructions, the result of a permutation
1113 // instruction depends also on vlmul. Also, the vslideup specs mention that
1114 // the destination vector remains unchanged the first |offset| elements (in
1115 // effect, the offset acts akin to vstart), in those cases skip can be used
1116 // to specify how many elements' mask will be skipped (counting from the
1117 // beginning, should be the same as the offset).
1118 //
1119 // If |ignore_vma_for_last| is true, an inactive element at vl-1 will be
1120 // treated as if vma=0 (Undisturbed).
1121 // If |last_elem_is_reg1| is true, the last element of the vector in
1122 // expected_result (that is, at vl-1) will be expected to be the same as
1123 // |regx1| when VL < VMAX and said element is active.
1124 template <TestVectorInstructionKind kTestVectorInstructionKind,
1125 typename... ExpectedResultType,
1126 size_t... kResultsCount>
TestVectorPermutationInstruction(ExecInsnFunc exec_insn,ExecInsnFunc exec_masked_insn,const SIMD128Register (& source)[16],uint8_t vlmul,uint64_t skip,bool ignore_vma_for_last,bool last_elem_is_reg1,uint64_t regt0,const ExpectedResultType (&...expected_result)[kResultsCount])1127 void TestVectorPermutationInstruction(
1128 ExecInsnFunc exec_insn,
1129 ExecInsnFunc exec_masked_insn,
1130 const SIMD128Register (&source)[16],
1131 uint8_t vlmul,
1132 uint64_t skip,
1133 bool ignore_vma_for_last,
1134 bool last_elem_is_reg1,
1135 uint64_t regt0,
1136 const ExpectedResultType (&... expected_result)[kResultsCount]) {
1137 auto Verify = [&source, vlmul, regt0, skip, ignore_vma_for_last, last_elem_is_reg1](
1138 ExecInsnFunc exec_insn,
1139 uint8_t vsew,
1140 const auto& expected_result_raw,
1141 auto mask) {
1142 uint64_t scalar_src = 0;
1143 if constexpr (kTestVectorInstructionKind == TestVectorInstructionKind::kFloat) {
1144 (void)(regt0);
1145 // We only support Float32/Float64 for float instructions, but there are conversion
1146 // instructions that work with double width floats.
1147 // These instructions never use float registers though and thus we don't need to store
1148 // anything into f1 register, if they are used.
1149 // For Float32/Float64 case we load 5.625 of the appropriate type into ft0.
1150 ASSERT_LE(vsew, 3);
1151 if (vsew == 2) {
1152 scalar_src = 0xffff'ffff'40b4'0000; // float 5.625
1153 } else if (vsew == 3) {
1154 scalar_src = 0x4016'8000'0000'0000; // double 5.625
1155 }
1156 } else {
1157 // Set t0 for vx instructions.
1158 scalar_src = regt0;
1159 }
1160
1161 const size_t kElementSize = 1 << vsew;
1162 size_t num_regs = 1 << vlmul;
1163 if (vlmul > 3) {
1164 num_regs = 1;
1165 }
1166 // Values for which the mask is not applied due to being before the offset when doing
1167 // vslideup.
1168 SIMD128Register skip_mask[num_regs];
1169 int64_t toskip = skip;
1170 for (size_t index = 0; index < num_regs && toskip > 0; ++index) {
1171 size_t skip_bits = toskip * kElementSize * 8;
1172 skip_mask[index] = ~MakeBitmaskFromVl(skip_bits > 128 ? 128 : skip_bits);
1173 toskip -= 16 / kElementSize;
1174 }
1175
1176 for (uint8_t vta = 0; vta < 2; ++vta) {
1177 for (uint8_t vma = 0; vma < 2; ++vma) {
1178 uint64_t vtype = (vma << 7) | (vta << 6) | (vsew << 3) | vlmul;
1179 uint64_t vlmax = 0;
1180 asm("vsetvl %0, zero, %1" : "=r"(vlmax) : "r"(vtype));
1181 // Incompatible vsew and vlmax. Skip it.
1182 if (vlmax == 0) {
1183 continue;
1184 }
1185
1186 // To make tests quick enough we don't test vstart and vl change with small register
1187 // sets. Only with vlmul == 2 (4 registers) we set vstart and vl to skip half of first
1188 // register, last register and half of next-to last register.
1189 // Don't use vlmul == 3 because that one may not be supported if instruction widens the
1190 // result.
1191 uint64_t vstart;
1192 uint64_t vl;
1193 if (vlmul == 2) {
1194 vstart = vlmax / 8;
1195 vl = (vlmax * 5) / 8;
1196 } else {
1197 vstart = 0;
1198 vl = vlmax;
1199 }
1200
1201 SIMD128Register result[8];
1202 // Set expected_result vector registers into 0b01010101… pattern.
1203 // Set undisturbed result vector registers.
1204 std::fill_n(result, 8, kUndisturbedResult);
1205
1206 uint64_t int_res, float_res;
1207 RunCommonVectorFunc(
1208 exec_insn, &source[0], &result[0], &int_res, &float_res, scalar_src, vstart, vtype, vl);
1209
1210 const size_t n = std::size(source);
1211 // Values for inactive elements (i.e. corresponding mask bit is 0).
1212 SIMD128Register expected_inactive[n];
1213 // For most instructions, follow basic inactive processing rules based on vma flag.
1214 std::fill_n(expected_inactive, n, (vma ? kAgnosticResult : kUndisturbedResult));
1215
1216 const size_t kElementsPerRegister = 16 / kElementSize;
1217 // TODO is this vl the input vl or vl after commands run?
1218 const size_t last_reg = (vl - 1) / kElementsPerRegister;
1219 const size_t last_elem = (vl - 1) % kElementsPerRegister;
1220 const auto mask_for_vl = MakeBitmaskFromVl(last_elem * kElementSize * 8);
1221 if (vma && ignore_vma_for_last) {
1222 // Set expected value for inactive element at vl-1 to Undisturbed.
1223 expected_inactive[last_reg] =
1224 (expected_inactive[last_reg] & ~mask_for_vl) | (kUndisturbedResult & mask_for_vl);
1225 }
1226
1227 SIMD128Register expected_result[std::size(expected_result_raw)];
1228 for (size_t index = 0; index < std::size(expected_result_raw); ++index) {
1229 expected_result[index] = SIMD128Register{expected_result_raw[index]};
1230 }
1231
1232 if (vlmul == 2 && last_elem_is_reg1) {
1233 switch (kElementSize) {
1234 case 1:
1235 expected_result[last_reg] = static_cast<__uint128_t>(static_cast<uint8_t>(int_res))
1236 << (last_elem * 8);
1237 break;
1238 case 2:
1239 expected_result[last_reg] = static_cast<__uint128_t>(static_cast<uint16_t>(int_res))
1240 << (last_elem * 16);
1241 break;
1242 case 4:
1243 if constexpr (kTestVectorInstructionKind == TestVectorInstructionKind::kFloat) {
1244 expected_result[last_reg] =
1245 static_cast<__uint128_t>(static_cast<uint32_t>(float_res)) << (last_elem * 32);
1246 } else {
1247 expected_result[last_reg] = static_cast<__uint128_t>(static_cast<uint32_t>(int_res))
1248 << (last_elem * 32);
1249 }
1250 break;
1251 case 8:
1252 if constexpr (kTestVectorInstructionKind == TestVectorInstructionKind::kFloat) {
1253 expected_result[last_reg] =
1254 static_cast<__uint128_t>(static_cast<uint64_t>(float_res)) << (last_elem * 64);
1255 } else {
1256 expected_result[last_reg] = static_cast<__uint128_t>(static_cast<uint64_t>(int_res))
1257 << (last_elem * 64);
1258 }
1259 break;
1260 default:
1261 FAIL() << "Element size is " << kElementSize;
1262 }
1263 }
1264
1265 if (vlmul < 4) {
1266 for (size_t index = 0; index < num_regs; ++index) {
1267 if (index == 0 && vlmul == 2) {
1268 EXPECT_EQ(result[index],
1269 (kUndisturbedResult & kFractionMaskInt8[3]) |
1270 (expected_result[index] & (mask[index] | skip_mask[index]) &
1271 ~kFractionMaskInt8[3]) |
1272 (expected_inactive[index] & ~mask[index] & ~skip_mask[index] &
1273 ~kFractionMaskInt8[3]));
1274 } else if (index == 2 && vlmul == 2) {
1275 EXPECT_EQ(result[index],
1276 (expected_result[index] & (mask[index] | skip_mask[index]) &
1277 kFractionMaskInt8[3]) |
1278 (expected_inactive[index] & ~mask[index] & ~skip_mask[index] &
1279 kFractionMaskInt8[3]) |
1280 ((vta ? kAgnosticResult : kUndisturbedResult) & ~kFractionMaskInt8[3]));
1281 } else if (index == 3 && vlmul == 2) {
1282 EXPECT_EQ(result[index], vta ? kAgnosticResult : kUndisturbedResult);
1283 } else {
1284 EXPECT_EQ(result[index],
1285 (expected_result[index] & (mask[index] | skip_mask[index])) |
1286 (expected_inactive[index] & ~(mask[index] | skip_mask[index])));
1287 }
1288 }
1289 } else {
1290 SIMD128Register affected_part{expected_result[0] &
1291 ((mask[0] & kFractionMaskInt8[vlmul - 4]) | skip_mask[0])};
1292 SIMD128Register masked_part{expected_inactive[0] & ~mask[0] & ~skip_mask[0] &
1293 kFractionMaskInt8[vlmul - 4]};
1294 SIMD128Register tail_part{(vta ? kAgnosticResult : kUndisturbedResult) &
1295 ~kFractionMaskInt8[vlmul - 4]};
1296
1297 EXPECT_EQ(result[0], affected_part | masked_part | tail_part)
1298 << "vlmul=" << uint32_t{vlmul} << " vsew=" << uint32_t{vsew}
1299 << " vma=" << uint32_t{vma} << " vl=" << vl << " vstart=" << vstart
1300 << " affected_part=" << affected_part;
1301 }
1302 }
1303 }
1304 };
1305
1306 // Test with and without masking enabled.
1307 (Verify(exec_masked_insn,
1308 BitUtilLog2(sizeof(std::tuple_element_t<0, ExpectedResultType>)),
1309 expected_result,
1310 MaskForElem<std::tuple_element_t<0, ExpectedResultType>>()),
1311 ...);
1312 (Verify(exec_insn,
1313 BitUtilLog2(sizeof(std::tuple_element_t<0, ExpectedResultType>)),
1314 expected_result,
1315 kNoMask),
1316 ...);
1317 }
1318
TestVectorPermutationInstruction(ExecInsnFunc exec_insn,ExecInsnFunc exec_masked_insn,const UInt8x16Tuple (& expected_result_int8)[8],const UInt16x8Tuple (& expected_result_int16)[8],const UInt32x4Tuple (& expected_result_int32)[8],const UInt64x2Tuple (& expected_result_int64)[8],const SIMD128Register (& source)[16],uint8_t vlmul,uint64_t regt0=0x0,uint64_t skip=0,bool ignore_vma_for_last=false,bool last_elem_is_x1=false)1319 void TestVectorPermutationInstruction(ExecInsnFunc exec_insn,
1320 ExecInsnFunc exec_masked_insn,
1321 const UInt8x16Tuple (&expected_result_int8)[8],
1322 const UInt16x8Tuple (&expected_result_int16)[8],
1323 const UInt32x4Tuple (&expected_result_int32)[8],
1324 const UInt64x2Tuple (&expected_result_int64)[8],
1325 const SIMD128Register (&source)[16],
1326 uint8_t vlmul,
1327 uint64_t regt0 = 0x0,
1328 uint64_t skip = 0,
1329 bool ignore_vma_for_last = false,
1330 bool last_elem_is_x1 = false) {
1331 TestVectorPermutationInstruction<TestVectorInstructionKind::kInteger>(exec_insn,
1332 exec_masked_insn,
1333 source,
1334 vlmul,
1335 skip,
1336 ignore_vma_for_last,
1337 last_elem_is_x1,
1338 regt0,
1339 expected_result_int8,
1340 expected_result_int16,
1341 expected_result_int32,
1342 expected_result_int64);
1343 }
1344
1345 template <typename... ExpectedResultType>
TestVectorMaskTargetInstruction(ExecInsnFunc exec_insn,ExecInsnFunc exec_masked_insn,const SIMD128Register (& source)[16],const ExpectedResultType (&...expected_result))1346 void TestVectorMaskTargetInstruction(ExecInsnFunc exec_insn,
1347 ExecInsnFunc exec_masked_insn,
1348 const SIMD128Register (&source)[16],
1349 const ExpectedResultType(&... expected_result)) {
1350 auto Verify = [&source](
1351 ExecInsnFunc exec_insn, uint8_t vsew, const auto& expected_result, auto mask) {
1352 // Set t0 for vx instructions.
1353 uint64_t scalar_src = 0xaaaa'aaaa'aaaa'aaaa;
1354
1355 // Set ft0 for vf instructions.
1356 if (vsew == 2) {
1357 scalar_src = 0xffff'ffff'40b4'0000; // float 5.625
1358 } else if (vsew == 3) {
1359 scalar_src = 0x4016'8000'0000'0000; // double 5.625
1360 }
1361 for (uint8_t vlmul = 0; vlmul < 8; ++vlmul) {
1362 for (uint8_t vta = 0; vta < 2; ++vta) { // vta should be ignored but we test both values!
1363 for (uint8_t vma = 0; vma < 2; ++vma) {
1364 uint64_t vtype = (vma << 7) | (vta << 6) | (vsew << 3) | vlmul;
1365 uint64_t vlmax = 0;
1366 asm("vsetvl %0, zero, %1" : "=r"(vlmax) : "r"(vtype));
1367 // Incompatible vsew and vlmax. Skip it.
1368 if (vlmax == 0) {
1369 continue;
1370 }
1371
1372 // To make tests quick enough we don't test vstart and vl change with small register
1373 // sets. Only with vlmul == 2 (4 registers) we set vstart and vl to skip half of first
1374 // register, last register and half of next-to last register.
1375 // Don't use vlmul == 3 because that one may not be supported if instruction widens the
1376 // result.
1377 uint64_t vstart;
1378 uint64_t vl;
1379 if (vlmul == 2) {
1380 vstart = vlmax / 8;
1381 vl = (vlmax * 5) / 8;
1382 } else {
1383 vstart = 0;
1384 vl = vlmax;
1385 }
1386
1387 SIMD128Register result[8];
1388 // Set expected_result vector registers into 0b01010101… pattern.
1389 // Set undisturbed result vector registers.
1390 std::fill_n(result, 8, kUndisturbedResult);
1391
1392 RunCommonVectorFunc(
1393 exec_insn, &source[0], &result[0], nullptr, nullptr, scalar_src, vstart, vtype, vl);
1394
1395 SIMD128Register expected_result_in_register(expected_result);
1396 expected_result_in_register = (expected_result_in_register & mask) |
1397 ((vma ? kAgnosticResult : kUndisturbedResult) & ~mask);
1398 // Mask registers are always processing tail like vta is set.
1399 if (vlmax != 128) {
1400 const SIMD128Register vl_mask = MakeBitmaskFromVl(vl);
1401 expected_result_in_register =
1402 (kAgnosticResult & vl_mask) | (expected_result_in_register & ~vl_mask);
1403 }
1404 if (vlmul == 2) {
1405 const SIMD128Register start_mask = MakeBitmaskFromVl(vstart);
1406 expected_result_in_register =
1407 (kUndisturbedResult & ~start_mask) | (expected_result_in_register & start_mask);
1408 }
1409 EXPECT_EQ(result[0], expected_result_in_register)
1410 << "vlmul=" << uint32_t{vlmul} << " vsew=" << uint32_t{vsew}
1411 << " vma=" << uint32_t{vma} << " vl=" << vl << " vstart=" << vstart;
1412 }
1413 }
1414 }
1415 };
1416
1417 ((Verify(exec_insn,
1418 BitUtilLog2(sizeof(__uint128_t) / sizeof(ExpectedResultType)),
1419 expected_result,
1420 kNoMask[0]),
1421 Verify(exec_masked_insn,
1422 BitUtilLog2(sizeof(__uint128_t) / sizeof(ExpectedResultType)),
1423 expected_result,
1424 kMask)),
1425 ...);
1426 }
1427
TestVectorMaskTargetInstruction(ExecInsnFunc exec_insn,ExecInsnFunc exec_masked_insn,const uint32_t expected_result_int32,const uint16_t expected_result_int64,const SIMD128Register (& source)[16])1428 void TestVectorMaskTargetInstruction(ExecInsnFunc exec_insn,
1429 ExecInsnFunc exec_masked_insn,
1430 const uint32_t expected_result_int32,
1431 const uint16_t expected_result_int64,
1432 const SIMD128Register (&source)[16]) {
1433 TestVectorMaskTargetInstruction(
1434 exec_insn, exec_masked_insn, source, expected_result_int32, expected_result_int64);
1435 }
1436
TestVectorMaskTargetInstruction(ExecInsnFunc exec_insn,ExecInsnFunc exec_masked_insn,const UInt8x16Tuple expected_result_int8,const uint64_t expected_result_int16,const uint32_t expected_result_int32,const uint16_t expected_result_int64,const SIMD128Register (& source)[16])1437 void TestVectorMaskTargetInstruction(ExecInsnFunc exec_insn,
1438 ExecInsnFunc exec_masked_insn,
1439 const UInt8x16Tuple expected_result_int8,
1440 const uint64_t expected_result_int16,
1441 const uint32_t expected_result_int32,
1442 const uint16_t expected_result_int64,
1443 const SIMD128Register (&source)[16]) {
1444 TestVectorMaskTargetInstruction(exec_insn,
1445 exec_masked_insn,
1446 source,
1447 expected_result_int8,
1448 expected_result_int16,
1449 expected_result_int32,
1450 expected_result_int64);
1451 }
1452
1453 // clang-format off
1454 #define DEFINE_TWO_ARG_ONE_RES_FUNCTION(Name, Asm) \
1455 [[gnu::naked]] void Exec##Name() { \
1456 asm(#Asm " v8, v16, v24\n\t" \
1457 "ret\n\t"); \
1458 } \
1459 [[gnu::naked]] void ExecMasked##Name() { \
1460 asm(#Asm " v8, v16, v24, v0.t\n\t" \
1461 "ret\n\t"); \
1462 }
1463 // clang-format on
1464
1465 DEFINE_TWO_ARG_ONE_RES_FUNCTION(Vredsum, vredsum.vs)
1466
TEST(InlineAsmTestRiscv64,TestVredsum)1467 TEST(InlineAsmTestRiscv64, TestVredsum) {
1468 TestVectorReductionInstruction(
1469 ExecVredsum,
1470 ExecMaskedVredsum,
1471 // expected_result_vd0_int8
1472 {242, 228, 200, 144, /* unused */ 0, 146, 44, 121},
1473 // expected_result_vd0_int16
1474 {0x0172, 0x82e4, 0x88c8, 0xa090, /* unused */ 0, 0x1300, 0xa904, 0xe119},
1475 // expected_result_vd0_int32
1476 {0xcb44'b932,
1477 0x9407'71e4,
1478 0xa70e'64c8,
1479 0xd312'5090,
1480 /* unused */ 0,
1481 /* unused */ 0,
1482 0x1907'1300,
1483 0xb713'ad09},
1484 // expected_result_vd0_int64
1485 {0xb32f'a926'9f1b'9511,
1486 0x1f99'0d88'fb74'e962,
1487 0xb92c'970e'74e8'52c4,
1488 0xef4e'ad14'6aca'2888,
1489 /* unused */ 0,
1490 /* unused */ 0,
1491 /* unused */ 0,
1492 0x2513'1f0e'1907'1300},
1493 // expected_result_vd0_with_mask_int8
1494 {39, 248, 142, 27, /* unused */ 0, 0, 154, 210},
1495 // expected_result_vd0_with_mask_int16
1496 {0x5f45, 0xc22f, 0x99d0, 0x98bf, /* unused */ 0, 0x1300, 0x1300, 0x4b15},
1497 // expected_result_vd0_with_mask_int32
1498 {0x2d38'1f29,
1499 0x99a1'838a,
1500 0x1989'ef5c,
1501 0x9cf4'4aa1,
1502 /* unused */ 0,
1503 /* unused */ 0,
1504 0x1907'1300,
1505 0x1907'1300},
1506 // expected_result_vd0_with_mask_int64
1507 {0x2513'1f0e'1907'1300,
1508 0x917c'8370'7560'6751,
1509 0x4e56'3842'222a'0c13,
1510 0xc833'9e0e'73df'49b5,
1511 /* unused */ 0,
1512 /* unused */ 0,
1513 /* unused */ 0,
1514 0x2513'1f0e'1907'1300},
1515 kVectorCalculationsSource);
1516 }
1517
1518 DEFINE_TWO_ARG_ONE_RES_FUNCTION(Vwredsumu, vwredsumu.vs)
1519
TEST(InlineAsmTestRiscv64,TestVwredsumu)1520 TEST(InlineAsmTestRiscv64, TestVwredsumu) {
1521 TestWideningVectorReductionInstruction(
1522 ExecVwredsumu,
1523 ExecMaskedVwredsumu,
1524 // expected_result_vd0_int16
1525 {0x85f2, 0x8ce4, 0xa0c8, 0xc090, /* unused */ 0, 0x8192, 0x822c, 0x8379},
1526 // expected_result_vd0_int32
1527 {0x8307'0172,
1528 0x830c'82e4,
1529 0x831a'88c8,
1530 0x8322'a090,
1531 /* unused */ 0,
1532 0x8303'1300,
1533 0x8303'a904,
1534 0x8304'e119},
1535 // expected_result_vd0_int64
1536 {0x8706'8506'cb44'b932,
1537 0x8706'8509'9407'71e4,
1538 0x8706'8510'a70e'64c8,
1539 0x8706'8514'd312'5090,
1540 /* unused */ 0,
1541 /* unused */ 0,
1542 0x8706'8505'1907'1300,
1543 0x8706'8505'b713'ad09},
1544 // expected_result_vd0_with_mask_int16
1545 {0x8427, 0x88f8, 0x948e, 0xab1b, /* unused */ 0, 0x8100, 0x819a, 0x82d2},
1546 // expected_result_vd0_with_mask_int32
1547 {0x8305'5f45,
1548 0x8308'c22f,
1549 0x8311'99d0,
1550 0x8316'98bf,
1551 /* unused */ 0,
1552 0x8303'1300,
1553 0x8303'1300,
1554 0x8304'4b15},
1555 // expected_result_vd0_with_mask_int64
1556 {0x8706'8506'2d38'1f29,
1557 0x8706'8507'99a1'838a,
1558 0x8706'850c'1989'ef5c,
1559 0x8706'850e'9cf4'4aa1,
1560 /* unused */ 0,
1561 /* unused */ 0,
1562 0x8706'8505'1907'1300,
1563 0x8706'8505'1907'1300},
1564 kVectorCalculationsSource);
1565 }
1566
1567 DEFINE_TWO_ARG_ONE_RES_FUNCTION(Vwredsum, vwredsum.vs)
1568
TEST(InlineAsmTestRiscv64,TestVwredsum)1569 TEST(InlineAsmTestRiscv64, TestVwredsum) {
1570 TestWideningVectorReductionInstruction(
1571 ExecVwredsum,
1572 ExecMaskedVwredsum,
1573 // expected_result_vd0_int16
1574 {0x7df2, 0x7ce4, 0x80c8, 0x8090, /* unused */ 0, 0x8092, 0x802c, 0x7f79},
1575 // expected_result_vd0_int32
1576 {0x82ff'0172,
1577 0x82fc'82e4,
1578 0x82fa'88c8,
1579 0x8302'a090,
1580 /* unused */ 0,
1581 0x8302'1300,
1582 0x8301'a904,
1583 0x8300'e119},
1584 // expected_result_vd0_int64
1585 {0x8706'8502'cb44'b932,
1586 0x8706'8501'9407'71e4,
1587 0x8706'8500'a70e'64c8,
1588 0x8706'8504'd312'5090,
1589 /* unused */ 0,
1590 /* unused */ 0,
1591 0x8706'8504'1907'1300,
1592 0x8706'8503'b713'ad09},
1593 // expected_result_vd0_with_mask_int16
1594 {0x7f27, 0x7df8, 0x818e, 0x811b, /* unused */ 0, 0x8100, 0x809a, 0x7fd2},
1595 // expected_result_vd0_with_mask_int32
1596 {0x8300'5f45,
1597 0x82fe'c22f,
1598 0x82fd'99d0,
1599 0x8302'98bf,
1600 /* unused */ 0,
1601 0x8302'1300,
1602 0x8302'1300,
1603 0x8301'4b15},
1604 // expected_result_vd0_with_mask_int64
1605 {0x8706'8503'2d38'1f29,
1606 0x8706'8502'99a1'838a,
1607 0x8706'8502'1989'ef5c,
1608 0x8706'8504'9cf4'4aa1,
1609 /* unused */ 0,
1610 /* unused */ 0,
1611 0x8706'8504'1907'1300,
1612 0x8706'8504'1907'1300},
1613 kVectorCalculationsSource);
1614 }
1615
1616 DEFINE_TWO_ARG_ONE_RES_FUNCTION(Vfredosum, vfredosum.vs)
1617
TEST(InlineAsmTestRiscv64,TestVfredosum)1618 TEST(InlineAsmTestRiscv64, TestVfredosum) {
1619 TestVectorReductionInstruction(ExecVfredosum,
1620 ExecMaskedVfredosum,
1621 // expected_result_vd0_int32
1622 {0x9e0c'9a8e,
1623 0xbe2c'bace,
1624 0xfe6c'fb4e,
1625 0x7e6b'fc4d,
1626 /* unused */ 0,
1627 /* unused */ 0,
1628 0x9604'9200,
1629 0x9e0c'9a8e},
1630 // expected_result_vd0_int64
1631 {0x9e0c'9a09'9604'9200,
1632 0xbe2c'ba29'b624'b220,
1633 0xfe6c'fa69'f664'f260,
1634 0x7eec'5def'0cee'0dee,
1635 /* unused */ 0,
1636 /* unused */ 0,
1637 /* unused */ 0,
1638 0x9e0c'9a09'9604'9200},
1639 // expected_result_vd0_with_mask_int32
1640 {0x9604'929d,
1641 0xbe2c'ba29,
1642 0xfe6c'fb4e,
1643 0x7e6b'fa84,
1644 /* unused */ 0,
1645 /* unused */ 0,
1646 0x9604'9200,
1647 0x9604'9200},
1648 // expected_result_vd0_with_mask_int64
1649 {0x9e0c'9a09'9604'9200,
1650 0xbe2c'ba29'b624'b220,
1651 0xee7c'ea78'e674'e271,
1652 0x6efc'4e0d'ee0d'ee0f,
1653 /* unused */ 0,
1654 /* unused */ 0,
1655 /* unused */ 0,
1656 0x9e0c'9a09'9604'9200},
1657 kVectorCalculationsSource);
1658 }
1659
1660 DEFINE_TWO_ARG_ONE_RES_FUNCTION(Vfredusum, vfredusum.vs)
1661
1662 // Currently Vfredusum is implemented as Vfredosum (as explicitly permitted by RVV 1.0).
1663 // If we would implement some speedups which would change results then we may need to alter tests.
TEST(InlineAsmTestRiscv64,TestVfredusum)1664 TEST(InlineAsmTestRiscv64, TestVfredusum) {
1665 TestVectorReductionInstruction(ExecVfredusum,
1666 ExecMaskedVfredusum,
1667 // expected_result_vd0_int32
1668 {0x9e0c'9a8e,
1669 0xbe2c'bace,
1670 0xfe6c'fb4e,
1671 0x7e6b'fc4d,
1672 /* unused */ 0,
1673 /* unused */ 0,
1674 0x9604'9200,
1675 0x9e0c'9a8e},
1676 // expected_result_vd0_int64
1677 {0x9e0c'9a09'9604'9200,
1678 0xbe2c'ba29'b624'b220,
1679 0xfe6c'fa69'f664'f260,
1680 0x7eec'5def'0cee'0dee,
1681 /* unused */ 0,
1682 /* unused */ 0,
1683 /* unused */ 0,
1684 0x9e0c'9a09'9604'9200},
1685 // expected_result_vd0_with_mask_int32
1686 {0x9604'929d,
1687 0xbe2c'ba29,
1688 0xfe6c'fb4e,
1689 0x7e6b'fa84,
1690 /* unused */ 0,
1691 /* unused */ 0,
1692 0x9604'9200,
1693 0x9604'9200},
1694 // expected_result_vd0_with_mask_int64
1695 {0x9e0c'9a09'9604'9200,
1696 0xbe2c'ba29'b624'b220,
1697 0xee7c'ea78'e674'e271,
1698 0x6efc'4e0d'ee0d'ee0f,
1699 /* unused */ 0,
1700 /* unused */ 0,
1701 /* unused */ 0,
1702 0x9e0c'9a09'9604'9200},
1703 kVectorCalculationsSource);
1704 }
1705
1706 DEFINE_TWO_ARG_ONE_RES_FUNCTION(Vfwredusum, vfwredusum.vs)
1707
1708 // We currently don't support half-precision (16-bit) floats, so only check 32-bit to 64-bit
1709 // widening.
TEST(InlineAsmTestRiscv64,TestVfwredusum)1710 TEST(InlineAsmTestRiscv64, TestVfwredusum) {
1711 TestWideningVectorReductionInstruction(ExecVfwredusum,
1712 ExecMaskedVfwredusum,
1713 // expected_result_vd0_int64
1714 {0xbbc1'9351'b253'9156,
1715 0xbfc5'9759'b65b'955e,
1716 0xc7cd'9f69'be6b'9d6e,
1717 0x47cd'7f89'9e8b'7d8d,
1718 /* unused */ 0,
1719 /* unused */ 0,
1720 0xbac0'9240'0000'0000,
1721 0xbbc1'9351'b240'0000},
1722 // expected_result_vd0_with_mask_int64
1723 {0xbac0'9253'9155'9042,
1724 0xbfc5'9745'2017'9547,
1725 0xc7cd'9f69'be6b'9d4f,
1726 0x47cd'7f50'81d3'7d6f,
1727 /* unused */ 0,
1728 /* unused */ 0,
1729 0xbac0'9240'0000'0000,
1730 0xbac0'9240'0000'0000},
1731 kVectorCalculationsSource);
1732 }
1733
1734 DEFINE_TWO_ARG_ONE_RES_FUNCTION(Vfwredosum, vfwredosum.vs)
1735
1736 // We currently don't support half-precision (16-bit) floats, so only check 32-bit to 64-bit
1737 // widening.
TEST(InlineAsmTestRiscv64,TestVfwredosum)1738 TEST(InlineAsmTestRiscv64, TestVfwredosum) {
1739 TestWideningVectorReductionInstruction(ExecVfwredosum,
1740 ExecMaskedVfwredosum,
1741 // expected_result_vd0_int64
1742 {0xbbc1'9351'b253'9156,
1743 0xbfc5'9759'b65b'955e,
1744 0xc7cd'9f69'be6b'9d6e,
1745 0x47cd'7f89'9e8b'7d8d,
1746 /* unused */ 0,
1747 /* unused */ 0,
1748 0xbac0'9240'0000'0000,
1749 0xbbc1'9351'b240'0000},
1750 // expected_result_vd0_with_mask_int64
1751 {0xbac0'9253'9155'9042,
1752 0xbfc5'9745'2017'9547,
1753 0xc7cd'9f69'be6b'9d4f,
1754 0x47cd'7f50'81d3'7d6f,
1755 /* unused */ 0,
1756 /* unused */ 0,
1757 0xbac0'9240'0000'0000,
1758 0xbac0'9240'0000'0000},
1759 kVectorCalculationsSource);
1760 }
1761
1762 DEFINE_TWO_ARG_ONE_RES_FUNCTION(Vredand, vredand.vs)
1763
TEST(InlineAsmTestRiscv64,TestVredand)1764 TEST(InlineAsmTestRiscv64, TestVredand) {
1765 TestVectorReductionInstruction(
1766 ExecVredand,
1767 ExecMaskedVredand,
1768 // expected_result_vd0_int8
1769 {0, 0, 0, 0, /* unused */ 0, 0, 0, 0},
1770 // expected_result_vd0_int16
1771 {0x8000, 0x8000, 0x8000, 0x0000, /* unused */ 0, 0x8000, 0x8000, 0x8000},
1772 // expected_result_vd0_int32
1773 {0x8200'8000,
1774 0x8200'8000,
1775 0x8200'8000,
1776 0x0200'0000,
1777 /* unused */ 0,
1778 /* unused */ 0,
1779 0x8200'8000,
1780 0x8200'8000},
1781 // expected_result_vd0_int64
1782 {0x8604'8000'8200'8000,
1783 0x8604'8000'8200'8000,
1784 0x8604'8000'8200'8000,
1785 0x0604'0000'0200'0000,
1786 /* unused */ 0,
1787 /* unused */ 0,
1788 /* unused */ 0,
1789 0x8604'8000'8200'8000},
1790 // expected_result_vd0_with_mask_int8
1791 {0, 0, 0, 0, /* unused */ 0, 0, 0, 0},
1792 // expected_result_vd0_with_mask_int16
1793 {0x8000, 0x8000, 0x8000, 0x0000, /* unused */ 0, 0x8000, 0x8000, 0x8000},
1794 // expected_result_vd0_with_mask_int32
1795 {0x8200'8000,
1796 0x8200'8000,
1797 0x8200'8000,
1798 0x0200'0000,
1799 /* unused */ 0,
1800 /* unused */ 0,
1801 0x8200'8000,
1802 0x8200'8000},
1803 // expected_result_vd0_with_mask_int64
1804 {0x8604'8000'8200'8000,
1805 0x8604'8000'8200'8000,
1806 0x8604'8000'8200'8000,
1807 0x0604'0000'0200'0000,
1808 /* unused */ 0,
1809 /* unused */ 0,
1810 /* unused */ 0,
1811 0x8604'8000'8200'8000},
1812 kVectorCalculationsSource);
1813 }
1814
1815 DEFINE_TWO_ARG_ONE_RES_FUNCTION(Vredor, vredor.vs)
1816
TEST(InlineAsmTestRiscv64,TestVredor)1817 TEST(InlineAsmTestRiscv64, TestVredor) {
1818 TestVectorReductionInstruction(
1819 ExecVredor,
1820 ExecMaskedVredor,
1821 // expected_result_vd0_int8
1822 {159, 191, 255, 255, /* unused */ 0, 146, 150, 159},
1823 // expected_result_vd0_int16
1824 {0x9f1d, 0xbf3d, 0xff7d, 0xfffd, /* unused */ 0, 0x9300, 0x9704, 0x9f0d},
1825 // expected_result_vd0_int32
1826 {0x9f1e'9b19,
1827 0xbf3e'bb39,
1828 0xff7e'fb79,
1829 0xfffe'fbf9,
1830 /* unused */ 0,
1831 /* unused */ 0,
1832 0x9706'9300,
1833 0x9f0e'9b09},
1834 // expected_result_vd0_int64
1835 {0x9f1e'9f1d'9716'9311,
1836 0xbf3e'bf3d'b736'b331,
1837 0xff7e'ff7d'f776'f371,
1838 0xfffe'fffd'f7f6'f3f1,
1839 /* unused */ 0,
1840 /* unused */ 0,
1841 /* unused */ 0,
1842 0x9f0e'9f0d'9706'9300},
1843 // expected_result_vd0_with_mask_int8
1844 {159, 191, 255, 255, /* unused */ 0, 0, 150, 158},
1845 // expected_result_vd0_with_mask_int16
1846 {0x9f1d, 0xbf3d, 0xff7d, 0xfffd, /* unused */ 0, 0x9300, 0x9300, 0x9f0d},
1847 // expected_result_vd0_with_mask_int32
1848 {0x9f1e'9b19,
1849 0xbf3e'bb39,
1850 0xff7e'fb79,
1851 0xfffe'fbf9,
1852 /* unused */ 0,
1853 /* unused */ 0,
1854 0x9706'9300,
1855 0x9706'9300},
1856 // expected_result_vd0_with_mask_int64
1857 {0x9f0e'9f0d'9706'9300,
1858 0xbf3e'bf3d'b736'b331,
1859 0xff7e'ff7d'f776'f371,
1860 0xfffe'fffd'f7f6'f3f1,
1861 /* unused */ 0,
1862 /* unused */ 0,
1863 /* unused */ 0,
1864 0x9f0e'9f0d'9706'9300},
1865 kVectorCalculationsSource);
1866 }
1867
1868 DEFINE_TWO_ARG_ONE_RES_FUNCTION(Vredxor, vredxor.vs)
1869
TEST(InlineAsmTestRiscv64,TestVredxor)1870 TEST(InlineAsmTestRiscv64, TestVredxor) {
1871 TestVectorReductionInstruction(
1872 ExecVredxor,
1873 ExecMaskedVredxor,
1874 // expected_result_vd0_int8
1875 {0, 0, 0, 0, /* unused */ 0, 146, 0, 1},
1876 // expected_result_vd0_int16
1877 {0x8100, 0x8100, 0x8100, 0x8100, /* unused */ 0, 0x1300, 0x8504, 0x8101},
1878 // expected_result_vd0_int32
1879 {0x8302'8100,
1880 0x8302'8100,
1881 0x8302'8100,
1882 0x8302'8100,
1883 /* unused */ 0,
1884 /* unused */ 0,
1885 0x1506'1300,
1886 0x8b0a'8909},
1887 // expected_result_vd0_int64
1888 {0x9716'9515'9312'9111,
1889 0x8706'8504'8302'8100,
1890 0x8706'8504'8302'8100,
1891 0x8706'8504'8302'8100,
1892 /* unused */ 0,
1893 /* unused */ 0,
1894 /* unused */ 0,
1895 0x190a'1f0d'1506'1300},
1896 // expected_result_vd0_with_mask_int8
1897 {143, 154, 150, 43, /* unused */ 0, 0, 146, 150},
1898 // expected_result_vd0_with_mask_int16
1899 {0x1f0d, 0xbd3d, 0x9514, 0x8d0d, /* unused */ 0, 0x1300, 0x1300, 0x1705},
1900 // expected_result_vd0_with_mask_int32
1901 {0x1d0e'1b09,
1902 0x0d1e'0b18,
1903 0xfb7a'f978,
1904 0xab2a'a929,
1905 /* unused */ 0,
1906 /* unused */ 0,
1907 0x1506'1300,
1908 0x1506'1300},
1909 // expected_result_vd0_with_mask_int64
1910 {0x190a'1f0d'1506'1300,
1911 0x091a'0f1c'0516'0311,
1912 0x293a'2f3c'2536'2331,
1913 0x77f6'75f5'73f2'71f1,
1914 /* unused */ 0,
1915 /* unused */ 0,
1916 /* unused */ 0,
1917 0x190a'1f0d'1506'1300},
1918 kVectorCalculationsSource);
1919 }
1920
1921 DEFINE_TWO_ARG_ONE_RES_FUNCTION(Vredminu, vredminu.vs)
1922
TEST(InlineAsmTestRiscv64,TestVredminu)1923 TEST(InlineAsmTestRiscv64, TestVredminu) {
1924 TestVectorReductionInstruction(
1925 ExecVredminu,
1926 ExecMaskedVredminu,
1927 // expected_result_vd0_int8
1928 {0, 0, 0, 0, /* unused */ 0, 0, 0, 0},
1929 // expected_result_vd0_int16
1930 {0x8100, 0x8100, 0x8100, 0x0291, /* unused */ 0, 0x8100, 0x8100, 0x8100},
1931 // expected_result_vd0_int32
1932 {0x83028100,
1933 0x83028100,
1934 0x83028100,
1935 0x06940291,
1936 /* unused */ 0,
1937 /* unused */ 0,
1938 0x83028100,
1939 0x83028100},
1940 // expected_result_vd0_int64
1941 {0x8706'8504'8302'8100,
1942 0x8706'8504'8302'8100,
1943 0x8706'8504'8302'8100,
1944 0x0e9c'0a98'0694'0291,
1945 /* unused */ 0,
1946 /* unused */ 0,
1947 /* unused */ 0,
1948 0x8706'8504'8302'8100},
1949 // expected_result_vd0_with_mask_int8
1950 {0, 0, 0, 0, /* unused */ 0, 0, 0, 0},
1951 // expected_result_vd0_with_mask_int16
1952 {0x8100, 0x8100, 0x8100, 0x0291, /* unused */ 0, 0x8100, 0x8100, 0x8100},
1953 // expected_result_vd0_with_mask_int32
1954 {0x8302'8100,
1955 0x8302'8100,
1956 0x8302'8100,
1957 0x0e9c'0a98,
1958 /* unused */ 0,
1959 /* unused */ 0,
1960 0x8302'8100,
1961 0x8302'8100},
1962 // expected_result_vd0_with_mask_int64
1963 {0x8706'8504'8302'8100,
1964 0x8706'8504'8302'8100,
1965 0x8706'8504'8302'8100,
1966 0x1e8c'1a89'1684'1280,
1967 /* unused */ 0,
1968 /* unused */ 0,
1969 /* unused */ 0,
1970 0x8706'8504'8302'8100},
1971 kVectorCalculationsSource);
1972 }
1973
1974 DEFINE_TWO_ARG_ONE_RES_FUNCTION(Vredmin, vredmin.vs)
1975
TEST(InlineAsmTestRiscv64,TestVredmin)1976 TEST(InlineAsmTestRiscv64, TestVredmin) {
1977 TestVectorReductionInstruction(
1978 ExecVredmin,
1979 ExecMaskedVredmin,
1980 // expected_result_vd0_int8
1981 {130, 130, 130, 128, /* unused */ 0, 146, 146, 146},
1982 // expected_result_vd0_int16
1983 {0x8100, 0x8100, 0x8100, 0x8100, /* unused */ 0, 0x8100, 0x8100, 0x8100},
1984 // expected_result_vd0_int32
1985 {0x8302'8100,
1986 0x8302'8100,
1987 0x8302'8100,
1988 0x8302'8100,
1989 /* unused */ 0,
1990 /* unused */ 0,
1991 0x8302'8100,
1992 0x8302'8100},
1993 // expected_result_vd0_int64
1994 {0x8706'8504'8302'8100,
1995 0x8706'8504'8302'8100,
1996 0x8706'8504'8302'8100,
1997 0x8706'8504'8302'8100,
1998 /* unused */ 0,
1999 /* unused */ 0,
2000 /* unused */ 0,
2001 0x8706'8504'8302'8100},
2002 // expected_result_vd0_with_mask_int8
2003 {138, 138, 138, 128, /* unused */ 0, 0, 150, 150},
2004 // expected_result_vd0_with_mask_int16
2005 {0x8100, 0x8100, 0x8100, 0x8100, /* unused */ 0, 0x8100, 0x8100, 0x8100},
2006 // expected_result_vd0_with_mask_int32
2007 {0x8302'8100,
2008 0x8302'8100,
2009 0x8302'8100,
2010 0x8302'8100,
2011 /* unused */ 0,
2012 /* unused */ 0,
2013 0x8302'8100,
2014 0x8302'8100},
2015 // expected_result_vd0_with_mask_int64
2016 {0x8706'8504'8302'8100,
2017 0x8706'8504'8302'8100,
2018 0x8706'8504'8302'8100,
2019 0x8706'8504'8302'8100,
2020 /* unused */ 0,
2021 /* unused */ 0,
2022 /* unused */ 0,
2023 0x8706'8504'8302'8100},
2024 kVectorCalculationsSource);
2025 }
2026
2027 DEFINE_TWO_ARG_ONE_RES_FUNCTION(Vfredmin, vfredmin.vs)
2028
TEST(InlineAsmTestRiscv64,TestVfredmin)2029 TEST(InlineAsmTestRiscv64, TestVfredmin) {
2030 TestVectorReductionInstruction(ExecVfredmin,
2031 ExecMaskedVfredmin,
2032 // expected_result_vd0_int32
2033 {0x9e0c'9a09,
2034 0xbe2c'ba29,
2035 0xfe6c'fa69,
2036 0xfe6c'fa69,
2037 /* unused */ 0,
2038 /* unused */ 0,
2039 0x9604'9200,
2040 0x9e0c'9a09},
2041 // expected_result_vd0_int64
2042 {0x9e0c'9a09'9604'9200,
2043 0xbe2c'ba29'b624'b220,
2044 0xfe6c'fa69'f664'f260,
2045 0xfe6c'fa69'f664'f260,
2046 /* unused */ 0,
2047 /* unused */ 0,
2048 /* unused */ 0,
2049 0x9e0c'9a09'9604'9200},
2050 // expected_result_vd0_with_mask_int32
2051 {0x9604'9200,
2052 0xbe2c'ba29,
2053 0xfe6c'fa69,
2054 0xfe6c'fa69,
2055 /* unused */ 0,
2056 /* unused */ 0,
2057 0x9604'9200,
2058 0x9604'9200},
2059 // expected_result_vd0_with_mask_int64
2060 {0x9e0c'9a09'9604'9200,
2061 0xbe2c'ba29'b624'b220,
2062 0xee7c'ea78'e674'e271,
2063 0xee7c'ea78'e674'e271,
2064 /* unused */ 0,
2065 /* unused */ 0,
2066 /* unused */ 0,
2067 0x9e0c'9a09'9604'9200},
2068 kVectorCalculationsSource);
2069 }
2070
2071 DEFINE_TWO_ARG_ONE_RES_FUNCTION(Vredmaxu, vredmaxu.vs)
2072
TEST(InlineAsmTestRiscv64,TestVredmaxu)2073 TEST(InlineAsmTestRiscv64, TestVredmaxu) {
2074 TestVectorReductionInstruction(
2075 ExecVredmaxu,
2076 ExecMaskedVredmaxu,
2077 // expected_result_vd0_int8
2078 {158, 190, 254, 254, /* unused */ 0, 146, 150, 158},
2079 // expected_result_vd0_int16
2080 {0x9e0c, 0xbe2c, 0xfe6c, 0xfe6c, /* unused */ 0, 0x9200, 0x9604, 0x9e0c},
2081 // expected_result_vd0_int32
2082 {0x9e0c'9a09,
2083 0xbe2c'ba29,
2084 0xfe6c'fa69,
2085 0xfe6c'fa69,
2086 /* unused */ 0,
2087 /* unused */ 0,
2088 0x9604'9200,
2089 0x9e0c'9a09},
2090 // expected_result_vd0_int64
2091 {0x9e0c'9a09'9604'9200,
2092 0xbe2c'ba29'b624'b220,
2093 0xfe6c'fa69'f664'f260,
2094 0xfe6c'fa69'f664'f260,
2095 /* unused */ 0,
2096 /* unused */ 0,
2097 /* unused */ 0,
2098 0x9e0c'9a09'9604'9200},
2099 // expected_result_vd0_with_mask_int8
2100 {158, 186, 254, 254, /* unused */ 0, 0, 150, 158},
2101 // expected_result_vd0_with_mask_int16
2102 {0x9e0c, 0xba29, 0xfe6c, 0xfe6c, /* unused */ 0, 0x9200, 0x9200, 0x9e0c},
2103 // expected_result_vd0_with_mask_int32
2104 {0x9604'9200,
2105 0xbe2c'ba29,
2106 0xfe6c'fa69,
2107 0xfe6c'fa69,
2108 /* unused */ 0,
2109 /* unused */ 0,
2110 0x9604'9200,
2111 0x9604'9200},
2112 // expected_result_vd0_with_mask_int64
2113 {0x9e0c'9a09'9604'9200,
2114 0xbe2c'ba29'b624'b220,
2115 0xee7c'ea78'e674'e271,
2116 0xee7c'ea78'e674'e271,
2117 /* unused */ 0,
2118 /* unused */ 0,
2119 /* unused */ 0,
2120 0x9e0c'9a09'9604'9200},
2121 kVectorCalculationsSource);
2122 }
2123
2124 DEFINE_TWO_ARG_ONE_RES_FUNCTION(Vredmax, vredmax.vs)
2125
TEST(InlineAsmTestRiscv64,TestVredmax)2126 TEST(InlineAsmTestRiscv64, TestVredmax) {
2127 TestVectorReductionInstruction(
2128 ExecVredmax,
2129 ExecMaskedVredmax,
2130 // expected_result_vd0_int8
2131 {28, 60, 124, 126, /* unused */ 0, 0, 4, 12},
2132 // expected_result_vd0_int16
2133 {0x9e0c, 0xbe2c, 0xfe6c, 0x7eec, /* unused */ 0, 0x9200, 0x9604, 0x9e0c},
2134 // expected_result_vd0_int32
2135 {0x9e0c'9a09,
2136 0xbe2c'ba29,
2137 0xfe6c'fa69,
2138 0x7eec'7ae9,
2139 /* unused */ 0,
2140 /* unused */ 0,
2141 0x9604'9200,
2142 0x9e0c'9a09},
2143 // expected_result_vd0_int64
2144 {0x9e0c'9a09'9604'9200,
2145 0xbe2c'ba29'b624'b220,
2146 0xfe6c'fa69'f664'f260,
2147 0x7eec'7ae9'76e4'72e0,
2148 /* unused */ 0,
2149 /* unused */ 0,
2150 /* unused */ 0,
2151 0x9e0c'9a09'9604'9200},
2152 // expected_result_vd0_with_mask_int8
2153 {24, 52, 124, 126, /* unused */ 0, 0, 4, 4},
2154 // expected_result_vd0_with_mask_int16
2155 {0x9e0c, 0xba29, 0xfe6c, 0x7ae9, /* unused */ 0, 0x9200, 0x9200, 0x9e0c},
2156 // expected_result_vd0_with_mask_int32
2157 {0x9604'9200,
2158 0xbe2c'ba29,
2159 0xfe6c'fa69,
2160 0x7eec'7ae9,
2161 /* unused */ 0,
2162 /* unused */ 0,
2163 0x9604'9200,
2164 0x9604'9200},
2165 // expected_result_vd0_with_mask_int64
2166 {0x9e0c'9a09'9604'9200,
2167 0xbe2c'ba29'b624'b220,
2168 0xee7c'ea78'e674'e271,
2169 0x6efc'6af8'66f4'62f1,
2170 /* unused */ 0,
2171 /* unused */ 0,
2172 /* unused */ 0,
2173 0x9e0c'9a09'9604'9200},
2174 kVectorCalculationsSource);
2175 }
2176
2177 DEFINE_TWO_ARG_ONE_RES_FUNCTION(Vfredmax, vfredmax.vs)
2178
TEST(InlineAsmTestRiscv64,TestVfredmax)2179 TEST(InlineAsmTestRiscv64, TestVfredmax) {
2180 TestVectorReductionInstruction(ExecVfredmax,
2181 ExecMaskedVfredmax,
2182 // expected_result_vd0_int32
2183 {0x8302'8100,
2184 0x8302'8100,
2185 0x8302'8100,
2186 0x7eec'7ae9,
2187 /* unused */ 0,
2188 /* unused */ 0,
2189 0x8302'8100,
2190 0x8302'8100},
2191 // expected_result_vd0_int64
2192 {0x8706'8504'8302'8100,
2193 0x8706'8504'8302'8100,
2194 0x8706'8504'8302'8100,
2195 0x7eec'7ae9'76e4'72e0,
2196 /* unused */ 0,
2197 /* unused */ 0,
2198 /* unused */ 0,
2199 0x8706'8504'8302'8100},
2200 // expected_result_vd0_with_mask_int32
2201 {0x8302'8100,
2202 0x8302'8100,
2203 0x8302'8100,
2204 0x7eec'7ae9,
2205 /* unused */ 0,
2206 /* unused */ 0,
2207 0x8302'8100,
2208 0x8302'8100},
2209 // expected_result_vd0_with_mask_int64
2210 {0x8706'8504'8302'8100,
2211 0x8706'8504'8302'8100,
2212 0x8706'8504'8302'8100,
2213 0x6efc'6af8'66f4'62f1,
2214 /* unused */ 0,
2215 /* unused */ 0,
2216 /* unused */ 0,
2217 0x8706'8504'8302'8100},
2218 kVectorCalculationsSource);
2219 }
2220
2221 #undef DEFINE_TWO_ARG_ONE_RES_FUNCTION
2222
ExecVfsqrtv()2223 [[gnu::naked]] void ExecVfsqrtv() {
2224 asm("vfsqrt.v v8, v24\n\t"
2225 "ret\n\t");
2226 }
2227
ExecMaskedVfsqrtv()2228 [[gnu::naked]] void ExecMaskedVfsqrtv() {
2229 asm("vfsqrt.v v8, v24, v0.t\n\t"
2230 "ret\n\t");
2231 }
2232
TEST(InlineAsmTestRiscv64,TestVfsqrtv)2233 TEST(InlineAsmTestRiscv64, TestVfsqrtv) {
2234 TestVectorFloatInstruction(ExecVfsqrtv,
2235 ExecMaskedVfsqrtv,
2236 {{0x7fc0'0000, 0x7fc0'0000, 0x7fc0'0000, 0x7fc0'0000},
2237 {0x7fc0'0000, 0x7fc0'0000, 0x7fc0'0000, 0x7fc0'0000},
2238 {0x7fc0'0000, 0x7fc0'0000, 0x7fc0'0000, 0x7fc0'0000},
2239 {0x7fc0'0000, 0x7fc0'0000, 0x7fc0'0000, 0x7fc0'0000},
2240 {0x2b02'052b, 0x2f05'ea47, 0x2309'a451, 0x270d'53b1},
2241 {0x3b10'f937, 0x3f14'7a09, 0x3317'd8b1, 0x371b'31d0},
2242 {0x4b1e'85c1, 0x4f21'bb83, 0x4324'd4da, 0x4727'ebbf},
2243 {0x5b2b'0054, 0x5f2d'fb2f, 0x5330'dd9e, 0x5733'bf97}},
2244 {{0x7ff8'0000'0000'0000, 0x7ff8'0000'0000'0000},
2245 {0x7ff8'0000'0000'0000, 0x7ff8'0000'0000'0000},
2246 {0x7ff8'0000'0000'0000, 0x7ff8'0000'0000'0000},
2247 {0x7ff8'0000'0000'0000, 0x7ff8'0000'0000'0000},
2248 {0x2f3d'fd15'c59f'19b3, 0x2745'2e80'5593'4661},
2249 {0x3f4e'0e34'c013'd37a, 0x3755'3a9e'ffea'ec9f},
2250 {0x4f5e'1f49'ff52'69b6, 0x4765'46b6'c2dc'cddd},
2251 {0x5f6e'3055'93df'fb07, 0x5775'52c7'aa27'df73}},
2252 kVectorCalculationsSource);
2253 }
2254
ExecVfcvtxufv()2255 [[gnu::naked]] void ExecVfcvtxufv() {
2256 asm("vfcvt.xu.f.v v8, v24\n\t"
2257 "ret\n\t");
2258 }
2259
ExecMaskedVfcvtxufv()2260 [[gnu::naked]] void ExecMaskedVfcvtxufv() {
2261 asm("vfcvt.xu.f.v v8, v24, v0.t\n\t"
2262 "ret\n\t");
2263 }
2264
ExecVfcvtxfv()2265 [[gnu::naked]] void ExecVfcvtxfv() {
2266 asm("vfcvt.x.f.v v8, v24\n\t"
2267 "ret\n\t");
2268 }
2269
ExecMaskedVfcvtxfv()2270 [[gnu::naked]] void ExecMaskedVfcvtxfv() {
2271 asm("vfcvt.x.f.v v8, v24, v0.t\n\t"
2272 "ret\n\t");
2273 }
2274
ExecVfcvtfxuv()2275 [[gnu::naked]] void ExecVfcvtfxuv() {
2276 asm("vfcvt.f.xu.v v8, v24\n\t"
2277 "ret\n\t");
2278 }
2279
ExecMaskedVfcvtfxuv()2280 [[gnu::naked]] void ExecMaskedVfcvtfxuv() {
2281 asm("vfcvt.f.xu.v v8, v24, v0.t\n\t"
2282 "ret\n\t");
2283 }
2284
ExecVfcvtfxv()2285 [[gnu::naked]] void ExecVfcvtfxv() {
2286 asm("vfcvt.f.x.v v8, v24\n\t"
2287 "ret\n\t");
2288 }
2289
ExecMaskedVfcvtfxv()2290 [[gnu::naked]] void ExecMaskedVfcvtfxv() {
2291 asm("vfcvt.f.x.v v8, v24, v0.t\n\t"
2292 "ret\n\t");
2293 }
2294
ExecVfcvtrtzxuf()2295 [[gnu::naked]] void ExecVfcvtrtzxuf() {
2296 asm("vfcvt.rtz.xu.f.v v8, v24\n\t"
2297 "ret\n\t");
2298 }
2299
ExecMaskedVfcvtrtzxuf()2300 [[gnu::naked]] void ExecMaskedVfcvtrtzxuf() {
2301 asm("vfcvt.rtz.xu.f.v v8, v24, v0.t\n\t"
2302 "ret\n\t");
2303 }
2304
ExecVfcvtrtzxf()2305 [[gnu::naked]] void ExecVfcvtrtzxf() {
2306 asm("vfcvt.rtz.x.f.v v8, v24\n\t"
2307 "ret\n\t");
2308 }
2309
ExecMaskedVfcvtrtzxf()2310 [[gnu::naked]] void ExecMaskedVfcvtrtzxf() {
2311 asm("vfcvt.rtz.x.f.v v8, v24, v0.t\n\t"
2312 "ret\n\t");
2313 }
2314
ExecVfwcvtxufv()2315 [[gnu::naked]] void ExecVfwcvtxufv() {
2316 asm("vfwcvt.xu.f.v v8, v28\n\t"
2317 "ret\n\t");
2318 }
2319
ExecMaskedVfwcvtxufv()2320 [[gnu::naked]] void ExecMaskedVfwcvtxufv() {
2321 asm("vfwcvt.xu.f.v v8, v28, v0.t\n\t"
2322 "ret\n\t");
2323 }
2324
ExecVfwcvtxfv()2325 [[gnu::naked]] void ExecVfwcvtxfv() {
2326 asm("vfwcvt.x.f.v v8, v24\n\t"
2327 "ret\n\t");
2328 }
2329
ExecMaskedVfwcvtxfv()2330 [[gnu::naked]] void ExecMaskedVfwcvtxfv() {
2331 asm("vfwcvt.x.f.v v8, v24, v0.t\n\t"
2332 "ret\n\t");
2333 }
2334
ExecVfwcvtffv()2335 [[gnu::naked]] void ExecVfwcvtffv() {
2336 asm("vfwcvt.f.f.v v8, v24\n\t"
2337 "ret\n\t");
2338 }
2339
ExecMaskedVfwcvtffv()2340 [[gnu::naked]] void ExecMaskedVfwcvtffv() {
2341 asm("vfwcvt.f.f.v v8, v24, v0.t\n\t"
2342 "ret\n\t");
2343 }
2344
ExecVfwcvtfxuv()2345 [[gnu::naked]] void ExecVfwcvtfxuv() {
2346 asm("vfwcvt.f.xu.v v8, v24\n\t"
2347 "ret\n\t");
2348 }
2349
ExecMaskedVfwcvtfxuv()2350 [[gnu::naked]] void ExecMaskedVfwcvtfxuv() {
2351 asm("vfwcvt.f.xu.v v8, v24, v0.t\n\t"
2352 "ret\n\t");
2353 }
2354
ExecVfwcvtfxv()2355 [[gnu::naked]] void ExecVfwcvtfxv() {
2356 asm("vfwcvt.f.x.v v8, v24\n\t"
2357 "ret\n\t");
2358 }
2359
ExecMaskedVfwcvtfxv()2360 [[gnu::naked]] void ExecMaskedVfwcvtfxv() {
2361 asm("vfwcvt.f.x.v v8, v24, v0.t\n\t"
2362 "ret\n\t");
2363 }
2364
ExecVfwcvtrtzxuf()2365 [[gnu::naked]] void ExecVfwcvtrtzxuf() {
2366 asm("vfwcvt.rtz.xu.f.v v8, v28\n\t"
2367 "ret\n\t");
2368 }
2369
ExecMaskedVfwcvtrtzxuf()2370 [[gnu::naked]] void ExecMaskedVfwcvtrtzxuf() {
2371 asm("vfwcvt.rtz.xu.f.v v8, v28, v0.t\n\t"
2372 "ret\n\t");
2373 }
2374
ExecVfwcvtrtzxf()2375 [[gnu::naked]] void ExecVfwcvtrtzxf() {
2376 asm("vfwcvt.rtz.x.f.v v8, v24\n\t"
2377 "ret\n\t");
2378 }
2379
ExecMaskedVfwcvtrtzxf()2380 [[gnu::naked]] void ExecMaskedVfwcvtrtzxf() {
2381 asm("vfwcvt.rtz.x.f.v v8, v24, v0.t\n\t"
2382 "ret\n\t");
2383 }
2384
ExecVfncvtxufw()2385 [[gnu::naked]] void ExecVfncvtxufw() {
2386 asm("vfncvt.xu.f.w v8, v24\n\t"
2387 "ret\n\t");
2388 }
2389
ExecMaskedVfncvtxufw()2390 [[gnu::naked]] void ExecMaskedVfncvtxufw() {
2391 asm("vfncvt.xu.f.w v8, v24, v0.t\n\t"
2392 "ret\n\t");
2393 }
2394
ExecVfncvtxfw()2395 [[gnu::naked]] void ExecVfncvtxfw() {
2396 asm("vfncvt.x.f.w v8, v24\n\t"
2397 "ret\n\t");
2398 }
2399
ExecMaskedVfncvtxfw()2400 [[gnu::naked]] void ExecMaskedVfncvtxfw() {
2401 asm("vfncvt.x.f.w v8, v24, v0.t\n\t"
2402 "ret\n\t");
2403 }
2404
ExecVfncvtffw()2405 [[gnu::naked]] void ExecVfncvtffw() {
2406 asm("vfncvt.f.f.w v8, v24\n\t"
2407 "ret\n\t");
2408 }
2409
ExecMaskedVfncvtffw()2410 [[gnu::naked]] void ExecMaskedVfncvtffw() {
2411 asm("vfncvt.f.f.w v8, v24, v0.t\n\t"
2412 "ret\n\t");
2413 }
2414
ExecVfncvtfxuw()2415 [[gnu::naked]] void ExecVfncvtfxuw() {
2416 asm("vfncvt.f.xu.w v8, v24\n\t"
2417 "ret\n\t");
2418 }
2419
ExecMaskedVfncvtfxuw()2420 [[gnu::naked]] void ExecMaskedVfncvtfxuw() {
2421 asm("vfncvt.f.xu.w v8, v24, v0.t\n\t"
2422 "ret\n\t");
2423 }
2424
ExecVfncvtfxw()2425 [[gnu::naked]] void ExecVfncvtfxw() {
2426 asm("vfncvt.f.x.w v8, v24\n\t"
2427 "ret\n\t");
2428 }
2429
ExecMaskedVfncvtfxw()2430 [[gnu::naked]] void ExecMaskedVfncvtfxw() {
2431 asm("vfncvt.f.x.w v8, v24, v0.t\n\t"
2432 "ret\n\t");
2433 }
2434
ExecVfncvtrtzxuf()2435 [[gnu::naked]] void ExecVfncvtrtzxuf() {
2436 asm("vfncvt.rtz.xu.f.w v8, v24\n\t"
2437 "ret\n\t");
2438 }
2439
ExecMaskedVfncvtrtzxuf()2440 [[gnu::naked]] void ExecMaskedVfncvtrtzxuf() {
2441 asm("vfncvt.rtz.xu.f.w v8, v24, v0.t\n\t"
2442 "ret\n\t");
2443 }
2444
ExecVfncvtrtzxfw()2445 [[gnu::naked]] void ExecVfncvtrtzxfw() {
2446 asm("vfncvt.rtz.x.f.w v8, v24\n\t"
2447 "ret\n\t");
2448 }
2449
ExecMaskedVfncvtrtzxfw()2450 [[gnu::naked]] void ExecMaskedVfncvtrtzxfw() {
2451 asm("vfncvt.rtz.x.f.w v8, v24, v0.t\n\t"
2452 "ret\n\t");
2453 }
2454
TEST(InlineAsmTestRiscv64,TestVfcvtxfv)2455 TEST(InlineAsmTestRiscv64, TestVfcvtxfv) {
2456 TestVectorFloatInstruction(ExecVfcvtxufv,
2457 ExecMaskedVfcvtxufv,
2458 {{0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
2459 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
2460 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
2461 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
2462 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
2463 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
2464 {0xffff'ffff, 0xffff'ffff, 0x0000'6a21, 0x6e25'6c00},
2465 {0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff}},
2466 {{0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
2467 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
2468 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
2469 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
2470 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
2471 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
2472 {0xffff'ffff'ffff'ffff, 0xffff'ffff'ffff'ffff},
2473 {0xffff'ffff'ffff'ffff, 0xffff'ffff'ffff'ffff}},
2474 kVectorCalculationsSource);
2475 TestVectorFloatInstruction(ExecVfcvtxfv,
2476 ExecMaskedVfcvtxfv,
2477 {{0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
2478 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
2479 {0x8000'0000, 0x8000'0000, 0xffff'cacf, 0xc8cd'6a00},
2480 {0x8000'0000, 0x8000'0000, 0x8000'0000, 0x8000'0000},
2481 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
2482 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
2483 {0x7fff'ffff, 0x7fff'ffff, 0x0000'6a21, 0x6e25'6c00},
2484 {0x7fff'ffff, 0x7fff'ffff, 0x7fff'ffff, 0x7fff'ffff}},
2485 {{0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
2486 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
2487 {0x8000'0000'0000'0000, 0x8000'0000'0000'0000},
2488 {0x8000'0000'0000'0000, 0x8000'0000'0000'0000},
2489 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
2490 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
2491 {0x7fff'ffff'ffff'ffff, 0x7fff'ffff'ffff'ffff},
2492 {0x7fff'ffff'ffff'ffff, 0x7fff'ffff'ffff'ffff}},
2493 kVectorCalculationsSource);
2494 TestVectorFloatInstruction(ExecVfcvtfxuv,
2495 ExecMaskedVfcvtfxuv,
2496 {{0x4f16'0492, 0x4f1e'0c9a, 0x4f06'1482, 0x4f0e'1c8a},
2497 {0x4f36'24b2, 0x4f3e'2cba, 0x4f26'34a2, 0x4f2e'3caa},
2498 {0x4f56'44d2, 0x4f5e'4cda, 0x4f46'54c2, 0x4f4e'5cca},
2499 {0x4f76'64f2, 0x4f7e'6cfa, 0x4f66'74e2, 0x4f6e'7cea},
2500 {0x4db4'2094, 0x4df4'60d4, 0x4cd2'8052, 0x4d69'c0aa},
2501 {0x4e5a'90ca, 0x4e7a'b0eb, 0x4e1a'd08b, 0x4e3a'f0ab},
2502 {0x4ead'88a6, 0x4ebd'98b6, 0x4e8d'a886, 0x4e9d'b896},
2503 {0x4eed'c8e6, 0x4efd'd8f6, 0x4ecd'e8c6, 0x4edd'f8d6}},
2504 {{0x43e3'c193'4132'c092, 0x43e1'c391'4310'c290},
2505 {0x43e7'c597'4536'c496, 0x43e5'c795'4714'c694},
2506 {0x43eb'c99b'493a'c89a, 0x43e9'cb99'4b18'ca98},
2507 {0x43ef'cd9f'4d3e'cc9e, 0x43ed'cf9d'4f1c'ce9c},
2508 {0x43be'8c1a'8916'8412, 0x43ad'3815'300d'2805},
2509 {0x43cf'561d'549b'5219, 0x43c7'5e15'5c13'5a11},
2510 {0x43d7'b316'b255'b115, 0x43d3'b712'b611'b511},
2511 {0x43df'bb1e'ba5d'b91d, 0x43db'bf1a'be19'bd19}},
2512 kVectorCalculationsSource);
2513 TestVectorFloatInstruction(ExecVfcvtfxv,
2514 ExecMaskedVfcvtfxv,
2515 {{0xced3'f6dc, 0xcec3'e6cc, 0xcef3'd6fc, 0xcee3'c6ec},
2516 {0xce93'b69c, 0xce83'a68c, 0xceb3'96bc, 0xcea3'86ac},
2517 {0xce26'ecb7, 0xce06'cc97, 0xce66'acf7, 0xce46'8cd7},
2518 {0xcd19'b0da, 0xcbc9'82cc, 0xcdcc'58ec, 0xcd8c'18ac},
2519 {0x4db4'2094, 0x4df4'60d4, 0x4cd2'8052, 0x4d69'c0aa},
2520 {0x4e5a'90ca, 0x4e7a'b0eb, 0x4e1a'd08b, 0x4e3a'f0ab},
2521 {0x4ead'88a6, 0x4ebd'98b6, 0x4e8d'a886, 0x4e9d'b896},
2522 {0x4eed'c8e6, 0x4efd'd8f6, 0x4ecd'e8c6, 0x4edd'f8d6}},
2523 {{0xc3d8'7cd9'7d9a'7edc, 0xc3dc'78dd'79de'7adf},
2524 {0xc3d0'74d1'7592'76d3, 0xc3d4'70d5'71d6'72d7},
2525 {0xc3c0'd992'db14'dd97, 0xc3c8'd19a'd39c'd59f},
2526 {0xc379'3059'6099'b0da, 0xc3b1'8315'8719'8b1e},
2527 {0x43be'8c1a'8916'8412, 0x43ad'3815'300d'2805},
2528 {0x43cf'561d'549b'5219, 0x43c7'5e15'5c13'5a11},
2529 {0x43d7'b316'b255'b115, 0x43d3'b712'b611'b511},
2530 {0x43df'bb1e'ba5d'b91d, 0x43db'bf1a'be19'bd19}},
2531 kVectorCalculationsSource);
2532 TestVectorFloatInstruction(ExecVfcvtrtzxuf,
2533 ExecMaskedVfcvtrtzxuf,
2534 {{0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
2535 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
2536 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
2537 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
2538 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
2539 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
2540 {0xffff'ffff, 0xffff'ffff, 0x0000'6a21, 0x6e25'6c00},
2541 {0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff}},
2542 {{0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
2543 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
2544 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
2545 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
2546 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
2547 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
2548 {0xffff'ffff'ffff'ffff, 0xffff'ffff'ffff'ffff},
2549 {0xffff'ffff'ffff'ffff, 0xffff'ffff'ffff'ffff}},
2550 kVectorCalculationsSource);
2551 TestVectorFloatInstruction(ExecVfcvtrtzxf,
2552 ExecMaskedVfcvtrtzxf,
2553 {{0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
2554 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
2555 {0x8000'0000, 0x8000'0000, 0xffff'cad0, 0xc8cd'6a00},
2556 {0x8000'0000, 0x8000'0000, 0x8000'0000, 0x8000'0000},
2557 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
2558 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
2559 {0x7fff'ffff, 0x7fff'ffff, 0x0000'6a21, 0x6e25'6c00},
2560 {0x7fff'ffff, 0x7fff'ffff, 0x7fff'ffff, 0x7fff'ffff}},
2561 {{0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
2562 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
2563 {0x8000'0000'0000'0000, 0x8000'0000'0000'0000},
2564 {0x8000'0000'0000'0000, 0x8000'0000'0000'0000},
2565 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
2566 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
2567 {0x7fff'ffff'ffff'ffff, 0x7fff'ffff'ffff'ffff},
2568 {0x7fff'ffff'ffff'ffff, 0x7fff'ffff'ffff'ffff}},
2569 kVectorCalculationsSource);
2570 TestWideningVectorFloatInstruction(ExecVfwcvtxufv,
2571 ExecMaskedVfwcvtxufv,
2572 {{0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
2573 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
2574 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
2575 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
2576 {0x0000'6229'6000'0000, 0x662d'6480'0000'0000},
2577 {0x0000'0000'0000'6a21, 0x0000'0000'6e25'6c00},
2578 {0xffff'ffff'ffff'ffff, 0xffff'ffff'ffff'ffff},
2579 {0xffff'ffff'ffff'ffff, 0xffff'ffff'ffff'ffff}},
2580 kVectorCalculationsSource);
2581 TestWideningVectorFloatInstruction(ExecVfwcvtxfv,
2582 ExecMaskedVfwcvtxfv,
2583 {{0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
2584 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
2585 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
2586 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
2587 {0xffff'cecb'7000'0000, 0xccc9'6dc0'0000'0000},
2588 {0xffff'ffff'ffff'cacf, 0xffff'ffff'c8cd'6a00},
2589 {0x8000'0000'0000'0000, 0x8000'0000'0000'0000},
2590 {0x8000'0000'0000'0000, 0x8000'0000'0000'0000}},
2591 kVectorCalculationsSource);
2592 TestWideningVectorFloatInstruction(ExecVfwcvtffv,
2593 ExecMaskedVfwcvtffv,
2594 {{0xbac0'9240'0000'0000, 0xbbc1'9341'2000'0000},
2595 {0xb8c2'9042'2000'0000, 0xb9c3'9143'0000'0000},
2596 {0xbec4'9644'0000'0000, 0xbfc5'9745'2000'0000},
2597 {0xbcc6'9446'2000'0000, 0xbdc7'9547'0000'0000},
2598 {0xc2c8'9a48'0000'0000, 0xc3c9'9b49'2000'0000},
2599 {0xc0ca'984a'2000'0000, 0xc1cb'994b'0000'0000},
2600 {0xc6cc'9e4c'0000'0000, 0xc7cd'9f4d'2000'0000},
2601 {0xc4ce'9c4e'2000'0000, 0xc5cf'9d4f'0000'0000}},
2602 kVectorCalculationsSource);
2603 TestWideningVectorFloatInstruction(ExecVfwcvtfxuv,
2604 ExecMaskedVfwcvtfxuv,
2605 {{0x4712'0000, 0x4716'0400, 0x471a'0900, 0x471e'0c00},
2606 {0x4702'1100, 0x4706'1400, 0x470a'1800, 0x470e'1c00},
2607 {0x4732'2000, 0x4736'2400, 0x473a'2900, 0x473e'2c00},
2608 {0x4722'3100, 0x4726'3400, 0x472a'3800, 0x472e'3c00},
2609 {0x4752'4000, 0x4756'4400, 0x475a'4900, 0x475e'4c00},
2610 {0x4742'5100, 0x4746'5400, 0x474a'5800, 0x474e'5c00},
2611 {0x4772'6000, 0x4776'6400, 0x477a'6900, 0x477e'6c00},
2612 {0x4762'7100, 0x4766'7400, 0x476a'7800, 0x476e'7c00}},
2613 {{0x41e2'c092'4000'0000, 0x41e3'c193'4120'0000},
2614 {0x41e0'c290'4220'0000, 0x41e1'c391'4300'0000},
2615 {0x41e6'c496'4400'0000, 0x41e7'c597'4520'0000},
2616 {0x41e4'c694'4620'0000, 0x41e5'c795'4700'0000},
2617 {0x41ea'c89a'4800'0000, 0x41eb'c99b'4920'0000},
2618 {0x41e8'ca98'4a20'0000, 0x41e9'cb99'4b00'0000},
2619 {0x41ee'cc9e'4c00'0000, 0x41ef'cd9f'4d20'0000},
2620 {0x41ec'ce9c'4e20'0000, 0x41ed'cf9d'4f00'0000}},
2621 kVectorCalculationsSource);
2622 TestWideningVectorFloatInstruction(ExecVfwcvtfxv,
2623 ExecMaskedVfwcvtfxv,
2624 {{0xc6dc'0000, 0xc6d3'f800, 0xc6cb'ee00, 0xc6c3'e800},
2625 {0xc6fb'de00, 0xc6f3'd800, 0xc6eb'd000, 0xc6e3'c800},
2626 {0xc69b'c000, 0xc693'b800, 0xc68b'ae00, 0xc683'a800},
2627 {0xc6bb'9e00, 0xc6b3'9800, 0xc6ab'9000, 0xc6a3'8800},
2628 {0xc637'0000, 0xc626'f000, 0xc616'dc00, 0xc606'd000},
2629 {0xc676'bc00, 0xc666'b000, 0xc656'a000, 0xc646'9000},
2630 {0xc55a'0000, 0xc519'c000, 0xc4b2'e000, 0xc3ca'0000},
2631 {0xc5ec'7800, 0xc5cc'6000, 0xc5ac'4000, 0xc58c'2000}},
2632 {{0xc1da'7edb'8000'0000, 0xc1d8'7cd9'7dc0'0000},
2633 {0xc1de'7adf'7bc0'0000, 0xc1dc'78dd'7a00'0000},
2634 {0xc1d2'76d3'7800'0000, 0xc1d0'74d1'75c0'0000},
2635 {0xc1d6'72d7'73c0'0000, 0xc1d4'70d5'7200'0000},
2636 {0xc1c4'dd96'e000'0000, 0xc1c0'd992'db80'0000},
2637 {0xc1cc'd59e'd780'0000, 0xc1c8'd19a'd400'0000},
2638 {0xc1a3'361b'4000'0000, 0xc179'3059'7000'0000},
2639 {0xc1b9'8b1d'8f00'0000, 0xc1b1'8315'8800'0000}},
2640 kVectorCalculationsSource);
2641 TestWideningVectorFloatInstruction(ExecVfwcvtrtzxuf,
2642 ExecMaskedVfwcvtrtzxuf,
2643 {{0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
2644 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
2645 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
2646 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
2647 {0x0000'6229'6000'0000, 0x662d'6480'0000'0000},
2648 {0x0000'0000'0000'6a21, 0x0000'0000'6e25'6c00},
2649 {0xffff'ffff'ffff'ffff, 0xffff'ffff'ffff'ffff},
2650 {0xffff'ffff'ffff'ffff, 0xffff'ffff'ffff'ffff}},
2651 kVectorCalculationsSource);
2652 TestWideningVectorFloatInstruction(ExecVfwcvtrtzxf,
2653 ExecMaskedVfwcvtrtzxf,
2654 {{0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
2655 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
2656 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
2657 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
2658 {0xffff'cecb'7000'0000, 0xccc9'6dc0'0000'0000},
2659 {0xffff'ffff'ffff'cad0, 0xffff'ffff'c8cd'6a00},
2660 {0x8000'0000'0000'0000, 0x8000'0000'0000'0000},
2661 {0x8000'0000'0000'0000, 0x8000'0000'0000'0000}},
2662 kVectorCalculationsSource);
2663 TestNarrowingVectorFloatInstruction(
2664 ExecVfncvtxufw,
2665 ExecMaskedVfncvtxufw,
2666 {{0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
2667 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
2668 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
2669 {0xffff, 0xffff, 0x6a21, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff}},
2670 {{0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
2671 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
2672 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
2673 {0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff}},
2674 kVectorCalculationsSource);
2675 TestNarrowingVectorFloatInstruction(
2676 ExecVfncvtxfw,
2677 ExecMaskedVfncvtxfw,
2678 {{0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
2679 {0x8000, 0x8000, 0xcacf, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000},
2680 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
2681 {0x7fff, 0x7fff, 0x6a21, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff}},
2682 {{0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
2683 {0x8000'0000, 0x8000'0000, 0x8000'0000, 0x8000'0000},
2684 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
2685 {0x7fff'ffff, 0x7fff'ffff, 0x7fff'ffff, 0x7fff'ffff}},
2686 kVectorCalculationsSource);
2687 TestNarrowingVectorFloatInstruction(ExecVfncvtffw,
2688 ExecMaskedVfncvtffw,
2689 {{0x8000'0000, 0x8000'0000, 0xb165'd14e, 0x8000'0000},
2690 {0xff80'0000, 0xff80'0000, 0xff80'0000, 0xff80'0000},
2691 {0x0000'0000, 0x0000'0000, 0x3561'd54a, 0x0000'0000},
2692 {0x7f80'0000, 0x7f80'0000, 0x7f80'0000, 0x7f80'0000}},
2693 kVectorCalculationsSource);
2694 TestNarrowingVectorFloatInstruction(ExecVfncvtfxuw,
2695 ExecMaskedVfncvtfxuw,
2696 {{0x5f1e'0c9a, 0x5f0e'1c8a, 0x5f3e'2cba, 0x5f2e'3caa},
2697 {0x5f5e'4cda, 0x5f4e'5cca, 0x5f7e'6cfa, 0x5f6e'7cea},
2698 {0x5df4'60d4, 0x5d69'c0aa, 0x5e7a'b0eb, 0x5e3a'f0ab},
2699 {0x5ebd'98b6, 0x5e9d'b896, 0x5efd'd8f6, 0x5edd'f8d6}},
2700 kVectorCalculationsSource);
2701 TestNarrowingVectorFloatInstruction(ExecVfncvtfxw,
2702 ExecMaskedVfncvtfxw,
2703 {{0xdec3'e6cc, 0xdee3'c6ec, 0xde83'a68c, 0xdea3'86ac},
2704 {0xde06'cc97, 0xde46'8cd7, 0xdbc9'82cb, 0xdd8c'18ac},
2705 {0x5df4'60d4, 0x5d69'c0aa, 0x5e7a'b0eb, 0x5e3a'f0ab},
2706 {0x5ebd'98b6, 0x5e9d'b896, 0x5efd'd8f6, 0x5edd'f8d6}},
2707 kVectorCalculationsSource);
2708 TestNarrowingVectorFloatInstruction(
2709 ExecVfncvtrtzxuf,
2710 ExecMaskedVfncvtrtzxuf,
2711 {{0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
2712 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
2713 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
2714 {0xffff, 0xffff, 0x6a21, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff}},
2715 {{0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
2716 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
2717 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
2718 {0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff}},
2719 kVectorCalculationsSource);
2720 TestNarrowingVectorFloatInstruction(
2721 ExecVfncvtrtzxfw,
2722 ExecMaskedVfncvtrtzxfw,
2723 {{0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
2724 {0x8000, 0x8000, 0xcad0, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000},
2725 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
2726 {0x7fff, 0x7fff, 0x6a21, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff}},
2727 {{0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
2728 {0x8000'0000, 0x8000'0000, 0x8000'0000, 0x8000'0000},
2729 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
2730 {0x7fff'ffff, 0x7fff'ffff, 0x7fff'ffff, 0x7fff'ffff}},
2731 kVectorCalculationsSource);
2732 }
2733
ExecVid()2734 [[gnu::naked]] void ExecVid() {
2735 asm("vid.v v8\n\t"
2736 "ret\n\t");
2737 }
2738
ExecMaskedVid()2739 [[gnu::naked]] void ExecMaskedVid() {
2740 asm("vid.v v8, v0.t\n\t"
2741 "ret\n\t");
2742 }
2743
TEST(InlineAsmTestRiscv64,TestVid)2744 TEST(InlineAsmTestRiscv64, TestVid) {
2745 TestVectorInstruction(
2746 ExecVid,
2747 ExecMaskedVid,
2748 {{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
2749 {16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31},
2750 {32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47},
2751 {48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63},
2752 {64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79},
2753 {80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95},
2754 {96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111},
2755 {112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127}},
2756 {{0, 1, 2, 3, 4, 5, 6, 7},
2757 {8, 9, 10, 11, 12, 13, 14, 15},
2758 {16, 17, 18, 19, 20, 21, 22, 23},
2759 {24, 25, 26, 27, 28, 29, 30, 31},
2760 {32, 33, 34, 35, 36, 37, 38, 39},
2761 {40, 41, 42, 43, 44, 45, 46, 47},
2762 {48, 49, 50, 51, 52, 53, 54, 55},
2763 {56, 57, 58, 59, 60, 61, 62, 63}},
2764 {{0, 1, 2, 3},
2765 {4, 5, 6, 7},
2766 {8, 9, 10, 11},
2767 {12, 13, 14, 15},
2768 {16, 17, 18, 19},
2769 {20, 21, 22, 23},
2770 {24, 25, 26, 27},
2771 {28, 29, 30, 31}},
2772 {{0, 1}, {2, 3}, {4, 5}, {6, 7}, {8, 9}, {10, 11}, {12, 13}, {14, 15}},
2773 kVectorCalculationsSourceLegacy);
2774 }
2775
ExecViotam()2776 [[gnu::naked]] void ExecViotam() {
2777 asm("viota.m v8, v16\n\t"
2778 "ret\n\t");
2779 }
2780
ExecMaskedViotam()2781 [[gnu::naked]] void ExecMaskedViotam() {
2782 asm("viota.m v8, v16, v0.t\n\t"
2783 "ret\n\t");
2784 }
2785
TEST(InlineAsmTestRiscv64,TestIota)2786 TEST(InlineAsmTestRiscv64, TestIota) {
2787 TestVectorIota<false>(ExecViotam,
2788 {{0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1},
2789 {2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 5, 5, 5, 5, 5, 5},
2790 {6, 6, 6, 7, 7, 7, 7, 7, 7, 8, 8, 9, 9, 9, 9, 9},
2791 {10, 10, 11, 12, 12, 12, 12, 12, 12, 13, 14, 15, 15, 15, 15, 15},
2792 {16, 16, 16, 16, 17, 17, 17, 17, 17, 18, 18, 18, 19, 19, 19, 19},
2793 {20, 20, 21, 21, 22, 22, 22, 22, 22, 23, 24, 24, 25, 25, 25, 25},
2794 {26, 26, 26, 27, 28, 28, 28, 28, 28, 29, 29, 30, 31, 31, 31, 31},
2795 {32, 32, 33, 34, 35, 35, 35, 35, 35, 36, 37, 38, 39, 39, 39, 39}},
2796 {{0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
2797 {0x0000, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001},
2798 {0x0002, 0x0002, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003},
2799 {0x0003, 0x0004, 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0005},
2800 {0x0006, 0x0006, 0x0006, 0x0007, 0x0007, 0x0007, 0x0007, 0x0007},
2801 {0x0007, 0x0008, 0x0008, 0x0009, 0x0009, 0x0009, 0x0009, 0x0009},
2802 {0x000a, 0x000a, 0x000b, 0x000c, 0x000c, 0x000c, 0x000c, 0x000c},
2803 {0x000c, 0x000d, 0x000e, 0x000f, 0x000f, 0x000f, 0x000f, 0x000f}},
2804 {{0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
2805 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
2806 {0x0000'0000, 0x0000'0001, 0x0000'0001, 0x0000'0001},
2807 {0x0000'0001, 0x0000'0001, 0x0000'0001, 0x0000'0001},
2808 {0x0000'0002, 0x0000'0002, 0x0000'0003, 0x0000'0003},
2809 {0x0000'0003, 0x0000'0003, 0x0000'0003, 0x0000'0003},
2810 {0x0000'0003, 0x0000'0004, 0x0000'0005, 0x0000'0005},
2811 {0x0000'0005, 0x0000'0005, 0x0000'0005, 0x0000'0005}},
2812 {{0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
2813 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
2814 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
2815 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
2816 {0x0000'0000'0000'0000, 0x0000'0000'0000'0001},
2817 {0x0000'0000'0000'0001, 0x0000'0000'0000'0001},
2818 {0x0000'0000'0000'0001, 0x0000'0000'0000'0001},
2819 {0x0000'0000'0000'0001, 0x0000'0000'0000'0001}},
2820 kVectorCalculationsSource);
2821 TestVectorIota<true>(ExecMaskedViotam,
2822 {{0, 0x55, 0, 0, 0x55, 0, 0x55, 0, 0, 0x55, 1, 0x55, 1, 1, 0x55, 1},
2823 {2, 2, 0x55, 3, 0x55, 3, 3, 0x55, 3, 0x55, 4, 4, 0x55, 4, 0x55, 4},
2824 {5, 0x55, 5, 0x55, 6, 6, 0x55, 6, 0x55, 6, 6, 0x55, 7, 0x55, 7, 7},
2825 {8, 0x55, 8, 9, 0x55, 9, 0x55, 9, 9, 0x55, 10, 0x55, 11, 0x55, 11, 11},
2826 {12, 0x55, 12, 0x55, 12, 12, 0x55, 12, 12, 13, 0x55, 13, 14, 14, 14, 0x55},
2827 {14, 0x55, 14, 14, 0x55, 15, 15, 15, 0x55, 15, 16, 16, 17, 0x55, 17, 17},
2828 {18, 18, 0x55, 18, 19, 19, 0x55, 19, 19, 20, 20, 0x55, 21, 0x55, 21, 0x55},
2829 {21, 21, 22, 0x55, 23, 23, 23, 23, 0x55, 23, 0x55, 24, 0x55, 25, 25, 0x55}},
2830 {{0x0000, 0x5555, 0x0000, 0x0000, 0x5555, 0x0000, 0x5555, 0x0000},
2831 {0x0000, 0x5555, 0x0001, 0x5555, 0x0001, 0x0001, 0x5555, 0x0001},
2832 {0x0002, 0x0002, 0x5555, 0x0003, 0x5555, 0x0003, 0x0003, 0x5555},
2833 {0x0003, 0x5555, 0x0004, 0x0004, 0x5555, 0x0004, 0x5555, 0x0004},
2834 {0x0005, 0x5555, 0x0005, 0x5555, 0x0006, 0x0006, 0x5555, 0x0006},
2835 {0x5555, 0x0006, 0x0006, 0x5555, 0x0007, 0x5555, 0x0007, 0x0007},
2836 {0x0008, 0x5555, 0x0008, 0x0009, 0x5555, 0x0009, 0x5555, 0x0009},
2837 {0x0009, 0x5555, 0x000a, 0x5555, 0x000b, 0x5555, 0x000b, 0x000b}},
2838 {{0x0000'0000, 0x5555'5555, 0x0000'0000, 0x0000'0000},
2839 {0x5555'5555, 0x0000'0000, 0x5555'5555, 0x0000'0000},
2840 {0x0000'0000, 0x5555'5555, 0x0000'0001, 0x5555'5555},
2841 {0x0000'0001, 0x0000'0001, 0x5555'5555, 0x0000'0001},
2842 {0x0000'0002, 0x0000'0002, 0x5555'5555, 0x0000'0003},
2843 {0x5555'5555, 0x0000'0003, 0x0000'0003, 0x5555'5555},
2844 {0x0000'0003, 0x5555'5555, 0x0000'0004, 0x0000'0004},
2845 {0x5555'5555, 0x0000'0004, 0x5555'5555, 0x0000'0004}},
2846 {{0x0000'0000'0000'0000, 0x5555'5555'5555'5555},
2847 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
2848 {0x5555'5555'5555'5555, 0x0000'0000'0000'0000},
2849 {0x5555'5555'5555'5555, 0x0000'0000'0000'0000},
2850 {0x0000'0000'0000'0000, 0x5555'5555'5555'5555},
2851 {0x0000'0000'0000'0001, 0x5555'5555'5555'5555},
2852 {0x0000'0000'0000'0001, 0x0000'0000'0000'0001},
2853 {0x5555'5555'5555'5555, 0x0000'0000'0000'0001}},
2854 kVectorCalculationsSource);
2855 }
2856
ExecVrsubvx()2857 [[gnu::naked]] void ExecVrsubvx() {
2858 asm("vrsub.vx v8, v16, t0\n\t"
2859 "ret\n\t");
2860 }
2861
ExecMaskedVrsubvx()2862 [[gnu::naked]] void ExecMaskedVrsubvx() {
2863 asm("vrsub.vx v8, v16, t0, v0.t\n\t"
2864 "ret\n\t");
2865 }
2866
ExecVrsubvi()2867 [[gnu::naked]] void ExecVrsubvi() {
2868 asm("vrsub.vi v8, v16, -0xb\n\t"
2869 "ret\n\t");
2870 }
2871
ExecMaskedVrsubvi()2872 [[gnu::naked]] void ExecMaskedVrsubvi() {
2873 asm("vrsub.vi v8, v16, -0xb, v0.t\n\t"
2874 "ret\n\t");
2875 }
2876
ExecVfrsubvf()2877 [[gnu::naked]] void ExecVfrsubvf() {
2878 asm("vfrsub.vf v8, v16, ft0\n\t"
2879 "ret\n\t");
2880 }
2881
ExecMaskedVfrsubvf()2882 [[gnu::naked]] void ExecMaskedVfrsubvf() {
2883 asm("vfrsub.vf v8, v16, ft0, v0.t\n\t"
2884 "ret\n\t");
2885 }
2886
TEST(InlineAsmTestRiscv64,TestVrsub)2887 TEST(InlineAsmTestRiscv64, TestVrsub) {
2888 TestVectorInstruction(
2889 ExecVrsubvx,
2890 ExecMaskedVrsubvx,
2891 {{170, 41, 168, 39, 166, 37, 164, 35, 162, 33, 160, 31, 158, 29, 156, 27},
2892 {154, 25, 152, 23, 150, 21, 148, 19, 146, 17, 144, 15, 142, 13, 140, 11},
2893 {138, 9, 136, 7, 134, 5, 132, 3, 130, 1, 128, 255, 126, 253, 124, 251},
2894 {122, 249, 120, 247, 118, 245, 116, 243, 114, 241, 112, 239, 110, 237, 108, 235},
2895 {106, 233, 104, 231, 102, 229, 100, 227, 98, 225, 96, 223, 94, 221, 92, 219},
2896 {90, 217, 88, 215, 86, 213, 84, 211, 82, 209, 80, 207, 78, 205, 76, 203},
2897 {74, 201, 72, 199, 70, 197, 68, 195, 66, 193, 64, 191, 62, 189, 60, 187},
2898 {58, 185, 56, 183, 54, 181, 52, 179, 50, 177, 48, 175, 46, 173, 44, 171}},
2899 {{0x29aa, 0x27a8, 0x25a6, 0x23a4, 0x21a2, 0x1fa0, 0x1d9e, 0x1b9c},
2900 {0x199a, 0x1798, 0x1596, 0x1394, 0x1192, 0x0f90, 0x0d8e, 0x0b8c},
2901 {0x098a, 0x0788, 0x0586, 0x0384, 0x0182, 0xff80, 0xfd7e, 0xfb7c},
2902 {0xf97a, 0xf778, 0xf576, 0xf374, 0xf172, 0xef70, 0xed6e, 0xeb6c},
2903 {0xe96a, 0xe768, 0xe566, 0xe364, 0xe162, 0xdf60, 0xdd5e, 0xdb5c},
2904 {0xd95a, 0xd758, 0xd556, 0xd354, 0xd152, 0xcf50, 0xcd4e, 0xcb4c},
2905 {0xc94a, 0xc748, 0xc546, 0xc344, 0xc142, 0xbf40, 0xbd3e, 0xbb3c},
2906 {0xb93a, 0xb738, 0xb536, 0xb334, 0xb132, 0xaf30, 0xad2e, 0xab2c}},
2907 {{0x27a8'29aa, 0x23a4'25a6, 0x1fa0'21a2, 0x1b9c'1d9e},
2908 {0x1798'199a, 0x1394'1596, 0x0f90'1192, 0x0b8c'0d8e},
2909 {0x0788'098a, 0x0384'0586, 0xff80'0182, 0xfb7b'fd7e},
2910 {0xf777'f97a, 0xf373'f576, 0xef6f'f172, 0xeb6b'ed6e},
2911 {0xe767'e96a, 0xe363'e566, 0xdf5f'e162, 0xdb5b'dd5e},
2912 {0xd757'd95a, 0xd353'd556, 0xcf4f'd152, 0xcb4b'cd4e},
2913 {0xc747'c94a, 0xc343'c546, 0xbf3f'c142, 0xbb3b'bd3e},
2914 {0xb737'b93a, 0xb333'b536, 0xaf2f'b132, 0xab2b'ad2e}},
2915 {{0x23a4'25a6'27a8'29aa, 0x1b9c'1d9e'1fa0'21a2},
2916 {0x1394'1596'1798'199a, 0x0b8c'0d8e'0f90'1192},
2917 {0x0384'0586'0788'098a, 0xfb7b'fd7d'ff80'0182},
2918 {0xf373'f575'f777'f97a, 0xeb6b'ed6d'ef6f'f172},
2919 {0xe363'e565'e767'e96a, 0xdb5b'dd5d'df5f'e162},
2920 {0xd353'd555'd757'd95a, 0xcb4b'cd4d'cf4f'd152},
2921 {0xc343'c545'c747'c94a, 0xbb3b'bd3d'bf3f'c142},
2922 {0xb333'b535'b737'b93a, 0xab2b'ad2d'af2f'b132}},
2923 kVectorCalculationsSourceLegacy);
2924 TestVectorInstruction(
2925 ExecVrsubvi,
2926 ExecMaskedVrsubvi,
2927 {{245, 116, 243, 114, 241, 112, 239, 110, 237, 108, 235, 106, 233, 104, 231, 102},
2928 {229, 100, 227, 98, 225, 96, 223, 94, 221, 92, 219, 90, 217, 88, 215, 86},
2929 {213, 84, 211, 82, 209, 80, 207, 78, 205, 76, 203, 74, 201, 72, 199, 70},
2930 {197, 68, 195, 66, 193, 64, 191, 62, 189, 60, 187, 58, 185, 56, 183, 54},
2931 {181, 52, 179, 50, 177, 48, 175, 46, 173, 44, 171, 42, 169, 40, 167, 38},
2932 {165, 36, 163, 34, 161, 32, 159, 30, 157, 28, 155, 26, 153, 24, 151, 22},
2933 {149, 20, 147, 18, 145, 16, 143, 14, 141, 12, 139, 10, 137, 8, 135, 6},
2934 {133, 4, 131, 2, 129, 0, 127, 254, 125, 252, 123, 250, 121, 248, 119, 246}},
2935 {{0x7ef5, 0x7cf3, 0x7af1, 0x78ef, 0x76ed, 0x74eb, 0x72e9, 0x70e7},
2936 {0x6ee5, 0x6ce3, 0x6ae1, 0x68df, 0x66dd, 0x64db, 0x62d9, 0x60d7},
2937 {0x5ed5, 0x5cd3, 0x5ad1, 0x58cf, 0x56cd, 0x54cb, 0x52c9, 0x50c7},
2938 {0x4ec5, 0x4cc3, 0x4ac1, 0x48bf, 0x46bd, 0x44bb, 0x42b9, 0x40b7},
2939 {0x3eb5, 0x3cb3, 0x3ab1, 0x38af, 0x36ad, 0x34ab, 0x32a9, 0x30a7},
2940 {0x2ea5, 0x2ca3, 0x2aa1, 0x289f, 0x269d, 0x249b, 0x2299, 0x2097},
2941 {0x1e95, 0x1c93, 0x1a91, 0x188f, 0x168d, 0x148b, 0x1289, 0x1087},
2942 {0x0e85, 0x0c83, 0x0a81, 0x087f, 0x067d, 0x047b, 0x0279, 0x0077}},
2943 {{0x7cfd'7ef5, 0x78f9'7af1, 0x74f5'76ed, 0x70f1'72e9},
2944 {0x6ced'6ee5, 0x68e9'6ae1, 0x64e5'66dd, 0x60e1'62d9},
2945 {0x5cdd'5ed5, 0x58d9'5ad1, 0x54d5'56cd, 0x50d1'52c9},
2946 {0x4ccd'4ec5, 0x48c9'4ac1, 0x44c5'46bd, 0x40c1'42b9},
2947 {0x3cbd'3eb5, 0x38b9'3ab1, 0x34b5'36ad, 0x30b1'32a9},
2948 {0x2cad'2ea5, 0x28a9'2aa1, 0x24a5'269d, 0x20a1'2299},
2949 {0x1c9d'1e95, 0x1899'1a91, 0x1495'168d, 0x1091'1289},
2950 {0x0c8d'0e85, 0x0889'0a81, 0x0485'067d, 0x0081'0279}},
2951 {{0x78f9'7afb'7cfd'7ef5, 0x70f1'72f3'74f5'76ed},
2952 {0x68e9'6aeb'6ced'6ee5, 0x60e1'62e3'64e5'66dd},
2953 {0x58d9'5adb'5cdd'5ed5, 0x50d1'52d3'54d5'56cd},
2954 {0x48c9'4acb'4ccd'4ec5, 0x40c1'42c3'44c5'46bd},
2955 {0x38b9'3abb'3cbd'3eb5, 0x30b1'32b3'34b5'36ad},
2956 {0x28a9'2aab'2cad'2ea5, 0x20a1'22a3'24a5'269d},
2957 {0x1899'1a9b'1c9d'1e95, 0x1091'1293'1495'168d},
2958 {0x0889'0a8b'0c8d'0e85, 0x0081'0283'0485'067d}},
2959 kVectorCalculationsSourceLegacy);
2960
2961 TestVectorFloatInstruction(ExecVfrsubvf,
2962 ExecMaskedVfrsubvf,
2963 {{0x40b4'0000, 0x40b4'0000, 0x40b4'0000, 0x40b4'0000},
2964 {0x40b4'0000, 0x40b4'0000, 0x40b4'0000, 0x40b4'0000},
2965 {0x40b4'0000, 0x40b4'0000, 0x40b4'0000, 0x40b4'0000},
2966 {0x40b4'0000, 0x40b4'0017, 0x40b4'1757, 0x40cb'd7a8},
2967 {0x4348'6140, 0x4746'cae4, 0x4b4a'c94e, 0x4f4e'cd4c},
2968 {0x5352'd150, 0x5756'd554, 0x5b5a'd958, 0x5f5e'dd5c},
2969 {0x6362'e160, 0x6766'e564, 0x6b6a'e968, 0x6f6e'ed6c},
2970 {0x7372'f170, 0x7776'f574, 0x7b7a'f978, 0x7f7e'fd7c}},
2971 {{0x4016'8000'0000'0000, 0x4016'8000'0000'0000},
2972 {0x4016'8000'0000'0000, 0x4016'8000'0000'0000},
2973 {0x4016'8000'0000'0000, 0x4016'8000'0000'0000},
2974 {0x4016'8000'0000'0000, 0x4016'807a'f4f2'eceb},
2975 {0x4746'c544'c342'c140, 0x4f4e'cd4c'cb4a'c948},
2976 {0x5756'd554'd352'd150, 0x5f5e'dd5c'db5a'd958},
2977 {0x6766'e564'e362'e160, 0x6f6e'ed6c'eb6a'e968},
2978 {0x7776'f574'f372'f170, 0x7f7e'fd7c'fb7a'f978}},
2979 kVectorCalculationsSource);
2980 }
2981
ExecVaddvv()2982 [[gnu::naked]] void ExecVaddvv() {
2983 asm("vadd.vv v8, v16, v24\n\t"
2984 "ret\n\t");
2985 }
2986
ExecMaskedVaddvv()2987 [[gnu::naked]] void ExecMaskedVaddvv() {
2988 asm("vadd.vv v8, v16, v24, v0.t\n\t"
2989 "ret\n\t");
2990 }
2991
ExecVaddvx()2992 [[gnu::naked]] void ExecVaddvx() {
2993 asm("vadd.vx v8, v16, t0\n\t"
2994 "ret\n\t");
2995 }
2996
ExecMaskedVaddvx()2997 [[gnu::naked]] void ExecMaskedVaddvx() {
2998 asm("vadd.vx v8, v16, t0, v0.t\n\t"
2999 "ret\n\t");
3000 }
3001
ExecVaddvi()3002 [[gnu::naked]] void ExecVaddvi() {
3003 asm("vadd.vi v8, v16, -0xb\n\t"
3004 "ret\n\t");
3005 }
3006
ExecMaskedVaddvi()3007 [[gnu::naked]] void ExecMaskedVaddvi() {
3008 asm("vadd.vi v8, v16, -0xb, v0.t\n\t"
3009 "ret\n\t");
3010 }
3011
ExecVsadduvv()3012 [[gnu::naked]] void ExecVsadduvv() {
3013 asm("vsaddu.vv v8, v16, v24\n\t"
3014 "ret\n\t");
3015 }
3016
ExecMaskedVsadduvv()3017 [[gnu::naked]] void ExecMaskedVsadduvv() {
3018 asm("vsaddu.vv v8, v16, v24, v0.t\n\t"
3019 "ret\n\t");
3020 }
3021
ExecVsadduvx()3022 [[gnu::naked]] void ExecVsadduvx() {
3023 asm("vsaddu.vx v8, v16, t0\n\t"
3024 "ret\n\t");
3025 }
3026
ExecMaskedVsadduvx()3027 [[gnu::naked]] void ExecMaskedVsadduvx() {
3028 asm("vsaddu.vx v8, v16, t0, v0.t\n\t"
3029 "ret\n\t");
3030 }
3031
ExecVsadduvi()3032 [[gnu::naked]] void ExecVsadduvi() {
3033 asm("vsaddu.vi v8, v16, -0xb\n\t"
3034 "ret\n\t");
3035 }
3036
ExecMaskedVsadduvi()3037 [[gnu::naked]] void ExecMaskedVsadduvi() {
3038 asm("vsaddu.vi v8, v16, -0xb, v0.t\n\t"
3039 "ret\n\t");
3040 }
3041
ExecVsaddvv()3042 [[gnu::naked]] void ExecVsaddvv() {
3043 asm("vsadd.vv v8, v16, v24\n\t"
3044 "ret\n\t");
3045 }
3046
ExecMaskedVsaddvv()3047 [[gnu::naked]] void ExecMaskedVsaddvv() {
3048 asm("vsadd.vv v8, v16, v24, v0.t\n\t"
3049 "ret\n\t");
3050 }
3051
ExecVsaddvx()3052 [[gnu::naked]] void ExecVsaddvx() {
3053 asm("vsadd.vx v8, v16, t0\n\t"
3054 "ret\n\t");
3055 }
3056
ExecMaskedVsaddvx()3057 [[gnu::naked]] void ExecMaskedVsaddvx() {
3058 asm("vsadd.vx v8, v16, t0, v0.t\n\t"
3059 "ret\n\t");
3060 }
3061
ExecVsaddvi()3062 [[gnu::naked]] void ExecVsaddvi() {
3063 asm("vsadd.vi v8, v16, -0xb\n\t"
3064 "ret\n\t");
3065 }
3066
ExecMaskedVsaddvi()3067 [[gnu::naked]] void ExecMaskedVsaddvi() {
3068 asm("vsadd.vi v8, v16, -0xb, v0.t\n\t"
3069 "ret\n\t");
3070 }
3071
ExecVfaddvv()3072 [[gnu::naked]] void ExecVfaddvv() {
3073 asm("vfadd.vv v8, v16, v24\n\t"
3074 "ret\n\t");
3075 }
3076
ExecMaskedVfaddvv()3077 [[gnu::naked]] void ExecMaskedVfaddvv() {
3078 asm("vfadd.vv v8, v16, v24, v0.t\n\t"
3079 "ret\n\t");
3080 }
3081
ExecVfaddvf()3082 [[gnu::naked]] void ExecVfaddvf() {
3083 asm("vfadd.vf v8, v16, ft0\n\t"
3084 "ret\n\t");
3085 }
3086
ExecMaskedVfaddvf()3087 [[gnu::naked]] void ExecMaskedVfaddvf() {
3088 asm("vfadd.vf v8, v16, ft0, v0.t\n\t"
3089 "ret\n\t");
3090 }
3091
ExecVfwaddvv()3092 [[gnu::naked]] void ExecVfwaddvv() {
3093 asm("vfwadd.vv v8, v16, v24\n\t"
3094 "ret\n\t");
3095 }
3096
ExecMaskedVfwaddvv()3097 [[gnu::naked]] void ExecMaskedVfwaddvv() {
3098 asm("vfwadd.vv v8, v16, v24, v0.t\n\t"
3099 "ret\n\t");
3100 }
3101
ExecVfwaddwv()3102 [[gnu::naked]] void ExecVfwaddwv() {
3103 asm("vfwadd.wv v8, v16, v24\n\t"
3104 "ret\n\t");
3105 }
3106
ExecMaskedVfwaddwv()3107 [[gnu::naked]] void ExecMaskedVfwaddwv() {
3108 asm("vfwadd.wv v8, v16, v24, v0.t\n\t"
3109 "ret\n\t");
3110 }
3111
ExecVfwaddwf()3112 [[gnu::naked]] void ExecVfwaddwf() {
3113 asm("vfwadd.wf v8, v16, ft0\n\t"
3114 "ret\n\t");
3115 }
3116
ExecMaskedVfwaddwf()3117 [[gnu::naked]] void ExecMaskedVfwaddwf() {
3118 asm("vfwadd.wf v8, v16, ft0, v0.t\n\t"
3119 "ret\n\t");
3120 }
3121
TEST(InlineAsmTestRiscv64,TestVadd)3122 TEST(InlineAsmTestRiscv64, TestVadd) {
3123 TestVectorInstruction(
3124 ExecVaddvv,
3125 ExecMaskedVaddvv,
3126 {{0, 131, 6, 137, 13, 143, 18, 149, 25, 155, 30, 161, 36, 167, 42, 173},
3127 {48, 179, 54, 185, 61, 191, 66, 197, 73, 203, 78, 209, 84, 215, 90, 221},
3128 {96, 227, 102, 233, 109, 239, 114, 245, 121, 251, 126, 1, 132, 7, 138, 13},
3129 {144, 19, 150, 25, 157, 31, 162, 37, 169, 43, 174, 49, 180, 55, 186, 61},
3130 {192, 67, 198, 73, 205, 79, 210, 85, 217, 91, 222, 97, 228, 103, 234, 109},
3131 {240, 115, 246, 121, 253, 127, 2, 133, 9, 139, 14, 145, 20, 151, 26, 157},
3132 {32, 163, 38, 169, 45, 175, 50, 181, 57, 187, 62, 193, 68, 199, 74, 205},
3133 {80, 211, 86, 217, 93, 223, 98, 229, 105, 235, 110, 241, 116, 247, 122, 253}},
3134 {{0x8300, 0x8906, 0x8f0d, 0x9512, 0x9b19, 0xa11e, 0xa724, 0xad2a},
3135 {0xb330, 0xb936, 0xbf3d, 0xc542, 0xcb49, 0xd14e, 0xd754, 0xdd5a},
3136 {0xe360, 0xe966, 0xef6d, 0xf572, 0xfb79, 0x017e, 0x0784, 0x0d8a},
3137 {0x1390, 0x1996, 0x1f9d, 0x25a2, 0x2ba9, 0x31ae, 0x37b4, 0x3dba},
3138 {0x43c0, 0x49c6, 0x4fcd, 0x55d2, 0x5bd9, 0x61de, 0x67e4, 0x6dea},
3139 {0x73f0, 0x79f6, 0x7ffd, 0x8602, 0x8c09, 0x920e, 0x9814, 0x9e1a},
3140 {0xa420, 0xaa26, 0xb02d, 0xb632, 0xbc39, 0xc23e, 0xc844, 0xce4a},
3141 {0xd450, 0xda56, 0xe05d, 0xe662, 0xec69, 0xf26e, 0xf874, 0xfe7a}},
3142 {{0x8906'8300, 0x9512'8f0d, 0xa11e'9b19, 0xad2a'a724},
3143 {0xb936'b330, 0xc542'bf3d, 0xd14e'cb49, 0xdd5a'd754},
3144 {0xe966'e360, 0xf572'ef6d, 0x017e'fb79, 0x0d8b'0784},
3145 {0x1997'1390, 0x25a3'1f9d, 0x31af'2ba9, 0x3dbb'37b4},
3146 {0x49c7'43c0, 0x55d3'4fcd, 0x61df'5bd9, 0x6deb'67e4},
3147 {0x79f7'73f0, 0x8603'7ffd, 0x920f'8c09, 0x9e1b'9814},
3148 {0xaa27'a420, 0xb633'b02d, 0xc23f'bc39, 0xce4b'c844},
3149 {0xda57'd450, 0xe663'e05d, 0xf26f'ec69, 0xfe7b'f874}},
3150 {{0x9512'8f0d'8906'8300, 0xad2a'a724'a11e'9b19},
3151 {0xc542'bf3d'b936'b330, 0xdd5a'd754'd14e'cb49},
3152 {0xf572'ef6d'e966'e360, 0x0d8b'0785'017e'fb79},
3153 {0x25a3'1f9e'1997'1390, 0x3dbb'37b5'31af'2ba9},
3154 {0x55d3'4fce'49c7'43c0, 0x6deb'67e5'61df'5bd9},
3155 {0x8603'7ffe'79f7'73f0, 0x9e1b'9815'920f'8c09},
3156 {0xb633'b02e'aa27'a420, 0xce4b'c845'c23f'bc39},
3157 {0xe663'e05e'da57'd450, 0xfe7b'f875'f26f'ec69}},
3158 kVectorCalculationsSourceLegacy);
3159 TestVectorInstruction(
3160 ExecVaddvx,
3161 ExecMaskedVaddvx,
3162 {{170, 43, 172, 45, 174, 47, 176, 49, 178, 51, 180, 53, 182, 55, 184, 57},
3163 {186, 59, 188, 61, 190, 63, 192, 65, 194, 67, 196, 69, 198, 71, 200, 73},
3164 {202, 75, 204, 77, 206, 79, 208, 81, 210, 83, 212, 85, 214, 87, 216, 89},
3165 {218, 91, 220, 93, 222, 95, 224, 97, 226, 99, 228, 101, 230, 103, 232, 105},
3166 {234, 107, 236, 109, 238, 111, 240, 113, 242, 115, 244, 117, 246, 119, 248, 121},
3167 {250, 123, 252, 125, 254, 127, 0, 129, 2, 131, 4, 133, 6, 135, 8, 137},
3168 {10, 139, 12, 141, 14, 143, 16, 145, 18, 147, 20, 149, 22, 151, 24, 153},
3169 {26, 155, 28, 157, 30, 159, 32, 161, 34, 163, 36, 165, 38, 167, 40, 169}},
3170 {{0x2baa, 0x2dac, 0x2fae, 0x31b0, 0x33b2, 0x35b4, 0x37b6, 0x39b8},
3171 {0x3bba, 0x3dbc, 0x3fbe, 0x41c0, 0x43c2, 0x45c4, 0x47c6, 0x49c8},
3172 {0x4bca, 0x4dcc, 0x4fce, 0x51d0, 0x53d2, 0x55d4, 0x57d6, 0x59d8},
3173 {0x5bda, 0x5ddc, 0x5fde, 0x61e0, 0x63e2, 0x65e4, 0x67e6, 0x69e8},
3174 {0x6bea, 0x6dec, 0x6fee, 0x71f0, 0x73f2, 0x75f4, 0x77f6, 0x79f8},
3175 {0x7bfa, 0x7dfc, 0x7ffe, 0x8200, 0x8402, 0x8604, 0x8806, 0x8a08},
3176 {0x8c0a, 0x8e0c, 0x900e, 0x9210, 0x9412, 0x9614, 0x9816, 0x9a18},
3177 {0x9c1a, 0x9e1c, 0xa01e, 0xa220, 0xa422, 0xa624, 0xa826, 0xaa28}},
3178 {{0x2dad'2baa, 0x31b1'2fae, 0x35b5'33b2, 0x39b9'37b6},
3179 {0x3dbd'3bba, 0x41c1'3fbe, 0x45c5'43c2, 0x49c9'47c6},
3180 {0x4dcd'4bca, 0x51d1'4fce, 0x55d5'53d2, 0x59d9'57d6},
3181 {0x5ddd'5bda, 0x61e1'5fde, 0x65e5'63e2, 0x69e9'67e6},
3182 {0x6ded'6bea, 0x71f1'6fee, 0x75f5'73f2, 0x79f9'77f6},
3183 {0x7dfd'7bfa, 0x8201'7ffe, 0x8605'8402, 0x8a09'8806},
3184 {0x8e0d'8c0a, 0x9211'900e, 0x9615'9412, 0x9a19'9816},
3185 {0x9e1d'9c1a, 0xa221'a01e, 0xa625'a422, 0xaa29'a826}},
3186 {{0x31b1'2faf'2dad'2baa, 0x39b9'37b7'35b5'33b2},
3187 {0x41c1'3fbf'3dbd'3bba, 0x49c9'47c7'45c5'43c2},
3188 {0x51d1'4fcf'4dcd'4bca, 0x59d9'57d7'55d5'53d2},
3189 {0x61e1'5fdf'5ddd'5bda, 0x69e9'67e7'65e5'63e2},
3190 {0x71f1'6fef'6ded'6bea, 0x79f9'77f7'75f5'73f2},
3191 {0x8201'7fff'7dfd'7bfa, 0x8a09'8807'8605'8402},
3192 {0x9211'900f'8e0d'8c0a, 0x9a19'9817'9615'9412},
3193 {0xa221'a01f'9e1d'9c1a, 0xaa29'a827'a625'a422}},
3194 kVectorCalculationsSourceLegacy);
3195 TestVectorInstruction(
3196 ExecVaddvi,
3197 ExecMaskedVaddvi,
3198 {{245, 118, 247, 120, 249, 122, 251, 124, 253, 126, 255, 128, 1, 130, 3, 132},
3199 {5, 134, 7, 136, 9, 138, 11, 140, 13, 142, 15, 144, 17, 146, 19, 148},
3200 {21, 150, 23, 152, 25, 154, 27, 156, 29, 158, 31, 160, 33, 162, 35, 164},
3201 {37, 166, 39, 168, 41, 170, 43, 172, 45, 174, 47, 176, 49, 178, 51, 180},
3202 {53, 182, 55, 184, 57, 186, 59, 188, 61, 190, 63, 192, 65, 194, 67, 196},
3203 {69, 198, 71, 200, 73, 202, 75, 204, 77, 206, 79, 208, 81, 210, 83, 212},
3204 {85, 214, 87, 216, 89, 218, 91, 220, 93, 222, 95, 224, 97, 226, 99, 228},
3205 {101, 230, 103, 232, 105, 234, 107, 236, 109, 238, 111, 240, 113, 242, 115, 244}},
3206 {{0x80f5, 0x82f7, 0x84f9, 0x86fb, 0x88fd, 0x8aff, 0x8d01, 0x8f03},
3207 {0x9105, 0x9307, 0x9509, 0x970b, 0x990d, 0x9b0f, 0x9d11, 0x9f13},
3208 {0xa115, 0xa317, 0xa519, 0xa71b, 0xa91d, 0xab1f, 0xad21, 0xaf23},
3209 {0xb125, 0xb327, 0xb529, 0xb72b, 0xb92d, 0xbb2f, 0xbd31, 0xbf33},
3210 {0xc135, 0xc337, 0xc539, 0xc73b, 0xc93d, 0xcb3f, 0xcd41, 0xcf43},
3211 {0xd145, 0xd347, 0xd549, 0xd74b, 0xd94d, 0xdb4f, 0xdd51, 0xdf53},
3212 {0xe155, 0xe357, 0xe559, 0xe75b, 0xe95d, 0xeb5f, 0xed61, 0xef63},
3213 {0xf165, 0xf367, 0xf569, 0xf76b, 0xf96d, 0xfb6f, 0xfd71, 0xff73}},
3214 {{0x8302'80f5, 0x8706'84f9, 0x8b0a'88fd, 0x8f0e'8d01},
3215 {0x9312'9105, 0x9716'9509, 0x9b1a'990d, 0x9f1e'9d11},
3216 {0xa322'a115, 0xa726'a519, 0xab2a'a91d, 0xaf2e'ad21},
3217 {0xb332'b125, 0xb736'b529, 0xbb3a'b92d, 0xbf3e'bd31},
3218 {0xc342'c135, 0xc746'c539, 0xcb4a'c93d, 0xcf4e'cd41},
3219 {0xd352'd145, 0xd756'd549, 0xdb5a'd94d, 0xdf5e'dd51},
3220 {0xe362'e155, 0xe766'e559, 0xeb6a'e95d, 0xef6e'ed61},
3221 {0xf372'f165, 0xf776'f569, 0xfb7a'f96d, 0xff7e'fd71}},
3222 {{0x8706'8504'8302'80f5, 0x8f0e'8d0c'8b0a'88fd},
3223 {0x9716'9514'9312'9105, 0x9f1e'9d1c'9b1a'990d},
3224 {0xa726'a524'a322'a115, 0xaf2e'ad2c'ab2a'a91d},
3225 {0xb736'b534'b332'b125, 0xbf3e'bd3c'bb3a'b92d},
3226 {0xc746'c544'c342'c135, 0xcf4e'cd4c'cb4a'c93d},
3227 {0xd756'd554'd352'd145, 0xdf5e'dd5c'db5a'd94d},
3228 {0xe766'e564'e362'e155, 0xef6e'ed6c'eb6a'e95d},
3229 {0xf776'f574'f372'f165, 0xff7e'fd7c'fb7a'f96d}},
3230 kVectorCalculationsSourceLegacy);
3231 TestVectorInstruction(
3232 ExecVsadduvv,
3233 ExecMaskedVsadduvv,
3234 {{0, 255, 6, 255, 13, 255, 18, 255, 25, 255, 30, 255, 36, 255, 42, 255},
3235 {48, 255, 54, 255, 61, 255, 66, 255, 73, 255, 78, 255, 84, 255, 90, 255},
3236 {96, 255, 102, 255, 109, 255, 114, 255, 121, 255, 126, 255, 132, 255, 138, 255},
3237 {144, 255, 150, 255, 157, 255, 162, 255, 169, 255, 174, 255, 180, 255, 186, 255},
3238 {192, 211, 198, 217, 205, 223, 210, 229, 217, 203, 222, 209, 228, 215, 234, 221},
3239 {240, 255, 246, 255, 253, 255, 255, 255, 255, 251, 255, 255, 255, 255, 255, 255},
3240 {255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
3241 {255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}},
3242 {{0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
3243 {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
3244 {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
3245 {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
3246 {0xd3c0, 0xd9c6, 0xdfcd, 0xe5d2, 0xcbd9, 0xd1de, 0xd7e4, 0xddea},
3247 {0xffff, 0xffff, 0xffff, 0xffff, 0xfc09, 0xffff, 0xffff, 0xffff},
3248 {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
3249 {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff}},
3250 {{0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff},
3251 {0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff},
3252 {0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff},
3253 {0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff},
3254 {0xd9c6'd3c0, 0xe5d2'dfcd, 0xd1de'cbd9, 0xddea'd7e4},
3255 {0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff},
3256 {0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff},
3257 {0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff}},
3258 {{0xffff'ffff'ffff'ffff, 0xffff'ffff'ffff'ffff},
3259 {0xffff'ffff'ffff'ffff, 0xffff'ffff'ffff'ffff},
3260 {0xffff'ffff'ffff'ffff, 0xffff'ffff'ffff'ffff},
3261 {0xffff'ffff'ffff'ffff, 0xffff'ffff'ffff'ffff},
3262 {0xe5d2'dfcd'd9c6'd3c0, 0xddea'd7e4'd1de'cbd9},
3263 {0xffff'ffff'ffff'ffff, 0xffff'ffff'ffff'ffff},
3264 {0xffff'ffff'ffff'ffff, 0xffff'ffff'ffff'ffff},
3265 {0xffff'ffff'ffff'ffff, 0xffff'ffff'ffff'ffff}},
3266 kVectorCalculationsSource);
3267 TestVectorInstruction(
3268 ExecVsadduvx,
3269 ExecMaskedVsadduvx,
3270 {{170, 255, 172, 255, 174, 255, 176, 255, 178, 255, 180, 255, 182, 255, 184, 255},
3271 {186, 255, 188, 255, 190, 255, 192, 255, 194, 255, 196, 255, 198, 255, 200, 255},
3272 {202, 255, 204, 255, 206, 255, 208, 255, 210, 255, 212, 255, 214, 255, 216, 255},
3273 {218, 255, 220, 255, 222, 255, 224, 255, 226, 255, 228, 255, 230, 255, 232, 255},
3274 {234, 255, 236, 255, 238, 255, 240, 255, 242, 255, 244, 255, 246, 255, 248, 255},
3275 {250, 255, 252, 255, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
3276 {255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
3277 {255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}},
3278 {{0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
3279 {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
3280 {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
3281 {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
3282 {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
3283 {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
3284 {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
3285 {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff}},
3286 {{0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff},
3287 {0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff},
3288 {0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff},
3289 {0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff},
3290 {0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff},
3291 {0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff},
3292 {0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff},
3293 {0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff}},
3294 {{0xffff'ffff'ffff'ffff, 0xffff'ffff'ffff'ffff},
3295 {0xffff'ffff'ffff'ffff, 0xffff'ffff'ffff'ffff},
3296 {0xffff'ffff'ffff'ffff, 0xffff'ffff'ffff'ffff},
3297 {0xffff'ffff'ffff'ffff, 0xffff'ffff'ffff'ffff},
3298 {0xffff'ffff'ffff'ffff, 0xffff'ffff'ffff'ffff},
3299 {0xffff'ffff'ffff'ffff, 0xffff'ffff'ffff'ffff},
3300 {0xffff'ffff'ffff'ffff, 0xffff'ffff'ffff'ffff},
3301 {0xffff'ffff'ffff'ffff, 0xffff'ffff'ffff'ffff}},
3302 kVectorCalculationsSource);
3303 TestVectorInstruction(
3304 ExecVsadduvi,
3305 ExecMaskedVsadduvi,
3306 {{245, 255, 247, 255, 249, 255, 251, 255, 253, 255, 255, 255, 255, 255, 255, 255},
3307 {255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
3308 {255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
3309 {255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
3310 {255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
3311 {255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
3312 {255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
3313 {255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}},
3314 {{0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
3315 {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
3316 {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
3317 {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
3318 {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
3319 {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
3320 {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
3321 {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff}},
3322 {{0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff},
3323 {0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff},
3324 {0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff},
3325 {0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff},
3326 {0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff},
3327 {0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff},
3328 {0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff},
3329 {0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff}},
3330 {{0xffff'ffff'ffff'ffff, 0xffff'ffff'ffff'ffff},
3331 {0xffff'ffff'ffff'ffff, 0xffff'ffff'ffff'ffff},
3332 {0xffff'ffff'ffff'ffff, 0xffff'ffff'ffff'ffff},
3333 {0xffff'ffff'ffff'ffff, 0xffff'ffff'ffff'ffff},
3334 {0xffff'ffff'ffff'ffff, 0xffff'ffff'ffff'ffff},
3335 {0xffff'ffff'ffff'ffff, 0xffff'ffff'ffff'ffff},
3336 {0xffff'ffff'ffff'ffff, 0xffff'ffff'ffff'ffff},
3337 {0xffff'ffff'ffff'ffff, 0xffff'ffff'ffff'ffff}},
3338 kVectorCalculationsSource);
3339 TestVectorInstruction(
3340 ExecVsaddvv,
3341 ExecMaskedVsaddvv,
3342 {{0, 128, 6, 128, 13, 128, 18, 128, 25, 128, 30, 128, 36, 128, 42, 128},
3343 {48, 128, 54, 128, 61, 128, 66, 128, 73, 128, 78, 128, 84, 128, 90, 128},
3344 {96, 128, 102, 128, 109, 128, 114, 133, 121, 128, 126, 128, 127, 128, 127, 128},
3345 {127, 163, 127, 169, 127, 175, 127, 181, 127, 155, 127, 161, 127, 167, 127, 173},
3346 {192, 211, 198, 217, 205, 223, 210, 229, 217, 203, 222, 209, 228, 215, 234, 221},
3347 {240, 3, 246, 9, 253, 15, 2, 21, 9, 251, 14, 1, 20, 7, 26, 13},
3348 {32, 51, 38, 57, 45, 63, 50, 69, 57, 43, 62, 49, 68, 55, 74, 61},
3349 {80, 99, 86, 105, 93, 111, 98, 117, 105, 91, 110, 97, 116, 103, 122, 109}},
3350 {{0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000},
3351 {0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000},
3352 {0x8000, 0x8000, 0x8000, 0x8572, 0x8000, 0x8000, 0x8000, 0x8000},
3353 {0xa390, 0xa996, 0xaf9d, 0xb5a2, 0x9ba9, 0xa1ae, 0xa7b4, 0xadba},
3354 {0xd3c0, 0xd9c6, 0xdfcd, 0xe5d2, 0xcbd9, 0xd1de, 0xd7e4, 0xddea},
3355 {0x03f0, 0x09f6, 0x0ffd, 0x1602, 0xfc09, 0x020e, 0x0814, 0x0e1a},
3356 {0x3420, 0x3a26, 0x402d, 0x4632, 0x2c39, 0x323e, 0x3844, 0x3e4a},
3357 {0x6450, 0x6a56, 0x705d, 0x7662, 0x5c69, 0x626e, 0x6874, 0x6e7a}},
3358 {{0x8000'0000, 0x8000'0000, 0x8000'0000, 0x8000'0000},
3359 {0x8000'0000, 0x8000'0000, 0x8000'0000, 0x8000'0000},
3360 {0x8000'0000, 0x8573'7f6d, 0x8000'0000, 0x8000'0000},
3361 {0xa997'a390, 0xb5a3'af9d, 0xa1af'9ba9, 0xadbb'a7b4},
3362 {0xd9c6'd3c0, 0xe5d2'dfcd, 0xd1de'cbd9, 0xddea'd7e4},
3363 {0x09f7'03f0, 0x1603'0ffd, 0x020e'fc09, 0x0e1b'0814},
3364 {0x3a27'3420, 0x4633'402d, 0x323f'2c39, 0x3e4b'3844},
3365 {0x6a57'6450, 0x7663'705d, 0x626f'5c69, 0x6e7b'6874}},
3366 {{0x8000'0000'0000'0000, 0x8000'0000'0000'0000},
3367 {0x8000'0000'0000'0000, 0x8000'0000'0000'0000},
3368 {0x8573'7f6e'7967'7360, 0x8000'0000'0000'0000},
3369 {0xb5a3'af9e'a997'a390, 0xadbb'a7b5'a1af'9ba9},
3370 {0xe5d2'dfcd'd9c6'd3c0, 0xddea'd7e4'd1de'cbd9},
3371 {0x1603'0ffe'09f7'03f0, 0x0e1b'0815'020e'fc09},
3372 {0x4633'402e'3a27'3420, 0x3e4b'3845'323f'2c39},
3373 {0x7663'705e'6a57'6450, 0x6e7b'6875'626f'5c69}},
3374 kVectorCalculationsSource);
3375 TestVectorInstruction(
3376 ExecVsaddvx,
3377 ExecMaskedVsaddvx,
3378 {{170, 128, 172, 128, 174, 128, 176, 128, 178, 128, 180, 128, 182, 128, 184, 128},
3379 {186, 128, 188, 128, 190, 128, 192, 128, 194, 128, 196, 128, 198, 128, 200, 128},
3380 {202, 128, 204, 128, 206, 128, 208, 128, 210, 128, 212, 128, 214, 128, 216, 128},
3381 {218, 128, 220, 128, 222, 128, 224, 128, 226, 128, 228, 128, 230, 128, 232, 128},
3382 {234, 128, 236, 128, 238, 128, 240, 128, 242, 128, 244, 128, 246, 128, 248, 128},
3383 {250, 128, 252, 128, 254, 128, 0, 129, 2, 131, 4, 133, 6, 135, 8, 137},
3384 {10, 139, 12, 141, 14, 143, 16, 145, 18, 147, 20, 149, 22, 151, 24, 153},
3385 {26, 155, 28, 157, 30, 159, 32, 161, 34, 163, 36, 165, 38, 167, 40, 169}},
3386 {{0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000},
3387 {0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000},
3388 {0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000},
3389 {0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000},
3390 {0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000},
3391 {0x8000, 0x8000, 0x8000, 0x8200, 0x8402, 0x8604, 0x8806, 0x8a08},
3392 {0x8c0a, 0x8e0c, 0x900e, 0x9210, 0x9412, 0x9614, 0x9816, 0x9a18},
3393 {0x9c1a, 0x9e1c, 0xa01e, 0xa220, 0xa422, 0xa624, 0xa826, 0xaa28}},
3394 {{0x8000'0000, 0x8000'0000, 0x8000'0000, 0x8000'0000},
3395 {0x8000'0000, 0x8000'0000, 0x8000'0000, 0x8000'0000},
3396 {0x8000'0000, 0x8000'0000, 0x8000'0000, 0x8000'0000},
3397 {0x8000'0000, 0x8000'0000, 0x8000'0000, 0x8000'0000},
3398 {0x8000'0000, 0x8000'0000, 0x8000'0000, 0x8000'0000},
3399 {0x8000'0000, 0x8201'7ffe, 0x8605'8402, 0x8a09'8806},
3400 {0x8e0d'8c0a, 0x9211'900e, 0x9615'9412, 0x9a19'9816},
3401 {0x9e1d'9c1a, 0xa221'a01e, 0xa625'a422, 0xaa29'a826}},
3402 {{0x8000'0000'0000'0000, 0x8000'0000'0000'0000},
3403 {0x8000'0000'0000'0000, 0x8000'0000'0000'0000},
3404 {0x8000'0000'0000'0000, 0x8000'0000'0000'0000},
3405 {0x8000'0000'0000'0000, 0x8000'0000'0000'0000},
3406 {0x8000'0000'0000'0000, 0x8000'0000'0000'0000},
3407 {0x8201'7fff'7dfd'7bfa, 0x8a09'8807'8605'8402},
3408 {0x9211'900f'8e0d'8c0a, 0x9a19'9817'9615'9412},
3409 {0xa221'a01f'9e1d'9c1a, 0xaa29'a827'a625'a422}},
3410 kVectorCalculationsSource);
3411 TestVectorInstruction(
3412 ExecVsaddvi,
3413 ExecMaskedVsaddvi,
3414 {{245, 128, 247, 128, 249, 128, 251, 128, 253, 128, 255, 128, 1, 130, 3, 132},
3415 {5, 134, 7, 136, 9, 138, 11, 140, 13, 142, 15, 144, 17, 146, 19, 148},
3416 {21, 150, 23, 152, 25, 154, 27, 156, 29, 158, 31, 160, 33, 162, 35, 164},
3417 {37, 166, 39, 168, 41, 170, 43, 172, 45, 174, 47, 176, 49, 178, 51, 180},
3418 {53, 182, 55, 184, 57, 186, 59, 188, 61, 190, 63, 192, 65, 194, 67, 196},
3419 {69, 198, 71, 200, 73, 202, 75, 204, 77, 206, 79, 208, 81, 210, 83, 212},
3420 {85, 214, 87, 216, 89, 218, 91, 220, 93, 222, 95, 224, 97, 226, 99, 228},
3421 {101, 230, 103, 232, 105, 234, 107, 236, 109, 238, 111, 240, 113, 242, 115, 244}},
3422 {{0x80f5, 0x82f7, 0x84f9, 0x86fb, 0x88fd, 0x8aff, 0x8d01, 0x8f03},
3423 {0x9105, 0x9307, 0x9509, 0x970b, 0x990d, 0x9b0f, 0x9d11, 0x9f13},
3424 {0xa115, 0xa317, 0xa519, 0xa71b, 0xa91d, 0xab1f, 0xad21, 0xaf23},
3425 {0xb125, 0xb327, 0xb529, 0xb72b, 0xb92d, 0xbb2f, 0xbd31, 0xbf33},
3426 {0xc135, 0xc337, 0xc539, 0xc73b, 0xc93d, 0xcb3f, 0xcd41, 0xcf43},
3427 {0xd145, 0xd347, 0xd549, 0xd74b, 0xd94d, 0xdb4f, 0xdd51, 0xdf53},
3428 {0xe155, 0xe357, 0xe559, 0xe75b, 0xe95d, 0xeb5f, 0xed61, 0xef63},
3429 {0xf165, 0xf367, 0xf569, 0xf76b, 0xf96d, 0xfb6f, 0xfd71, 0xff73}},
3430 {{0x8302'80f5, 0x8706'84f9, 0x8b0a'88fd, 0x8f0e'8d01},
3431 {0x9312'9105, 0x9716'9509, 0x9b1a'990d, 0x9f1e'9d11},
3432 {0xa322'a115, 0xa726'a519, 0xab2a'a91d, 0xaf2e'ad21},
3433 {0xb332'b125, 0xb736'b529, 0xbb3a'b92d, 0xbf3e'bd31},
3434 {0xc342'c135, 0xc746'c539, 0xcb4a'c93d, 0xcf4e'cd41},
3435 {0xd352'd145, 0xd756'd549, 0xdb5a'd94d, 0xdf5e'dd51},
3436 {0xe362'e155, 0xe766'e559, 0xeb6a'e95d, 0xef6e'ed61},
3437 {0xf372'f165, 0xf776'f569, 0xfb7a'f96d, 0xff7e'fd71}},
3438 {{0x8706'8504'8302'80f5, 0x8f0e'8d0c'8b0a'88fd},
3439 {0x9716'9514'9312'9105, 0x9f1e'9d1c'9b1a'990d},
3440 {0xa726'a524'a322'a115, 0xaf2e'ad2c'ab2a'a91d},
3441 {0xb736'b534'b332'b125, 0xbf3e'bd3c'bb3a'b92d},
3442 {0xc746'c544'c342'c135, 0xcf4e'cd4c'cb4a'c93d},
3443 {0xd756'd554'd352'd145, 0xdf5e'dd5c'db5a'd94d},
3444 {0xe766'e564'e362'e155, 0xef6e'ed6c'eb6a'e95d},
3445 {0xf776'f574'f372'f165, 0xff7e'fd7c'fb7a'f96d}},
3446 kVectorCalculationsSource);
3447
3448 TestVectorFloatInstruction(ExecVfaddvv,
3449 ExecMaskedVfaddvv,
3450 {{0x9604'9200, 0x9e0c'9a09, 0x8b0a'ae29, 0x8f35'af92},
3451 {0xb624'b220, 0xbe2c'ba29, 0xa634'a233, 0xae3c'aa38},
3452 {0xd644'd240, 0xde4c'da49, 0xc654'c251, 0xce5c'ca58},
3453 {0xf664'f260, 0xfe6c'fa69, 0xe674'e271, 0xee7c'ea78},
3454 {0xc342'c140, 0xc746'c544, 0xcb4a'c948, 0xcf4e'cd4c},
3455 {0xd352'd150, 0xd756'd554, 0xdb5a'd958, 0xdf5e'dd5c},
3456 {0xe362'e160, 0xe766'e4fe, 0xeb6a'e968, 0xef6e'ed6c},
3457 {0x76e2'8cfd, 0x7eec'78fb, 0xfb7a'f978, 0xff7e'fd7c}},
3458 {{0x9e0c'9a09'9604'9200, 0x8f0e'8d45'9f3b'9531},
3459 {0xbe2c'ba29'b624'b220, 0xae3c'aa38'a634'a231},
3460 {0xde4c'da49'd644'd240, 0xce5c'ca58'c654'c251},
3461 {0xfe6c'fa69'f664'f260, 0xee7c'ea78'e674'e271},
3462 {0xc746'c544'c342'c140, 0xcf4e'cd4c'cb4a'c948},
3463 {0xd756'd554'd352'd150, 0xdf5e'dd5c'db5a'd958},
3464 {0xe766'e564'e362'e160, 0xef6e'ed6c'eb6a'e968},
3465 {0x7eec'7ae9'76e4'72e0, 0xff7e'fd7c'fb7a'f978}},
3466 kVectorCalculationsSource);
3467 TestVectorFloatInstruction(ExecVfaddvf,
3468 ExecMaskedVfaddvf,
3469 {{0x40b4'0000, 0x40b4'0000, 0x40b4'0000, 0x40b4'0000},
3470 {0x40b4'0000, 0x40b4'0000, 0x40b4'0000, 0x40b4'0000},
3471 {0x40b4'0000, 0x40b4'0000, 0x40b4'0000, 0x40b4'0000},
3472 {0x40b4'0000, 0x40b3'ffe9, 0x40b3'e8a9, 0x409c'2858},
3473 {0xc33d'2140, 0xc746'bfa4, 0xcb4a'c942, 0xcf4e'cd4c},
3474 {0xd352'd150, 0xd756'd554, 0xdb5a'd958, 0xdf5e'dd5c},
3475 {0xe362'e160, 0xe766'e564, 0xeb6a'e968, 0xef6e'ed6c},
3476 {0xf372'f170, 0xf776'f574, 0xfb7a'f978, 0xff7e'fd7c}},
3477 {{0x4016'8000'0000'0000, 0x4016'8000'0000'0000},
3478 {0x4016'8000'0000'0000, 0x4016'8000'0000'0000},
3479 {0x4016'8000'0000'0000, 0x4016'8000'0000'0000},
3480 {0x4016'8000'0000'0000, 0x4016'7f85'0b0d'1315},
3481 {0xc746'c544'c342'c140, 0xcf4e'cd4c'cb4a'c948},
3482 {0xd756'd554'd352'd150, 0xdf5e'dd5c'db5a'd958},
3483 {0xe766'e564'e362'e160, 0xef6e'ed6c'eb6a'e968},
3484 {0xf776'f574'f372'f170, 0xff7e'fd7c'fb7a'f978}},
3485 kVectorCalculationsSource);
3486
3487 TestWideningVectorFloatInstruction(ExecVfwaddvv,
3488 ExecMaskedVfwaddvv,
3489 {{0xbac0'9240'0000'4140, 0xbbc1'9341'2000'0043},
3490 {0xb961'55c5'1088'0000, 0xb9e6'b5f2'4000'0000},
3491 {0xbec4'9644'0000'0000, 0xbfc5'9745'2000'0000},
3492 {0xbcc6'9446'6d4c'8c00, 0xbdc7'9547'004f'4e8e},
3493 {0xc2c8'9a48'0000'0000, 0xc3c9'9b49'2000'0000},
3494 {0xc0ca'984a'2000'0000, 0xc1cb'994b'0000'0000},
3495 {0xc6cc'9e4c'0000'0000, 0xc7cd'9f4d'2000'0000},
3496 {0xc4ce'9c4e'2000'0000, 0xc5cf'9d4f'0000'0000}},
3497 kVectorCalculationsSource);
3498
3499 TestWideningVectorFloatInstruction(ExecVfwaddwv,
3500 ExecMaskedVfwaddwv,
3501 {{0xbac0'9240'0000'0000, 0xbbc1'9341'2000'0000},
3502 {0xb8c2'9042'2000'0000, 0xb9c3'9143'0000'0000},
3503 {0xbec4'9644'0000'0000, 0xbfc5'9745'2000'0000},
3504 {0xbcc6'9446'2000'0000, 0xbf3e'bd3c'ea65'4738},
3505 {0xc746'c544'c342'c140, 0xcf4e'cd4c'cb4a'c948},
3506 {0xd756'd554'd352'd150, 0xdf5e'dd5c'db5a'd958},
3507 {0xe766'e564'e362'e160, 0xef6e'ed6c'eb6a'e968},
3508 {0xf776'f574'f372'f170, 0xff7e'fd7c'fb7a'f978}},
3509 kVectorCalculationsSource);
3510
3511 TestWideningVectorFloatInstruction(ExecVfwaddwf,
3512 ExecMaskedVfwaddwf,
3513 {{0x4016'8000'0000'0000, 0x4016'8000'0000'0000},
3514 {0x4016'8000'0000'0000, 0x4016'8000'0000'0000},
3515 {0x4016'8000'0000'0000, 0x4016'8000'0000'0000},
3516 {0x4016'8000'0000'0000, 0x4016'7f85'0b0d'1315},
3517 {0xc746'c544'c342'c140, 0xcf4e'cd4c'cb4a'c948},
3518 {0xd756'd554'd352'd150, 0xdf5e'dd5c'db5a'd958},
3519 {0xe766'e564'e362'e160, 0xef6e'ed6c'eb6a'e968},
3520 {0xf776'f574'f372'f170, 0xff7e'fd7c'fb7a'f978}},
3521 kVectorCalculationsSource);
3522 }
3523
ExecVsubvv()3524 [[gnu::naked]] void ExecVsubvv() {
3525 asm("vsub.vv v8, v16, v24\n\t"
3526 "ret\n\t");
3527 }
ExecMaskedVsubvv()3528 [[gnu::naked]] void ExecMaskedVsubvv() {
3529 asm("vsub.vv v8, v16, v24, v0.t\n\t"
3530 "ret\n\t");
3531 }
ExecVsubvx()3532 [[gnu::naked]] void ExecVsubvx() {
3533 asm("vsub.vx v8, v16, t0\n\t"
3534 "ret\n\t");
3535 }
ExecMaskedVsubvx()3536 [[gnu::naked]] void ExecMaskedVsubvx() {
3537 asm("vsub.vx v8, v16, t0, v0.t\n\t"
3538 "ret\n\t");
3539 }
ExecVssubuvv()3540 [[gnu::naked]] void ExecVssubuvv() {
3541 asm("vssubu.vv v8, v16, v24\n\t"
3542 "ret\n\t");
3543 }
ExecMaskedVssubuvv()3544 [[gnu::naked]] void ExecMaskedVssubuvv() {
3545 asm("vssubu.vv v8, v16, v24, v0.t\n\t"
3546 "ret\n\t");
3547 }
ExecVssubuvx()3548 [[gnu::naked]] void ExecVssubuvx() {
3549 asm("vssubu.vx v8, v16, t0\n\t"
3550 "ret\n\t");
3551 }
ExecMaskedVssubuvx()3552 [[gnu::naked]] void ExecMaskedVssubuvx() {
3553 asm("vssubu.vx v8, v16, t0, v0.t\n\t"
3554 "ret\n\t");
3555 }
ExecVssubvv()3556 [[gnu::naked]] void ExecVssubvv() {
3557 asm("vssub.vv v8, v16, v24\n\t"
3558 "ret\n\t");
3559 }
ExecMaskedVssubvv()3560 [[gnu::naked]] void ExecMaskedVssubvv() {
3561 asm("vssub.vv v8, v16, v24, v0.t\n\t"
3562 "ret\n\t");
3563 }
ExecVssubvx()3564 [[gnu::naked]] void ExecVssubvx() {
3565 asm("vssub.vx v8, v16, t0\n\t"
3566 "ret\n\t");
3567 }
ExecMaskedVssubvx()3568 [[gnu::naked]] void ExecMaskedVssubvx() {
3569 asm("vssub.vx v8, v16, t0, v0.t\n\t"
3570 "ret\n\t");
3571 }
3572
ExecVfsubvv()3573 [[gnu::naked]] void ExecVfsubvv() {
3574 asm("vfsub.vv v8, v16, v24\n\t"
3575 "ret\n\t");
3576 }
3577
ExecMaskedVfsubvv()3578 [[gnu::naked]] void ExecMaskedVfsubvv() {
3579 asm("vfsub.vv v8, v16, v24, v0.t\n\t"
3580 "ret\n\t");
3581 }
3582
ExecVfsubvf()3583 [[gnu::naked]] void ExecVfsubvf() {
3584 asm("vfsub.vf v8, v16, ft0\n\t"
3585 "ret\n\t");
3586 }
3587
ExecMaskedVfsubvf()3588 [[gnu::naked]] void ExecMaskedVfsubvf() {
3589 asm("vfsub.vf v8, v16, ft0, v0.t\n\t"
3590 "ret\n\t");
3591 }
3592
ExecVfwsubvv()3593 [[gnu::naked]] void ExecVfwsubvv() {
3594 asm("vfwsub.vv v8, v16, v24\n\t"
3595 "ret\n\t");
3596 }
3597
ExecMaskedVfwsubvv()3598 [[gnu::naked]] void ExecMaskedVfwsubvv() {
3599 asm("vfwsub.vv v8, v16, v24, v0.t\n\t"
3600 "ret\n\t");
3601 }
3602
ExecVfwsubvf()3603 [[gnu::naked]] void ExecVfwsubvf() {
3604 asm("vfwsub.vf v8, v16, ft0\n\t"
3605 "ret\n\t");
3606 }
3607
ExecMaskedVfwsubvf()3608 [[gnu::naked]] void ExecMaskedVfwsubvf() {
3609 asm("vfwsub.vf v8, v16, ft0, v0.t\n\t"
3610 "ret\n\t");
3611 }
3612
ExecVfwsubwv()3613 [[gnu::naked]] void ExecVfwsubwv() {
3614 asm("vfwsub.wv v8, v16, v24\n\t"
3615 "ret\n\t");
3616 }
3617
ExecMaskedVfwsubwv()3618 [[gnu::naked]] void ExecMaskedVfwsubwv() {
3619 asm("vfwsub.wv v8, v16, v24, v0.t\n\t"
3620 "ret\n\t");
3621 }
3622
ExecVfwsubwf()3623 [[gnu::naked]] void ExecVfwsubwf() {
3624 asm("vfwsub.wf v8, v16, ft0\n\t"
3625 "ret\n\t");
3626 }
3627
ExecMaskedVfwsubwf()3628 [[gnu::naked]] void ExecMaskedVfwsubwf() {
3629 asm("vfwsub.wf v8, v16, ft0, v0.t\n\t"
3630 "ret\n\t");
3631 }
3632
TEST(InlineAsmTestRiscv64,TestVsub)3633 TEST(InlineAsmTestRiscv64, TestVsub) {
3634 TestVectorInstruction(
3635 ExecVsubvv,
3636 ExecMaskedVsubvv,
3637 {{0, 127, 254, 125, 251, 123, 250, 121, 247, 119, 246, 117, 244, 115, 242, 113},
3638 {240, 111, 238, 109, 235, 107, 234, 105, 231, 103, 230, 101, 228, 99, 226, 97},
3639 {224, 95, 222, 93, 219, 91, 218, 89, 215, 87, 214, 85, 212, 83, 210, 81},
3640 {208, 79, 206, 77, 203, 75, 202, 73, 199, 71, 198, 69, 196, 67, 194, 65},
3641 {192, 63, 190, 61, 187, 59, 186, 57, 183, 55, 182, 53, 180, 51, 178, 49},
3642 {176, 47, 174, 45, 171, 43, 170, 41, 167, 39, 166, 37, 164, 35, 162, 33},
3643 {160, 31, 158, 29, 155, 27, 154, 25, 151, 23, 150, 21, 148, 19, 146, 17},
3644 {144, 15, 142, 13, 139, 11, 138, 9, 135, 7, 134, 5, 132, 3, 130, 1}},
3645 {{0x7f00, 0x7cfe, 0x7afb, 0x78fa, 0x76f7, 0x74f6, 0x72f4, 0x70f2},
3646 {0x6ef0, 0x6cee, 0x6aeb, 0x68ea, 0x66e7, 0x64e6, 0x62e4, 0x60e2},
3647 {0x5ee0, 0x5cde, 0x5adb, 0x58da, 0x56d7, 0x54d6, 0x52d4, 0x50d2},
3648 {0x4ed0, 0x4cce, 0x4acb, 0x48ca, 0x46c7, 0x44c6, 0x42c4, 0x40c2},
3649 {0x3ec0, 0x3cbe, 0x3abb, 0x38ba, 0x36b7, 0x34b6, 0x32b4, 0x30b2},
3650 {0x2eb0, 0x2cae, 0x2aab, 0x28aa, 0x26a7, 0x24a6, 0x22a4, 0x20a2},
3651 {0x1ea0, 0x1c9e, 0x1a9b, 0x189a, 0x1697, 0x1496, 0x1294, 0x1092},
3652 {0x0e90, 0x0c8e, 0x0a8b, 0x088a, 0x0687, 0x0486, 0x0284, 0x0082}},
3653 {{0x7cfe'7f00, 0x78fa'7afb, 0x74f6'76f7, 0x70f2'72f4},
3654 {0x6cee'6ef0, 0x68ea'6aeb, 0x64e6'66e7, 0x60e2'62e4},
3655 {0x5cde'5ee0, 0x58da'5adb, 0x54d6'56d7, 0x50d2'52d4},
3656 {0x4cce'4ed0, 0x48ca'4acb, 0x44c6'46c7, 0x40c2'42c4},
3657 {0x3cbe'3ec0, 0x38ba'3abb, 0x34b6'36b7, 0x30b2'32b4},
3658 {0x2cae'2eb0, 0x28aa'2aab, 0x24a6'26a7, 0x20a2'22a4},
3659 {0x1c9e'1ea0, 0x189a'1a9b, 0x1496'1697, 0x1092'1294},
3660 {0x0c8e'0e90, 0x088a'0a8b, 0x0486'0687, 0x0082'0284}},
3661 {{0x78fa'7afb'7cfe'7f00, 0x70f2'72f4'74f6'76f7},
3662 {0x68ea'6aeb'6cee'6ef0, 0x60e2'62e4'64e6'66e7},
3663 {0x58da'5adb'5cde'5ee0, 0x50d2'52d4'54d6'56d7},
3664 {0x48ca'4acb'4cce'4ed0, 0x40c2'42c4'44c6'46c7},
3665 {0x38ba'3abb'3cbe'3ec0, 0x30b2'32b4'34b6'36b7},
3666 {0x28aa'2aab'2cae'2eb0, 0x20a2'22a4'24a6'26a7},
3667 {0x189a'1a9b'1c9e'1ea0, 0x1092'1294'1496'1697},
3668 {0x088a'0a8b'0c8e'0e90, 0x0082'0284'0486'0687}},
3669 kVectorCalculationsSourceLegacy);
3670 TestVectorInstruction(
3671 ExecVsubvx,
3672 ExecMaskedVsubvx,
3673 {{86, 215, 88, 217, 90, 219, 92, 221, 94, 223, 96, 225, 98, 227, 100, 229},
3674 {102, 231, 104, 233, 106, 235, 108, 237, 110, 239, 112, 241, 114, 243, 116, 245},
3675 {118, 247, 120, 249, 122, 251, 124, 253, 126, 255, 128, 1, 130, 3, 132, 5},
3676 {134, 7, 136, 9, 138, 11, 140, 13, 142, 15, 144, 17, 146, 19, 148, 21},
3677 {150, 23, 152, 25, 154, 27, 156, 29, 158, 31, 160, 33, 162, 35, 164, 37},
3678 {166, 39, 168, 41, 170, 43, 172, 45, 174, 47, 176, 49, 178, 51, 180, 53},
3679 {182, 55, 184, 57, 186, 59, 188, 61, 190, 63, 192, 65, 194, 67, 196, 69},
3680 {198, 71, 200, 73, 202, 75, 204, 77, 206, 79, 208, 81, 210, 83, 212, 85}},
3681 {{0xd656, 0xd858, 0xda5a, 0xdc5c, 0xde5e, 0xe060, 0xe262, 0xe464},
3682 {0xe666, 0xe868, 0xea6a, 0xec6c, 0xee6e, 0xf070, 0xf272, 0xf474},
3683 {0xf676, 0xf878, 0xfa7a, 0xfc7c, 0xfe7e, 0x0080, 0x0282, 0x0484},
3684 {0x0686, 0x0888, 0x0a8a, 0x0c8c, 0x0e8e, 0x1090, 0x1292, 0x1494},
3685 {0x1696, 0x1898, 0x1a9a, 0x1c9c, 0x1e9e, 0x20a0, 0x22a2, 0x24a4},
3686 {0x26a6, 0x28a8, 0x2aaa, 0x2cac, 0x2eae, 0x30b0, 0x32b2, 0x34b4},
3687 {0x36b6, 0x38b8, 0x3aba, 0x3cbc, 0x3ebe, 0x40c0, 0x42c2, 0x44c4},
3688 {0x46c6, 0x48c8, 0x4aca, 0x4ccc, 0x4ece, 0x50d0, 0x52d2, 0x54d4}},
3689 {{0xd857'd656, 0xdc5b'da5a, 0xe05f'de5e, 0xe463'e262},
3690 {0xe867'e666, 0xec6b'ea6a, 0xf06f'ee6e, 0xf473'f272},
3691 {0xf877'f676, 0xfc7b'fa7a, 0x007f'fe7e, 0x0484'0282},
3692 {0x0888'0686, 0x0c8c'0a8a, 0x1090'0e8e, 0x1494'1292},
3693 {0x1898'1696, 0x1c9c'1a9a, 0x20a0'1e9e, 0x24a4'22a2},
3694 {0x28a8'26a6, 0x2cac'2aaa, 0x30b0'2eae, 0x34b4'32b2},
3695 {0x38b8'36b6, 0x3cbc'3aba, 0x40c0'3ebe, 0x44c4'42c2},
3696 {0x48c8'46c6, 0x4ccc'4aca, 0x50d0'4ece, 0x54d4'52d2}},
3697 {{0xdc5b'da59'd857'd656, 0xe463'e261'e05f'de5e},
3698 {0xec6b'ea69'e867'e666, 0xf473'f271'f06f'ee6e},
3699 {0xfc7b'fa79'f877'f676, 0x0484'0282'007f'fe7e},
3700 {0x0c8c'0a8a'0888'0686, 0x1494'1292'1090'0e8e},
3701 {0x1c9c'1a9a'1898'1696, 0x24a4'22a2'20a0'1e9e},
3702 {0x2cac'2aaa'28a8'26a6, 0x34b4'32b2'30b0'2eae},
3703 {0x3cbc'3aba'38b8'36b6, 0x44c4'42c2'40c0'3ebe},
3704 {0x4ccc'4aca'48c8'46c6, 0x54d4'52d2'50d0'4ece}},
3705 kVectorCalculationsSourceLegacy);
3706 TestVectorInstruction(ExecVssubuvv,
3707 ExecMaskedVssubuvv,
3708 {{0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 5, 0, 3, 0, 1},
3709 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
3710 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
3711 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
3712 {0, 175, 0, 173, 0, 171, 0, 169, 0, 199, 0, 197, 0, 195, 0, 193},
3713 {0, 159, 0, 157, 0, 155, 0, 153, 0, 183, 0, 181, 0, 179, 0, 177},
3714 {0, 143, 0, 141, 0, 139, 0, 137, 0, 167, 0, 165, 0, 163, 0, 161},
3715 {0, 127, 0, 125, 0, 123, 0, 121, 0, 151, 0, 149, 0, 147, 0, 145}},
3716 {{0x0000, 0x0000, 0x0000, 0x0000, 0x06f7, 0x04f6, 0x02f4, 0x00f2},
3717 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
3718 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
3719 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
3720 {0xaec0, 0xacbe, 0xaabb, 0xa8ba, 0xc6b7, 0xc4b6, 0xc2b4, 0xc0b2},
3721 {0x9eb0, 0x9cae, 0x9aab, 0x98aa, 0xb6a7, 0xb4a6, 0xb2a4, 0xb0a2},
3722 {0x8ea0, 0x8c9e, 0x8a9b, 0x889a, 0xa697, 0xa496, 0xa294, 0xa092},
3723 {0x7e90, 0x7c8e, 0x7a8b, 0x788a, 0x9687, 0x9486, 0x9284, 0x9082}},
3724 {{0x0000'0000, 0x0000'0000, 0x04f6'06f7, 0x00f2'02f4},
3725 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
3726 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
3727 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
3728 {0xacbe'aec0, 0xa8ba'aabb, 0xc4b6'c6b7, 0xc0b2'c2b4},
3729 {0x9cae'9eb0, 0x98aa'9aab, 0xb4a6'b6a7, 0xb0a2'b2a4},
3730 {0x8c9e'8ea0, 0x889a'8a9b, 0xa496'a697, 0xa092'a294},
3731 {0x7c8e'7e90, 0x788a'7a8b, 0x9486'9687, 0x9082'9284}},
3732 {{0x0000'0000'0000'0000, 0x00f2'02f4'04f6'06f7},
3733 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
3734 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
3735 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
3736 {0xa8ba'aabb'acbe'aec0, 0xc0b2'c2b4'c4b6'c6b7},
3737 {0x98aa'9aab'9cae'9eb0, 0xb0a2'b2a4'b4a6'b6a7},
3738 {0x889a'8a9b'8c9e'8ea0, 0xa092'a294'a496'a697},
3739 {0x788a'7a8b'7c8e'7e90, 0x9082'9284'9486'9687}},
3740 kVectorCalculationsSource);
3741 TestVectorInstruction(ExecVssubuvx,
3742 ExecMaskedVssubuvx,
3743 {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
3744 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
3745 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 3, 0, 5},
3746 {0, 7, 0, 9, 0, 11, 0, 13, 0, 15, 0, 17, 0, 19, 0, 21},
3747 {0, 23, 0, 25, 0, 27, 0, 29, 0, 31, 0, 33, 0, 35, 0, 37},
3748 {0, 39, 0, 41, 0, 43, 0, 45, 0, 47, 0, 49, 0, 51, 0, 53},
3749 {0, 55, 0, 57, 0, 59, 0, 61, 0, 63, 0, 65, 0, 67, 0, 69},
3750 {0, 71, 0, 73, 0, 75, 0, 77, 0, 79, 0, 81, 0, 83, 0, 85}},
3751 {{0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
3752 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
3753 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0080, 0x0282, 0x0484},
3754 {0x0686, 0x0888, 0x0a8a, 0x0c8c, 0x0e8e, 0x1090, 0x1292, 0x1494},
3755 {0x1696, 0x1898, 0x1a9a, 0x1c9c, 0x1e9e, 0x20a0, 0x22a2, 0x24a4},
3756 {0x26a6, 0x28a8, 0x2aaa, 0x2cac, 0x2eae, 0x30b0, 0x32b2, 0x34b4},
3757 {0x36b6, 0x38b8, 0x3aba, 0x3cbc, 0x3ebe, 0x40c0, 0x42c2, 0x44c4},
3758 {0x46c6, 0x48c8, 0x4aca, 0x4ccc, 0x4ece, 0x50d0, 0x52d2, 0x54d4}},
3759 {{0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
3760 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
3761 {0x0000'0000, 0x0000'0000, 0x007f'fe7e, 0x0484'0282},
3762 {0x0888'0686, 0x0c8c'0a8a, 0x1090'0e8e, 0x1494'1292},
3763 {0x1898'1696, 0x1c9c'1a9a, 0x20a0'1e9e, 0x24a4'22a2},
3764 {0x28a8'26a6, 0x2cac'2aaa, 0x30b0'2eae, 0x34b4'32b2},
3765 {0x38b8'36b6, 0x3cbc'3aba, 0x40c0'3ebe, 0x44c4'42c2},
3766 {0x48c8'46c6, 0x4ccc'4aca, 0x50d0'4ece, 0x54d4'52d2}},
3767 {{0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
3768 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
3769 {0x0000'0000'0000'0000, 0x0484'0282'007f'fe7e},
3770 {0x0c8c'0a8a'0888'0686, 0x1494'1292'1090'0e8e},
3771 {0x1c9c'1a9a'1898'1696, 0x24a4'22a2'20a0'1e9e},
3772 {0x2cac'2aaa'28a8'26a6, 0x34b4'32b2'30b0'2eae},
3773 {0x3cbc'3aba'38b8'36b6, 0x44c4'42c2'40c0'3ebe},
3774 {0x4ccc'4aca'48c8'46c6, 0x54d4'52d2'50d0'4ece}},
3775 kVectorCalculationsSource);
3776 TestVectorInstruction(
3777 ExecVssubvv,
3778 ExecMaskedVssubvv,
3779 {{0, 239, 254, 237, 251, 235, 250, 233, 247, 7, 246, 5, 244, 3, 242, 1},
3780 {240, 223, 238, 221, 235, 219, 234, 217, 231, 247, 230, 245, 228, 243, 226, 241},
3781 {224, 207, 222, 205, 219, 203, 218, 201, 215, 231, 214, 229, 212, 227, 210, 225},
3782 {208, 191, 206, 189, 203, 187, 202, 185, 199, 215, 198, 213, 196, 211, 194, 209},
3783 {127, 175, 127, 173, 127, 171, 127, 169, 127, 199, 127, 197, 127, 195, 127, 193},
3784 {127, 159, 127, 157, 127, 155, 127, 153, 127, 183, 127, 181, 127, 179, 127, 177},
3785 {127, 143, 127, 141, 127, 139, 127, 137, 127, 167, 127, 165, 127, 163, 127, 161},
3786 {127, 128, 127, 128, 127, 128, 127, 128, 127, 151, 127, 149, 127, 147, 127, 145}},
3787 {{0xef00, 0xecfe, 0xeafb, 0xe8fa, 0x06f7, 0x04f6, 0x02f4, 0x00f2},
3788 {0xdef0, 0xdcee, 0xdaeb, 0xd8ea, 0xf6e7, 0xf4e6, 0xf2e4, 0xf0e2},
3789 {0xcee0, 0xccde, 0xcadb, 0xc8da, 0xe6d7, 0xe4d6, 0xe2d4, 0xe0d2},
3790 {0xbed0, 0xbcce, 0xbacb, 0xb8ca, 0xd6c7, 0xd4c6, 0xd2c4, 0xd0c2},
3791 {0xaec0, 0xacbe, 0xaabb, 0xa8ba, 0xc6b7, 0xc4b6, 0xc2b4, 0xc0b2},
3792 {0x9eb0, 0x9cae, 0x9aab, 0x98aa, 0xb6a7, 0xb4a6, 0xb2a4, 0xb0a2},
3793 {0x8ea0, 0x8c9e, 0x8a9b, 0x889a, 0xa697, 0xa496, 0xa294, 0xa092},
3794 {0x8000, 0x8000, 0x8000, 0x8000, 0x9687, 0x9486, 0x9284, 0x9082}},
3795 {{0xecfd'ef00, 0xe8f9'eafb, 0x04f6'06f7, 0x00f2'02f4},
3796 {0xdced'def0, 0xd8e9'daeb, 0xf4e5'f6e7, 0xf0e1'f2e4},
3797 {0xccdd'cee0, 0xc8d9'cadb, 0xe4d5'e6d7, 0xe0d1'e2d4},
3798 {0xbccd'bed0, 0xb8c9'bacb, 0xd4c5'd6c7, 0xd0c1'd2c4},
3799 {0xacbe'aec0, 0xa8ba'aabb, 0xc4b6'c6b7, 0xc0b2'c2b4},
3800 {0x9cae'9eb0, 0x98aa'9aab, 0xb4a6'b6a7, 0xb0a2'b2a4},
3801 {0x8c9e'8ea0, 0x889a'8a9b, 0xa496'a697, 0xa092'a294},
3802 {0x8000'0000, 0x8000'0000, 0x9486'9687, 0x9082'9284}},
3803 {{0xe8f9'eafa'ecfd'ef00, 0x00f2'02f4'04f6'06f7},
3804 {0xd8e9'daea'dced'def0, 0xf0e1'f2e3'f4e5'f6e7},
3805 {0xc8d9'cada'ccdd'cee0, 0xe0d1'e2d3'e4d5'e6d7},
3806 {0xb8c9'baca'bccd'bed0, 0xd0c1'd2c3'd4c5'd6c7},
3807 {0xa8ba'aabb'acbe'aec0, 0xc0b2'c2b4'c4b6'c6b7},
3808 {0x98aa'9aab'9cae'9eb0, 0xb0a2'b2a4'b4a6'b6a7},
3809 {0x889a'8a9b'8c9e'8ea0, 0xa092'a294'a496'a697},
3810 {0x8000'0000'0000'0000, 0x9082'9284'9486'9687}},
3811 kVectorCalculationsSource);
3812 TestVectorInstruction(
3813 ExecVssubvx,
3814 ExecMaskedVssubvx,
3815 {{86, 215, 88, 217, 90, 219, 92, 221, 94, 223, 96, 225, 98, 227, 100, 229},
3816 {102, 231, 104, 233, 106, 235, 108, 237, 110, 239, 112, 241, 114, 243, 116, 245},
3817 {118, 247, 120, 249, 122, 251, 124, 253, 126, 255, 127, 1, 127, 3, 127, 5},
3818 {127, 7, 127, 9, 127, 11, 127, 13, 127, 15, 127, 17, 127, 19, 127, 21},
3819 {127, 23, 127, 25, 127, 27, 127, 29, 127, 31, 127, 33, 127, 35, 127, 37},
3820 {127, 39, 127, 41, 127, 43, 127, 45, 127, 47, 127, 49, 127, 51, 127, 53},
3821 {127, 55, 127, 57, 127, 59, 127, 61, 127, 63, 127, 65, 127, 67, 127, 69},
3822 {127, 71, 127, 73, 127, 75, 127, 77, 127, 79, 127, 81, 127, 83, 127, 85}},
3823 {{0xd656, 0xd858, 0xda5a, 0xdc5c, 0xde5e, 0xe060, 0xe262, 0xe464},
3824 {0xe666, 0xe868, 0xea6a, 0xec6c, 0xee6e, 0xf070, 0xf272, 0xf474},
3825 {0xf676, 0xf878, 0xfa7a, 0xfc7c, 0xfe7e, 0x0080, 0x0282, 0x0484},
3826 {0x0686, 0x0888, 0x0a8a, 0x0c8c, 0x0e8e, 0x1090, 0x1292, 0x1494},
3827 {0x1696, 0x1898, 0x1a9a, 0x1c9c, 0x1e9e, 0x20a0, 0x22a2, 0x24a4},
3828 {0x26a6, 0x28a8, 0x2aaa, 0x2cac, 0x2eae, 0x30b0, 0x32b2, 0x34b4},
3829 {0x36b6, 0x38b8, 0x3aba, 0x3cbc, 0x3ebe, 0x40c0, 0x42c2, 0x44c4},
3830 {0x46c6, 0x48c8, 0x4aca, 0x4ccc, 0x4ece, 0x50d0, 0x52d2, 0x54d4}},
3831 {{0xd857'd656, 0xdc5b'da5a, 0xe05f'de5e, 0xe463'e262},
3832 {0xe867'e666, 0xec6b'ea6a, 0xf06f'ee6e, 0xf473'f272},
3833 {0xf877'f676, 0xfc7b'fa7a, 0x007f'fe7e, 0x0484'0282},
3834 {0x0888'0686, 0x0c8c'0a8a, 0x1090'0e8e, 0x1494'1292},
3835 {0x1898'1696, 0x1c9c'1a9a, 0x20a0'1e9e, 0x24a4'22a2},
3836 {0x28a8'26a6, 0x2cac'2aaa, 0x30b0'2eae, 0x34b4'32b2},
3837 {0x38b8'36b6, 0x3cbc'3aba, 0x40c0'3ebe, 0x44c4'42c2},
3838 {0x48c8'46c6, 0x4ccc'4aca, 0x50d0'4ece, 0x54d4'52d2}},
3839 {{0xdc5b'da59'd857'd656, 0xe463'e261'e05f'de5e},
3840 {0xec6b'ea69'e867'e666, 0xf473'f271'f06f'ee6e},
3841 {0xfc7b'fa79'f877'f676, 0x0484'0282'007f'fe7e},
3842 {0x0c8c'0a8a'0888'0686, 0x1494'1292'1090'0e8e},
3843 {0x1c9c'1a9a'1898'1696, 0x24a4'22a2'20a0'1e9e},
3844 {0x2cac'2aaa'28a8'26a6, 0x34b4'32b2'30b0'2eae},
3845 {0x3cbc'3aba'38b8'36b6, 0x44c4'42c2'40c0'3ebe},
3846 {0x4ccc'4aca'48c8'46c6, 0x54d4'52d2'50d0'4ece}},
3847 kVectorCalculationsSource);
3848
3849 TestVectorFloatInstruction(ExecVfsubvv,
3850 ExecMaskedVfsubvv,
3851 {{0x1604'9200, 0x1e0c'9a09, 0x8b0a'63e7, 0x8ece'd50c},
3852 {0x3624'b220, 0x3e2c'ba29, 0x2634'a22f, 0x2e3c'aa38},
3853 {0x5644'd240, 0x5e4c'da49, 0x4654'c251, 0x4e5c'ca58},
3854 {0x7664'f260, 0x7e6c'fa69, 0x6674'e271, 0x6e7c'ea78},
3855 {0xc342'c140, 0xc746'c544, 0xcb4a'c948, 0xcf4e'cd4c},
3856 {0xd352'd150, 0xd756'd554, 0xdb5a'd958, 0xdf5e'dd5c},
3857 {0xe362'e160, 0xe766'e5ca, 0xeb6a'e968, 0xef6e'ed6c},
3858 {0xf6e6'58c3, 0xfeec'7cd7, 0xfb7a'f978, 0xff7e'fd7c}},
3859 {{0x1e0c'9a09'9604'9200, 0x8f0e'8cd3'76d9'7cdf},
3860 {0x3e2c'ba29'b624'b220, 0x2e3c'aa38'a634'a231},
3861 {0x5e4c'da49'd644'd240, 0x4e5c'ca58'c654'c251},
3862 {0x7e6c'fa69'f664'f260, 0x6e7c'ea78'e674'e271},
3863 {0xc746'c544'c342'c140, 0xcf4e'cd4c'cb4a'c948},
3864 {0xd756'd554'd352'd150, 0xdf5e'dd5c'db5a'd958},
3865 {0xe766'e564'e362'e160, 0xef6e'ed6c'eb6a'e968},
3866 {0xfeec'7ae9'76e4'72e0, 0xff7e'fd7c'fb7a'f978}},
3867 kVectorCalculationsSource);
3868 TestVectorFloatInstruction(ExecVfsubvf,
3869 ExecMaskedVfsubvf,
3870 {{0xc0b4'0000, 0xc0b4'0000, 0xc0b4'0000, 0xc0b4'0000},
3871 {0xc0b4'0000, 0xc0b4'0000, 0xc0b4'0000, 0xc0b4'0000},
3872 {0xc0b4'0000, 0xc0b4'0000, 0xc0b4'0000, 0xc0b4'0000},
3873 {0xc0b4'0000, 0xc0b4'0017, 0xc0b4'1757, 0xc0cb'd7a8},
3874 {0xc348'6140, 0xc746'cae4, 0xcb4a'c94e, 0xcf4e'cd4c},
3875 {0xd352'd150, 0xd756'd554, 0xdb5a'd958, 0xdf5e'dd5c},
3876 {0xe362'e160, 0xe766'e564, 0xeb6a'e968, 0xef6e'ed6c},
3877 {0xf372'f170, 0xf776'f574, 0xfb7a'f978, 0xff7e'fd7c}},
3878 {{0xc016'8000'0000'0000, 0xc016'8000'0000'0000},
3879 {0xc016'8000'0000'0000, 0xc016'8000'0000'0000},
3880 {0xc016'8000'0000'0000, 0xc016'8000'0000'0000},
3881 {0xc016'8000'0000'0000, 0xc016'807a'f4f2'eceb},
3882 {0xc746'c544'c342'c140, 0xcf4e'cd4c'cb4a'c948},
3883 {0xd756'd554'd352'd150, 0xdf5e'dd5c'db5a'd958},
3884 {0xe766'e564'e362'e160, 0xef6e'ed6c'eb6a'e968},
3885 {0xf776'f574'f372'f170, 0xff7e'fd7c'fb7a'f978}},
3886 kVectorCalculationsSource);
3887
3888 TestWideningVectorFloatInstruction(ExecVfwsubvv,
3889 ExecMaskedVfwsubvv,
3890 {{0x3ac0'923f'ffff'bec0, 0x3bc1'9341'1fff'ffbd},
3891 {0xb961'4c7c'ef78'0000, 0xb9d9'daa1'8000'0000},
3892 {0x3ec4'9644'0000'0000, 0x3fc5'9745'2000'0000},
3893 {0x3cc6'9445'd2b3'7400, 0x3dc7'9546'ffb0'b172},
3894 {0x42c8'9a48'0000'0000, 0x43c9'9b49'2000'0000},
3895 {0x40ca'984a'2000'0000, 0x41cb'994b'0000'0000},
3896 {0x46cc'9e4c'0000'0000, 0x47cd'9f4d'2000'0000},
3897 {0x44ce'9c4e'2000'0000, 0x45cf'9d4f'0000'0000}},
3898 kVectorCalculationsSource);
3899 TestWideningVectorFloatInstruction(ExecVfwsubvf,
3900 ExecMaskedVfwsubvf,
3901 {{0xc016'8000'0000'0000, 0xc016'8000'0000'0000},
3902 {0xc016'8000'0000'0000, 0xc016'8000'0000'0000},
3903 {0xc016'8000'0000'0000, 0xc016'8000'0000'0000},
3904 {0xc016'8000'0000'0000, 0xc016'8000'0000'0000},
3905 {0xc016'8000'0000'0000, 0xc016'8000'0000'0003},
3906 {0xc016'8000'0000'02ab, 0xc016'8000'0002'bab5},
3907 {0xc016'8000'02ca'c4c0, 0xc016'8002'dad4'd000},
3908 {0xc016'82ea'e4e0'0000, 0xc019'7af4'f000'0000}},
3909 kVectorCalculationsSource);
3910
3911 TestWideningVectorFloatInstruction(ExecVfwsubwv,
3912 ExecMaskedVfwsubwv,
3913 {{0x3ac0'9240'0000'0000, 0x3bc1'9341'2000'0000},
3914 {0x38c2'9042'2000'0000, 0x39c3'9143'0000'0000},
3915 {0x3ec4'9644'0000'0000, 0x3fc5'9745'2000'0000},
3916 {0x3cc6'9446'2000'0000, 0xbf3e'bd3c'8c10'2b38},
3917 {0xc746'c544'c342'c140, 0xcf4e'cd4c'cb4a'c948},
3918 {0xd756'd554'd352'd150, 0xdf5e'dd5c'db5a'd958},
3919 {0xe766'e564'e362'e160, 0xef6e'ed6c'eb6a'e968},
3920 {0xf776'f574'f372'f170, 0xff7e'fd7c'fb7a'f978}},
3921 kVectorCalculationsSource);
3922 TestWideningVectorFloatInstruction(ExecVfwsubwf,
3923 ExecMaskedVfwsubwf,
3924 {{0xc016'8000'0000'0000, 0xc016'8000'0000'0000},
3925 {0xc016'8000'0000'0000, 0xc016'8000'0000'0000},
3926 {0xc016'8000'0000'0000, 0xc016'8000'0000'0000},
3927 {0xc016'8000'0000'0000, 0xc016'807a'f4f2'eceb},
3928 {0xc746'c544'c342'c140, 0xcf4e'cd4c'cb4a'c948},
3929 {0xd756'd554'd352'd150, 0xdf5e'dd5c'db5a'd958},
3930 {0xe766'e564'e362'e160, 0xef6e'ed6c'eb6a'e968},
3931 {0xf776'f574'f372'f170, 0xff7e'fd7c'fb7a'f978}},
3932 kVectorCalculationsSource);
3933 }
3934
ExecVandvv()3935 [[gnu::naked]] void ExecVandvv() {
3936 asm("vand.vv v8, v16, v24\n\t"
3937 "ret\n\t");
3938 }
3939
ExecMaskedVandvv()3940 [[gnu::naked]] void ExecMaskedVandvv() {
3941 asm("vand.vv v8, v16, v24, v0.t\n\t"
3942 "ret\n\t");
3943 }
3944
ExecVandvx()3945 [[gnu::naked]] void ExecVandvx() {
3946 asm("vand.vx v8, v16, t0\n\t"
3947 "ret\n\t");
3948 }
3949
ExecMaskedVandvx()3950 [[gnu::naked]] void ExecMaskedVandvx() {
3951 asm("vand.vx v8, v16, t0, v0.t\n\t"
3952 "ret\n\t");
3953 }
3954
ExecVandvi()3955 [[gnu::naked]] void ExecVandvi() {
3956 asm("vand.vi v8, v16, -0xb\n\t"
3957 "ret\n\t");
3958 }
3959
ExecMaskedVandvi()3960 [[gnu::naked]] void ExecMaskedVandvi() {
3961 asm("vand.vi v8, v16, -0xb, v0.t\n\t"
3962 "ret\n\t");
3963 }
3964
TEST(InlineAsmTestRiscv64,TestVand)3965 TEST(InlineAsmTestRiscv64, TestVand) {
3966 TestVectorInstruction(
3967 ExecVandvv,
3968 ExecMaskedVandvv,
3969 {{0, 0, 0, 2, 0, 0, 4, 6, 0, 0, 0, 2, 8, 8, 12, 14},
3970 {0, 0, 0, 2, 0, 0, 4, 6, 16, 16, 16, 18, 24, 24, 28, 30},
3971 {0, 0, 0, 2, 0, 0, 4, 6, 0, 0, 0, 2, 8, 8, 12, 14},
3972 {32, 32, 32, 34, 32, 32, 36, 38, 48, 48, 48, 50, 56, 56, 60, 62},
3973 {0, 128, 0, 130, 0, 128, 4, 134, 0, 128, 0, 130, 8, 136, 12, 142},
3974 {0, 128, 0, 130, 0, 128, 4, 134, 16, 144, 16, 146, 24, 152, 28, 158},
3975 {64, 192, 64, 194, 64, 192, 68, 198, 64, 192, 64, 194, 72, 200, 76, 206},
3976 {96, 224, 96, 226, 96, 224, 100, 230, 112, 240, 112, 242, 120, 248, 124, 254}},
3977 {{0x0000, 0x0200, 0x0000, 0x0604, 0x0000, 0x0200, 0x0808, 0x0e0c},
3978 {0x0000, 0x0200, 0x0000, 0x0604, 0x1010, 0x1210, 0x1818, 0x1e1c},
3979 {0x0000, 0x0200, 0x0000, 0x0604, 0x0000, 0x0200, 0x0808, 0x0e0c},
3980 {0x2020, 0x2220, 0x2020, 0x2624, 0x3030, 0x3230, 0x3838, 0x3e3c},
3981 {0x8000, 0x8200, 0x8000, 0x8604, 0x8000, 0x8200, 0x8808, 0x8e0c},
3982 {0x8000, 0x8200, 0x8000, 0x8604, 0x9010, 0x9210, 0x9818, 0x9e1c},
3983 {0xc040, 0xc240, 0xc040, 0xc644, 0xc040, 0xc240, 0xc848, 0xce4c},
3984 {0xe060, 0xe260, 0xe060, 0xe664, 0xf070, 0xf270, 0xf878, 0xfe7c}},
3985 {{0x0200'0000, 0x0604'0000, 0x0200'0000, 0x0e0c'0808},
3986 {0x0200'0000, 0x0604'0000, 0x1210'1010, 0x1e1c'1818},
3987 {0x0200'0000, 0x0604'0000, 0x0200'0000, 0x0e0c'0808},
3988 {0x2220'2020, 0x2624'2020, 0x3230'3030, 0x3e3c'3838},
3989 {0x8200'8000, 0x8604'8000, 0x8200'8000, 0x8e0c'8808},
3990 {0x8200'8000, 0x8604'8000, 0x9210'9010, 0x9e1c'9818},
3991 {0xc240'c040, 0xc644'c040, 0xc240'c040, 0xce4c'c848},
3992 {0xe260'e060, 0xe664'e060, 0xf270'f070, 0xfe7c'f878}},
3993 {{0x0604'0000'0200'0000, 0x0e0c'0808'0200'0000},
3994 {0x0604'0000'0200'0000, 0x1e1c'1818'1210'1010},
3995 {0x0604'0000'0200'0000, 0x0e0c'0808'0200'0000},
3996 {0x2624'2020'2220'2020, 0x3e3c'3838'3230'3030},
3997 {0x8604'8000'8200'8000, 0x8e0c'8808'8200'8000},
3998 {0x8604'8000'8200'8000, 0x9e1c'9818'9210'9010},
3999 {0xc644'c040'c240'c040, 0xce4c'c848'c240'c040},
4000 {0xe664'e060'e260'e060, 0xfe7c'f878'f270'f070}},
4001 kVectorCalculationsSourceLegacy);
4002 TestVectorInstruction(ExecVandvx,
4003 ExecMaskedVandvx,
4004 {{0, 128, 2, 130, 0, 128, 2, 130, 8, 136, 10, 138, 8, 136, 10, 138},
4005 {0, 128, 2, 130, 0, 128, 2, 130, 8, 136, 10, 138, 8, 136, 10, 138},
4006 {32, 160, 34, 162, 32, 160, 34, 162, 40, 168, 42, 170, 40, 168, 42, 170},
4007 {32, 160, 34, 162, 32, 160, 34, 162, 40, 168, 42, 170, 40, 168, 42, 170},
4008 {0, 128, 2, 130, 0, 128, 2, 130, 8, 136, 10, 138, 8, 136, 10, 138},
4009 {0, 128, 2, 130, 0, 128, 2, 130, 8, 136, 10, 138, 8, 136, 10, 138},
4010 {32, 160, 34, 162, 32, 160, 34, 162, 40, 168, 42, 170, 40, 168, 42, 170},
4011 {32, 160, 34, 162, 32, 160, 34, 162, 40, 168, 42, 170, 40, 168, 42, 170}},
4012 {{0x8000, 0x8202, 0x8000, 0x8202, 0x8808, 0x8a0a, 0x8808, 0x8a0a},
4013 {0x8000, 0x8202, 0x8000, 0x8202, 0x8808, 0x8a0a, 0x8808, 0x8a0a},
4014 {0xa020, 0xa222, 0xa020, 0xa222, 0xa828, 0xaa2a, 0xa828, 0xaa2a},
4015 {0xa020, 0xa222, 0xa020, 0xa222, 0xa828, 0xaa2a, 0xa828, 0xaa2a},
4016 {0x8000, 0x8202, 0x8000, 0x8202, 0x8808, 0x8a0a, 0x8808, 0x8a0a},
4017 {0x8000, 0x8202, 0x8000, 0x8202, 0x8808, 0x8a0a, 0x8808, 0x8a0a},
4018 {0xa020, 0xa222, 0xa020, 0xa222, 0xa828, 0xaa2a, 0xa828, 0xaa2a},
4019 {0xa020, 0xa222, 0xa020, 0xa222, 0xa828, 0xaa2a, 0xa828, 0xaa2a}},
4020 {{0x8202'8000, 0x8202'8000, 0x8a0a'8808, 0x8a0a'8808},
4021 {0x8202'8000, 0x8202'8000, 0x8a0a'8808, 0x8a0a'8808},
4022 {0xa222'a020, 0xa222'a020, 0xaa2a'a828, 0xaa2a'a828},
4023 {0xa222'a020, 0xa222'a020, 0xaa2a'a828, 0xaa2a'a828},
4024 {0x8202'8000, 0x8202'8000, 0x8a0a'8808, 0x8a0a'8808},
4025 {0x8202'8000, 0x8202'8000, 0x8a0a'8808, 0x8a0a'8808},
4026 {0xa222'a020, 0xa222'a020, 0xaa2a'a828, 0xaa2a'a828},
4027 {0xa222'a020, 0xa222'a020, 0xaa2a'a828, 0xaa2a'a828}},
4028 {{0x8202'8000'8202'8000, 0x8a0a'8808'8a0a'8808},
4029 {0x8202'8000'8202'8000, 0x8a0a'8808'8a0a'8808},
4030 {0xa222'a020'a222'a020, 0xaa2a'a828'aa2a'a828},
4031 {0xa222'a020'a222'a020, 0xaa2a'a828'aa2a'a828},
4032 {0x8202'8000'8202'8000, 0x8a0a'8808'8a0a'8808},
4033 {0x8202'8000'8202'8000, 0x8a0a'8808'8a0a'8808},
4034 {0xa222'a020'a222'a020, 0xaa2a'a828'aa2a'a828},
4035 {0xa222'a020'a222'a020, 0xaa2a'a828'aa2a'a828}},
4036 kVectorCalculationsSourceLegacy);
4037 TestVectorInstruction(
4038 ExecVandvi,
4039 ExecMaskedVandvi,
4040 {{0, 129, 0, 129, 4, 133, 4, 133, 0, 129, 0, 129, 4, 133, 4, 133},
4041 {16, 145, 16, 145, 20, 149, 20, 149, 16, 145, 16, 145, 20, 149, 20, 149},
4042 {32, 161, 32, 161, 36, 165, 36, 165, 32, 161, 32, 161, 36, 165, 36, 165},
4043 {48, 177, 48, 177, 52, 181, 52, 181, 48, 177, 48, 177, 52, 181, 52, 181},
4044 {64, 193, 64, 193, 68, 197, 68, 197, 64, 193, 64, 193, 68, 197, 68, 197},
4045 {80, 209, 80, 209, 84, 213, 84, 213, 80, 209, 80, 209, 84, 213, 84, 213},
4046 {96, 225, 96, 225, 100, 229, 100, 229, 96, 225, 96, 225, 100, 229, 100, 229},
4047 {112, 241, 112, 241, 116, 245, 116, 245, 112, 241, 112, 241, 116, 245, 116, 245}},
4048 {{0x8100, 0x8300, 0x8504, 0x8704, 0x8900, 0x8b00, 0x8d04, 0x8f04},
4049 {0x9110, 0x9310, 0x9514, 0x9714, 0x9910, 0x9b10, 0x9d14, 0x9f14},
4050 {0xa120, 0xa320, 0xa524, 0xa724, 0xa920, 0xab20, 0xad24, 0xaf24},
4051 {0xb130, 0xb330, 0xb534, 0xb734, 0xb930, 0xbb30, 0xbd34, 0xbf34},
4052 {0xc140, 0xc340, 0xc544, 0xc744, 0xc940, 0xcb40, 0xcd44, 0xcf44},
4053 {0xd150, 0xd350, 0xd554, 0xd754, 0xd950, 0xdb50, 0xdd54, 0xdf54},
4054 {0xe160, 0xe360, 0xe564, 0xe764, 0xe960, 0xeb60, 0xed64, 0xef64},
4055 {0xf170, 0xf370, 0xf574, 0xf774, 0xf970, 0xfb70, 0xfd74, 0xff74}},
4056 {{0x8302'8100, 0x8706'8504, 0x8b0a'8900, 0x8f0e'8d04},
4057 {0x9312'9110, 0x9716'9514, 0x9b1a'9910, 0x9f1e'9d14},
4058 {0xa322'a120, 0xa726'a524, 0xab2a'a920, 0xaf2e'ad24},
4059 {0xb332'b130, 0xb736'b534, 0xbb3a'b930, 0xbf3e'bd34},
4060 {0xc342'c140, 0xc746'c544, 0xcb4a'c940, 0xcf4e'cd44},
4061 {0xd352'd150, 0xd756'd554, 0xdb5a'd950, 0xdf5e'dd54},
4062 {0xe362'e160, 0xe766'e564, 0xeb6a'e960, 0xef6e'ed64},
4063 {0xf372'f170, 0xf776'f574, 0xfb7a'f970, 0xff7e'fd74}},
4064 {{0x8706'8504'8302'8100, 0x8f0e'8d0c'8b0a'8900},
4065 {0x9716'9514'9312'9110, 0x9f1e'9d1c'9b1a'9910},
4066 {0xa726'a524'a322'a120, 0xaf2e'ad2c'ab2a'a920},
4067 {0xb736'b534'b332'b130, 0xbf3e'bd3c'bb3a'b930},
4068 {0xc746'c544'c342'c140, 0xcf4e'cd4c'cb4a'c940},
4069 {0xd756'd554'd352'd150, 0xdf5e'dd5c'db5a'd950},
4070 {0xe766'e564'e362'e160, 0xef6e'ed6c'eb6a'e960},
4071 {0xf776'f574'f372'f170, 0xff7e'fd7c'fb7a'f970}},
4072 kVectorCalculationsSourceLegacy);
4073 }
4074
ExecVorvv()4075 [[gnu::naked]] void ExecVorvv() {
4076 asm("vor.vv v8, v16, v24\n\t"
4077 "ret\n\t");
4078 }
4079
ExecMaskedVorvv()4080 [[gnu::naked]] void ExecMaskedVorvv() {
4081 asm("vor.vv v8, v16, v24, v0.t\n\t"
4082 "ret\n\t");
4083 }
ExecVorvx()4084 [[gnu::naked]] void ExecVorvx() {
4085 asm("vor.vx v8, v16, t0\n\t"
4086 "ret\n\t");
4087 }
4088
ExecMaskedVorvx()4089 [[gnu::naked]] void ExecMaskedVorvx() {
4090 asm("vor.vx v8, v16, t0, v0.t\n\t"
4091 "ret\n\t");
4092 }
ExecVorvi()4093 [[gnu::naked]] void ExecVorvi() {
4094 asm("vor.vi v8, v16, -0xb\n\t"
4095 "ret\n\t");
4096 }
4097
ExecMaskedVorvi()4098 [[gnu::naked]] void ExecMaskedVorvi() {
4099 asm("vor.vi v8, v16, -0xb, v0.t\n\t"
4100 "ret\n\t");
4101 }
4102
TEST(InlineAsmTestRiscv64,TestVor)4103 TEST(InlineAsmTestRiscv64, TestVor) {
4104 TestVectorInstruction(
4105 ExecVorvv,
4106 ExecMaskedVorvv,
4107 {{0, 131, 6, 135, 13, 143, 14, 143, 25, 155, 30, 159, 28, 159, 30, 159},
4108 {48, 179, 54, 183, 61, 191, 62, 191, 57, 187, 62, 191, 60, 191, 62, 191},
4109 {96, 227, 102, 231, 109, 239, 110, 239, 121, 251, 126, 255, 124, 255, 126, 255},
4110 {112, 243, 118, 247, 125, 255, 126, 255, 121, 251, 126, 255, 124, 255, 126, 255},
4111 {192, 195, 198, 199, 205, 207, 206, 207, 217, 219, 222, 223, 220, 223, 222, 223},
4112 {240, 243, 246, 247, 253, 255, 254, 255, 249, 251, 254, 255, 252, 255, 254, 255},
4113 {224, 227, 230, 231, 237, 239, 238, 239, 249, 251, 254, 255, 252, 255, 254, 255},
4114 {240, 243, 246, 247, 253, 255, 254, 255, 249, 251, 254, 255, 252, 255, 254, 255}},
4115 {{0x8300, 0x8706, 0x8f0d, 0x8f0e, 0x9b19, 0x9f1e, 0x9f1c, 0x9f1e},
4116 {0xb330, 0xb736, 0xbf3d, 0xbf3e, 0xbb39, 0xbf3e, 0xbf3c, 0xbf3e},
4117 {0xe360, 0xe766, 0xef6d, 0xef6e, 0xfb79, 0xff7e, 0xff7c, 0xff7e},
4118 {0xf370, 0xf776, 0xff7d, 0xff7e, 0xfb79, 0xff7e, 0xff7c, 0xff7e},
4119 {0xc3c0, 0xc7c6, 0xcfcd, 0xcfce, 0xdbd9, 0xdfde, 0xdfdc, 0xdfde},
4120 {0xf3f0, 0xf7f6, 0xfffd, 0xfffe, 0xfbf9, 0xfffe, 0xfffc, 0xfffe},
4121 {0xe3e0, 0xe7e6, 0xefed, 0xefee, 0xfbf9, 0xfffe, 0xfffc, 0xfffe},
4122 {0xf3f0, 0xf7f6, 0xfffd, 0xfffe, 0xfbf9, 0xfffe, 0xfffc, 0xfffe}},
4123 {{0x8706'8300, 0x8f0e'8f0d, 0x9f1e'9b19, 0x9f1e'9f1c},
4124 {0xb736'b330, 0xbf3e'bf3d, 0xbf3e'bb39, 0xbf3e'bf3c},
4125 {0xe766'e360, 0xef6e'ef6d, 0xff7e'fb79, 0xff7e'ff7c},
4126 {0xf776'f370, 0xff7e'ff7d, 0xff7e'fb79, 0xff7e'ff7c},
4127 {0xc7c6'c3c0, 0xcfce'cfcd, 0xdfde'dbd9, 0xdfde'dfdc},
4128 {0xf7f6'f3f0, 0xfffe'fffd, 0xfffe'fbf9, 0xfffe'fffc},
4129 {0xe7e6'e3e0, 0xefee'efed, 0xfffe'fbf9, 0xfffe'fffc},
4130 {0xf7f6'f3f0, 0xfffe'fffd, 0xfffe'fbf9, 0xfffe'fffc}},
4131 {{0x8f0e'8f0d'8706'8300, 0x9f1e'9f1c'9f1e'9b19},
4132 {0xbf3e'bf3d'b736'b330, 0xbf3e'bf3c'bf3e'bb39},
4133 {0xef6e'ef6d'e766'e360, 0xff7e'ff7c'ff7e'fb79},
4134 {0xff7e'ff7d'f776'f370, 0xff7e'ff7c'ff7e'fb79},
4135 {0xcfce'cfcd'c7c6'c3c0, 0xdfde'dfdc'dfde'dbd9},
4136 {0xfffe'fffd'f7f6'f3f0, 0xfffe'fffc'fffe'fbf9},
4137 {0xefee'efed'e7e6'e3e0, 0xfffe'fffc'fffe'fbf9},
4138 {0xfffe'fffd'f7f6'f3f0, 0xfffe'fffc'fffe'fbf9}},
4139 kVectorCalculationsSourceLegacy);
4140 TestVectorInstruction(
4141 ExecVorvx,
4142 ExecMaskedVorvx,
4143 {{170, 171, 170, 171, 174, 175, 174, 175, 170, 171, 170, 171, 174, 175, 174, 175},
4144 {186, 187, 186, 187, 190, 191, 190, 191, 186, 187, 186, 187, 190, 191, 190, 191},
4145 {170, 171, 170, 171, 174, 175, 174, 175, 170, 171, 170, 171, 174, 175, 174, 175},
4146 {186, 187, 186, 187, 190, 191, 190, 191, 186, 187, 186, 187, 190, 191, 190, 191},
4147 {234, 235, 234, 235, 238, 239, 238, 239, 234, 235, 234, 235, 238, 239, 238, 239},
4148 {250, 251, 250, 251, 254, 255, 254, 255, 250, 251, 250, 251, 254, 255, 254, 255},
4149 {234, 235, 234, 235, 238, 239, 238, 239, 234, 235, 234, 235, 238, 239, 238, 239},
4150 {250, 251, 250, 251, 254, 255, 254, 255, 250, 251, 250, 251, 254, 255, 254, 255}},
4151 {{0xabaa, 0xabaa, 0xafae, 0xafae, 0xabaa, 0xabaa, 0xafae, 0xafae},
4152 {0xbbba, 0xbbba, 0xbfbe, 0xbfbe, 0xbbba, 0xbbba, 0xbfbe, 0xbfbe},
4153 {0xabaa, 0xabaa, 0xafae, 0xafae, 0xabaa, 0xabaa, 0xafae, 0xafae},
4154 {0xbbba, 0xbbba, 0xbfbe, 0xbfbe, 0xbbba, 0xbbba, 0xbfbe, 0xbfbe},
4155 {0xebea, 0xebea, 0xefee, 0xefee, 0xebea, 0xebea, 0xefee, 0xefee},
4156 {0xfbfa, 0xfbfa, 0xfffe, 0xfffe, 0xfbfa, 0xfbfa, 0xfffe, 0xfffe},
4157 {0xebea, 0xebea, 0xefee, 0xefee, 0xebea, 0xebea, 0xefee, 0xefee},
4158 {0xfbfa, 0xfbfa, 0xfffe, 0xfffe, 0xfbfa, 0xfbfa, 0xfffe, 0xfffe}},
4159 {{0xabaa'abaa, 0xafae'afae, 0xabaa'abaa, 0xafae'afae},
4160 {0xbbba'bbba, 0xbfbe'bfbe, 0xbbba'bbba, 0xbfbe'bfbe},
4161 {0xabaa'abaa, 0xafae'afae, 0xabaa'abaa, 0xafae'afae},
4162 {0xbbba'bbba, 0xbfbe'bfbe, 0xbbba'bbba, 0xbfbe'bfbe},
4163 {0xebea'ebea, 0xefee'efee, 0xebea'ebea, 0xefee'efee},
4164 {0xfbfa'fbfa, 0xfffe'fffe, 0xfbfa'fbfa, 0xfffe'fffe},
4165 {0xebea'ebea, 0xefee'efee, 0xebea'ebea, 0xefee'efee},
4166 {0xfbfa'fbfa, 0xfffe'fffe, 0xfbfa'fbfa, 0xfffe'fffe}},
4167 {{0xafae'afae'abaa'abaa, 0xafae'afae'abaa'abaa},
4168 {0xbfbe'bfbe'bbba'bbba, 0xbfbe'bfbe'bbba'bbba},
4169 {0xafae'afae'abaa'abaa, 0xafae'afae'abaa'abaa},
4170 {0xbfbe'bfbe'bbba'bbba, 0xbfbe'bfbe'bbba'bbba},
4171 {0xefee'efee'ebea'ebea, 0xefee'efee'ebea'ebea},
4172 {0xfffe'fffe'fbfa'fbfa, 0xfffe'fffe'fbfa'fbfa},
4173 {0xefee'efee'ebea'ebea, 0xefee'efee'ebea'ebea},
4174 {0xfffe'fffe'fbfa'fbfa, 0xfffe'fffe'fbfa'fbfa}},
4175 kVectorCalculationsSourceLegacy);
4176 TestVectorInstruction(
4177 ExecVorvi,
4178 ExecMaskedVorvi,
4179 {{245, 245, 247, 247, 245, 245, 247, 247, 253, 253, 255, 255, 253, 253, 255, 255},
4180 {245, 245, 247, 247, 245, 245, 247, 247, 253, 253, 255, 255, 253, 253, 255, 255},
4181 {245, 245, 247, 247, 245, 245, 247, 247, 253, 253, 255, 255, 253, 253, 255, 255},
4182 {245, 245, 247, 247, 245, 245, 247, 247, 253, 253, 255, 255, 253, 253, 255, 255},
4183 {245, 245, 247, 247, 245, 245, 247, 247, 253, 253, 255, 255, 253, 253, 255, 255},
4184 {245, 245, 247, 247, 245, 245, 247, 247, 253, 253, 255, 255, 253, 253, 255, 255},
4185 {245, 245, 247, 247, 245, 245, 247, 247, 253, 253, 255, 255, 253, 253, 255, 255},
4186 {245, 245, 247, 247, 245, 245, 247, 247, 253, 253, 255, 255, 253, 253, 255, 255}},
4187 {{0xfff5, 0xfff7, 0xfff5, 0xfff7, 0xfffd, 0xffff, 0xfffd, 0xffff},
4188 {0xfff5, 0xfff7, 0xfff5, 0xfff7, 0xfffd, 0xffff, 0xfffd, 0xffff},
4189 {0xfff5, 0xfff7, 0xfff5, 0xfff7, 0xfffd, 0xffff, 0xfffd, 0xffff},
4190 {0xfff5, 0xfff7, 0xfff5, 0xfff7, 0xfffd, 0xffff, 0xfffd, 0xffff},
4191 {0xfff5, 0xfff7, 0xfff5, 0xfff7, 0xfffd, 0xffff, 0xfffd, 0xffff},
4192 {0xfff5, 0xfff7, 0xfff5, 0xfff7, 0xfffd, 0xffff, 0xfffd, 0xffff},
4193 {0xfff5, 0xfff7, 0xfff5, 0xfff7, 0xfffd, 0xffff, 0xfffd, 0xffff},
4194 {0xfff5, 0xfff7, 0xfff5, 0xfff7, 0xfffd, 0xffff, 0xfffd, 0xffff}},
4195 {{0xffff'fff5, 0xffff'fff5, 0xffff'fffd, 0xffff'fffd},
4196 {0xffff'fff5, 0xffff'fff5, 0xffff'fffd, 0xffff'fffd},
4197 {0xffff'fff5, 0xffff'fff5, 0xffff'fffd, 0xffff'fffd},
4198 {0xffff'fff5, 0xffff'fff5, 0xffff'fffd, 0xffff'fffd},
4199 {0xffff'fff5, 0xffff'fff5, 0xffff'fffd, 0xffff'fffd},
4200 {0xffff'fff5, 0xffff'fff5, 0xffff'fffd, 0xffff'fffd},
4201 {0xffff'fff5, 0xffff'fff5, 0xffff'fffd, 0xffff'fffd},
4202 {0xffff'fff5, 0xffff'fff5, 0xffff'fffd, 0xffff'fffd}},
4203 {{0xffff'ffff'ffff'fff5, 0xffff'ffff'ffff'fffd},
4204 {0xffff'ffff'ffff'fff5, 0xffff'ffff'ffff'fffd},
4205 {0xffff'ffff'ffff'fff5, 0xffff'ffff'ffff'fffd},
4206 {0xffff'ffff'ffff'fff5, 0xffff'ffff'ffff'fffd},
4207 {0xffff'ffff'ffff'fff5, 0xffff'ffff'ffff'fffd},
4208 {0xffff'ffff'ffff'fff5, 0xffff'ffff'ffff'fffd},
4209 {0xffff'ffff'ffff'fff5, 0xffff'ffff'ffff'fffd},
4210 {0xffff'ffff'ffff'fff5, 0xffff'ffff'ffff'fffd}},
4211 kVectorCalculationsSourceLegacy);
4212 }
4213
ExecVxorvv()4214 [[gnu::naked]] void ExecVxorvv() {
4215 asm("vxor.vv v8, v16, v24\n\t"
4216 "ret\n\t");
4217 }
4218
ExecMaskedVxorvv()4219 [[gnu::naked]] void ExecMaskedVxorvv() {
4220 asm("vxor.vv v8, v16, v24, v0.t\n\t"
4221 "ret\n\t");
4222 }
ExecVxorvx()4223 [[gnu::naked]] void ExecVxorvx() {
4224 asm("vxor.vx v8, v16, t0\n\t"
4225 "ret\n\t");
4226 }
4227
ExecMaskedVxorvx()4228 [[gnu::naked]] void ExecMaskedVxorvx() {
4229 asm("vxor.vx v8, v16, t0, v0.t\n\t"
4230 "ret\n\t");
4231 }
ExecVxorvi()4232 [[gnu::naked]] void ExecVxorvi() {
4233 asm("vxor.vi v8, v16, -0xb\n\t"
4234 "ret\n\t");
4235 }
4236
ExecMaskedVxorvi()4237 [[gnu::naked]] void ExecMaskedVxorvi() {
4238 asm("vxor.vi v8, v16, -0xb, v0.t\n\t"
4239 "ret\n\t");
4240 }
4241
TEST(InlineAsmTestRiscv64,TestVxor)4242 TEST(InlineAsmTestRiscv64, TestVxor) {
4243 TestVectorInstruction(
4244 ExecVxorvv,
4245 ExecMaskedVxorvv,
4246 {{0, 131, 6, 133, 13, 143, 10, 137, 25, 155, 30, 157, 20, 151, 18, 145},
4247 {48, 179, 54, 181, 61, 191, 58, 185, 41, 171, 46, 173, 36, 167, 34, 161},
4248 {96, 227, 102, 229, 109, 239, 106, 233, 121, 251, 126, 253, 116, 247, 114, 241},
4249 {80, 211, 86, 213, 93, 223, 90, 217, 73, 203, 78, 205, 68, 199, 66, 193},
4250 {192, 67, 198, 69, 205, 79, 202, 73, 217, 91, 222, 93, 212, 87, 210, 81},
4251 {240, 115, 246, 117, 253, 127, 250, 121, 233, 107, 238, 109, 228, 103, 226, 97},
4252 {160, 35, 166, 37, 173, 47, 170, 41, 185, 59, 190, 61, 180, 55, 178, 49},
4253 {144, 19, 150, 21, 157, 31, 154, 25, 137, 11, 142, 13, 132, 7, 130, 1}},
4254 {{0x8300, 0x8506, 0x8f0d, 0x890a, 0x9b19, 0x9d1e, 0x9714, 0x9112},
4255 {0xb330, 0xb536, 0xbf3d, 0xb93a, 0xab29, 0xad2e, 0xa724, 0xa122},
4256 {0xe360, 0xe566, 0xef6d, 0xe96a, 0xfb79, 0xfd7e, 0xf774, 0xf172},
4257 {0xd350, 0xd556, 0xdf5d, 0xd95a, 0xcb49, 0xcd4e, 0xc744, 0xc142},
4258 {0x43c0, 0x45c6, 0x4fcd, 0x49ca, 0x5bd9, 0x5dde, 0x57d4, 0x51d2},
4259 {0x73f0, 0x75f6, 0x7ffd, 0x79fa, 0x6be9, 0x6dee, 0x67e4, 0x61e2},
4260 {0x23a0, 0x25a6, 0x2fad, 0x29aa, 0x3bb9, 0x3dbe, 0x37b4, 0x31b2},
4261 {0x1390, 0x1596, 0x1f9d, 0x199a, 0x0b89, 0x0d8e, 0x0784, 0x0182}},
4262 {{0x8506'8300, 0x890a'8f0d, 0x9d1e'9b19, 0x9112'9714},
4263 {0xb536'b330, 0xb93a'bf3d, 0xad2e'ab29, 0xa122'a724},
4264 {0xe566'e360, 0xe96a'ef6d, 0xfd7e'fb79, 0xf172'f774},
4265 {0xd556'd350, 0xd95a'df5d, 0xcd4e'cb49, 0xc142'c744},
4266 {0x45c6'43c0, 0x49ca'4fcd, 0x5dde'5bd9, 0x51d2'57d4},
4267 {0x75f6'73f0, 0x79fa'7ffd, 0x6dee'6be9, 0x61e2'67e4},
4268 {0x25a6'23a0, 0x29aa'2fad, 0x3dbe'3bb9, 0x31b2'37b4},
4269 {0x1596'1390, 0x199a'1f9d, 0x0d8e'0b89, 0x0182'0784}},
4270 {{0x890a'8f0d'8506'8300, 0x9112'9714'9d1e'9b19},
4271 {0xb93a'bf3d'b536'b330, 0xa122'a724'ad2e'ab29},
4272 {0xe96a'ef6d'e566'e360, 0xf172'f774'fd7e'fb79},
4273 {0xd95a'df5d'd556'd350, 0xc142'c744'cd4e'cb49},
4274 {0x49ca'4fcd'45c6'43c0, 0x51d2'57d4'5dde'5bd9},
4275 {0x79fa'7ffd'75f6'73f0, 0x61e2'67e4'6dee'6be9},
4276 {0x29aa'2fad'25a6'23a0, 0x31b2'37b4'3dbe'3bb9},
4277 {0x199a'1f9d'1596'1390, 0x0182'0784'0d8e'0b89}},
4278 kVectorCalculationsSourceLegacy);
4279 TestVectorInstruction(
4280 ExecVxorvx,
4281 ExecMaskedVxorvx,
4282 {{170, 43, 168, 41, 174, 47, 172, 45, 162, 35, 160, 33, 166, 39, 164, 37},
4283 {186, 59, 184, 57, 190, 63, 188, 61, 178, 51, 176, 49, 182, 55, 180, 53},
4284 {138, 11, 136, 9, 142, 15, 140, 13, 130, 3, 128, 1, 134, 7, 132, 5},
4285 {154, 27, 152, 25, 158, 31, 156, 29, 146, 19, 144, 17, 150, 23, 148, 21},
4286 {234, 107, 232, 105, 238, 111, 236, 109, 226, 99, 224, 97, 230, 103, 228, 101},
4287 {250, 123, 248, 121, 254, 127, 252, 125, 242, 115, 240, 113, 246, 119, 244, 117},
4288 {202, 75, 200, 73, 206, 79, 204, 77, 194, 67, 192, 65, 198, 71, 196, 69},
4289 {218, 91, 216, 89, 222, 95, 220, 93, 210, 83, 208, 81, 214, 87, 212, 85}},
4290 {{0x2baa, 0x29a8, 0x2fae, 0x2dac, 0x23a2, 0x21a0, 0x27a6, 0x25a4},
4291 {0x3bba, 0x39b8, 0x3fbe, 0x3dbc, 0x33b2, 0x31b0, 0x37b6, 0x35b4},
4292 {0x0b8a, 0x0988, 0x0f8e, 0x0d8c, 0x0382, 0x0180, 0x0786, 0x0584},
4293 {0x1b9a, 0x1998, 0x1f9e, 0x1d9c, 0x1392, 0x1190, 0x1796, 0x1594},
4294 {0x6bea, 0x69e8, 0x6fee, 0x6dec, 0x63e2, 0x61e0, 0x67e6, 0x65e4},
4295 {0x7bfa, 0x79f8, 0x7ffe, 0x7dfc, 0x73f2, 0x71f0, 0x77f6, 0x75f4},
4296 {0x4bca, 0x49c8, 0x4fce, 0x4dcc, 0x43c2, 0x41c0, 0x47c6, 0x45c4},
4297 {0x5bda, 0x59d8, 0x5fde, 0x5ddc, 0x53d2, 0x51d0, 0x57d6, 0x55d4}},
4298 {{0x29a8'2baa, 0x2dac'2fae, 0x21a0'23a2, 0x25a4'27a6},
4299 {0x39b8'3bba, 0x3dbc'3fbe, 0x31b0'33b2, 0x35b4'37b6},
4300 {0x0988'0b8a, 0x0d8c'0f8e, 0x0180'0382, 0x0584'0786},
4301 {0x1998'1b9a, 0x1d9c'1f9e, 0x1190'1392, 0x1594'1796},
4302 {0x69e8'6bea, 0x6dec'6fee, 0x61e0'63e2, 0x65e4'67e6},
4303 {0x79f8'7bfa, 0x7dfc'7ffe, 0x71f0'73f2, 0x75f4'77f6},
4304 {0x49c8'4bca, 0x4dcc'4fce, 0x41c0'43c2, 0x45c4'47c6},
4305 {0x59d8'5bda, 0x5ddc'5fde, 0x51d0'53d2, 0x55d4'57d6}},
4306 {{0x2dac'2fae'29a8'2baa, 0x25a4'27a6'21a0'23a2},
4307 {0x3dbc'3fbe'39b8'3bba, 0x35b4'37b6'31b0'33b2},
4308 {0x0d8c'0f8e'0988'0b8a, 0x0584'0786'0180'0382},
4309 {0x1d9c'1f9e'1998'1b9a, 0x1594'1796'1190'1392},
4310 {0x6dec'6fee'69e8'6bea, 0x65e4'67e6'61e0'63e2},
4311 {0x7dfc'7ffe'79f8'7bfa, 0x75f4'77f6'71f0'73f2},
4312 {0x4dcc'4fce'49c8'4bca, 0x45c4'47c6'41c0'43c2},
4313 {0x5ddc'5fde'59d8'5bda, 0x55d4'57d6'51d0'53d2}},
4314 kVectorCalculationsSourceLegacy);
4315 TestVectorInstruction(
4316 ExecVxorvi,
4317 ExecMaskedVxorvi,
4318 {{245, 116, 247, 118, 241, 112, 243, 114, 253, 124, 255, 126, 249, 120, 251, 122},
4319 {229, 100, 231, 102, 225, 96, 227, 98, 237, 108, 239, 110, 233, 104, 235, 106},
4320 {213, 84, 215, 86, 209, 80, 211, 82, 221, 92, 223, 94, 217, 88, 219, 90},
4321 {197, 68, 199, 70, 193, 64, 195, 66, 205, 76, 207, 78, 201, 72, 203, 74},
4322 {181, 52, 183, 54, 177, 48, 179, 50, 189, 60, 191, 62, 185, 56, 187, 58},
4323 {165, 36, 167, 38, 161, 32, 163, 34, 173, 44, 175, 46, 169, 40, 171, 42},
4324 {149, 20, 151, 22, 145, 16, 147, 18, 157, 28, 159, 30, 153, 24, 155, 26},
4325 {133, 4, 135, 6, 129, 0, 131, 2, 141, 12, 143, 14, 137, 8, 139, 10}},
4326 {{0x7ef5, 0x7cf7, 0x7af1, 0x78f3, 0x76fd, 0x74ff, 0x72f9, 0x70fb},
4327 {0x6ee5, 0x6ce7, 0x6ae1, 0x68e3, 0x66ed, 0x64ef, 0x62e9, 0x60eb},
4328 {0x5ed5, 0x5cd7, 0x5ad1, 0x58d3, 0x56dd, 0x54df, 0x52d9, 0x50db},
4329 {0x4ec5, 0x4cc7, 0x4ac1, 0x48c3, 0x46cd, 0x44cf, 0x42c9, 0x40cb},
4330 {0x3eb5, 0x3cb7, 0x3ab1, 0x38b3, 0x36bd, 0x34bf, 0x32b9, 0x30bb},
4331 {0x2ea5, 0x2ca7, 0x2aa1, 0x28a3, 0x26ad, 0x24af, 0x22a9, 0x20ab},
4332 {0x1e95, 0x1c97, 0x1a91, 0x1893, 0x169d, 0x149f, 0x1299, 0x109b},
4333 {0x0e85, 0x0c87, 0x0a81, 0x0883, 0x068d, 0x048f, 0x0289, 0x008b}},
4334 {{0x7cfd'7ef5, 0x78f9'7af1, 0x74f5'76fd, 0x70f1'72f9},
4335 {0x6ced'6ee5, 0x68e9'6ae1, 0x64e5'66ed, 0x60e1'62e9},
4336 {0x5cdd'5ed5, 0x58d9'5ad1, 0x54d5'56dd, 0x50d1'52d9},
4337 {0x4ccd'4ec5, 0x48c9'4ac1, 0x44c5'46cd, 0x40c1'42c9},
4338 {0x3cbd'3eb5, 0x38b9'3ab1, 0x34b5'36bd, 0x30b1'32b9},
4339 {0x2cad'2ea5, 0x28a9'2aa1, 0x24a5'26ad, 0x20a1'22a9},
4340 {0x1c9d'1e95, 0x1899'1a91, 0x1495'169d, 0x1091'1299},
4341 {0x0c8d'0e85, 0x0889'0a81, 0x0485'068d, 0x0081'0289}},
4342 {{0x78f9'7afb'7cfd'7ef5, 0x70f1'72f3'74f5'76fd},
4343 {0x68e9'6aeb'6ced'6ee5, 0x60e1'62e3'64e5'66ed},
4344 {0x58d9'5adb'5cdd'5ed5, 0x50d1'52d3'54d5'56dd},
4345 {0x48c9'4acb'4ccd'4ec5, 0x40c1'42c3'44c5'46cd},
4346 {0x38b9'3abb'3cbd'3eb5, 0x30b1'32b3'34b5'36bd},
4347 {0x28a9'2aab'2cad'2ea5, 0x20a1'22a3'24a5'26ad},
4348 {0x1899'1a9b'1c9d'1e95, 0x1091'1293'1495'169d},
4349 {0x0889'0a8b'0c8d'0e85, 0x0081'0283'0485'068d}},
4350 kVectorCalculationsSourceLegacy);
4351 }
4352
ExecVmfeqvv()4353 [[gnu::naked]] void ExecVmfeqvv() {
4354 asm("vmfeq.vv v8, v16, v24\n\t"
4355 "ret\n\t");
4356 }
4357
ExecMaskedVmfeqvv()4358 [[gnu::naked]] void ExecMaskedVmfeqvv() {
4359 asm("vmfeq.vv v8, v16, v24, v0.t\n\t"
4360 "ret\n\t");
4361 }
ExecVmfeqvf()4362 [[gnu::naked]] void ExecVmfeqvf() {
4363 asm("vmfeq.vf v8, v16, ft0\n\t"
4364 "ret\n\t");
4365 }
4366
ExecMaskedVmfeqvf()4367 [[gnu::naked]] void ExecMaskedVmfeqvf() {
4368 asm("vmfeq.vf v8, v16, ft0, v0.t\n\t"
4369 "ret\n\t");
4370 }
4371
TEST(InlineAsmTestRiscv64,TestVmfeq)4372 TEST(InlineAsmTestRiscv64, TestVmfeq) {
4373 TestVectorMaskTargetInstruction(
4374 ExecVmfeqvv, ExecMaskedVmfeqvv, 0x0000'0007, 0x0001, kVectorComparisonSource);
4375 TestVectorMaskTargetInstruction(
4376 ExecVmfeqvf, ExecMaskedVmfeqvf, 0x0000'0040, 0x0020, kVectorComparisonSource);
4377 }
4378
ExecVaadduvv()4379 [[gnu::naked]] void ExecVaadduvv() {
4380 asm("vaaddu.vv v8, v16, v24\n\t"
4381 "ret\n\t");
4382 }
4383
ExecMaskedVaadduvv()4384 [[gnu::naked]] void ExecMaskedVaadduvv() {
4385 asm("vaaddu.vv v8, v16, v24, v0.t\n\t"
4386 "ret\n\t");
4387 }
4388
ExecVaadduvx()4389 [[gnu::naked]] void ExecVaadduvx() {
4390 asm("vaaddu.vx v8, v16, t0\n\t"
4391 "ret\n\t");
4392 }
4393
ExecMaskedVaadduvx()4394 [[gnu::naked]] void ExecMaskedVaadduvx() {
4395 asm("vaaddu.vx v8, v16, t0, v0.t\n\t"
4396 "ret\n\t");
4397 }
4398
ExecVaaddvv()4399 [[gnu::naked]] void ExecVaaddvv() {
4400 asm("vaadd.vv v8, v16, v24\n\t"
4401 "ret\n\t");
4402 }
4403
ExecMaskedVaaddvv()4404 [[gnu::naked]] void ExecMaskedVaaddvv() {
4405 asm("vaadd.vv v8, v16, v24, v0.t\n\t"
4406 "ret\n\t");
4407 }
4408
ExecVaaddvx()4409 [[gnu::naked]] void ExecVaaddvx() {
4410 asm("vaadd.vx v8, v16, t0\n\t"
4411 "ret\n\t");
4412 }
4413
ExecMaskedVaaddvx()4414 [[gnu::naked]] void ExecMaskedVaaddvx() {
4415 asm("vaadd.vx v8, v16, t0, v0.t\n\t"
4416 "ret\n\t");
4417 }
4418
ExecVasubuvv()4419 [[gnu::naked]] void ExecVasubuvv() {
4420 asm("vasubu.vv v8, v16, v24\n\t"
4421 "ret\n\t");
4422 }
4423
ExecMaskedVasubuvv()4424 [[gnu::naked]] void ExecMaskedVasubuvv() {
4425 asm("vasubu.vv v8, v16, v24, v0.t\n\t"
4426 "ret\n\t");
4427 }
4428
ExecVasubuvx()4429 [[gnu::naked]] void ExecVasubuvx() {
4430 asm("vasubu.vx v8, v16, t0\n\t"
4431 "ret\n\t");
4432 }
4433
ExecMaskedVasubuvx()4434 [[gnu::naked]] void ExecMaskedVasubuvx() {
4435 asm("vasubu.vx v8, v16, t0, v0.t\n\t"
4436 "ret\n\t");
4437 }
4438
ExecVasubvv()4439 [[gnu::naked]] void ExecVasubvv() {
4440 asm("vasub.vv v8, v16, v24\n\t"
4441 "ret\n\t");
4442 }
4443
ExecMaskedVasubvv()4444 [[gnu::naked]] void ExecMaskedVasubvv() {
4445 asm("vasub.vv v8, v16, v24, v0.t\n\t"
4446 "ret\n\t");
4447 }
4448
ExecVasubvx()4449 [[gnu::naked]] void ExecVasubvx() {
4450 asm("vasub.vx v8, v16, t0\n\t"
4451 "ret\n\t");
4452 }
4453
ExecMaskedVasubvx()4454 [[gnu::naked]] void ExecMaskedVasubvx() {
4455 asm("vasub.vx v8, v16, t0, v0.t\n\t"
4456 "ret\n\t");
4457 }
4458
ExecVnclipuwi()4459 [[gnu::naked]] void ExecVnclipuwi() {
4460 asm("vnclipu.wi v8, v16, 0xa\n\t"
4461 "ret\n\t");
4462 }
4463
ExecMaskedVnclipuwi()4464 [[gnu::naked]] void ExecMaskedVnclipuwi() {
4465 asm("vnclipu.wi v8, v16, 0xa, v0.t\n\t"
4466 "ret\n\t");
4467 }
4468
ExecVnclipwi()4469 [[gnu::naked]] void ExecVnclipwi() {
4470 asm("vnclip.wi v8, v16, 0xa\n\t"
4471 "ret\n\t");
4472 }
4473
ExecMaskedVnclipwi()4474 [[gnu::naked]] void ExecMaskedVnclipwi() {
4475 asm("vnclip.wi v8, v16, 0xa, v0.t\n\t"
4476 "ret\n\t");
4477 }
4478
ExecVnclipuwx()4479 [[gnu::naked]] void ExecVnclipuwx() {
4480 asm("vnclipu.wx v8, v16, t0\n\t"
4481 "ret\n\t");
4482 }
4483
ExecMaskedVnclipuwx()4484 [[gnu::naked]] void ExecMaskedVnclipuwx() {
4485 asm("vnclipu.wx v8, v16, t0, v0.t\n\t"
4486 "ret\n\t");
4487 }
4488
ExecVnclipwx()4489 [[gnu::naked]] void ExecVnclipwx() {
4490 asm("vnclip.wx v8, v16, t0\n\t"
4491 "ret\n\t");
4492 }
4493
ExecMaskedVnclipwx()4494 [[gnu::naked]] void ExecMaskedVnclipwx() {
4495 asm("vnclip.wx v8, v16, t0, v0.t\n\t"
4496 "ret\n\t");
4497 }
4498
ExecVnclipuwv()4499 [[gnu::naked]] void ExecVnclipuwv() {
4500 asm("vnclipu.wv v8, v16, v24\n\t"
4501 "ret\n\t");
4502 }
4503
ExecMaskedVnclipuwv()4504 [[gnu::naked]] void ExecMaskedVnclipuwv() {
4505 asm("vnclipu.wv v8, v16, v24, v0.t\n\t"
4506 "ret\n\t");
4507 }
4508
ExecVnclipwv()4509 [[gnu::naked]] void ExecVnclipwv() {
4510 asm("vnclip.wv v8, v16, v24\n\t"
4511 "ret\n\t");
4512 }
4513
ExecMaskedVnclipwv()4514 [[gnu::naked]] void ExecMaskedVnclipwv() {
4515 asm("vnclip.wv v8, v16, v24, v0.t\n\t"
4516 "ret\n\t");
4517 }
4518
ExecVsmulvv()4519 [[gnu::naked]] void ExecVsmulvv() {
4520 asm("vsmul.vv v8, v16, v24\n\t"
4521 "ret\n\t");
4522 }
4523
ExecMaskedVsmulvv()4524 [[gnu::naked]] void ExecMaskedVsmulvv() {
4525 asm("vsmul.vv v8, v16, v24, v0.t\n\t"
4526 "ret\n\t");
4527 }
4528
ExecVsmulvx()4529 [[gnu::naked]] void ExecVsmulvx() {
4530 asm("vsmul.vx v8, v16, t0\n\t"
4531 "ret\n\t");
4532 }
4533
ExecMaskedVsmulvx()4534 [[gnu::naked]] void ExecMaskedVsmulvx() {
4535 asm("vsmul.vx v8, v16, t0, v0.t\n\t"
4536 "ret\n\t");
4537 }
4538
ExecVssrlvv()4539 [[gnu::naked]] void ExecVssrlvv() {
4540 asm("vssrl.vv v8, v16, v24\n\t"
4541 "ret\n\t");
4542 }
4543
ExecMaskedVssrlvv()4544 [[gnu::naked]] void ExecMaskedVssrlvv() {
4545 asm("vssrl.vv v8, v16, v24, v0.t\n\t"
4546 "ret\n\t");
4547 }
4548
ExecVssrlvx()4549 [[gnu::naked]] void ExecVssrlvx() {
4550 asm("vssrl.vx v8, v16, t0\n\t"
4551 "ret\n\t");
4552 }
4553
ExecMaskedVssrlvx()4554 [[gnu::naked]] void ExecMaskedVssrlvx() {
4555 asm("vssrl.vx v8, v16, t0, v0.t\n\t"
4556 "ret\n\t");
4557 }
4558
ExecVssrlvi()4559 [[gnu::naked]] void ExecVssrlvi() {
4560 asm("vssrl.vi v8, v16, 0xa\n\t"
4561 "ret\n\t");
4562 }
4563
ExecMaskedVssrlvi()4564 [[gnu::naked]] void ExecMaskedVssrlvi() {
4565 asm("vssrl.vi v8, v16, 0xa, v0.t\n\t"
4566 "ret\n\t");
4567 }
4568
ExecVssravv()4569 [[gnu::naked]] void ExecVssravv() {
4570 asm("vssra.vv v8, v16, v24\n\t"
4571 "ret\n\t");
4572 }
4573
ExecMaskedVssravv()4574 [[gnu::naked]] void ExecMaskedVssravv() {
4575 asm("vssra.vv v8, v16, v24, v0.t\n\t"
4576 "ret\n\t");
4577 }
4578
ExecVssravx()4579 [[gnu::naked]] void ExecVssravx() {
4580 asm("vssra.vx v8, v16, t0\n\t"
4581 "ret\n\t");
4582 }
4583
ExecMaskedVssravx()4584 [[gnu::naked]] void ExecMaskedVssravx() {
4585 asm("vssra.vx v8, v16, t0, v0.t\n\t"
4586 "ret\n\t");
4587 }
4588
ExecVssravi()4589 [[gnu::naked]] void ExecVssravi() {
4590 asm("vssra.vi v8, v16, 0xa\n\t"
4591 "ret\n\t");
4592 }
4593
ExecMaskedVssravi()4594 [[gnu::naked]] void ExecMaskedVssravi() {
4595 asm("vssra.vi v8, v16, 0xa, v0.t\n\t"
4596 "ret\n\t");
4597 }
4598
TEST(InlineAsmTestRiscv64,TestRDN)4599 TEST(InlineAsmTestRiscv64, TestRDN) {
4600 uint64_t vxrm;
4601 asm volatile(
4602 "csrr %0, vxrm\n\t"
4603 "csrwi vxrm, %c1\n\t"
4604 : "=r"(vxrm)
4605 : "i"(VXRMFlags::RDN));
4606 TestVectorInstruction(
4607 ExecVaadduvv,
4608 ExecMaskedVaadduvv,
4609 {{0, 137, 3, 140, 6, 143, 9, 146, 12, 133, 15, 136, 18, 139, 21, 142},
4610 {24, 161, 27, 164, 30, 167, 33, 170, 36, 157, 39, 160, 42, 163, 45, 166},
4611 {48, 185, 51, 188, 54, 191, 57, 194, 60, 181, 63, 184, 66, 187, 69, 190},
4612 {72, 209, 75, 212, 78, 215, 81, 218, 84, 205, 87, 208, 90, 211, 93, 214},
4613 {96, 105, 99, 108, 102, 111, 105, 114, 108, 101, 111, 104, 114, 107, 117, 110},
4614 {120, 129, 123, 132, 126, 135, 129, 138, 132, 125, 135, 128, 138, 131, 141, 134},
4615 {144, 153, 147, 156, 150, 159, 153, 162, 156, 149, 159, 152, 162, 155, 165, 158},
4616 {168, 177, 171, 180, 174, 183, 177, 186, 180, 173, 183, 176, 186, 179, 189, 182}},
4617 {{0x8980, 0x8c83, 0x8f86, 0x9289, 0x858c, 0x888f, 0x8b92, 0x8e95},
4618 {0xa198, 0xa49b, 0xa79e, 0xaaa1, 0x9da4, 0xa0a7, 0xa3aa, 0xa6ad},
4619 {0xb9b0, 0xbcb3, 0xbfb6, 0xc2b9, 0xb5bc, 0xb8bf, 0xbbc2, 0xbec5},
4620 {0xd1c8, 0xd4cb, 0xd7ce, 0xdad1, 0xcdd4, 0xd0d7, 0xd3da, 0xd6dd},
4621 {0x69e0, 0x6ce3, 0x6fe6, 0x72e9, 0x65ec, 0x68ef, 0x6bf2, 0x6ef5},
4622 {0x81f8, 0x84fb, 0x87fe, 0x8b01, 0x7e04, 0x8107, 0x840a, 0x870d},
4623 {0x9a10, 0x9d13, 0xa016, 0xa319, 0x961c, 0x991f, 0x9c22, 0x9f25},
4624 {0xb228, 0xb52b, 0xb82e, 0xbb31, 0xae34, 0xb137, 0xb43a, 0xb73d}},
4625 {{0x8c83'8980, 0x9289'8f86, 0x888f'858c, 0x8e95'8b92},
4626 {0xa49b'a198, 0xaaa1'a79e, 0xa0a7'9da4, 0xa6ad'a3aa},
4627 {0xbcb3'b9b0, 0xc2b9'bfb6, 0xb8bf'b5bc, 0xbec5'bbc2},
4628 {0xd4cb'd1c8, 0xdad1'd7ce, 0xd0d7'cdd4, 0xd6dd'd3da},
4629 {0x6ce3'69e0, 0x72e9'6fe6, 0x68ef'65ec, 0x6ef5'6bf2},
4630 {0x84fb'81f8, 0x8b01'87fe, 0x8107'7e04, 0x870d'840a},
4631 {0x9d13'9a10, 0xa319'a016, 0x991f'961c, 0x9f25'9c22},
4632 {0xb52b'b228, 0xbb31'b82e, 0xb137'ae34, 0xb73d'b43a}},
4633 {{0x9289'8f87'0c83'8980, 0x8e95'8b92'888f'858c},
4634 {0xaaa1'a79f'249b'a198, 0xa6ad'a3aa'a0a7'9da4},
4635 {0xc2b9'bfb7'3cb3'b9b0, 0xbec5'bbc2'b8bf'b5bc},
4636 {0xdad1'd7cf'54cb'd1c8, 0xd6dd'd3da'd0d7'cdd4},
4637 {0x72e9'6fe6'ece3'69e0, 0x6ef5'6bf2'68ef'65ec},
4638 {0x8b01'87ff'04fb'81f8, 0x870d'840a'8107'7e04},
4639 {0xa319'a017'1d13'9a10, 0x9f25'9c22'991f'961c},
4640 {0xbb31'b82f'352b'b228, 0xb73d'b43a'b137'ae34}},
4641 kVectorCalculationsSource);
4642 TestVectorInstruction(
4643 ExecVaadduvx,
4644 ExecMaskedVaadduvx,
4645 {{85, 149, 86, 150, 87, 151, 88, 152, 89, 153, 90, 154, 91, 155, 92, 156},
4646 {93, 157, 94, 158, 95, 159, 96, 160, 97, 161, 98, 162, 99, 163, 100, 164},
4647 {101, 165, 102, 166, 103, 167, 104, 168, 105, 169, 106, 170, 107, 171, 108, 172},
4648 {109, 173, 110, 174, 111, 175, 112, 176, 113, 177, 114, 178, 115, 179, 116, 180},
4649 {117, 181, 118, 182, 119, 183, 120, 184, 121, 185, 122, 186, 123, 187, 124, 188},
4650 {125, 189, 126, 190, 127, 191, 128, 192, 129, 193, 130, 194, 131, 195, 132, 196},
4651 {133, 197, 134, 198, 135, 199, 136, 200, 137, 201, 138, 202, 139, 203, 140, 204},
4652 {141, 205, 142, 206, 143, 207, 144, 208, 145, 209, 146, 210, 147, 211, 148, 212}},
4653 {{0x95d5, 0x96d6, 0x97d7, 0x98d8, 0x99d9, 0x9ada, 0x9bdb, 0x9cdc},
4654 {0x9ddd, 0x9ede, 0x9fdf, 0xa0e0, 0xa1e1, 0xa2e2, 0xa3e3, 0xa4e4},
4655 {0xa5e5, 0xa6e6, 0xa7e7, 0xa8e8, 0xa9e9, 0xaaea, 0xabeb, 0xacec},
4656 {0xaded, 0xaeee, 0xafef, 0xb0f0, 0xb1f1, 0xb2f2, 0xb3f3, 0xb4f4},
4657 {0xb5f5, 0xb6f6, 0xb7f7, 0xb8f8, 0xb9f9, 0xbafa, 0xbbfb, 0xbcfc},
4658 {0xbdfd, 0xbefe, 0xbfff, 0xc100, 0xc201, 0xc302, 0xc403, 0xc504},
4659 {0xc605, 0xc706, 0xc807, 0xc908, 0xca09, 0xcb0a, 0xcc0b, 0xcd0c},
4660 {0xce0d, 0xcf0e, 0xd00f, 0xd110, 0xd211, 0xd312, 0xd413, 0xd514}},
4661 {{0x96d6'95d5, 0x98d8'97d7, 0x9ada'99d9, 0x9cdc'9bdb},
4662 {0x9ede'9ddd, 0xa0e0'9fdf, 0xa2e2'a1e1, 0xa4e4'a3e3},
4663 {0xa6e6'a5e5, 0xa8e8'a7e7, 0xaaea'a9e9, 0xacec'abeb},
4664 {0xaeee'aded, 0xb0f0'afef, 0xb2f2'b1f1, 0xb4f4'b3f3},
4665 {0xb6f6'b5f5, 0xb8f8'b7f7, 0xbafa'b9f9, 0xbcfc'bbfb},
4666 {0xbefe'bdfd, 0xc100'bfff, 0xc302'c201, 0xc504'c403},
4667 {0xc706'c605, 0xc908'c807, 0xcb0a'ca09, 0xcd0c'cc0b},
4668 {0xcf0e'ce0d, 0xd110'd00f, 0xd312'd211, 0xd514'd413}},
4669 {{0x98d8'97d7'96d6'95d5, 0x9cdc'9bdb'9ada'99d9},
4670 {0xa0e0'9fdf'9ede'9ddd, 0xa4e4'a3e3'a2e2'a1e1},
4671 {0xa8e8'a7e7'a6e6'a5e5, 0xacec'abeb'aaea'a9e9},
4672 {0xb0f0'afef'aeee'aded, 0xb4f4'b3f3'b2f2'b1f1},
4673 {0xb8f8'b7f7'b6f6'b5f5, 0xbcfc'bbfb'bafa'b9f9},
4674 {0xc100'bfff'befe'bdfd, 0xc504'c403'c302'c201},
4675 {0xc908'c807'c706'c605, 0xcd0c'cc0b'cb0a'ca09},
4676 {0xd110'd00f'cf0e'ce0d, 0xd514'd413'd312'd211}},
4677 kVectorCalculationsSource);
4678 TestVectorInstruction(
4679 ExecVaaddvv,
4680 ExecMaskedVaaddvv,
4681 {{0, 137, 3, 140, 6, 143, 9, 146, 12, 133, 15, 136, 18, 139, 21, 142},
4682 {24, 161, 27, 164, 30, 167, 33, 170, 36, 157, 39, 160, 42, 163, 45, 166},
4683 {48, 185, 51, 188, 54, 191, 57, 194, 60, 181, 63, 184, 66, 187, 69, 190},
4684 {72, 209, 75, 212, 78, 215, 81, 218, 84, 205, 87, 208, 90, 211, 93, 214},
4685 {224, 233, 227, 236, 230, 239, 233, 242, 236, 229, 239, 232, 242, 235, 245, 238},
4686 {248, 1, 251, 4, 254, 7, 1, 10, 4, 253, 7, 0, 10, 3, 13, 6},
4687 {16, 25, 19, 28, 22, 31, 25, 34, 28, 21, 31, 24, 34, 27, 37, 30},
4688 {40, 49, 43, 52, 46, 55, 49, 58, 52, 45, 55, 48, 58, 51, 61, 54}},
4689 {{0x8980, 0x8c83, 0x8f86, 0x9289, 0x858c, 0x888f, 0x8b92, 0x8e95},
4690 {0xa198, 0xa49b, 0xa79e, 0xaaa1, 0x9da4, 0xa0a7, 0xa3aa, 0xa6ad},
4691 {0xb9b0, 0xbcb3, 0xbfb6, 0xc2b9, 0xb5bc, 0xb8bf, 0xbbc2, 0xbec5},
4692 {0xd1c8, 0xd4cb, 0xd7ce, 0xdad1, 0xcdd4, 0xd0d7, 0xd3da, 0xd6dd},
4693 {0xe9e0, 0xece3, 0xefe6, 0xf2e9, 0xe5ec, 0xe8ef, 0xebf2, 0xeef5},
4694 {0x01f8, 0x04fb, 0x07fe, 0x0b01, 0xfe04, 0x0107, 0x040a, 0x070d},
4695 {0x1a10, 0x1d13, 0x2016, 0x2319, 0x161c, 0x191f, 0x1c22, 0x1f25},
4696 {0x3228, 0x352b, 0x382e, 0x3b31, 0x2e34, 0x3137, 0x343a, 0x373d}},
4697 {{0x8c83'8980, 0x9289'8f86, 0x888f'858c, 0x8e95'8b92},
4698 {0xa49b'a198, 0xaaa1'a79e, 0xa0a7'9da4, 0xa6ad'a3aa},
4699 {0xbcb3'b9b0, 0xc2b9'bfb6, 0xb8bf'b5bc, 0xbec5'bbc2},
4700 {0xd4cb'd1c8, 0xdad1'd7ce, 0xd0d7'cdd4, 0xd6dd'd3da},
4701 {0xece3'69e0, 0xf2e9'6fe6, 0xe8ef'65ec, 0xeef5'6bf2},
4702 {0x04fb'81f8, 0x0b01'87fe, 0x0107'7e04, 0x070d'840a},
4703 {0x1d13'9a10, 0x2319'a016, 0x191f'961c, 0x1f25'9c22},
4704 {0x352b'b228, 0x3b31'b82e, 0x3137'ae34, 0x373d'b43a}},
4705 {{0x9289'8f87'0c83'8980, 0x8e95'8b92'888f'858c},
4706 {0xaaa1'a79f'249b'a198, 0xa6ad'a3aa'a0a7'9da4},
4707 {0xc2b9'bfb7'3cb3'b9b0, 0xbec5'bbc2'b8bf'b5bc},
4708 {0xdad1'd7cf'54cb'd1c8, 0xd6dd'd3da'd0d7'cdd4},
4709 {0xf2e9'6fe6'ece3'69e0, 0xeef5'6bf2'68ef'65ec},
4710 {0x0b01'87ff'04fb'81f8, 0x070d'840a'8107'7e04},
4711 {0x2319'a017'1d13'9a10, 0x1f25'9c22'991f'961c},
4712 {0x3b31'b82f'352b'b228, 0x373d'b43a'b137'ae34}},
4713 kVectorCalculationsSource);
4714 TestVectorInstruction(
4715 ExecVaaddvx,
4716 ExecMaskedVaaddvx,
4717 {{213, 149, 214, 150, 215, 151, 216, 152, 217, 153, 218, 154, 219, 155, 220, 156},
4718 {221, 157, 222, 158, 223, 159, 224, 160, 225, 161, 226, 162, 227, 163, 228, 164},
4719 {229, 165, 230, 166, 231, 167, 232, 168, 233, 169, 234, 170, 235, 171, 236, 172},
4720 {237, 173, 238, 174, 239, 175, 240, 176, 241, 177, 242, 178, 243, 179, 244, 180},
4721 {245, 181, 246, 182, 247, 183, 248, 184, 249, 185, 250, 186, 251, 187, 252, 188},
4722 {253, 189, 254, 190, 255, 191, 0, 192, 1, 193, 2, 194, 3, 195, 4, 196},
4723 {5, 197, 6, 198, 7, 199, 8, 200, 9, 201, 10, 202, 11, 203, 12, 204},
4724 {13, 205, 14, 206, 15, 207, 16, 208, 17, 209, 18, 210, 19, 211, 20, 212}},
4725 {{0x95d5, 0x96d6, 0x97d7, 0x98d8, 0x99d9, 0x9ada, 0x9bdb, 0x9cdc},
4726 {0x9ddd, 0x9ede, 0x9fdf, 0xa0e0, 0xa1e1, 0xa2e2, 0xa3e3, 0xa4e4},
4727 {0xa5e5, 0xa6e6, 0xa7e7, 0xa8e8, 0xa9e9, 0xaaea, 0xabeb, 0xacec},
4728 {0xaded, 0xaeee, 0xafef, 0xb0f0, 0xb1f1, 0xb2f2, 0xb3f3, 0xb4f4},
4729 {0xb5f5, 0xb6f6, 0xb7f7, 0xb8f8, 0xb9f9, 0xbafa, 0xbbfb, 0xbcfc},
4730 {0xbdfd, 0xbefe, 0xbfff, 0xc100, 0xc201, 0xc302, 0xc403, 0xc504},
4731 {0xc605, 0xc706, 0xc807, 0xc908, 0xca09, 0xcb0a, 0xcc0b, 0xcd0c},
4732 {0xce0d, 0xcf0e, 0xd00f, 0xd110, 0xd211, 0xd312, 0xd413, 0xd514}},
4733 {{0x96d6'95d5, 0x98d8'97d7, 0x9ada'99d9, 0x9cdc'9bdb},
4734 {0x9ede'9ddd, 0xa0e0'9fdf, 0xa2e2'a1e1, 0xa4e4'a3e3},
4735 {0xa6e6'a5e5, 0xa8e8'a7e7, 0xaaea'a9e9, 0xacec'abeb},
4736 {0xaeee'aded, 0xb0f0'afef, 0xb2f2'b1f1, 0xb4f4'b3f3},
4737 {0xb6f6'b5f5, 0xb8f8'b7f7, 0xbafa'b9f9, 0xbcfc'bbfb},
4738 {0xbefe'bdfd, 0xc100'bfff, 0xc302'c201, 0xc504'c403},
4739 {0xc706'c605, 0xc908'c807, 0xcb0a'ca09, 0xcd0c'cc0b},
4740 {0xcf0e'ce0d, 0xd110'd00f, 0xd312'd211, 0xd514'd413}},
4741 {{0x98d8'97d7'96d6'95d5, 0x9cdc'9bdb'9ada'99d9},
4742 {0xa0e0'9fdf'9ede'9ddd, 0xa4e4'a3e3'a2e2'a1e1},
4743 {0xa8e8'a7e7'a6e6'a5e5, 0xacec'abeb'aaea'a9e9},
4744 {0xb0f0'afef'aeee'aded, 0xb4f4'b3f3'b2f2'b1f1},
4745 {0xb8f8'b7f7'b6f6'b5f5, 0xbcfc'bbfb'bafa'b9f9},
4746 {0xc100'bfff'befe'bdfd, 0xc504'c403'c302'c201},
4747 {0xc908'c807'c706'c605, 0xcd0c'cc0b'cb0a'ca09},
4748 {0xd110'd00f'cf0e'ce0d, 0xd514'd413'd312'd211}},
4749 kVectorCalculationsSource);
4750 TestVectorInstruction(
4751 ExecVasubuvv,
4752 ExecMaskedVasubuvv,
4753 {{0, 247, 255, 246, 253, 245, 253, 244, 251, 3, 251, 2, 250, 1, 249, 0},
4754 {248, 239, 247, 238, 245, 237, 245, 236, 243, 251, 243, 250, 242, 249, 241, 248},
4755 {240, 231, 239, 230, 237, 229, 237, 228, 235, 243, 235, 242, 234, 241, 233, 240},
4756 {232, 223, 231, 222, 229, 221, 229, 220, 227, 235, 227, 234, 226, 233, 225, 232},
4757 {224, 87, 223, 86, 221, 85, 221, 84, 219, 99, 219, 98, 218, 97, 217, 96},
4758 {216, 79, 215, 78, 213, 77, 213, 76, 211, 91, 211, 90, 210, 89, 209, 88},
4759 {208, 71, 207, 70, 205, 69, 205, 68, 203, 83, 203, 82, 202, 81, 201, 80},
4760 {200, 63, 199, 62, 197, 61, 197, 60, 195, 75, 195, 74, 194, 73, 193, 72}},
4761 {{0xf780, 0xf67f, 0xf57d, 0xf47d, 0x037b, 0x027b, 0x017a, 0x0079},
4762 {0xef78, 0xee77, 0xed75, 0xec75, 0xfb73, 0xfa73, 0xf972, 0xf871},
4763 {0xe770, 0xe66f, 0xe56d, 0xe46d, 0xf36b, 0xf26b, 0xf16a, 0xf069},
4764 {0xdf68, 0xde67, 0xdd65, 0xdc65, 0xeb63, 0xea63, 0xe962, 0xe861},
4765 {0x5760, 0x565f, 0x555d, 0x545d, 0x635b, 0x625b, 0x615a, 0x6059},
4766 {0x4f58, 0x4e57, 0x4d55, 0x4c55, 0x5b53, 0x5a53, 0x5952, 0x5851},
4767 {0x4750, 0x464f, 0x454d, 0x444d, 0x534b, 0x524b, 0x514a, 0x5049},
4768 {0x3f48, 0x3e47, 0x3d45, 0x3c45, 0x4b43, 0x4a43, 0x4942, 0x4841}},
4769 {{0xf67e'f780, 0xf47c'f57d, 0x027b'037b, 0x0079'017a},
4770 {0xee76'ef78, 0xec74'ed75, 0xfa72'fb73, 0xf870'f972},
4771 {0xe66e'e770, 0xe46c'e56d, 0xf26a'f36b, 0xf068'f16a},
4772 {0xde66'df68, 0xdc64'dd65, 0xea62'eb63, 0xe860'e962},
4773 {0x565f'5760, 0x545d'555d, 0x625b'635b, 0x6059'615a},
4774 {0x4e57'4f58, 0x4c55'4d55, 0x5a53'5b53, 0x5851'5952},
4775 {0x464f'4750, 0x444d'454d, 0x524b'534b, 0x5049'514a},
4776 {0x3e47'3f48, 0x3c45'3d45, 0x4a43'4b43, 0x4841'4942}},
4777 {{0xf47c'f57d'767e'f780, 0x0079'017a'027b'037b},
4778 {0xec74'ed75'6e76'ef78, 0xf870'f971'fa72'fb73},
4779 {0xe46c'e56d'666e'e770, 0xf068'f169'f26a'f36b},
4780 {0xdc64'dd65'5e66'df68, 0xe860'e961'ea62'eb63},
4781 {0x545d'555d'd65f'5760, 0x6059'615a'625b'635b},
4782 {0x4c55'4d55'ce57'4f58, 0x5851'5952'5a53'5b53},
4783 {0x444d'454d'c64f'4750, 0x5049'514a'524b'534b},
4784 {0x3c45'3d45'be47'3f48, 0x4841'4942'4a43'4b43}},
4785 kVectorCalculationsSource);
4786 TestVectorInstruction(
4787 ExecVasubuvx,
4788 ExecMaskedVasubuvx,
4789 {{171, 235, 172, 236, 173, 237, 174, 238, 175, 239, 176, 240, 177, 241, 178, 242},
4790 {179, 243, 180, 244, 181, 245, 182, 246, 183, 247, 184, 248, 185, 249, 186, 250},
4791 {187, 251, 188, 252, 189, 253, 190, 254, 191, 255, 192, 0, 193, 1, 194, 2},
4792 {195, 3, 196, 4, 197, 5, 198, 6, 199, 7, 200, 8, 201, 9, 202, 10},
4793 {203, 11, 204, 12, 205, 13, 206, 14, 207, 15, 208, 16, 209, 17, 210, 18},
4794 {211, 19, 212, 20, 213, 21, 214, 22, 215, 23, 216, 24, 217, 25, 218, 26},
4795 {219, 27, 220, 28, 221, 29, 222, 30, 223, 31, 224, 32, 225, 33, 226, 34},
4796 {227, 35, 228, 36, 229, 37, 230, 38, 231, 39, 232, 40, 233, 41, 234, 42}},
4797 {{0xeb2b, 0xec2c, 0xed2d, 0xee2e, 0xef2f, 0xf030, 0xf131, 0xf232},
4798 {0xf333, 0xf434, 0xf535, 0xf636, 0xf737, 0xf838, 0xf939, 0xfa3a},
4799 {0xfb3b, 0xfc3c, 0xfd3d, 0xfe3e, 0xff3f, 0x0040, 0x0141, 0x0242},
4800 {0x0343, 0x0444, 0x0545, 0x0646, 0x0747, 0x0848, 0x0949, 0x0a4a},
4801 {0x0b4b, 0x0c4c, 0x0d4d, 0x0e4e, 0x0f4f, 0x1050, 0x1151, 0x1252},
4802 {0x1353, 0x1454, 0x1555, 0x1656, 0x1757, 0x1858, 0x1959, 0x1a5a},
4803 {0x1b5b, 0x1c5c, 0x1d5d, 0x1e5e, 0x1f5f, 0x2060, 0x2161, 0x2262},
4804 {0x2363, 0x2464, 0x2565, 0x2666, 0x2767, 0x2868, 0x2969, 0x2a6a}},
4805 {{0xec2b'eb2b, 0xee2d'ed2d, 0xf02f'ef2f, 0xf231'f131},
4806 {0xf433'f333, 0xf635'f535, 0xf837'f737, 0xfa39'f939},
4807 {0xfc3b'fb3b, 0xfe3d'fd3d, 0x003f'ff3f, 0x0242'0141},
4808 {0x0444'0343, 0x0646'0545, 0x0848'0747, 0x0a4a'0949},
4809 {0x0c4c'0b4b, 0x0e4e'0d4d, 0x1050'0f4f, 0x1252'1151},
4810 {0x1454'1353, 0x1656'1555, 0x1858'1757, 0x1a5a'1959},
4811 {0x1c5c'1b5b, 0x1e5e'1d5d, 0x2060'1f5f, 0x2262'2161},
4812 {0x2464'2363, 0x2666'2565, 0x2868'2767, 0x2a6a'2969}},
4813 {{0xee2d'ed2c'ec2b'eb2b, 0xf231'f130'f02f'ef2f},
4814 {0xf635'f534'f433'f333, 0xfa39'f938'f837'f737},
4815 {0xfe3d'fd3c'fc3b'fb3b, 0x0242'0141'003f'ff3f},
4816 {0x0646'0545'0444'0343, 0x0a4a'0949'0848'0747},
4817 {0x0e4e'0d4d'0c4c'0b4b, 0x1252'1151'1050'0f4f},
4818 {0x1656'1555'1454'1353, 0x1a5a'1959'1858'1757},
4819 {0x1e5e'1d5d'1c5c'1b5b, 0x2262'2161'2060'1f5f},
4820 {0x2666'2565'2464'2363, 0x2a6a'2969'2868'2767}},
4821 kVectorCalculationsSource);
4822 TestVectorInstruction(
4823 ExecVasubvv,
4824 ExecMaskedVasubvv,
4825 {{0, 247, 255, 246, 253, 245, 253, 244, 251, 3, 251, 2, 250, 1, 249, 0},
4826 {248, 239, 247, 238, 245, 237, 245, 236, 243, 251, 243, 250, 242, 249, 241, 248},
4827 {240, 231, 239, 230, 237, 229, 237, 228, 235, 243, 235, 242, 234, 241, 233, 240},
4828 {232, 223, 231, 222, 229, 221, 229, 220, 227, 235, 227, 234, 226, 233, 225, 232},
4829 {96, 215, 95, 214, 93, 213, 93, 212, 91, 227, 91, 226, 90, 225, 89, 224},
4830 {88, 207, 87, 206, 85, 205, 85, 204, 83, 219, 83, 218, 82, 217, 81, 216},
4831 {80, 199, 79, 198, 77, 197, 77, 196, 75, 211, 75, 210, 74, 209, 73, 208},
4832 {72, 191, 71, 190, 69, 189, 69, 188, 67, 203, 67, 202, 66, 201, 65, 200}},
4833 {{0xf780, 0xf67f, 0xf57d, 0xf47d, 0x037b, 0x027b, 0x017a, 0x0079},
4834 {0xef78, 0xee77, 0xed75, 0xec75, 0xfb73, 0xfa73, 0xf972, 0xf871},
4835 {0xe770, 0xe66f, 0xe56d, 0xe46d, 0xf36b, 0xf26b, 0xf16a, 0xf069},
4836 {0xdf68, 0xde67, 0xdd65, 0xdc65, 0xeb63, 0xea63, 0xe962, 0xe861},
4837 {0xd760, 0xd65f, 0xd55d, 0xd45d, 0xe35b, 0xe25b, 0xe15a, 0xe059},
4838 {0xcf58, 0xce57, 0xcd55, 0xcc55, 0xdb53, 0xda53, 0xd952, 0xd851},
4839 {0xc750, 0xc64f, 0xc54d, 0xc44d, 0xd34b, 0xd24b, 0xd14a, 0xd049},
4840 {0xbf48, 0xbe47, 0xbd45, 0xbc45, 0xcb43, 0xca43, 0xc942, 0xc841}},
4841 {{0xf67e'f780, 0xf47c'f57d, 0x027b'037b, 0x0079'017a},
4842 {0xee76'ef78, 0xec74'ed75, 0xfa72'fb73, 0xf870'f972},
4843 {0xe66e'e770, 0xe46c'e56d, 0xf26a'f36b, 0xf068'f16a},
4844 {0xde66'df68, 0xdc64'dd65, 0xea62'eb63, 0xe860'e962},
4845 {0xd65f'5760, 0xd45d'555d, 0xe25b'635b, 0xe059'615a},
4846 {0xce57'4f58, 0xcc55'4d55, 0xda53'5b53, 0xd851'5952},
4847 {0xc64f'4750, 0xc44d'454d, 0xd24b'534b, 0xd049'514a},
4848 {0xbe47'3f48, 0xbc45'3d45, 0xca43'4b43, 0xc841'4942}},
4849 {{0xf47c'f57d'767e'f780, 0x0079'017a'027b'037b},
4850 {0xec74'ed75'6e76'ef78, 0xf870'f971'fa72'fb73},
4851 {0xe46c'e56d'666e'e770, 0xf068'f169'f26a'f36b},
4852 {0xdc64'dd65'5e66'df68, 0xe860'e961'ea62'eb63},
4853 {0xd45d'555d'd65f'5760, 0xe059'615a'625b'635b},
4854 {0xcc55'4d55'ce57'4f58, 0xd851'5952'5a53'5b53},
4855 {0xc44d'454d'c64f'4750, 0xd049'514a'524b'534b},
4856 {0xbc45'3d45'be47'3f48, 0xc841'4942'4a43'4b43}},
4857 kVectorCalculationsSource);
4858 TestVectorInstruction(ExecVasubvx,
4859 ExecMaskedVasubvx,
4860 {{43, 235, 44, 236, 45, 237, 46, 238, 47, 239, 48, 240, 49, 241, 50, 242},
4861 {51, 243, 52, 244, 53, 245, 54, 246, 55, 247, 56, 248, 57, 249, 58, 250},
4862 {59, 251, 60, 252, 61, 253, 62, 254, 63, 255, 64, 0, 65, 1, 66, 2},
4863 {67, 3, 68, 4, 69, 5, 70, 6, 71, 7, 72, 8, 73, 9, 74, 10},
4864 {75, 11, 76, 12, 77, 13, 78, 14, 79, 15, 80, 16, 81, 17, 82, 18},
4865 {83, 19, 84, 20, 85, 21, 86, 22, 87, 23, 88, 24, 89, 25, 90, 26},
4866 {91, 27, 92, 28, 93, 29, 94, 30, 95, 31, 96, 32, 97, 33, 98, 34},
4867 {99, 35, 100, 36, 101, 37, 102, 38, 103, 39, 104, 40, 105, 41, 106, 42}},
4868 {{0xeb2b, 0xec2c, 0xed2d, 0xee2e, 0xef2f, 0xf030, 0xf131, 0xf232},
4869 {0xf333, 0xf434, 0xf535, 0xf636, 0xf737, 0xf838, 0xf939, 0xfa3a},
4870 {0xfb3b, 0xfc3c, 0xfd3d, 0xfe3e, 0xff3f, 0x0040, 0x0141, 0x0242},
4871 {0x0343, 0x0444, 0x0545, 0x0646, 0x0747, 0x0848, 0x0949, 0x0a4a},
4872 {0x0b4b, 0x0c4c, 0x0d4d, 0x0e4e, 0x0f4f, 0x1050, 0x1151, 0x1252},
4873 {0x1353, 0x1454, 0x1555, 0x1656, 0x1757, 0x1858, 0x1959, 0x1a5a},
4874 {0x1b5b, 0x1c5c, 0x1d5d, 0x1e5e, 0x1f5f, 0x2060, 0x2161, 0x2262},
4875 {0x2363, 0x2464, 0x2565, 0x2666, 0x2767, 0x2868, 0x2969, 0x2a6a}},
4876 {{0xec2b'eb2b, 0xee2d'ed2d, 0xf02f'ef2f, 0xf231'f131},
4877 {0xf433'f333, 0xf635'f535, 0xf837'f737, 0xfa39'f939},
4878 {0xfc3b'fb3b, 0xfe3d'fd3d, 0x003f'ff3f, 0x0242'0141},
4879 {0x0444'0343, 0x0646'0545, 0x0848'0747, 0x0a4a'0949},
4880 {0x0c4c'0b4b, 0x0e4e'0d4d, 0x1050'0f4f, 0x1252'1151},
4881 {0x1454'1353, 0x1656'1555, 0x1858'1757, 0x1a5a'1959},
4882 {0x1c5c'1b5b, 0x1e5e'1d5d, 0x2060'1f5f, 0x2262'2161},
4883 {0x2464'2363, 0x2666'2565, 0x2868'2767, 0x2a6a'2969}},
4884 {{0xee2d'ed2c'ec2b'eb2b, 0xf231'f130'f02f'ef2f},
4885 {0xf635'f534'f433'f333, 0xfa39'f938'f837'f737},
4886 {0xfe3d'fd3c'fc3b'fb3b, 0x0242'0141'003f'ff3f},
4887 {0x0646'0545'0444'0343, 0x0a4a'0949'0848'0747},
4888 {0x0e4e'0d4d'0c4c'0b4b, 0x1252'1151'1050'0f4f},
4889 {0x1656'1555'1454'1353, 0x1a5a'1959'1858'1757},
4890 {0x1e5e'1d5d'1c5c'1b5b, 0x2262'2161'2060'1f5f},
4891 {0x2666'2565'2464'2363, 0x2a6a'2969'2868'2767}},
4892 kVectorCalculationsSource);
4893 TestNarrowingVectorInstruction(ExecVnclipuwi,
4894 ExecMaskedVnclipuwi,
4895 {{32, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37, 38, 38, 39, 39},
4896 {40, 40, 41, 41, 42, 42, 43, 43, 44, 44, 45, 45, 46, 46, 47, 47},
4897 {48, 48, 49, 49, 50, 50, 51, 51, 52, 52, 53, 53, 54, 54, 55, 55},
4898 {56, 56, 57, 57, 58, 58, 59, 59, 60, 60, 61, 61, 62, 62, 63, 63}},
4899 {{0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
4900 {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
4901 {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
4902 {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff}},
4903 {{0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff},
4904 {0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff},
4905 {0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff},
4906 {0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff}},
4907 kVectorCalculationsSource);
4908 TestNarrowingVectorInstruction(
4909 ExecVnclipwi,
4910 ExecMaskedVnclipwi,
4911 {{224, 224, 225, 225, 226, 226, 227, 227, 228, 228, 229, 229, 230, 230, 231, 231},
4912 {232, 232, 233, 233, 234, 234, 235, 235, 236, 236, 237, 237, 238, 238, 239, 239},
4913 {240, 240, 241, 241, 242, 242, 243, 243, 244, 244, 245, 245, 246, 246, 247, 247},
4914 {248, 248, 249, 249, 250, 250, 251, 251, 252, 252, 253, 253, 254, 254, 255, 255}},
4915 {{0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000},
4916 {0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000},
4917 {0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000},
4918 {0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0xdfbf}},
4919 {{0x8000'0000, 0x8000'0000, 0x8000'0000, 0x8000'0000},
4920 {0x8000'0000, 0x8000'0000, 0x8000'0000, 0x8000'0000},
4921 {0x8000'0000, 0x8000'0000, 0x8000'0000, 0x8000'0000},
4922 {0x8000'0000, 0x8000'0000, 0x8000'0000, 0x8000'0000}},
4923 kVectorCalculationsSource);
4924
4925 TestNarrowingVectorInstruction(ExecVnclipuwx,
4926 ExecMaskedVnclipuwx,
4927 {{32, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37, 38, 38, 39, 39},
4928 {40, 40, 41, 41, 42, 42, 43, 43, 44, 44, 45, 45, 46, 46, 47, 47},
4929 {48, 48, 49, 49, 50, 50, 51, 51, 52, 52, 53, 53, 54, 54, 55, 55},
4930 {56, 56, 57, 57, 58, 58, 59, 59, 60, 60, 61, 61, 62, 62, 63, 63}},
4931 {{0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
4932 {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
4933 {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
4934 {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff}},
4935 {{0x0021'c1a1, 0x0023'c3a3, 0x0025'c5a5, 0x0027'c7a7},
4936 {0x0029'c9a9, 0x002b'cbab, 0x002d'cdad, 0x002f'cfaf},
4937 {0x0031'd1b1, 0x0033'd3b3, 0x0035'd5b5, 0x0037'd7b7},
4938 {0x0039'd9b9, 0x003b'dbbb, 0x003d'ddbd, 0x003f'dfbf}},
4939 kVectorCalculationsSource);
4940
4941 TestNarrowingVectorInstruction(
4942 ExecVnclipwx,
4943 ExecMaskedVnclipwx,
4944 {{224, 224, 225, 225, 226, 226, 227, 227, 228, 228, 229, 229, 230, 230, 231, 231},
4945 {232, 232, 233, 233, 234, 234, 235, 235, 236, 236, 237, 237, 238, 238, 239, 239},
4946 {240, 240, 241, 241, 242, 242, 243, 243, 244, 244, 245, 245, 246, 246, 247, 247},
4947 {248, 248, 249, 249, 250, 250, 251, 251, 252, 252, 253, 253, 254, 254, 255, 255}},
4948 {{0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000},
4949 {0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000},
4950 {0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000},
4951 {0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0xdfbf}},
4952 {{0xffe1'c1a1, 0xffe3'c3a3, 0xffe5'c5a5, 0xffe7'c7a7},
4953 {0xffe9'c9a9, 0xffeb'cbab, 0xffed'cdad, 0xffef'cfaf},
4954 {0xfff1'd1b1, 0xfff3'd3b3, 0xfff5'd5b5, 0xfff7'd7b7},
4955 {0xfff9'd9b9, 0xfffb'dbbb, 0xfffd'ddbd, 0xffff'dfbf}},
4956 kVectorCalculationsSource);
4957
4958 TestNarrowingVectorInstruction(
4959 ExecVnclipuwv,
4960 ExecMaskedVnclipuwv,
4961 {{255, 255, 255, 255, 68, 34, 8, 2, 255, 255, 255, 255, 153, 38, 9, 2},
4962 {255, 255, 255, 255, 84, 42, 10, 2, 255, 255, 255, 255, 185, 46, 11, 2},
4963 {255, 255, 255, 255, 100, 50, 12, 3, 255, 255, 255, 255, 217, 54, 13, 3},
4964 {255, 255, 255, 255, 116, 58, 14, 3, 255, 255, 255, 255, 249, 62, 15, 3}},
4965 {{0xffff, 0xffff, 0xffff, 0xffff, 0x4989, 0x0971, 0x009b, 0x0009},
4966 {0xffff, 0xffff, 0xffff, 0xffff, 0x5999, 0x0b73, 0x00bb, 0x000b},
4967 {0xffff, 0xffff, 0xffff, 0xffff, 0x69a9, 0x0d75, 0x00db, 0x000d},
4968 {0xffff, 0xffff, 0xffff, 0xffff, 0x79b9, 0x0f77, 0x00fb, 0x000f}},
4969 {{0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff},
4970 {0xa726'a524, 0x0057'9756, 0x0000'5b9b, 0x0000'00bf},
4971 {0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff},
4972 {0xe766'e564, 0x0077'b776, 0x0000'7bbb, 0x0000'00ff}},
4973 kVectorCalculationsSource);
4974
4975 TestNarrowingVectorInstruction(
4976 ExecVnclipwv,
4977 ExecMaskedVnclipwv,
4978 {{128, 128, 128, 128, 196, 226, 248, 254, 128, 128, 128, 128, 153, 230, 249, 254},
4979 {128, 128, 128, 128, 212, 234, 250, 254, 128, 128, 128, 128, 185, 238, 251, 254},
4980 {128, 128, 128, 128, 228, 242, 252, 255, 128, 128, 128, 128, 217, 246, 253, 255},
4981 {128, 128, 128, 157, 244, 250, 254, 255, 128, 128, 128, 221, 249, 254, 255, 255}},
4982 {{0x8000, 0x8000, 0x8000, 0x8000, 0xc989, 0xf971, 0xff9b, 0xfff9},
4983 {0x8000, 0x8000, 0x8000, 0x8000, 0xd999, 0xfb73, 0xffbb, 0xfffb},
4984 {0x8000, 0x8000, 0x8000, 0x8000, 0xe9a9, 0xfd75, 0xffdb, 0xfffd},
4985 {0x8000, 0x8000, 0x8000, 0x8000, 0xf9b9, 0xff77, 0xfffb, 0xffff}},
4986 {{0x8000'0000, 0x8000'0000, 0x8000'0000, 0x8000'0000},
4987 {0xa726'a524, 0xffd7'9756, 0xffff'db9b, 0xffff'ffbf},
4988 {0x8000'0000, 0x8000'0000, 0x8000'0000, 0x8000'0000},
4989 {0xe766'e564, 0xfff7'b776, 0xffff'fbbb, 0xffff'ffff}},
4990 kVectorCalculationsSource);
4991
4992 TestVectorInstruction(
4993 ExecVsmulvv,
4994 ExecMaskedVsmulvv,
4995 {{0, 109, 0, 103, 0, 98, 0, 92, 1, 117, 1, 111, 2, 106, 3, 100},
4996 {4, 67, 5, 63, 6, 58, 7, 54, 9, 75, 10, 71, 12, 66, 14, 62},
4997 {16, 34, 18, 30, 20, 27, 22, 23, 25, 42, 27, 38, 30, 35, 33, 31},
4998 {36, 8, 39, 6, 42, 3, 45, 1, 49, 16, 52, 14, 56, 11, 60, 9},
4999 {192, 247, 192, 245, 192, 244, 192, 242, 193, 255, 193, 253, 194, 252, 195, 250},
5000 {196, 237, 197, 237, 198, 236, 199, 236, 201, 245, 202, 245, 204, 244, 206, 244},
5001 {208, 236, 210, 236, 213, 237, 214, 237, 217, 244, 219, 244, 222, 245, 225, 245},
5002 {228, 242, 231, 244, 235, 245, 237, 247, 241, 250, 244, 252, 248, 253, 252, 255}},
5003 {{0x6d24, 0x677e, 0x61f8, 0x5c94, 0x750c, 0x6f68, 0x69e3, 0x647e},
5004 {0x437e, 0x3eda, 0x3a56, 0x35f4, 0x4b6a, 0x46c8, 0x4245, 0x3de3},
5005 {0x21e9, 0x1e47, 0x1ac5, 0x1765, 0x29d9, 0x2639, 0x22b8, 0x1f57},
5006 {0x0863, 0x05c4, 0x0344, 0x00e5, 0x1058, 0x0db9, 0x0b3b, 0x08dc},
5007 {0xf6ee, 0xf550, 0xf3d2, 0xf276, 0xfee7, 0xfd4a, 0xfbcd, 0xfa71},
5008 {0xed88, 0xeced, 0xec71, 0xec17, 0xf585, 0xf4eb, 0xf470, 0xf415},
5009 {0xec33, 0xec9a, 0xed20, 0xedc7, 0xf434, 0xf49b, 0xf523, 0xf5ca},
5010 {0xf2ee, 0xf456, 0xf5df, 0xf788, 0xfaf3, 0xfc5c, 0xfde5, 0xff8f}},
5011 {{0x677d'76ae, 0x5c93'1930, 0x6f67'3830, 0x647d'dbb6},
5012 {0x3eda'09c6, 0x35f3'b250, 0x46c7'cf50, 0x3de2'78dd},
5013 {0x1e46'b4fd, 0x1764'638f, 0x2638'7e8f, 0x1f57'2e25},
5014 {0x05c3'7854, 0x00e5'2cef, 0x0db9'45ef, 0x08db'fb8c},
5015 {0xf550'cd46, 0xf276'7fe1, 0xfd4a'8ed9, 0xfa71'4276},
5016 {0xeced'a0be, 0xec17'5961, 0xf4eb'6659, 0xf416'1ffe},
5017 {0xec9a'8c56, 0xedc8'4b00, 0xf49c'55f8, 0xf5cb'15a6},
5018 {0xf457'900d, 0xf789'54c0, 0xfc5d'5db8, 0xff90'236d}},
5019 {{0x5c93'192f'ccd4'7781, 0x647d'dbb5'bb66'23af},
5020 {0x35f3'b24f'43d0'aa38, 0x3de2'78dd'1a4e'4256},
5021 {0x1764'638e'e2fd'152f, 0x1f57'2e24'a166'993d},
5022 {0x00e5'2cee'aa59'b866, 0x08db'fb8c'50af'2864},
5023 {0xf276'7fe1'80cf'f441, 0xfa71'4276'eef1'1fff},
5024 {0xec17'5961'584c'a798, 0xf416'1ffe'ae59'bf46},
5025 {0xedc8'4b01'57f9'9330, 0xf5cb'15a6'95f2'96ce},
5026 {0xf789'54c1'7fd6'b708, 0xff90'236e'a5bb'a696}},
5027 kVectorCalculationsSource);
5028 TestVectorInstruction(ExecVsmulvx,
5029 ExecMaskedVsmulvx,
5030 {{0, 85, 254, 83, 253, 82, 251, 81, 250, 79, 249, 78, 247, 77, 246, 75},
5031 {245, 74, 243, 73, 242, 71, 241, 70, 239, 69, 238, 67, 237, 66, 235, 65},
5032 {234, 63, 233, 62, 231, 61, 230, 59, 229, 58, 227, 57, 226, 55, 225, 54},
5033 {223, 53, 222, 51, 221, 50, 219, 49, 218, 47, 217, 46, 215, 45, 214, 43},
5034 {213, 42, 211, 40, 210, 39, 208, 38, 207, 36, 206, 35, 204, 34, 203, 32},
5035 {202, 31, 200, 30, 199, 28, 198, 27, 196, 26, 195, 24, 194, 23, 192, 22},
5036 {191, 20, 190, 19, 188, 18, 187, 16, 186, 15, 184, 14, 183, 12, 182, 11},
5037 {180, 10, 179, 8, 178, 7, 176, 6, 175, 4, 174, 3, 172, 2, 171, 0}},
5038 {{0x54ab, 0x5354, 0x51fd, 0x50a7, 0x4f50, 0x4df9, 0x4ca3, 0x4b4c},
5039 {0x49f5, 0x489f, 0x4748, 0x45f1, 0x449b, 0x4344, 0x41ed, 0x4097},
5040 {0x3f40, 0x3de9, 0x3c93, 0x3b3c, 0x39e5, 0x388f, 0x3738, 0x35e1},
5041 {0x348b, 0x3334, 0x31dd, 0x3087, 0x2f30, 0x2dd9, 0x2c83, 0x2b2c},
5042 {0x29d5, 0x287e, 0x2728, 0x25d1, 0x247a, 0x2324, 0x21cd, 0x2076},
5043 {0x1f20, 0x1dc9, 0x1c72, 0x1b1c, 0x19c5, 0x186e, 0x1718, 0x15c1},
5044 {0x146a, 0x1314, 0x11bd, 0x1066, 0x0f10, 0x0db9, 0x0c62, 0x0b0c},
5045 {0x09b5, 0x085e, 0x0708, 0x05b1, 0x045a, 0x0304, 0x01ad, 0x0056}},
5046 {{0x5353'aa00, 0x50a6'51fd, 0x4df8'f9fb, 0x4b4b'a1f8},
5047 {0x489e'49f5, 0x45f0'f1f3, 0x4343'99f0, 0x4096'41ed},
5048 {0x3de8'e9eb, 0x3b3b'91e8, 0x388e'39e5, 0x35e0'e1e3},
5049 {0x3333'89e0, 0x3086'31dd, 0x2dd8'd9db, 0x2b2b'81d8},
5050 {0x287e'29d5, 0x25d0'd1d2, 0x2323'79d0, 0x2076'21cd},
5051 {0x1dc8'c9ca, 0x1b1b'71c8, 0x186e'19c5, 0x15c0'c1c2},
5052 {0x1313'69c0, 0x1066'11bd, 0x0db8'b9ba, 0x0b0b'61b8},
5053 {0x085e'09b5, 0x05b0'b1b2, 0x0303'59b0, 0x0056'01ad}},
5054 {{0x50a6'51fc'fdfe'54ab, 0x4b4b'a1f7'a34e'4f50},
5055 {0x45f0'f1f2'489e'49f5, 0x4096'41ec'edee'449b},
5056 {0x3b3b'91e7'933e'3f40, 0x35e0'e1e2'388e'39e5},
5057 {0x3086'31dc'ddde'348b, 0x2b2b'81d7'832e'2f30},
5058 {0x25d0'd1d2'287e'29d5, 0x2076'21cc'cdce'247a},
5059 {0x1b1b'71c7'731e'1f20, 0x15c0'c1c2'186e'19c5},
5060 {0x1066'11bc'bdbe'146a, 0x0b0b'61b7'630e'0f10},
5061 {0x05b0'b1b2'085e'09b5, 0x0056'01ac'adae'045a}},
5062 kVectorCalculationsSource);
5063
5064 TestVectorInstruction(ExecVssrlvv,
5065 ExecMaskedVssrlvv,
5066 {{0, 32, 0, 2, 2, 33, 0, 2, 4, 34, 0, 2, 12, 35, 0, 2},
5067 {16, 36, 1, 2, 10, 37, 1, 2, 12, 38, 1, 2, 28, 39, 1, 2},
5068 {32, 40, 2, 2, 18, 41, 2, 2, 20, 42, 2, 2, 44, 43, 2, 2},
5069 {48, 44, 3, 2, 26, 45, 3, 2, 28, 46, 3, 2, 60, 47, 3, 2},
5070 {64, 48, 4, 3, 34, 49, 4, 3, 36, 50, 4, 3, 76, 51, 4, 3},
5071 {80, 52, 5, 3, 42, 53, 5, 3, 44, 54, 5, 3, 92, 55, 5, 3},
5072 {96, 56, 6, 3, 50, 57, 6, 3, 52, 58, 6, 3, 108, 59, 6, 3},
5073 {112, 60, 7, 3, 58, 61, 7, 3, 60, 62, 7, 3, 124, 63, 7, 3}},
5074 {{0x8100, 0x0830, 0x0042, 0x0008, 0x4484, 0x08b0, 0x008d, 0x0008},
5075 {0x9110, 0x0931, 0x004a, 0x0009, 0x4c8c, 0x09b1, 0x009d, 0x0009},
5076 {0xa120, 0x0a32, 0x0052, 0x000a, 0x5494, 0x0ab2, 0x00ad, 0x000a},
5077 {0xb130, 0x0b33, 0x005a, 0x000b, 0x5c9c, 0x0bb3, 0x00bd, 0x000b},
5078 {0xc140, 0x0c34, 0x0062, 0x000c, 0x64a4, 0x0cb4, 0x00cd, 0x000c},
5079 {0xd150, 0x0d35, 0x006a, 0x000d, 0x6cac, 0x0db5, 0x00dd, 0x000d},
5080 {0xe160, 0x0e36, 0x0072, 0x000e, 0x74b4, 0x0eb6, 0x00ed, 0x000e},
5081 {0xf170, 0x0f37, 0x007a, 0x000f, 0x7cbc, 0x0fb7, 0x00fd, 0x000f}},
5082 {{0x8302'8100, 0x0043'8342, 0x0000'4585, 0x0000'008f},
5083 {0x9312'9110, 0x004b'8b4a, 0x0000'4d8d, 0x0000'009f},
5084 {0xa322'a120, 0x0053'9352, 0x0000'5595, 0x0000'00af},
5085 {0xb332'b130, 0x005b'9b5a, 0x0000'5d9d, 0x0000'00bf},
5086 {0xc342'c140, 0x0063'a362, 0x0000'65a5, 0x0000'00cf},
5087 {0xd352'd150, 0x006b'ab6a, 0x0000'6dad, 0x0000'00df},
5088 {0xe362'e160, 0x0073'b372, 0x0000'75b5, 0x0000'00ef},
5089 {0xf372'f170, 0x007b'bb7a, 0x0000'7dbd, 0x0000'00ff}},
5090 {{0x8706'8504'8302'8100, 0x0000'4787'4686'4585},
5091 {0x0000'0000'9716'9514, 0x0000'0000'0000'4f8f},
5092 {0xa726'a524'a322'a120, 0x0000'5797'5696'5595},
5093 {0x0000'0000'b736'b534, 0x0000'0000'0000'5f9f},
5094 {0xc746'c544'c342'c140, 0x0000'67a7'66a6'65a5},
5095 {0x0000'0000'd756'd554, 0x0000'0000'0000'6faf},
5096 {0xe766'e564'e362'e160, 0x0000'77b7'76b6'75b5},
5097 {0x0000'0000'f776'f574, 0x0000'0000'0000'7fbf}},
5098 kVectorCalculationsSource);
5099
5100 TestVectorInstruction(ExecVssrlvx,
5101 ExecMaskedVssrlvx,
5102 {{0, 32, 0, 32, 1, 33, 1, 33, 2, 34, 2, 34, 3, 35, 3, 35},
5103 {4, 36, 4, 36, 5, 37, 5, 37, 6, 38, 6, 38, 7, 39, 7, 39},
5104 {8, 40, 8, 40, 9, 41, 9, 41, 10, 42, 10, 42, 11, 43, 11, 43},
5105 {12, 44, 12, 44, 13, 45, 13, 45, 14, 46, 14, 46, 15, 47, 15, 47},
5106 {16, 48, 16, 48, 17, 49, 17, 49, 18, 50, 18, 50, 19, 51, 19, 51},
5107 {20, 52, 20, 52, 21, 53, 21, 53, 22, 54, 22, 54, 23, 55, 23, 55},
5108 {24, 56, 24, 56, 25, 57, 25, 57, 26, 58, 26, 58, 27, 59, 27, 59},
5109 {28, 60, 28, 60, 29, 61, 29, 61, 30, 62, 30, 62, 31, 63, 31, 63}},
5110 {{0x0020, 0x0020, 0x0021, 0x0021, 0x0022, 0x0022, 0x0023, 0x0023},
5111 {0x0024, 0x0024, 0x0025, 0x0025, 0x0026, 0x0026, 0x0027, 0x0027},
5112 {0x0028, 0x0028, 0x0029, 0x0029, 0x002a, 0x002a, 0x002b, 0x002b},
5113 {0x002c, 0x002c, 0x002d, 0x002d, 0x002e, 0x002e, 0x002f, 0x002f},
5114 {0x0030, 0x0030, 0x0031, 0x0031, 0x0032, 0x0032, 0x0033, 0x0033},
5115 {0x0034, 0x0034, 0x0035, 0x0035, 0x0036, 0x0036, 0x0037, 0x0037},
5116 {0x0038, 0x0038, 0x0039, 0x0039, 0x003a, 0x003a, 0x003b, 0x003b},
5117 {0x003c, 0x003c, 0x003d, 0x003d, 0x003e, 0x003e, 0x003f, 0x003f}},
5118 {{0x0020'c0a0, 0x0021'c1a1, 0x0022'c2a2, 0x0023'c3a3},
5119 {0x0024'c4a4, 0x0025'c5a5, 0x0026'c6a6, 0x0027'c7a7},
5120 {0x0028'c8a8, 0x0029'c9a9, 0x002a'caaa, 0x002b'cbab},
5121 {0x002c'ccac, 0x002d'cdad, 0x002e'ceae, 0x002f'cfaf},
5122 {0x0030'd0b0, 0x0031'd1b1, 0x0032'd2b2, 0x0033'd3b3},
5123 {0x0034'd4b4, 0x0035'd5b5, 0x0036'd6b6, 0x0037'd7b7},
5124 {0x0038'd8b8, 0x0039'd9b9, 0x003a'daba, 0x003b'dbbb},
5125 {0x003c'dcbc, 0x003d'ddbd, 0x003e'debe, 0x003f'dfbf}},
5126 {{0x0000'0000'0021'c1a1, 0x0000'0000'0023'c3a3},
5127 {0x0000'0000'0025'c5a5, 0x0000'0000'0027'c7a7},
5128 {0x0000'0000'0029'c9a9, 0x0000'0000'002b'cbab},
5129 {0x0000'0000'002d'cdad, 0x0000'0000'002f'cfaf},
5130 {0x0000'0000'0031'd1b1, 0x0000'0000'0033'd3b3},
5131 {0x0000'0000'0035'd5b5, 0x0000'0000'0037'd7b7},
5132 {0x0000'0000'0039'd9b9, 0x0000'0000'003b'dbbb},
5133 {0x0000'0000'003d'ddbd, 0x0000'0000'003f'dfbf}},
5134 kVectorCalculationsSource);
5135
5136 TestVectorInstruction(ExecVssrlvi,
5137 ExecMaskedVssrlvi,
5138 {{0, 32, 0, 32, 1, 33, 1, 33, 2, 34, 2, 34, 3, 35, 3, 35},
5139 {4, 36, 4, 36, 5, 37, 5, 37, 6, 38, 6, 38, 7, 39, 7, 39},
5140 {8, 40, 8, 40, 9, 41, 9, 41, 10, 42, 10, 42, 11, 43, 11, 43},
5141 {12, 44, 12, 44, 13, 45, 13, 45, 14, 46, 14, 46, 15, 47, 15, 47},
5142 {16, 48, 16, 48, 17, 49, 17, 49, 18, 50, 18, 50, 19, 51, 19, 51},
5143 {20, 52, 20, 52, 21, 53, 21, 53, 22, 54, 22, 54, 23, 55, 23, 55},
5144 {24, 56, 24, 56, 25, 57, 25, 57, 26, 58, 26, 58, 27, 59, 27, 59},
5145 {28, 60, 28, 60, 29, 61, 29, 61, 30, 62, 30, 62, 31, 63, 31, 63}},
5146 {{0x0020, 0x0020, 0x0021, 0x0021, 0x0022, 0x0022, 0x0023, 0x0023},
5147 {0x0024, 0x0024, 0x0025, 0x0025, 0x0026, 0x0026, 0x0027, 0x0027},
5148 {0x0028, 0x0028, 0x0029, 0x0029, 0x002a, 0x002a, 0x002b, 0x002b},
5149 {0x002c, 0x002c, 0x002d, 0x002d, 0x002e, 0x002e, 0x002f, 0x002f},
5150 {0x0030, 0x0030, 0x0031, 0x0031, 0x0032, 0x0032, 0x0033, 0x0033},
5151 {0x0034, 0x0034, 0x0035, 0x0035, 0x0036, 0x0036, 0x0037, 0x0037},
5152 {0x0038, 0x0038, 0x0039, 0x0039, 0x003a, 0x003a, 0x003b, 0x003b},
5153 {0x003c, 0x003c, 0x003d, 0x003d, 0x003e, 0x003e, 0x003f, 0x003f}},
5154 {{0x0020'c0a0, 0x0021'c1a1, 0x0022'c2a2, 0x0023'c3a3},
5155 {0x0024'c4a4, 0x0025'c5a5, 0x0026'c6a6, 0x0027'c7a7},
5156 {0x0028'c8a8, 0x0029'c9a9, 0x002a'caaa, 0x002b'cbab},
5157 {0x002c'ccac, 0x002d'cdad, 0x002e'ceae, 0x002f'cfaf},
5158 {0x0030'd0b0, 0x0031'd1b1, 0x0032'd2b2, 0x0033'd3b3},
5159 {0x0034'd4b4, 0x0035'd5b5, 0x0036'd6b6, 0x0037'd7b7},
5160 {0x0038'd8b8, 0x0039'd9b9, 0x003a'daba, 0x003b'dbbb},
5161 {0x003c'dcbc, 0x003d'ddbd, 0x003e'debe, 0x003f'dfbf}},
5162 {{0x0021'c1a1'4120'c0a0, 0x0023'c3a3'4322'c2a2},
5163 {0x0025'c5a5'4524'c4a4, 0x0027'c7a7'4726'c6a6},
5164 {0x0029'c9a9'4928'c8a8, 0x002b'cbab'4b2a'caaa},
5165 {0x002d'cdad'4d2c'ccac, 0x002f'cfaf'4f2e'ceae},
5166 {0x0031'd1b1'5130'd0b0, 0x0033'd3b3'5332'd2b2},
5167 {0x0035'd5b5'5534'd4b4, 0x0037'd7b7'5736'd6b6},
5168 {0x0039'd9b9'5938'd8b8, 0x003b'dbbb'5b3a'daba},
5169 {0x003d'ddbd'5d3c'dcbc, 0x003f'dfbf'5f3e'debe}},
5170 kVectorCalculationsSource);
5171 TestVectorInstruction(ExecVssravv,
5172 ExecMaskedVssravv,
5173 {{0, 224, 0, 254, 2, 225, 0, 254, 4, 226, 0, 254, 12, 227, 0, 254},
5174 {16, 228, 1, 254, 10, 229, 1, 254, 12, 230, 1, 254, 28, 231, 1, 254},
5175 {32, 232, 2, 254, 18, 233, 2, 254, 20, 234, 2, 254, 44, 235, 2, 254},
5176 {48, 236, 3, 254, 26, 237, 3, 254, 28, 238, 3, 254, 60, 239, 3, 254},
5177 {64, 240, 4, 255, 34, 241, 4, 255, 36, 242, 4, 255, 76, 243, 4, 255},
5178 {80, 244, 5, 255, 42, 245, 5, 255, 44, 246, 5, 255, 92, 247, 5, 255},
5179 {96, 248, 6, 255, 50, 249, 6, 255, 52, 250, 6, 255, 108, 251, 6, 255},
5180 {112, 252, 7, 255, 58, 253, 7, 255, 60, 254, 7, 255, 124, 255, 7, 255}},
5181 {{0x8100, 0xf830, 0xffc2, 0xfff8, 0xc484, 0xf8b0, 0xff8d, 0xfff8},
5182 {0x9110, 0xf931, 0xffca, 0xfff9, 0xcc8c, 0xf9b1, 0xff9d, 0xfff9},
5183 {0xa120, 0xfa32, 0xffd2, 0xfffa, 0xd494, 0xfab2, 0xffad, 0xfffa},
5184 {0xb130, 0xfb33, 0xffda, 0xfffb, 0xdc9c, 0xfbb3, 0xffbd, 0xfffb},
5185 {0xc140, 0xfc34, 0xffe2, 0xfffc, 0xe4a4, 0xfcb4, 0xffcd, 0xfffc},
5186 {0xd150, 0xfd35, 0xffea, 0xfffd, 0xecac, 0xfdb5, 0xffdd, 0xfffd},
5187 {0xe160, 0xfe36, 0xfff2, 0xfffe, 0xf4b4, 0xfeb6, 0xffed, 0xfffe},
5188 {0xf170, 0xff37, 0xfffa, 0xffff, 0xfcbc, 0xffb7, 0xfffd, 0xffff}},
5189 {{0x8302'8100, 0xffc3'8342, 0xffff'c585, 0xffff'ff8f},
5190 {0x9312'9110, 0xffcb'8b4a, 0xffff'cd8d, 0xffff'ff9f},
5191 {0xa322'a120, 0xffd3'9352, 0xffff'd595, 0xffff'ffaf},
5192 {0xb332'b130, 0xffdb'9b5a, 0xffff'dd9d, 0xffff'ffbf},
5193 {0xc342'c140, 0xffe3'a362, 0xffff'e5a5, 0xffff'ffcf},
5194 {0xd352'd150, 0xffeb'ab6a, 0xffff'edad, 0xffff'ffdf},
5195 {0xe362'e160, 0xfff3'b372, 0xffff'f5b5, 0xffff'ffef},
5196 {0xf372'f170, 0xfffb'bb7a, 0xffff'fdbd, 0xffff'ffff}},
5197 {{0x8706'8504'8302'8100, 0xffff'c787'4686'4585},
5198 {0xffff'ffff'9716'9514, 0xffff'ffff'ffff'cf8f},
5199 {0xa726'a524'a322'a120, 0xffff'd797'5696'5595},
5200 {0xffff'ffff'b736'b534, 0xffff'ffff'ffff'df9f},
5201 {0xc746'c544'c342'c140, 0xffff'e7a7'66a6'65a5},
5202 {0xffff'ffff'd756'd554, 0xffff'ffff'ffff'efaf},
5203 {0xe766'e564'e362'e160, 0xffff'f7b7'76b6'75b5},
5204 {0xffff'ffff'f776'f574, 0xffff'ffff'ffff'ffbf}},
5205 kVectorCalculationsSource);
5206
5207 TestVectorInstruction(ExecVssravx,
5208 ExecMaskedVssravx,
5209 {{0, 224, 0, 224, 1, 225, 1, 225, 2, 226, 2, 226, 3, 227, 3, 227},
5210 {4, 228, 4, 228, 5, 229, 5, 229, 6, 230, 6, 230, 7, 231, 7, 231},
5211 {8, 232, 8, 232, 9, 233, 9, 233, 10, 234, 10, 234, 11, 235, 11, 235},
5212 {12, 236, 12, 236, 13, 237, 13, 237, 14, 238, 14, 238, 15, 239, 15, 239},
5213 {16, 240, 16, 240, 17, 241, 17, 241, 18, 242, 18, 242, 19, 243, 19, 243},
5214 {20, 244, 20, 244, 21, 245, 21, 245, 22, 246, 22, 246, 23, 247, 23, 247},
5215 {24, 248, 24, 248, 25, 249, 25, 249, 26, 250, 26, 250, 27, 251, 27, 251},
5216 {28, 252, 28, 252, 29, 253, 29, 253, 30, 254, 30, 254, 31, 255, 31, 255}},
5217 {{0xffe0, 0xffe0, 0xffe1, 0xffe1, 0xffe2, 0xffe2, 0xffe3, 0xffe3},
5218 {0xffe4, 0xffe4, 0xffe5, 0xffe5, 0xffe6, 0xffe6, 0xffe7, 0xffe7},
5219 {0xffe8, 0xffe8, 0xffe9, 0xffe9, 0xffea, 0xffea, 0xffeb, 0xffeb},
5220 {0xffec, 0xffec, 0xffed, 0xffed, 0xffee, 0xffee, 0xffef, 0xffef},
5221 {0xfff0, 0xfff0, 0xfff1, 0xfff1, 0xfff2, 0xfff2, 0xfff3, 0xfff3},
5222 {0xfff4, 0xfff4, 0xfff5, 0xfff5, 0xfff6, 0xfff6, 0xfff7, 0xfff7},
5223 {0xfff8, 0xfff8, 0xfff9, 0xfff9, 0xfffa, 0xfffa, 0xfffb, 0xfffb},
5224 {0xfffc, 0xfffc, 0xfffd, 0xfffd, 0xfffe, 0xfffe, 0xffff, 0xffff}},
5225 {{0xffe0'c0a0, 0xffe1'c1a1, 0xffe2'c2a2, 0xffe3'c3a3},
5226 {0xffe4'c4a4, 0xffe5'c5a5, 0xffe6'c6a6, 0xffe7'c7a7},
5227 {0xffe8'c8a8, 0xffe9'c9a9, 0xffea'caaa, 0xffeb'cbab},
5228 {0xffec'ccac, 0xffed'cdad, 0xffee'ceae, 0xffef'cfaf},
5229 {0xfff0'd0b0, 0xfff1'd1b1, 0xfff2'd2b2, 0xfff3'd3b3},
5230 {0xfff4'd4b4, 0xfff5'd5b5, 0xfff6'd6b6, 0xfff7'd7b7},
5231 {0xfff8'd8b8, 0xfff9'd9b9, 0xfffa'daba, 0xfffb'dbbb},
5232 {0xfffc'dcbc, 0xfffd'ddbd, 0xfffe'debe, 0xffff'dfbf}},
5233 {{0xffff'ffff'ffe1'c1a1, 0xffff'ffff'ffe3'c3a3},
5234 {0xffff'ffff'ffe5'c5a5, 0xffff'ffff'ffe7'c7a7},
5235 {0xffff'ffff'ffe9'c9a9, 0xffff'ffff'ffeb'cbab},
5236 {0xffff'ffff'ffed'cdad, 0xffff'ffff'ffef'cfaf},
5237 {0xffff'ffff'fff1'd1b1, 0xffff'ffff'fff3'd3b3},
5238 {0xffff'ffff'fff5'd5b5, 0xffff'ffff'fff7'd7b7},
5239 {0xffff'ffff'fff9'd9b9, 0xffff'ffff'fffb'dbbb},
5240 {0xffff'ffff'fffd'ddbd, 0xffff'ffff'ffff'dfbf}},
5241 kVectorCalculationsSource);
5242
5243 TestVectorInstruction(ExecVssravi,
5244 ExecMaskedVssravi,
5245 {{0, 224, 0, 224, 1, 225, 1, 225, 2, 226, 2, 226, 3, 227, 3, 227},
5246 {4, 228, 4, 228, 5, 229, 5, 229, 6, 230, 6, 230, 7, 231, 7, 231},
5247 {8, 232, 8, 232, 9, 233, 9, 233, 10, 234, 10, 234, 11, 235, 11, 235},
5248 {12, 236, 12, 236, 13, 237, 13, 237, 14, 238, 14, 238, 15, 239, 15, 239},
5249 {16, 240, 16, 240, 17, 241, 17, 241, 18, 242, 18, 242, 19, 243, 19, 243},
5250 {20, 244, 20, 244, 21, 245, 21, 245, 22, 246, 22, 246, 23, 247, 23, 247},
5251 {24, 248, 24, 248, 25, 249, 25, 249, 26, 250, 26, 250, 27, 251, 27, 251},
5252 {28, 252, 28, 252, 29, 253, 29, 253, 30, 254, 30, 254, 31, 255, 31, 255}},
5253 {{0xffe0, 0xffe0, 0xffe1, 0xffe1, 0xffe2, 0xffe2, 0xffe3, 0xffe3},
5254 {0xffe4, 0xffe4, 0xffe5, 0xffe5, 0xffe6, 0xffe6, 0xffe7, 0xffe7},
5255 {0xffe8, 0xffe8, 0xffe9, 0xffe9, 0xffea, 0xffea, 0xffeb, 0xffeb},
5256 {0xffec, 0xffec, 0xffed, 0xffed, 0xffee, 0xffee, 0xffef, 0xffef},
5257 {0xfff0, 0xfff0, 0xfff1, 0xfff1, 0xfff2, 0xfff2, 0xfff3, 0xfff3},
5258 {0xfff4, 0xfff4, 0xfff5, 0xfff5, 0xfff6, 0xfff6, 0xfff7, 0xfff7},
5259 {0xfff8, 0xfff8, 0xfff9, 0xfff9, 0xfffa, 0xfffa, 0xfffb, 0xfffb},
5260 {0xfffc, 0xfffc, 0xfffd, 0xfffd, 0xfffe, 0xfffe, 0xffff, 0xffff}},
5261 {{0xffe0'c0a0, 0xffe1'c1a1, 0xffe2'c2a2, 0xffe3'c3a3},
5262 {0xffe4'c4a4, 0xffe5'c5a5, 0xffe6'c6a6, 0xffe7'c7a7},
5263 {0xffe8'c8a8, 0xffe9'c9a9, 0xffea'caaa, 0xffeb'cbab},
5264 {0xffec'ccac, 0xffed'cdad, 0xffee'ceae, 0xffef'cfaf},
5265 {0xfff0'd0b0, 0xfff1'd1b1, 0xfff2'd2b2, 0xfff3'd3b3},
5266 {0xfff4'd4b4, 0xfff5'd5b5, 0xfff6'd6b6, 0xfff7'd7b7},
5267 {0xfff8'd8b8, 0xfff9'd9b9, 0xfffa'daba, 0xfffb'dbbb},
5268 {0xfffc'dcbc, 0xfffd'ddbd, 0xfffe'debe, 0xffff'dfbf}},
5269 {{0xffe1'c1a1'4120'c0a0, 0xffe3'c3a3'4322'c2a2},
5270 {0xffe5'c5a5'4524'c4a4, 0xffe7'c7a7'4726'c6a6},
5271 {0xffe9'c9a9'4928'c8a8, 0xffeb'cbab'4b2a'caaa},
5272 {0xffed'cdad'4d2c'ccac, 0xffef'cfaf'4f2e'ceae},
5273 {0xfff1'd1b1'5130'd0b0, 0xfff3'd3b3'5332'd2b2},
5274 {0xfff5'd5b5'5534'd4b4, 0xfff7'd7b7'5736'd6b6},
5275 {0xfff9'd9b9'5938'd8b8, 0xfffb'dbbb'5b3a'daba},
5276 {0xfffd'ddbd'5d3c'dcbc, 0xffff'dfbf'5f3e'debe}},
5277 kVectorCalculationsSource);
5278 asm volatile("csrw vxrm, %0\n\t" ::"r"(vxrm));
5279 }
5280
TEST(InlineAsmTestRiscv64,TestRNE)5281 TEST(InlineAsmTestRiscv64, TestRNE) {
5282 uint64_t vxrm;
5283 asm volatile(
5284 "csrr %0, vxrm\n\t"
5285 "csrwi vxrm, %c1\n\t"
5286 : "=r"(vxrm)
5287 : "i"(VXRMFlags::RNE));
5288 TestVectorInstruction(
5289 ExecVaadduvv,
5290 ExecMaskedVaadduvv,
5291 {{0, 138, 3, 140, 6, 144, 9, 146, 12, 134, 15, 136, 18, 140, 21, 142},
5292 {24, 162, 27, 164, 30, 168, 33, 170, 36, 158, 39, 160, 42, 164, 45, 166},
5293 {48, 186, 51, 188, 54, 192, 57, 194, 60, 182, 63, 184, 66, 188, 69, 190},
5294 {72, 210, 75, 212, 78, 216, 81, 218, 84, 206, 87, 208, 90, 212, 93, 214},
5295 {96, 106, 99, 108, 102, 112, 105, 114, 108, 102, 111, 104, 114, 108, 117, 110},
5296 {120, 130, 123, 132, 126, 136, 129, 138, 132, 126, 135, 128, 138, 132, 141, 134},
5297 {144, 154, 147, 156, 150, 160, 153, 162, 156, 150, 159, 152, 162, 156, 165, 158},
5298 {168, 178, 171, 180, 174, 184, 177, 186, 180, 174, 183, 176, 186, 180, 189, 182}},
5299 {{0x8980, 0x8c83, 0x8f86, 0x9289, 0x858c, 0x888f, 0x8b92, 0x8e95},
5300 {0xa198, 0xa49b, 0xa79e, 0xaaa1, 0x9da4, 0xa0a7, 0xa3aa, 0xa6ad},
5301 {0xb9b0, 0xbcb3, 0xbfb6, 0xc2b9, 0xb5bc, 0xb8bf, 0xbbc2, 0xbec5},
5302 {0xd1c8, 0xd4cb, 0xd7ce, 0xdad1, 0xcdd4, 0xd0d7, 0xd3da, 0xd6dd},
5303 {0x69e0, 0x6ce3, 0x6fe6, 0x72e9, 0x65ec, 0x68ef, 0x6bf2, 0x6ef5},
5304 {0x81f8, 0x84fb, 0x87fe, 0x8b01, 0x7e04, 0x8107, 0x840a, 0x870d},
5305 {0x9a10, 0x9d13, 0xa016, 0xa319, 0x961c, 0x991f, 0x9c22, 0x9f25},
5306 {0xb228, 0xb52b, 0xb82e, 0xbb31, 0xae34, 0xb137, 0xb43a, 0xb73d}},
5307 {{0x8c83'8980, 0x9289'8f86, 0x888f'858c, 0x8e95'8b92},
5308 {0xa49b'a198, 0xaaa1'a79e, 0xa0a7'9da4, 0xa6ad'a3aa},
5309 {0xbcb3'b9b0, 0xc2b9'bfb6, 0xb8bf'b5bc, 0xbec5'bbc2},
5310 {0xd4cb'd1c8, 0xdad1'd7ce, 0xd0d7'cdd4, 0xd6dd'd3da},
5311 {0x6ce3'69e0, 0x72e9'6fe6, 0x68ef'65ec, 0x6ef5'6bf2},
5312 {0x84fb'81f8, 0x8b01'87fe, 0x8107'7e04, 0x870d'840a},
5313 {0x9d13'9a10, 0xa319'a016, 0x991f'961c, 0x9f25'9c22},
5314 {0xb52b'b228, 0xbb31'b82e, 0xb137'ae34, 0xb73d'b43a}},
5315 {{0x9289'8f87'0c83'8980, 0x8e95'8b92'888f'858c},
5316 {0xaaa1'a79f'249b'a198, 0xa6ad'a3aa'a0a7'9da4},
5317 {0xc2b9'bfb7'3cb3'b9b0, 0xbec5'bbc2'b8bf'b5bc},
5318 {0xdad1'd7cf'54cb'd1c8, 0xd6dd'd3da'd0d7'cdd4},
5319 {0x72e9'6fe6'ece3'69e0, 0x6ef5'6bf2'68ef'65ec},
5320 {0x8b01'87ff'04fb'81f8, 0x870d'840a'8107'7e04},
5321 {0xa319'a017'1d13'9a10, 0x9f25'9c22'991f'961c},
5322 {0xbb31'b82f'352b'b228, 0xb73d'b43a'b137'ae34}},
5323 kVectorCalculationsSource);
5324 TestVectorInstruction(
5325 ExecVaadduvx,
5326 ExecMaskedVaadduvx,
5327 {{85, 150, 86, 150, 87, 152, 88, 152, 89, 154, 90, 154, 91, 156, 92, 156},
5328 {93, 158, 94, 158, 95, 160, 96, 160, 97, 162, 98, 162, 99, 164, 100, 164},
5329 {101, 166, 102, 166, 103, 168, 104, 168, 105, 170, 106, 170, 107, 172, 108, 172},
5330 {109, 174, 110, 174, 111, 176, 112, 176, 113, 178, 114, 178, 115, 180, 116, 180},
5331 {117, 182, 118, 182, 119, 184, 120, 184, 121, 186, 122, 186, 123, 188, 124, 188},
5332 {125, 190, 126, 190, 127, 192, 128, 192, 129, 194, 130, 194, 131, 196, 132, 196},
5333 {133, 198, 134, 198, 135, 200, 136, 200, 137, 202, 138, 202, 139, 204, 140, 204},
5334 {141, 206, 142, 206, 143, 208, 144, 208, 145, 210, 146, 210, 147, 212, 148, 212}},
5335 {{0x95d5, 0x96d6, 0x97d7, 0x98d8, 0x99d9, 0x9ada, 0x9bdb, 0x9cdc},
5336 {0x9ddd, 0x9ede, 0x9fdf, 0xa0e0, 0xa1e1, 0xa2e2, 0xa3e3, 0xa4e4},
5337 {0xa5e5, 0xa6e6, 0xa7e7, 0xa8e8, 0xa9e9, 0xaaea, 0xabeb, 0xacec},
5338 {0xaded, 0xaeee, 0xafef, 0xb0f0, 0xb1f1, 0xb2f2, 0xb3f3, 0xb4f4},
5339 {0xb5f5, 0xb6f6, 0xb7f7, 0xb8f8, 0xb9f9, 0xbafa, 0xbbfb, 0xbcfc},
5340 {0xbdfd, 0xbefe, 0xbfff, 0xc100, 0xc201, 0xc302, 0xc403, 0xc504},
5341 {0xc605, 0xc706, 0xc807, 0xc908, 0xca09, 0xcb0a, 0xcc0b, 0xcd0c},
5342 {0xce0d, 0xcf0e, 0xd00f, 0xd110, 0xd211, 0xd312, 0xd413, 0xd514}},
5343 {{0x96d6'95d5, 0x98d8'97d7, 0x9ada'99d9, 0x9cdc'9bdb},
5344 {0x9ede'9ddd, 0xa0e0'9fdf, 0xa2e2'a1e1, 0xa4e4'a3e3},
5345 {0xa6e6'a5e5, 0xa8e8'a7e7, 0xaaea'a9e9, 0xacec'abeb},
5346 {0xaeee'aded, 0xb0f0'afef, 0xb2f2'b1f1, 0xb4f4'b3f3},
5347 {0xb6f6'b5f5, 0xb8f8'b7f7, 0xbafa'b9f9, 0xbcfc'bbfb},
5348 {0xbefe'bdfd, 0xc100'bfff, 0xc302'c201, 0xc504'c403},
5349 {0xc706'c605, 0xc908'c807, 0xcb0a'ca09, 0xcd0c'cc0b},
5350 {0xcf0e'ce0d, 0xd110'd00f, 0xd312'd211, 0xd514'd413}},
5351 {{0x98d8'97d7'96d6'95d5, 0x9cdc'9bdb'9ada'99d9},
5352 {0xa0e0'9fdf'9ede'9ddd, 0xa4e4'a3e3'a2e2'a1e1},
5353 {0xa8e8'a7e7'a6e6'a5e5, 0xacec'abeb'aaea'a9e9},
5354 {0xb0f0'afef'aeee'aded, 0xb4f4'b3f3'b2f2'b1f1},
5355 {0xb8f8'b7f7'b6f6'b5f5, 0xbcfc'bbfb'bafa'b9f9},
5356 {0xc100'bfff'befe'bdfd, 0xc504'c403'c302'c201},
5357 {0xc908'c807'c706'c605, 0xcd0c'cc0b'cb0a'ca09},
5358 {0xd110'd00f'cf0e'ce0d, 0xd514'd413'd312'd211}},
5359 kVectorCalculationsSource);
5360 TestVectorInstruction(
5361 ExecVaaddvv,
5362 ExecMaskedVaaddvv,
5363 {{0, 138, 3, 140, 6, 144, 9, 146, 12, 134, 15, 136, 18, 140, 21, 142},
5364 {24, 162, 27, 164, 30, 168, 33, 170, 36, 158, 39, 160, 42, 164, 45, 166},
5365 {48, 186, 51, 188, 54, 192, 57, 194, 60, 182, 63, 184, 66, 188, 69, 190},
5366 {72, 210, 75, 212, 78, 216, 81, 218, 84, 206, 87, 208, 90, 212, 93, 214},
5367 {224, 234, 227, 236, 230, 240, 233, 242, 236, 230, 239, 232, 242, 236, 245, 238},
5368 {248, 2, 251, 4, 254, 8, 1, 10, 4, 254, 7, 0, 10, 4, 13, 6},
5369 {16, 26, 19, 28, 22, 32, 25, 34, 28, 22, 31, 24, 34, 28, 37, 30},
5370 {40, 50, 43, 52, 46, 56, 49, 58, 52, 46, 55, 48, 58, 52, 61, 54}},
5371 {{0x8980, 0x8c83, 0x8f86, 0x9289, 0x858c, 0x888f, 0x8b92, 0x8e95},
5372 {0xa198, 0xa49b, 0xa79e, 0xaaa1, 0x9da4, 0xa0a7, 0xa3aa, 0xa6ad},
5373 {0xb9b0, 0xbcb3, 0xbfb6, 0xc2b9, 0xb5bc, 0xb8bf, 0xbbc2, 0xbec5},
5374 {0xd1c8, 0xd4cb, 0xd7ce, 0xdad1, 0xcdd4, 0xd0d7, 0xd3da, 0xd6dd},
5375 {0xe9e0, 0xece3, 0xefe6, 0xf2e9, 0xe5ec, 0xe8ef, 0xebf2, 0xeef5},
5376 {0x01f8, 0x04fb, 0x07fe, 0x0b01, 0xfe04, 0x0107, 0x040a, 0x070d},
5377 {0x1a10, 0x1d13, 0x2016, 0x2319, 0x161c, 0x191f, 0x1c22, 0x1f25},
5378 {0x3228, 0x352b, 0x382e, 0x3b31, 0x2e34, 0x3137, 0x343a, 0x373d}},
5379 {{0x8c83'8980, 0x9289'8f86, 0x888f'858c, 0x8e95'8b92},
5380 {0xa49b'a198, 0xaaa1'a79e, 0xa0a7'9da4, 0xa6ad'a3aa},
5381 {0xbcb3'b9b0, 0xc2b9'bfb6, 0xb8bf'b5bc, 0xbec5'bbc2},
5382 {0xd4cb'd1c8, 0xdad1'd7ce, 0xd0d7'cdd4, 0xd6dd'd3da},
5383 {0xece3'69e0, 0xf2e9'6fe6, 0xe8ef'65ec, 0xeef5'6bf2},
5384 {0x04fb'81f8, 0x0b01'87fe, 0x0107'7e04, 0x070d'840a},
5385 {0x1d13'9a10, 0x2319'a016, 0x191f'961c, 0x1f25'9c22},
5386 {0x352b'b228, 0x3b31'b82e, 0x3137'ae34, 0x373d'b43a}},
5387 {{0x9289'8f87'0c83'8980, 0x8e95'8b92'888f'858c},
5388 {0xaaa1'a79f'249b'a198, 0xa6ad'a3aa'a0a7'9da4},
5389 {0xc2b9'bfb7'3cb3'b9b0, 0xbec5'bbc2'b8bf'b5bc},
5390 {0xdad1'd7cf'54cb'd1c8, 0xd6dd'd3da'd0d7'cdd4},
5391 {0xf2e9'6fe6'ece3'69e0, 0xeef5'6bf2'68ef'65ec},
5392 {0x0b01'87ff'04fb'81f8, 0x070d'840a'8107'7e04},
5393 {0x2319'a017'1d13'9a10, 0x1f25'9c22'991f'961c},
5394 {0x3b31'b82f'352b'b228, 0x373d'b43a'b137'ae34}},
5395 kVectorCalculationsSource);
5396 TestVectorInstruction(
5397 ExecVaaddvx,
5398 ExecMaskedVaaddvx,
5399 {{213, 150, 214, 150, 215, 152, 216, 152, 217, 154, 218, 154, 219, 156, 220, 156},
5400 {221, 158, 222, 158, 223, 160, 224, 160, 225, 162, 226, 162, 227, 164, 228, 164},
5401 {229, 166, 230, 166, 231, 168, 232, 168, 233, 170, 234, 170, 235, 172, 236, 172},
5402 {237, 174, 238, 174, 239, 176, 240, 176, 241, 178, 242, 178, 243, 180, 244, 180},
5403 {245, 182, 246, 182, 247, 184, 248, 184, 249, 186, 250, 186, 251, 188, 252, 188},
5404 {253, 190, 254, 190, 255, 192, 0, 192, 1, 194, 2, 194, 3, 196, 4, 196},
5405 {5, 198, 6, 198, 7, 200, 8, 200, 9, 202, 10, 202, 11, 204, 12, 204},
5406 {13, 206, 14, 206, 15, 208, 16, 208, 17, 210, 18, 210, 19, 212, 20, 212}},
5407 {{0x95d5, 0x96d6, 0x97d7, 0x98d8, 0x99d9, 0x9ada, 0x9bdb, 0x9cdc},
5408 {0x9ddd, 0x9ede, 0x9fdf, 0xa0e0, 0xa1e1, 0xa2e2, 0xa3e3, 0xa4e4},
5409 {0xa5e5, 0xa6e6, 0xa7e7, 0xa8e8, 0xa9e9, 0xaaea, 0xabeb, 0xacec},
5410 {0xaded, 0xaeee, 0xafef, 0xb0f0, 0xb1f1, 0xb2f2, 0xb3f3, 0xb4f4},
5411 {0xb5f5, 0xb6f6, 0xb7f7, 0xb8f8, 0xb9f9, 0xbafa, 0xbbfb, 0xbcfc},
5412 {0xbdfd, 0xbefe, 0xbfff, 0xc100, 0xc201, 0xc302, 0xc403, 0xc504},
5413 {0xc605, 0xc706, 0xc807, 0xc908, 0xca09, 0xcb0a, 0xcc0b, 0xcd0c},
5414 {0xce0d, 0xcf0e, 0xd00f, 0xd110, 0xd211, 0xd312, 0xd413, 0xd514}},
5415 {{0x96d6'95d5, 0x98d8'97d7, 0x9ada'99d9, 0x9cdc'9bdb},
5416 {0x9ede'9ddd, 0xa0e0'9fdf, 0xa2e2'a1e1, 0xa4e4'a3e3},
5417 {0xa6e6'a5e5, 0xa8e8'a7e7, 0xaaea'a9e9, 0xacec'abeb},
5418 {0xaeee'aded, 0xb0f0'afef, 0xb2f2'b1f1, 0xb4f4'b3f3},
5419 {0xb6f6'b5f5, 0xb8f8'b7f7, 0xbafa'b9f9, 0xbcfc'bbfb},
5420 {0xbefe'bdfd, 0xc100'bfff, 0xc302'c201, 0xc504'c403},
5421 {0xc706'c605, 0xc908'c807, 0xcb0a'ca09, 0xcd0c'cc0b},
5422 {0xcf0e'ce0d, 0xd110'd00f, 0xd312'd211, 0xd514'd413}},
5423 {{0x98d8'97d7'96d6'95d5, 0x9cdc'9bdb'9ada'99d9},
5424 {0xa0e0'9fdf'9ede'9ddd, 0xa4e4'a3e3'a2e2'a1e1},
5425 {0xa8e8'a7e7'a6e6'a5e5, 0xacec'abeb'aaea'a9e9},
5426 {0xb0f0'afef'aeee'aded, 0xb4f4'b3f3'b2f2'b1f1},
5427 {0xb8f8'b7f7'b6f6'b5f5, 0xbcfc'bbfb'bafa'b9f9},
5428 {0xc100'bfff'befe'bdfd, 0xc504'c403'c302'c201},
5429 {0xc908'c807'c706'c605, 0xcd0c'cc0b'cb0a'ca09},
5430 {0xd110'd00f'cf0e'ce0d, 0xd514'd413'd312'd211}},
5431 kVectorCalculationsSource);
5432 TestVectorInstruction(
5433 ExecVasubuvv,
5434 ExecMaskedVasubuvv,
5435 {{0, 248, 255, 246, 254, 246, 253, 244, 252, 4, 251, 2, 250, 2, 249, 0},
5436 {248, 240, 247, 238, 246, 238, 245, 236, 244, 252, 243, 250, 242, 250, 241, 248},
5437 {240, 232, 239, 230, 238, 230, 237, 228, 236, 244, 235, 242, 234, 242, 233, 240},
5438 {232, 224, 231, 222, 230, 222, 229, 220, 228, 236, 227, 234, 226, 234, 225, 232},
5439 {224, 88, 223, 86, 222, 86, 221, 84, 220, 100, 219, 98, 218, 98, 217, 96},
5440 {216, 80, 215, 78, 214, 78, 213, 76, 212, 92, 211, 90, 210, 90, 209, 88},
5441 {208, 72, 207, 70, 206, 70, 205, 68, 204, 84, 203, 82, 202, 82, 201, 80},
5442 {200, 64, 199, 62, 198, 62, 197, 60, 196, 76, 195, 74, 194, 74, 193, 72}},
5443 {{0xf780, 0xf67f, 0xf57e, 0xf47d, 0x037c, 0x027b, 0x017a, 0x0079},
5444 {0xef78, 0xee77, 0xed76, 0xec75, 0xfb74, 0xfa73, 0xf972, 0xf871},
5445 {0xe770, 0xe66f, 0xe56e, 0xe46d, 0xf36c, 0xf26b, 0xf16a, 0xf069},
5446 {0xdf68, 0xde67, 0xdd66, 0xdc65, 0xeb64, 0xea63, 0xe962, 0xe861},
5447 {0x5760, 0x565f, 0x555e, 0x545d, 0x635c, 0x625b, 0x615a, 0x6059},
5448 {0x4f58, 0x4e57, 0x4d56, 0x4c55, 0x5b54, 0x5a53, 0x5952, 0x5851},
5449 {0x4750, 0x464f, 0x454e, 0x444d, 0x534c, 0x524b, 0x514a, 0x5049},
5450 {0x3f48, 0x3e47, 0x3d46, 0x3c45, 0x4b44, 0x4a43, 0x4942, 0x4841}},
5451 {{0xf67e'f780, 0xf47c'f57e, 0x027b'037c, 0x0079'017a},
5452 {0xee76'ef78, 0xec74'ed76, 0xfa72'fb74, 0xf870'f972},
5453 {0xe66e'e770, 0xe46c'e56e, 0xf26a'f36c, 0xf068'f16a},
5454 {0xde66'df68, 0xdc64'dd66, 0xea62'eb64, 0xe860'e962},
5455 {0x565f'5760, 0x545d'555e, 0x625b'635c, 0x6059'615a},
5456 {0x4e57'4f58, 0x4c55'4d56, 0x5a53'5b54, 0x5851'5952},
5457 {0x464f'4750, 0x444d'454e, 0x524b'534c, 0x5049'514a},
5458 {0x3e47'3f48, 0x3c45'3d46, 0x4a43'4b44, 0x4841'4942}},
5459 {{0xf47c'f57d'767e'f780, 0x0079'017a'027b'037c},
5460 {0xec74'ed75'6e76'ef78, 0xf870'f971'fa72'fb74},
5461 {0xe46c'e56d'666e'e770, 0xf068'f169'f26a'f36c},
5462 {0xdc64'dd65'5e66'df68, 0xe860'e961'ea62'eb64},
5463 {0x545d'555d'd65f'5760, 0x6059'615a'625b'635c},
5464 {0x4c55'4d55'ce57'4f58, 0x5851'5952'5a53'5b54},
5465 {0x444d'454d'c64f'4750, 0x5049'514a'524b'534c},
5466 {0x3c45'3d45'be47'3f48, 0x4841'4942'4a43'4b44}},
5467 kVectorCalculationsSource);
5468 TestVectorInstruction(
5469 ExecVasubuvx,
5470 ExecMaskedVasubuvx,
5471 {{171, 236, 172, 236, 173, 238, 174, 238, 175, 240, 176, 240, 177, 242, 178, 242},
5472 {179, 244, 180, 244, 181, 246, 182, 246, 183, 248, 184, 248, 185, 250, 186, 250},
5473 {187, 252, 188, 252, 189, 254, 190, 254, 191, 0, 192, 0, 193, 2, 194, 2},
5474 {195, 4, 196, 4, 197, 6, 198, 6, 199, 8, 200, 8, 201, 10, 202, 10},
5475 {203, 12, 204, 12, 205, 14, 206, 14, 207, 16, 208, 16, 209, 18, 210, 18},
5476 {211, 20, 212, 20, 213, 22, 214, 22, 215, 24, 216, 24, 217, 26, 218, 26},
5477 {219, 28, 220, 28, 221, 30, 222, 30, 223, 32, 224, 32, 225, 34, 226, 34},
5478 {227, 36, 228, 36, 229, 38, 230, 38, 231, 40, 232, 40, 233, 42, 234, 42}},
5479 {{0xeb2b, 0xec2c, 0xed2d, 0xee2e, 0xef2f, 0xf030, 0xf131, 0xf232},
5480 {0xf333, 0xf434, 0xf535, 0xf636, 0xf737, 0xf838, 0xf939, 0xfa3a},
5481 {0xfb3b, 0xfc3c, 0xfd3d, 0xfe3e, 0xff3f, 0x0040, 0x0141, 0x0242},
5482 {0x0343, 0x0444, 0x0545, 0x0646, 0x0747, 0x0848, 0x0949, 0x0a4a},
5483 {0x0b4b, 0x0c4c, 0x0d4d, 0x0e4e, 0x0f4f, 0x1050, 0x1151, 0x1252},
5484 {0x1353, 0x1454, 0x1555, 0x1656, 0x1757, 0x1858, 0x1959, 0x1a5a},
5485 {0x1b5b, 0x1c5c, 0x1d5d, 0x1e5e, 0x1f5f, 0x2060, 0x2161, 0x2262},
5486 {0x2363, 0x2464, 0x2565, 0x2666, 0x2767, 0x2868, 0x2969, 0x2a6a}},
5487 {{0xec2b'eb2b, 0xee2d'ed2d, 0xf02f'ef2f, 0xf231'f131},
5488 {0xf433'f333, 0xf635'f535, 0xf837'f737, 0xfa39'f939},
5489 {0xfc3b'fb3b, 0xfe3d'fd3d, 0x003f'ff3f, 0x0242'0141},
5490 {0x0444'0343, 0x0646'0545, 0x0848'0747, 0x0a4a'0949},
5491 {0x0c4c'0b4b, 0x0e4e'0d4d, 0x1050'0f4f, 0x1252'1151},
5492 {0x1454'1353, 0x1656'1555, 0x1858'1757, 0x1a5a'1959},
5493 {0x1c5c'1b5b, 0x1e5e'1d5d, 0x2060'1f5f, 0x2262'2161},
5494 {0x2464'2363, 0x2666'2565, 0x2868'2767, 0x2a6a'2969}},
5495 {{0xee2d'ed2c'ec2b'eb2b, 0xf231'f130'f02f'ef2f},
5496 {0xf635'f534'f433'f333, 0xfa39'f938'f837'f737},
5497 {0xfe3d'fd3c'fc3b'fb3b, 0x0242'0141'003f'ff3f},
5498 {0x0646'0545'0444'0343, 0x0a4a'0949'0848'0747},
5499 {0x0e4e'0d4d'0c4c'0b4b, 0x1252'1151'1050'0f4f},
5500 {0x1656'1555'1454'1353, 0x1a5a'1959'1858'1757},
5501 {0x1e5e'1d5d'1c5c'1b5b, 0x2262'2161'2060'1f5f},
5502 {0x2666'2565'2464'2363, 0x2a6a'2969'2868'2767}},
5503 kVectorCalculationsSource);
5504 TestVectorInstruction(
5505 ExecVasubvv,
5506 ExecMaskedVasubvv,
5507 {{0, 248, 255, 246, 254, 246, 253, 244, 252, 4, 251, 2, 250, 2, 249, 0},
5508 {248, 240, 247, 238, 246, 238, 245, 236, 244, 252, 243, 250, 242, 250, 241, 248},
5509 {240, 232, 239, 230, 238, 230, 237, 228, 236, 244, 235, 242, 234, 242, 233, 240},
5510 {232, 224, 231, 222, 230, 222, 229, 220, 228, 236, 227, 234, 226, 234, 225, 232},
5511 {96, 216, 95, 214, 94, 214, 93, 212, 92, 228, 91, 226, 90, 226, 89, 224},
5512 {88, 208, 87, 206, 86, 206, 85, 204, 84, 220, 83, 218, 82, 218, 81, 216},
5513 {80, 200, 79, 198, 78, 198, 77, 196, 76, 212, 75, 210, 74, 210, 73, 208},
5514 {72, 192, 71, 190, 70, 190, 69, 188, 68, 204, 67, 202, 66, 202, 65, 200}},
5515 {{0xf780, 0xf67f, 0xf57e, 0xf47d, 0x037c, 0x027b, 0x017a, 0x0079},
5516 {0xef78, 0xee77, 0xed76, 0xec75, 0xfb74, 0xfa73, 0xf972, 0xf871},
5517 {0xe770, 0xe66f, 0xe56e, 0xe46d, 0xf36c, 0xf26b, 0xf16a, 0xf069},
5518 {0xdf68, 0xde67, 0xdd66, 0xdc65, 0xeb64, 0xea63, 0xe962, 0xe861},
5519 {0xd760, 0xd65f, 0xd55e, 0xd45d, 0xe35c, 0xe25b, 0xe15a, 0xe059},
5520 {0xcf58, 0xce57, 0xcd56, 0xcc55, 0xdb54, 0xda53, 0xd952, 0xd851},
5521 {0xc750, 0xc64f, 0xc54e, 0xc44d, 0xd34c, 0xd24b, 0xd14a, 0xd049},
5522 {0xbf48, 0xbe47, 0xbd46, 0xbc45, 0xcb44, 0xca43, 0xc942, 0xc841}},
5523 {{0xf67e'f780, 0xf47c'f57e, 0x027b'037c, 0x0079'017a},
5524 {0xee76'ef78, 0xec74'ed76, 0xfa72'fb74, 0xf870'f972},
5525 {0xe66e'e770, 0xe46c'e56e, 0xf26a'f36c, 0xf068'f16a},
5526 {0xde66'df68, 0xdc64'dd66, 0xea62'eb64, 0xe860'e962},
5527 {0xd65f'5760, 0xd45d'555e, 0xe25b'635c, 0xe059'615a},
5528 {0xce57'4f58, 0xcc55'4d56, 0xda53'5b54, 0xd851'5952},
5529 {0xc64f'4750, 0xc44d'454e, 0xd24b'534c, 0xd049'514a},
5530 {0xbe47'3f48, 0xbc45'3d46, 0xca43'4b44, 0xc841'4942}},
5531 {{0xf47c'f57d'767e'f780, 0x0079'017a'027b'037c},
5532 {0xec74'ed75'6e76'ef78, 0xf870'f971'fa72'fb74},
5533 {0xe46c'e56d'666e'e770, 0xf068'f169'f26a'f36c},
5534 {0xdc64'dd65'5e66'df68, 0xe860'e961'ea62'eb64},
5535 {0xd45d'555d'd65f'5760, 0xe059'615a'625b'635c},
5536 {0xcc55'4d55'ce57'4f58, 0xd851'5952'5a53'5b54},
5537 {0xc44d'454d'c64f'4750, 0xd049'514a'524b'534c},
5538 {0xbc45'3d45'be47'3f48, 0xc841'4942'4a43'4b44}},
5539 kVectorCalculationsSource);
5540 TestVectorInstruction(ExecVasubvx,
5541 ExecMaskedVasubvx,
5542 {{43, 236, 44, 236, 45, 238, 46, 238, 47, 240, 48, 240, 49, 242, 50, 242},
5543 {51, 244, 52, 244, 53, 246, 54, 246, 55, 248, 56, 248, 57, 250, 58, 250},
5544 {59, 252, 60, 252, 61, 254, 62, 254, 63, 0, 64, 0, 65, 2, 66, 2},
5545 {67, 4, 68, 4, 69, 6, 70, 6, 71, 8, 72, 8, 73, 10, 74, 10},
5546 {75, 12, 76, 12, 77, 14, 78, 14, 79, 16, 80, 16, 81, 18, 82, 18},
5547 {83, 20, 84, 20, 85, 22, 86, 22, 87, 24, 88, 24, 89, 26, 90, 26},
5548 {91, 28, 92, 28, 93, 30, 94, 30, 95, 32, 96, 32, 97, 34, 98, 34},
5549 {99, 36, 100, 36, 101, 38, 102, 38, 103, 40, 104, 40, 105, 42, 106, 42}},
5550 {{0xeb2b, 0xec2c, 0xed2d, 0xee2e, 0xef2f, 0xf030, 0xf131, 0xf232},
5551 {0xf333, 0xf434, 0xf535, 0xf636, 0xf737, 0xf838, 0xf939, 0xfa3a},
5552 {0xfb3b, 0xfc3c, 0xfd3d, 0xfe3e, 0xff3f, 0x0040, 0x0141, 0x0242},
5553 {0x0343, 0x0444, 0x0545, 0x0646, 0x0747, 0x0848, 0x0949, 0x0a4a},
5554 {0x0b4b, 0x0c4c, 0x0d4d, 0x0e4e, 0x0f4f, 0x1050, 0x1151, 0x1252},
5555 {0x1353, 0x1454, 0x1555, 0x1656, 0x1757, 0x1858, 0x1959, 0x1a5a},
5556 {0x1b5b, 0x1c5c, 0x1d5d, 0x1e5e, 0x1f5f, 0x2060, 0x2161, 0x2262},
5557 {0x2363, 0x2464, 0x2565, 0x2666, 0x2767, 0x2868, 0x2969, 0x2a6a}},
5558 {{0xec2b'eb2b, 0xee2d'ed2d, 0xf02f'ef2f, 0xf231'f131},
5559 {0xf433'f333, 0xf635'f535, 0xf837'f737, 0xfa39'f939},
5560 {0xfc3b'fb3b, 0xfe3d'fd3d, 0x003f'ff3f, 0x0242'0141},
5561 {0x0444'0343, 0x0646'0545, 0x0848'0747, 0x0a4a'0949},
5562 {0x0c4c'0b4b, 0x0e4e'0d4d, 0x1050'0f4f, 0x1252'1151},
5563 {0x1454'1353, 0x1656'1555, 0x1858'1757, 0x1a5a'1959},
5564 {0x1c5c'1b5b, 0x1e5e'1d5d, 0x2060'1f5f, 0x2262'2161},
5565 {0x2464'2363, 0x2666'2565, 0x2868'2767, 0x2a6a'2969}},
5566 {{0xee2d'ed2c'ec2b'eb2b, 0xf231'f130'f02f'ef2f},
5567 {0xf635'f534'f433'f333, 0xfa39'f938'f837'f737},
5568 {0xfe3d'fd3c'fc3b'fb3b, 0x0242'0141'003f'ff3f},
5569 {0x0646'0545'0444'0343, 0x0a4a'0949'0848'0747},
5570 {0x0e4e'0d4d'0c4c'0b4b, 0x1252'1151'1050'0f4f},
5571 {0x1656'1555'1454'1353, 0x1a5a'1959'1858'1757},
5572 {0x1e5e'1d5d'1c5c'1b5b, 0x2262'2161'2060'1f5f},
5573 {0x2666'2565'2464'2363, 0x2a6a'2969'2868'2767}},
5574 kVectorCalculationsSource);
5575 TestNarrowingVectorInstruction(ExecVnclipuwi,
5576 ExecMaskedVnclipuwi,
5577 {{32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37, 38, 38, 39, 39, 40},
5578 {40, 41, 41, 42, 42, 43, 43, 44, 44, 45, 45, 46, 46, 47, 47, 48},
5579 {48, 49, 49, 50, 50, 51, 51, 52, 52, 53, 53, 54, 54, 55, 55, 56},
5580 {56, 57, 57, 58, 58, 59, 59, 60, 60, 61, 61, 62, 62, 63, 63, 64}},
5581 {{0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
5582 {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
5583 {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
5584 {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff}},
5585 {{0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff},
5586 {0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff},
5587 {0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff},
5588 {0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff}},
5589 kVectorCalculationsSource);
5590 TestNarrowingVectorInstruction(
5591 ExecVnclipwi,
5592 ExecMaskedVnclipwi,
5593 {{224, 225, 225, 226, 226, 227, 227, 228, 228, 229, 229, 230, 230, 231, 231, 232},
5594 {232, 233, 233, 234, 234, 235, 235, 236, 236, 237, 237, 238, 238, 239, 239, 240},
5595 {240, 241, 241, 242, 242, 243, 243, 244, 244, 245, 245, 246, 246, 247, 247, 248},
5596 {248, 249, 249, 250, 250, 251, 251, 252, 252, 253, 253, 254, 254, 255, 255, 0}},
5597 {{0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000},
5598 {0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000},
5599 {0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000},
5600 {0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0xdfbf}},
5601 {{0x8000'0000, 0x8000'0000, 0x8000'0000, 0x8000'0000},
5602 {0x8000'0000, 0x8000'0000, 0x8000'0000, 0x8000'0000},
5603 {0x8000'0000, 0x8000'0000, 0x8000'0000, 0x8000'0000},
5604 {0x8000'0000, 0x8000'0000, 0x8000'0000, 0x8000'0000}},
5605 kVectorCalculationsSource);
5606
5607 TestNarrowingVectorInstruction(ExecVnclipuwx,
5608 ExecMaskedVnclipuwx,
5609 {{32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37, 38, 38, 39, 39, 40},
5610 {40, 41, 41, 42, 42, 43, 43, 44, 44, 45, 45, 46, 46, 47, 47, 48},
5611 {48, 49, 49, 50, 50, 51, 51, 52, 52, 53, 53, 54, 54, 55, 55, 56},
5612 {56, 57, 57, 58, 58, 59, 59, 60, 60, 61, 61, 62, 62, 63, 63, 64}},
5613 {{0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
5614 {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
5615 {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
5616 {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff}},
5617 {{0x0021'c1a1, 0x0023'c3a3, 0x0025'c5a5, 0x0027'c7a7},
5618 {0x0029'c9a9, 0x002b'cbab, 0x002d'cdad, 0x002f'cfaf},
5619 {0x0031'd1b1, 0x0033'd3b3, 0x0035'd5b5, 0x0037'd7b7},
5620 {0x0039'd9b9, 0x003b'dbbb, 0x003d'ddbd, 0x003f'dfbf}},
5621 kVectorCalculationsSource);
5622
5623 TestNarrowingVectorInstruction(
5624 ExecVnclipwx,
5625 ExecMaskedVnclipwx,
5626 {{224, 225, 225, 226, 226, 227, 227, 228, 228, 229, 229, 230, 230, 231, 231, 232},
5627 {232, 233, 233, 234, 234, 235, 235, 236, 236, 237, 237, 238, 238, 239, 239, 240},
5628 {240, 241, 241, 242, 242, 243, 243, 244, 244, 245, 245, 246, 246, 247, 247, 248},
5629 {248, 249, 249, 250, 250, 251, 251, 252, 252, 253, 253, 254, 254, 255, 255, 0}},
5630 {{0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000},
5631 {0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000},
5632 {0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000},
5633 {0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0xdfbf}},
5634 {{0xffe1'c1a1, 0xffe3'c3a3, 0xffe5'c5a5, 0xffe7'c7a7},
5635 {0xffe9'c9a9, 0xffeb'cbab, 0xffed'cdad, 0xffef'cfaf},
5636 {0xfff1'd1b1, 0xfff3'd3b3, 0xfff5'd5b5, 0xfff7'd7b7},
5637 {0xfff9'd9b9, 0xfffb'dbbb, 0xfffd'ddbd, 0xffff'dfbf}},
5638 kVectorCalculationsSource);
5639
5640 TestNarrowingVectorInstruction(
5641 ExecVnclipuwv,
5642 ExecMaskedVnclipuwv,
5643 {{255, 255, 255, 255, 69, 35, 9, 2, 255, 255, 255, 255, 153, 39, 10, 2},
5644 {255, 255, 255, 255, 85, 43, 11, 3, 255, 255, 255, 255, 185, 47, 12, 3},
5645 {255, 255, 255, 255, 101, 51, 13, 3, 255, 255, 255, 255, 217, 55, 14, 3},
5646 {255, 255, 255, 255, 117, 59, 15, 4, 255, 255, 255, 255, 249, 63, 16, 4}},
5647 {{0xffff, 0xffff, 0xffff, 0xffff, 0x4989, 0x0971, 0x009b, 0x000a},
5648 {0xffff, 0xffff, 0xffff, 0xffff, 0x5999, 0x0b73, 0x00bb, 0x000c},
5649 {0xffff, 0xffff, 0xffff, 0xffff, 0x69a9, 0x0d75, 0x00db, 0x000e},
5650 {0xffff, 0xffff, 0xffff, 0xffff, 0x79b9, 0x0f77, 0x00fb, 0x0010}},
5651 {{0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff},
5652 {0xa726'a525, 0x0057'9757, 0x0000'5b9b, 0x0000'00bf},
5653 {0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff},
5654 {0xe766'e565, 0x0077'b777, 0x0000'7bbb, 0x0000'00ff}},
5655 kVectorCalculationsSource);
5656
5657 TestNarrowingVectorInstruction(
5658 ExecVnclipwv,
5659 ExecMaskedVnclipwv,
5660 {{128, 128, 128, 128, 197, 227, 249, 254, 128, 128, 128, 128, 153, 231, 250, 254},
5661 {128, 128, 128, 128, 213, 235, 251, 255, 128, 128, 128, 128, 185, 239, 252, 255},
5662 {128, 128, 128, 128, 229, 243, 253, 255, 128, 128, 128, 128, 217, 247, 254, 255},
5663 {128, 128, 128, 158, 245, 251, 255, 0, 128, 128, 128, 222, 249, 255, 0, 0}},
5664 {{0x8000, 0x8000, 0x8000, 0x8000, 0xc989, 0xf971, 0xff9b, 0xfffa},
5665 {0x8000, 0x8000, 0x8000, 0x8000, 0xd999, 0xfb73, 0xffbb, 0xfffc},
5666 {0x8000, 0x8000, 0x8000, 0x8000, 0xe9a9, 0xfd75, 0xffdb, 0xfffe},
5667 {0x8000, 0x8000, 0x8000, 0x8000, 0xf9b9, 0xff77, 0xfffb, 0x0000}},
5668 {{0x8000'0000, 0x8000'0000, 0x8000'0000, 0x8000'0000},
5669 {0xa726'a525, 0xffd7'9757, 0xffff'db9b, 0xffff'ffbf},
5670 {0x8000'0000, 0x8000'0000, 0x8000'0000, 0x8000'0000},
5671 {0xe766'e565, 0xfff7'b777, 0xffff'fbbb, 0xffff'ffff}},
5672 kVectorCalculationsSource);
5673
5674 TestVectorInstruction(
5675 ExecVsmulvv,
5676 ExecMaskedVsmulvv,
5677 {{0, 109, 0, 104, 0, 98, 1, 93, 1, 117, 2, 112, 2, 106, 3, 101},
5678 {4, 68, 5, 63, 6, 59, 8, 54, 9, 76, 11, 71, 12, 67, 14, 62},
5679 {16, 34, 18, 31, 21, 27, 23, 24, 25, 42, 28, 39, 30, 35, 33, 32},
5680 {36, 9, 39, 6, 43, 4, 46, 1, 49, 17, 53, 14, 56, 12, 60, 9},
5681 {192, 247, 192, 246, 193, 244, 193, 243, 194, 255, 194, 254, 194, 252, 195, 251},
5682 {196, 238, 197, 237, 199, 237, 200, 236, 202, 246, 203, 245, 204, 245, 206, 244},
5683 {208, 236, 210, 237, 213, 237, 215, 238, 218, 244, 220, 245, 222, 245, 225, 246},
5684 {228, 243, 231, 244, 235, 246, 238, 247, 242, 251, 245, 252, 248, 254, 252, 255}},
5685 {{0x6d24, 0x677e, 0x61f8, 0x5c94, 0x750c, 0x6f68, 0x69e3, 0x647f},
5686 {0x437f, 0x3edb, 0x3a57, 0x35f5, 0x4b6b, 0x46c9, 0x4246, 0x3de3},
5687 {0x21e9, 0x1e48, 0x1ac5, 0x1765, 0x29da, 0x2639, 0x22b8, 0x1f58},
5688 {0x0864, 0x05c4, 0x0344, 0x00e6, 0x1058, 0x0dba, 0x0b3b, 0x08dd},
5689 {0xf6ee, 0xf551, 0xf3d3, 0xf276, 0xfee7, 0xfd4b, 0xfbce, 0xfa71},
5690 {0xed89, 0xeced, 0xec72, 0xec17, 0xf586, 0xf4eb, 0xf470, 0xf416},
5691 {0xec34, 0xec9a, 0xed21, 0xedc8, 0xf435, 0xf49c, 0xf523, 0xf5cb},
5692 {0xf2ee, 0xf457, 0xf5df, 0xf788, 0xfaf4, 0xfc5d, 0xfde6, 0xff8f}},
5693 {{0x677d'76af, 0x5c93'1931, 0x6f67'3831, 0x647d'dbb7},
5694 {0x3eda'09c6, 0x35f3'b250, 0x46c7'cf50, 0x3de2'78de},
5695 {0x1e46'b4fd, 0x1764'6390, 0x2638'7e90, 0x1f57'2e25},
5696 {0x05c3'7855, 0x00e5'2cef, 0x0db9'45ef, 0x08db'fb8d},
5697 {0xf550'cd47, 0xf276'7fe1, 0xfd4a'8eda, 0xfa71'4277},
5698 {0xeced'a0be, 0xec17'5961, 0xf4eb'6659, 0xf416'1ffe},
5699 {0xec9a'8c56, 0xedc8'4b01, 0xf49c'55f9, 0xf5cb'15a6},
5700 {0xf457'900e, 0xf789'54c1, 0xfc5d'5db9, 0xff90'236e}},
5701 {{0x5c93'192f'ccd4'7781, 0x647d'dbb5'bb66'23af},
5702 {0x35f3'b24f'43d0'aa38, 0x3de2'78dd'1a4e'4256},
5703 {0x1764'638e'e2fd'152f, 0x1f57'2e24'a166'993d},
5704 {0x00e5'2cee'aa59'b866, 0x08db'fb8c'50af'2865},
5705 {0xf276'7fe1'80cf'f441, 0xfa71'4276'eef1'1fff},
5706 {0xec17'5961'584c'a799, 0xf416'1ffe'ae59'bf47},
5707 {0xedc8'4b01'57f9'9330, 0xf5cb'15a6'95f2'96cf},
5708 {0xf789'54c1'7fd6'b708, 0xff90'236e'a5bb'a696}},
5709 kVectorCalculationsSource);
5710 TestVectorInstruction(ExecVsmulvx,
5711 ExecMaskedVsmulvx,
5712 {{0, 85, 255, 84, 253, 83, 252, 81, 251, 80, 249, 79, 248, 77, 247, 76},
5713 {245, 75, 244, 73, 243, 72, 241, 71, 240, 69, 239, 68, 237, 67, 236, 65},
5714 {234, 64, 233, 62, 232, 61, 230, 60, 229, 58, 228, 57, 226, 56, 225, 54},
5715 {224, 53, 222, 52, 221, 50, 220, 49, 218, 48, 217, 46, 216, 45, 214, 44},
5716 {213, 42, 212, 41, 210, 40, 209, 38, 208, 37, 206, 36, 205, 34, 204, 33},
5717 {202, 32, 201, 30, 200, 29, 198, 28, 197, 26, 196, 25, 194, 24, 193, 22},
5718 {192, 21, 190, 19, 189, 18, 187, 17, 186, 15, 185, 14, 183, 13, 182, 11},
5719 {181, 10, 179, 9, 178, 7, 177, 6, 175, 5, 174, 3, 173, 2, 171, 1}},
5720 {{0x54ab, 0x5355, 0x51fe, 0x50a7, 0x4f51, 0x4dfa, 0x4ca3, 0x4b4d},
5721 {0x49f6, 0x489f, 0x4749, 0x45f2, 0x449b, 0x4345, 0x41ee, 0x4097},
5722 {0x3f40, 0x3dea, 0x3c93, 0x3b3c, 0x39e6, 0x388f, 0x3738, 0x35e2},
5723 {0x348b, 0x3334, 0x31de, 0x3087, 0x2f30, 0x2dda, 0x2c83, 0x2b2c},
5724 {0x29d6, 0x287f, 0x2728, 0x25d2, 0x247b, 0x2324, 0x21ce, 0x2077},
5725 {0x1f20, 0x1dca, 0x1c73, 0x1b1c, 0x19c6, 0x186f, 0x1718, 0x15c2},
5726 {0x146b, 0x1314, 0x11bd, 0x1067, 0x0f10, 0x0db9, 0x0c63, 0x0b0c},
5727 {0x09b5, 0x085f, 0x0708, 0x05b1, 0x045b, 0x0304, 0x01ad, 0x0057}},
5728 {{0x5353'aa01, 0x50a6'51fe, 0x4df8'f9fb, 0x4b4b'a1f9},
5729 {0x489e'49f6, 0x45f0'f1f3, 0x4343'99f1, 0x4096'41ee},
5730 {0x3de8'e9eb, 0x3b3b'91e8, 0x388e'39e6, 0x35e0'e1e3},
5731 {0x3333'89e0, 0x3086'31de, 0x2dd8'd9db, 0x2b2b'81d8},
5732 {0x287e'29d6, 0x25d0'd1d3, 0x2323'79d0, 0x2076'21ce},
5733 {0x1dc8'c9cb, 0x1b1b'71c8, 0x186e'19c6, 0x15c0'c1c3},
5734 {0x1313'69c0, 0x1066'11bd, 0x0db8'b9bb, 0x0b0b'61b8},
5735 {0x085e'09b5, 0x05b0'b1b3, 0x0303'59b0, 0x0056'01ad}},
5736 {{0x50a6'51fc'fdfe'54ab, 0x4b4b'a1f7'a34e'4f51},
5737 {0x45f0'f1f2'489e'49f6, 0x4096'41ec'edee'449b},
5738 {0x3b3b'91e7'933e'3f40, 0x35e0'e1e2'388e'39e6},
5739 {0x3086'31dc'ddde'348b, 0x2b2b'81d7'832e'2f30},
5740 {0x25d0'd1d2'287e'29d6, 0x2076'21cc'cdce'247b},
5741 {0x1b1b'71c7'731e'1f20, 0x15c0'c1c2'186e'19c6},
5742 {0x1066'11bc'bdbe'146b, 0x0b0b'61b7'630e'0f10},
5743 {0x05b0'b1b2'085e'09b5, 0x0056'01ac'adae'045b}},
5744 kVectorCalculationsSource);
5745 TestVectorInstruction(ExecVssrlvv,
5746 ExecMaskedVssrlvv,
5747 {{0, 32, 0, 2, 2, 33, 0, 2, 4, 34, 1, 2, 12, 35, 1, 2},
5748 {16, 36, 1, 2, 10, 37, 1, 2, 12, 38, 2, 2, 28, 39, 2, 2},
5749 {32, 40, 2, 3, 18, 41, 2, 3, 20, 42, 3, 3, 44, 43, 3, 3},
5750 {48, 44, 3, 3, 26, 45, 3, 3, 28, 46, 4, 3, 60, 47, 4, 3},
5751 {64, 48, 4, 3, 34, 49, 4, 3, 36, 50, 5, 3, 76, 51, 5, 3},
5752 {80, 52, 5, 3, 42, 53, 5, 3, 44, 54, 6, 3, 92, 55, 6, 3},
5753 {96, 56, 6, 4, 50, 57, 6, 4, 52, 58, 7, 4, 108, 59, 7, 4},
5754 {112, 60, 7, 4, 58, 61, 7, 4, 60, 62, 8, 4, 124, 63, 8, 4}},
5755 {{0x8100, 0x0830, 0x0043, 0x0008, 0x4484, 0x08b1, 0x008d, 0x0009},
5756 {0x9110, 0x0931, 0x004b, 0x0009, 0x4c8c, 0x09b2, 0x009d, 0x000a},
5757 {0xa120, 0x0a32, 0x0053, 0x000a, 0x5494, 0x0ab3, 0x00ad, 0x000b},
5758 {0xb130, 0x0b33, 0x005b, 0x000b, 0x5c9c, 0x0bb4, 0x00bd, 0x000c},
5759 {0xc140, 0x0c34, 0x0063, 0x000c, 0x64a4, 0x0cb5, 0x00cd, 0x000d},
5760 {0xd150, 0x0d35, 0x006b, 0x000d, 0x6cac, 0x0db6, 0x00dd, 0x000e},
5761 {0xe160, 0x0e36, 0x0073, 0x000e, 0x74b4, 0x0eb7, 0x00ed, 0x000f},
5762 {0xf170, 0x0f37, 0x007b, 0x000f, 0x7cbc, 0x0fb8, 0x00fd, 0x0010}},
5763 {{0x8302'8100, 0x0043'8343, 0x0000'4585, 0x0000'008f},
5764 {0x9312'9110, 0x004b'8b4b, 0x0000'4d8d, 0x0000'009f},
5765 {0xa322'a120, 0x0053'9353, 0x0000'5595, 0x0000'00af},
5766 {0xb332'b130, 0x005b'9b5b, 0x0000'5d9d, 0x0000'00bf},
5767 {0xc342'c140, 0x0063'a363, 0x0000'65a5, 0x0000'00cf},
5768 {0xd352'd150, 0x006b'ab6b, 0x0000'6dad, 0x0000'00df},
5769 {0xe362'e160, 0x0073'b373, 0x0000'75b5, 0x0000'00ef},
5770 {0xf372'f170, 0x007b'bb7b, 0x0000'7dbd, 0x0000'00ff}},
5771 {{0x8706'8504'8302'8100, 0x0000'4787'4686'4585},
5772 {0x0000'0000'9716'9515, 0x0000'0000'0000'4f8f},
5773 {0xa726'a524'a322'a120, 0x0000'5797'5696'5595},
5774 {0x0000'0000'b736'b535, 0x0000'0000'0000'5f9f},
5775 {0xc746'c544'c342'c140, 0x0000'67a7'66a6'65a5},
5776 {0x0000'0000'd756'd555, 0x0000'0000'0000'6faf},
5777 {0xe766'e564'e362'e160, 0x0000'77b7'76b6'75b5},
5778 {0x0000'0000'f776'f575, 0x0000'0000'0000'7fbf}},
5779 kVectorCalculationsSource);
5780
5781 TestVectorInstruction(ExecVssrlvx,
5782 ExecMaskedVssrlvx,
5783 {{0, 32, 0, 33, 1, 33, 2, 34, 2, 34, 2, 35, 3, 35, 4, 36},
5784 {4, 36, 4, 37, 5, 37, 6, 38, 6, 38, 6, 39, 7, 39, 8, 40},
5785 {8, 40, 8, 41, 9, 41, 10, 42, 10, 42, 10, 43, 11, 43, 12, 44},
5786 {12, 44, 12, 45, 13, 45, 14, 46, 14, 46, 14, 47, 15, 47, 16, 48},
5787 {16, 48, 16, 49, 17, 49, 18, 50, 18, 50, 18, 51, 19, 51, 20, 52},
5788 {20, 52, 20, 53, 21, 53, 22, 54, 22, 54, 22, 55, 23, 55, 24, 56},
5789 {24, 56, 24, 57, 25, 57, 26, 58, 26, 58, 26, 59, 27, 59, 28, 60},
5790 {28, 60, 28, 61, 29, 61, 30, 62, 30, 62, 30, 63, 31, 63, 32, 64}},
5791 {{0x0020, 0x0021, 0x0021, 0x0022, 0x0022, 0x0023, 0x0023, 0x0024},
5792 {0x0024, 0x0025, 0x0025, 0x0026, 0x0026, 0x0027, 0x0027, 0x0028},
5793 {0x0028, 0x0029, 0x0029, 0x002a, 0x002a, 0x002b, 0x002b, 0x002c},
5794 {0x002c, 0x002d, 0x002d, 0x002e, 0x002e, 0x002f, 0x002f, 0x0030},
5795 {0x0030, 0x0031, 0x0031, 0x0032, 0x0032, 0x0033, 0x0033, 0x0034},
5796 {0x0034, 0x0035, 0x0035, 0x0036, 0x0036, 0x0037, 0x0037, 0x0038},
5797 {0x0038, 0x0039, 0x0039, 0x003a, 0x003a, 0x003b, 0x003b, 0x003c},
5798 {0x003c, 0x003d, 0x003d, 0x003e, 0x003e, 0x003f, 0x003f, 0x0040}},
5799 {{0x0020'c0a0, 0x0021'c1a1, 0x0022'c2a2, 0x0023'c3a3},
5800 {0x0024'c4a4, 0x0025'c5a5, 0x0026'c6a6, 0x0027'c7a7},
5801 {0x0028'c8a8, 0x0029'c9a9, 0x002a'caaa, 0x002b'cbab},
5802 {0x002c'ccac, 0x002d'cdad, 0x002e'ceae, 0x002f'cfaf},
5803 {0x0030'd0b0, 0x0031'd1b1, 0x0032'd2b2, 0x0033'd3b3},
5804 {0x0034'd4b4, 0x0035'd5b5, 0x0036'd6b6, 0x0037'd7b7},
5805 {0x0038'd8b8, 0x0039'd9b9, 0x003a'daba, 0x003b'dbbb},
5806 {0x003c'dcbc, 0x003d'ddbd, 0x003e'debe, 0x003f'dfbf}},
5807 {{0x0000'0000'0021'c1a1, 0x0000'0000'0023'c3a3},
5808 {0x0000'0000'0025'c5a5, 0x0000'0000'0027'c7a7},
5809 {0x0000'0000'0029'c9a9, 0x0000'0000'002b'cbab},
5810 {0x0000'0000'002d'cdad, 0x0000'0000'002f'cfaf},
5811 {0x0000'0000'0031'd1b1, 0x0000'0000'0033'd3b3},
5812 {0x0000'0000'0035'd5b5, 0x0000'0000'0037'd7b7},
5813 {0x0000'0000'0039'd9b9, 0x0000'0000'003b'dbbb},
5814 {0x0000'0000'003d'ddbd, 0x0000'0000'003f'dfbf}},
5815 kVectorCalculationsSource);
5816
5817 TestVectorInstruction(ExecVssrlvi,
5818 ExecMaskedVssrlvi,
5819 {{0, 32, 0, 33, 1, 33, 2, 34, 2, 34, 2, 35, 3, 35, 4, 36},
5820 {4, 36, 4, 37, 5, 37, 6, 38, 6, 38, 6, 39, 7, 39, 8, 40},
5821 {8, 40, 8, 41, 9, 41, 10, 42, 10, 42, 10, 43, 11, 43, 12, 44},
5822 {12, 44, 12, 45, 13, 45, 14, 46, 14, 46, 14, 47, 15, 47, 16, 48},
5823 {16, 48, 16, 49, 17, 49, 18, 50, 18, 50, 18, 51, 19, 51, 20, 52},
5824 {20, 52, 20, 53, 21, 53, 22, 54, 22, 54, 22, 55, 23, 55, 24, 56},
5825 {24, 56, 24, 57, 25, 57, 26, 58, 26, 58, 26, 59, 27, 59, 28, 60},
5826 {28, 60, 28, 61, 29, 61, 30, 62, 30, 62, 30, 63, 31, 63, 32, 64}},
5827 {{0x0020, 0x0021, 0x0021, 0x0022, 0x0022, 0x0023, 0x0023, 0x0024},
5828 {0x0024, 0x0025, 0x0025, 0x0026, 0x0026, 0x0027, 0x0027, 0x0028},
5829 {0x0028, 0x0029, 0x0029, 0x002a, 0x002a, 0x002b, 0x002b, 0x002c},
5830 {0x002c, 0x002d, 0x002d, 0x002e, 0x002e, 0x002f, 0x002f, 0x0030},
5831 {0x0030, 0x0031, 0x0031, 0x0032, 0x0032, 0x0033, 0x0033, 0x0034},
5832 {0x0034, 0x0035, 0x0035, 0x0036, 0x0036, 0x0037, 0x0037, 0x0038},
5833 {0x0038, 0x0039, 0x0039, 0x003a, 0x003a, 0x003b, 0x003b, 0x003c},
5834 {0x003c, 0x003d, 0x003d, 0x003e, 0x003e, 0x003f, 0x003f, 0x0040}},
5835 {{0x0020'c0a0, 0x0021'c1a1, 0x0022'c2a2, 0x0023'c3a3},
5836 {0x0024'c4a4, 0x0025'c5a5, 0x0026'c6a6, 0x0027'c7a7},
5837 {0x0028'c8a8, 0x0029'c9a9, 0x002a'caaa, 0x002b'cbab},
5838 {0x002c'ccac, 0x002d'cdad, 0x002e'ceae, 0x002f'cfaf},
5839 {0x0030'd0b0, 0x0031'd1b1, 0x0032'd2b2, 0x0033'd3b3},
5840 {0x0034'd4b4, 0x0035'd5b5, 0x0036'd6b6, 0x0037'd7b7},
5841 {0x0038'd8b8, 0x0039'd9b9, 0x003a'daba, 0x003b'dbbb},
5842 {0x003c'dcbc, 0x003d'ddbd, 0x003e'debe, 0x003f'dfbf}},
5843 {{0x0021'c1a1'4120'c0a0, 0x0023'c3a3'4322'c2a2},
5844 {0x0025'c5a5'4524'c4a4, 0x0027'c7a7'4726'c6a6},
5845 {0x0029'c9a9'4928'c8a8, 0x002b'cbab'4b2a'caaa},
5846 {0x002d'cdad'4d2c'ccac, 0x002f'cfaf'4f2e'ceae},
5847 {0x0031'd1b1'5130'd0b0, 0x0033'd3b3'5332'd2b2},
5848 {0x0035'd5b5'5534'd4b4, 0x0037'd7b7'5736'd6b6},
5849 {0x0039'd9b9'5938'd8b8, 0x003b'dbbb'5b3a'daba},
5850 {0x003d'ddbd'5d3c'dcbc, 0x003f'dfbf'5f3e'debe}},
5851 kVectorCalculationsSource);
5852 TestVectorInstruction(ExecVssravv,
5853 ExecMaskedVssravv,
5854 {{0, 224, 0, 254, 2, 225, 0, 254, 4, 226, 1, 254, 12, 227, 1, 254},
5855 {16, 228, 1, 254, 10, 229, 1, 254, 12, 230, 2, 254, 28, 231, 2, 254},
5856 {32, 232, 2, 255, 18, 233, 2, 255, 20, 234, 3, 255, 44, 235, 3, 255},
5857 {48, 236, 3, 255, 26, 237, 3, 255, 28, 238, 4, 255, 60, 239, 4, 255},
5858 {64, 240, 4, 255, 34, 241, 4, 255, 36, 242, 5, 255, 76, 243, 5, 255},
5859 {80, 244, 5, 255, 42, 245, 5, 255, 44, 246, 6, 255, 92, 247, 6, 255},
5860 {96, 248, 6, 0, 50, 249, 6, 0, 52, 250, 7, 0, 108, 251, 7, 0},
5861 {112, 252, 7, 0, 58, 253, 7, 0, 60, 254, 8, 0, 124, 255, 8, 0}},
5862 {{0x8100, 0xf830, 0xffc3, 0xfff8, 0xc484, 0xf8b1, 0xff8d, 0xfff9},
5863 {0x9110, 0xf931, 0xffcb, 0xfff9, 0xcc8c, 0xf9b2, 0xff9d, 0xfffa},
5864 {0xa120, 0xfa32, 0xffd3, 0xfffa, 0xd494, 0xfab3, 0xffad, 0xfffb},
5865 {0xb130, 0xfb33, 0xffdb, 0xfffb, 0xdc9c, 0xfbb4, 0xffbd, 0xfffc},
5866 {0xc140, 0xfc34, 0xffe3, 0xfffc, 0xe4a4, 0xfcb5, 0xffcd, 0xfffd},
5867 {0xd150, 0xfd35, 0xffeb, 0xfffd, 0xecac, 0xfdb6, 0xffdd, 0xfffe},
5868 {0xe160, 0xfe36, 0xfff3, 0xfffe, 0xf4b4, 0xfeb7, 0xffed, 0xffff},
5869 {0xf170, 0xff37, 0xfffb, 0xffff, 0xfcbc, 0xffb8, 0xfffd, 0x0000}},
5870 {{0x8302'8100, 0xffc3'8343, 0xffff'c585, 0xffff'ff8f},
5871 {0x9312'9110, 0xffcb'8b4b, 0xffff'cd8d, 0xffff'ff9f},
5872 {0xa322'a120, 0xffd3'9353, 0xffff'd595, 0xffff'ffaf},
5873 {0xb332'b130, 0xffdb'9b5b, 0xffff'dd9d, 0xffff'ffbf},
5874 {0xc342'c140, 0xffe3'a363, 0xffff'e5a5, 0xffff'ffcf},
5875 {0xd352'd150, 0xffeb'ab6b, 0xffff'edad, 0xffff'ffdf},
5876 {0xe362'e160, 0xfff3'b373, 0xffff'f5b5, 0xffff'ffef},
5877 {0xf372'f170, 0xfffb'bb7b, 0xffff'fdbd, 0xffff'ffff}},
5878 {{0x8706'8504'8302'8100, 0xffff'c787'4686'4585},
5879 {0xffff'ffff'9716'9515, 0xffff'ffff'ffff'cf8f},
5880 {0xa726'a524'a322'a120, 0xffff'd797'5696'5595},
5881 {0xffff'ffff'b736'b535, 0xffff'ffff'ffff'df9f},
5882 {0xc746'c544'c342'c140, 0xffff'e7a7'66a6'65a5},
5883 {0xffff'ffff'd756'd555, 0xffff'ffff'ffff'efaf},
5884 {0xe766'e564'e362'e160, 0xffff'f7b7'76b6'75b5},
5885 {0xffff'ffff'f776'f575, 0xffff'ffff'ffff'ffbf}},
5886 kVectorCalculationsSource);
5887
5888 TestVectorInstruction(ExecVssravx,
5889 ExecMaskedVssravx,
5890 {{0, 224, 0, 225, 1, 225, 2, 226, 2, 226, 2, 227, 3, 227, 4, 228},
5891 {4, 228, 4, 229, 5, 229, 6, 230, 6, 230, 6, 231, 7, 231, 8, 232},
5892 {8, 232, 8, 233, 9, 233, 10, 234, 10, 234, 10, 235, 11, 235, 12, 236},
5893 {12, 236, 12, 237, 13, 237, 14, 238, 14, 238, 14, 239, 15, 239, 16, 240},
5894 {16, 240, 16, 241, 17, 241, 18, 242, 18, 242, 18, 243, 19, 243, 20, 244},
5895 {20, 244, 20, 245, 21, 245, 22, 246, 22, 246, 22, 247, 23, 247, 24, 248},
5896 {24, 248, 24, 249, 25, 249, 26, 250, 26, 250, 26, 251, 27, 251, 28, 252},
5897 {28, 252, 28, 253, 29, 253, 30, 254, 30, 254, 30, 255, 31, 255, 32, 0}},
5898 {{0xffe0, 0xffe1, 0xffe1, 0xffe2, 0xffe2, 0xffe3, 0xffe3, 0xffe4},
5899 {0xffe4, 0xffe5, 0xffe5, 0xffe6, 0xffe6, 0xffe7, 0xffe7, 0xffe8},
5900 {0xffe8, 0xffe9, 0xffe9, 0xffea, 0xffea, 0xffeb, 0xffeb, 0xffec},
5901 {0xffec, 0xffed, 0xffed, 0xffee, 0xffee, 0xffef, 0xffef, 0xfff0},
5902 {0xfff0, 0xfff1, 0xfff1, 0xfff2, 0xfff2, 0xfff3, 0xfff3, 0xfff4},
5903 {0xfff4, 0xfff5, 0xfff5, 0xfff6, 0xfff6, 0xfff7, 0xfff7, 0xfff8},
5904 {0xfff8, 0xfff9, 0xfff9, 0xfffa, 0xfffa, 0xfffb, 0xfffb, 0xfffc},
5905 {0xfffc, 0xfffd, 0xfffd, 0xfffe, 0xfffe, 0xffff, 0xffff, 0x0000}},
5906 {{0xffe0'c0a0, 0xffe1'c1a1, 0xffe2'c2a2, 0xffe3'c3a3},
5907 {0xffe4'c4a4, 0xffe5'c5a5, 0xffe6'c6a6, 0xffe7'c7a7},
5908 {0xffe8'c8a8, 0xffe9'c9a9, 0xffea'caaa, 0xffeb'cbab},
5909 {0xffec'ccac, 0xffed'cdad, 0xffee'ceae, 0xffef'cfaf},
5910 {0xfff0'd0b0, 0xfff1'd1b1, 0xfff2'd2b2, 0xfff3'd3b3},
5911 {0xfff4'd4b4, 0xfff5'd5b5, 0xfff6'd6b6, 0xfff7'd7b7},
5912 {0xfff8'd8b8, 0xfff9'd9b9, 0xfffa'daba, 0xfffb'dbbb},
5913 {0xfffc'dcbc, 0xfffd'ddbd, 0xfffe'debe, 0xffff'dfbf}},
5914 {{0xffff'ffff'ffe1'c1a1, 0xffff'ffff'ffe3'c3a3},
5915 {0xffff'ffff'ffe5'c5a5, 0xffff'ffff'ffe7'c7a7},
5916 {0xffff'ffff'ffe9'c9a9, 0xffff'ffff'ffeb'cbab},
5917 {0xffff'ffff'ffed'cdad, 0xffff'ffff'ffef'cfaf},
5918 {0xffff'ffff'fff1'd1b1, 0xffff'ffff'fff3'd3b3},
5919 {0xffff'ffff'fff5'd5b5, 0xffff'ffff'fff7'd7b7},
5920 {0xffff'ffff'fff9'd9b9, 0xffff'ffff'fffb'dbbb},
5921 {0xffff'ffff'fffd'ddbd, 0xffff'ffff'ffff'dfbf}},
5922 kVectorCalculationsSource);
5923
5924 TestVectorInstruction(ExecVssravi,
5925 ExecMaskedVssravi,
5926 {{0, 224, 0, 225, 1, 225, 2, 226, 2, 226, 2, 227, 3, 227, 4, 228},
5927 {4, 228, 4, 229, 5, 229, 6, 230, 6, 230, 6, 231, 7, 231, 8, 232},
5928 {8, 232, 8, 233, 9, 233, 10, 234, 10, 234, 10, 235, 11, 235, 12, 236},
5929 {12, 236, 12, 237, 13, 237, 14, 238, 14, 238, 14, 239, 15, 239, 16, 240},
5930 {16, 240, 16, 241, 17, 241, 18, 242, 18, 242, 18, 243, 19, 243, 20, 244},
5931 {20, 244, 20, 245, 21, 245, 22, 246, 22, 246, 22, 247, 23, 247, 24, 248},
5932 {24, 248, 24, 249, 25, 249, 26, 250, 26, 250, 26, 251, 27, 251, 28, 252},
5933 {28, 252, 28, 253, 29, 253, 30, 254, 30, 254, 30, 255, 31, 255, 32, 0}},
5934 {{0xffe0, 0xffe1, 0xffe1, 0xffe2, 0xffe2, 0xffe3, 0xffe3, 0xffe4},
5935 {0xffe4, 0xffe5, 0xffe5, 0xffe6, 0xffe6, 0xffe7, 0xffe7, 0xffe8},
5936 {0xffe8, 0xffe9, 0xffe9, 0xffea, 0xffea, 0xffeb, 0xffeb, 0xffec},
5937 {0xffec, 0xffed, 0xffed, 0xffee, 0xffee, 0xffef, 0xffef, 0xfff0},
5938 {0xfff0, 0xfff1, 0xfff1, 0xfff2, 0xfff2, 0xfff3, 0xfff3, 0xfff4},
5939 {0xfff4, 0xfff5, 0xfff5, 0xfff6, 0xfff6, 0xfff7, 0xfff7, 0xfff8},
5940 {0xfff8, 0xfff9, 0xfff9, 0xfffa, 0xfffa, 0xfffb, 0xfffb, 0xfffc},
5941 {0xfffc, 0xfffd, 0xfffd, 0xfffe, 0xfffe, 0xffff, 0xffff, 0x0000}},
5942 {{0xffe0'c0a0, 0xffe1'c1a1, 0xffe2'c2a2, 0xffe3'c3a3},
5943 {0xffe4'c4a4, 0xffe5'c5a5, 0xffe6'c6a6, 0xffe7'c7a7},
5944 {0xffe8'c8a8, 0xffe9'c9a9, 0xffea'caaa, 0xffeb'cbab},
5945 {0xffec'ccac, 0xffed'cdad, 0xffee'ceae, 0xffef'cfaf},
5946 {0xfff0'd0b0, 0xfff1'd1b1, 0xfff2'd2b2, 0xfff3'd3b3},
5947 {0xfff4'd4b4, 0xfff5'd5b5, 0xfff6'd6b6, 0xfff7'd7b7},
5948 {0xfff8'd8b8, 0xfff9'd9b9, 0xfffa'daba, 0xfffb'dbbb},
5949 {0xfffc'dcbc, 0xfffd'ddbd, 0xfffe'debe, 0xffff'dfbf}},
5950 {{0xffe1'c1a1'4120'c0a0, 0xffe3'c3a3'4322'c2a2},
5951 {0xffe5'c5a5'4524'c4a4, 0xffe7'c7a7'4726'c6a6},
5952 {0xffe9'c9a9'4928'c8a8, 0xffeb'cbab'4b2a'caaa},
5953 {0xffed'cdad'4d2c'ccac, 0xffef'cfaf'4f2e'ceae},
5954 {0xfff1'd1b1'5130'd0b0, 0xfff3'd3b3'5332'd2b2},
5955 {0xfff5'd5b5'5534'd4b4, 0xfff7'd7b7'5736'd6b6},
5956 {0xfff9'd9b9'5938'd8b8, 0xfffb'dbbb'5b3a'daba},
5957 {0xfffd'ddbd'5d3c'dcbc, 0xffff'dfbf'5f3e'debe}},
5958 kVectorCalculationsSource);
5959 asm volatile("csrw vxrm, %0\n\t" ::"r"(vxrm));
5960 }
5961
TEST(InlineAsmTestRiscv64,TestRNU)5962 TEST(InlineAsmTestRiscv64, TestRNU) {
5963 uint64_t vxrm;
5964 asm volatile(
5965 "csrr %0, vxrm\n\t"
5966 "csrwi vxrm, %c1\n\t"
5967 : "=r"(vxrm)
5968 : "i"(VXRMFlags::RNU));
5969 TestVectorInstruction(
5970 ExecVaadduvv,
5971 ExecMaskedVaadduvv,
5972 {{0, 138, 3, 141, 7, 144, 9, 147, 13, 134, 15, 137, 18, 140, 21, 143},
5973 {24, 162, 27, 165, 31, 168, 33, 171, 37, 158, 39, 161, 42, 164, 45, 167},
5974 {48, 186, 51, 189, 55, 192, 57, 195, 61, 182, 63, 185, 66, 188, 69, 191},
5975 {72, 210, 75, 213, 79, 216, 81, 219, 85, 206, 87, 209, 90, 212, 93, 215},
5976 {96, 106, 99, 109, 103, 112, 105, 115, 109, 102, 111, 105, 114, 108, 117, 111},
5977 {120, 130, 123, 133, 127, 136, 129, 139, 133, 126, 135, 129, 138, 132, 141, 135},
5978 {144, 154, 147, 157, 151, 160, 153, 163, 157, 150, 159, 153, 162, 156, 165, 159},
5979 {168, 178, 171, 181, 175, 184, 177, 187, 181, 174, 183, 177, 186, 180, 189, 183}},
5980 {{0x8980, 0x8c83, 0x8f87, 0x9289, 0x858d, 0x888f, 0x8b92, 0x8e95},
5981 {0xa198, 0xa49b, 0xa79f, 0xaaa1, 0x9da5, 0xa0a7, 0xa3aa, 0xa6ad},
5982 {0xb9b0, 0xbcb3, 0xbfb7, 0xc2b9, 0xb5bd, 0xb8bf, 0xbbc2, 0xbec5},
5983 {0xd1c8, 0xd4cb, 0xd7cf, 0xdad1, 0xcdd5, 0xd0d7, 0xd3da, 0xd6dd},
5984 {0x69e0, 0x6ce3, 0x6fe7, 0x72e9, 0x65ed, 0x68ef, 0x6bf2, 0x6ef5},
5985 {0x81f8, 0x84fb, 0x87ff, 0x8b01, 0x7e05, 0x8107, 0x840a, 0x870d},
5986 {0x9a10, 0x9d13, 0xa017, 0xa319, 0x961d, 0x991f, 0x9c22, 0x9f25},
5987 {0xb228, 0xb52b, 0xb82f, 0xbb31, 0xae35, 0xb137, 0xb43a, 0xb73d}},
5988 {{0x8c83'8980, 0x9289'8f87, 0x888f'858d, 0x8e95'8b92},
5989 {0xa49b'a198, 0xaaa1'a79f, 0xa0a7'9da5, 0xa6ad'a3aa},
5990 {0xbcb3'b9b0, 0xc2b9'bfb7, 0xb8bf'b5bd, 0xbec5'bbc2},
5991 {0xd4cb'd1c8, 0xdad1'd7cf, 0xd0d7'cdd5, 0xd6dd'd3da},
5992 {0x6ce3'69e0, 0x72e9'6fe7, 0x68ef'65ed, 0x6ef5'6bf2},
5993 {0x84fb'81f8, 0x8b01'87ff, 0x8107'7e05, 0x870d'840a},
5994 {0x9d13'9a10, 0xa319'a017, 0x991f'961d, 0x9f25'9c22},
5995 {0xb52b'b228, 0xbb31'b82f, 0xb137'ae35, 0xb73d'b43a}},
5996 {{0x9289'8f87'0c83'8980, 0x8e95'8b92'888f'858d},
5997 {0xaaa1'a79f'249b'a198, 0xa6ad'a3aa'a0a7'9da5},
5998 {0xc2b9'bfb7'3cb3'b9b0, 0xbec5'bbc2'b8bf'b5bd},
5999 {0xdad1'd7cf'54cb'd1c8, 0xd6dd'd3da'd0d7'cdd5},
6000 {0x72e9'6fe6'ece3'69e0, 0x6ef5'6bf2'68ef'65ed},
6001 {0x8b01'87ff'04fb'81f8, 0x870d'840a'8107'7e05},
6002 {0xa319'a017'1d13'9a10, 0x9f25'9c22'991f'961d},
6003 {0xbb31'b82f'352b'b228, 0xb73d'b43a'b137'ae35}},
6004 kVectorCalculationsSource);
6005 TestVectorInstruction(
6006 ExecVaadduvx,
6007 ExecMaskedVaadduvx,
6008 {{85, 150, 86, 151, 87, 152, 88, 153, 89, 154, 90, 155, 91, 156, 92, 157},
6009 {93, 158, 94, 159, 95, 160, 96, 161, 97, 162, 98, 163, 99, 164, 100, 165},
6010 {101, 166, 102, 167, 103, 168, 104, 169, 105, 170, 106, 171, 107, 172, 108, 173},
6011 {109, 174, 110, 175, 111, 176, 112, 177, 113, 178, 114, 179, 115, 180, 116, 181},
6012 {117, 182, 118, 183, 119, 184, 120, 185, 121, 186, 122, 187, 123, 188, 124, 189},
6013 {125, 190, 126, 191, 127, 192, 128, 193, 129, 194, 130, 195, 131, 196, 132, 197},
6014 {133, 198, 134, 199, 135, 200, 136, 201, 137, 202, 138, 203, 139, 204, 140, 205},
6015 {141, 206, 142, 207, 143, 208, 144, 209, 145, 210, 146, 211, 147, 212, 148, 213}},
6016 {{0x95d5, 0x96d6, 0x97d7, 0x98d8, 0x99d9, 0x9ada, 0x9bdb, 0x9cdc},
6017 {0x9ddd, 0x9ede, 0x9fdf, 0xa0e0, 0xa1e1, 0xa2e2, 0xa3e3, 0xa4e4},
6018 {0xa5e5, 0xa6e6, 0xa7e7, 0xa8e8, 0xa9e9, 0xaaea, 0xabeb, 0xacec},
6019 {0xaded, 0xaeee, 0xafef, 0xb0f0, 0xb1f1, 0xb2f2, 0xb3f3, 0xb4f4},
6020 {0xb5f5, 0xb6f6, 0xb7f7, 0xb8f8, 0xb9f9, 0xbafa, 0xbbfb, 0xbcfc},
6021 {0xbdfd, 0xbefe, 0xbfff, 0xc100, 0xc201, 0xc302, 0xc403, 0xc504},
6022 {0xc605, 0xc706, 0xc807, 0xc908, 0xca09, 0xcb0a, 0xcc0b, 0xcd0c},
6023 {0xce0d, 0xcf0e, 0xd00f, 0xd110, 0xd211, 0xd312, 0xd413, 0xd514}},
6024 {{0x96d6'95d5, 0x98d8'97d7, 0x9ada'99d9, 0x9cdc'9bdb},
6025 {0x9ede'9ddd, 0xa0e0'9fdf, 0xa2e2'a1e1, 0xa4e4'a3e3},
6026 {0xa6e6'a5e5, 0xa8e8'a7e7, 0xaaea'a9e9, 0xacec'abeb},
6027 {0xaeee'aded, 0xb0f0'afef, 0xb2f2'b1f1, 0xb4f4'b3f3},
6028 {0xb6f6'b5f5, 0xb8f8'b7f7, 0xbafa'b9f9, 0xbcfc'bbfb},
6029 {0xbefe'bdfd, 0xc100'bfff, 0xc302'c201, 0xc504'c403},
6030 {0xc706'c605, 0xc908'c807, 0xcb0a'ca09, 0xcd0c'cc0b},
6031 {0xcf0e'ce0d, 0xd110'd00f, 0xd312'd211, 0xd514'd413}},
6032 {{0x98d8'97d7'96d6'95d5, 0x9cdc'9bdb'9ada'99d9},
6033 {0xa0e0'9fdf'9ede'9ddd, 0xa4e4'a3e3'a2e2'a1e1},
6034 {0xa8e8'a7e7'a6e6'a5e5, 0xacec'abeb'aaea'a9e9},
6035 {0xb0f0'afef'aeee'aded, 0xb4f4'b3f3'b2f2'b1f1},
6036 {0xb8f8'b7f7'b6f6'b5f5, 0xbcfc'bbfb'bafa'b9f9},
6037 {0xc100'bfff'befe'bdfd, 0xc504'c403'c302'c201},
6038 {0xc908'c807'c706'c605, 0xcd0c'cc0b'cb0a'ca09},
6039 {0xd110'd00f'cf0e'ce0d, 0xd514'd413'd312'd211}},
6040 kVectorCalculationsSource);
6041 TestVectorInstruction(
6042 ExecVaaddvv,
6043 ExecMaskedVaaddvv,
6044 {{0, 138, 3, 141, 7, 144, 9, 147, 13, 134, 15, 137, 18, 140, 21, 143},
6045 {24, 162, 27, 165, 31, 168, 33, 171, 37, 158, 39, 161, 42, 164, 45, 167},
6046 {48, 186, 51, 189, 55, 192, 57, 195, 61, 182, 63, 185, 66, 188, 69, 191},
6047 {72, 210, 75, 213, 79, 216, 81, 219, 85, 206, 87, 209, 90, 212, 93, 215},
6048 {224, 234, 227, 237, 231, 240, 233, 243, 237, 230, 239, 233, 242, 236, 245, 239},
6049 {248, 2, 251, 5, 255, 8, 1, 11, 5, 254, 7, 1, 10, 4, 13, 7},
6050 {16, 26, 19, 29, 23, 32, 25, 35, 29, 22, 31, 25, 34, 28, 37, 31},
6051 {40, 50, 43, 53, 47, 56, 49, 59, 53, 46, 55, 49, 58, 52, 61, 55}},
6052 {{0x8980, 0x8c83, 0x8f87, 0x9289, 0x858d, 0x888f, 0x8b92, 0x8e95},
6053 {0xa198, 0xa49b, 0xa79f, 0xaaa1, 0x9da5, 0xa0a7, 0xa3aa, 0xa6ad},
6054 {0xb9b0, 0xbcb3, 0xbfb7, 0xc2b9, 0xb5bd, 0xb8bf, 0xbbc2, 0xbec5},
6055 {0xd1c8, 0xd4cb, 0xd7cf, 0xdad1, 0xcdd5, 0xd0d7, 0xd3da, 0xd6dd},
6056 {0xe9e0, 0xece3, 0xefe7, 0xf2e9, 0xe5ed, 0xe8ef, 0xebf2, 0xeef5},
6057 {0x01f8, 0x04fb, 0x07ff, 0x0b01, 0xfe05, 0x0107, 0x040a, 0x070d},
6058 {0x1a10, 0x1d13, 0x2017, 0x2319, 0x161d, 0x191f, 0x1c22, 0x1f25},
6059 {0x3228, 0x352b, 0x382f, 0x3b31, 0x2e35, 0x3137, 0x343a, 0x373d}},
6060 {{0x8c83'8980, 0x9289'8f87, 0x888f'858d, 0x8e95'8b92},
6061 {0xa49b'a198, 0xaaa1'a79f, 0xa0a7'9da5, 0xa6ad'a3aa},
6062 {0xbcb3'b9b0, 0xc2b9'bfb7, 0xb8bf'b5bd, 0xbec5'bbc2},
6063 {0xd4cb'd1c8, 0xdad1'd7cf, 0xd0d7'cdd5, 0xd6dd'd3da},
6064 {0xece3'69e0, 0xf2e9'6fe7, 0xe8ef'65ed, 0xeef5'6bf2},
6065 {0x04fb'81f8, 0x0b01'87ff, 0x0107'7e05, 0x070d'840a},
6066 {0x1d13'9a10, 0x2319'a017, 0x191f'961d, 0x1f25'9c22},
6067 {0x352b'b228, 0x3b31'b82f, 0x3137'ae35, 0x373d'b43a}},
6068 {{0x9289'8f87'0c83'8980, 0x8e95'8b92'888f'858d},
6069 {0xaaa1'a79f'249b'a198, 0xa6ad'a3aa'a0a7'9da5},
6070 {0xc2b9'bfb7'3cb3'b9b0, 0xbec5'bbc2'b8bf'b5bd},
6071 {0xdad1'd7cf'54cb'd1c8, 0xd6dd'd3da'd0d7'cdd5},
6072 {0xf2e9'6fe6'ece3'69e0, 0xeef5'6bf2'68ef'65ed},
6073 {0x0b01'87ff'04fb'81f8, 0x070d'840a'8107'7e05},
6074 {0x2319'a017'1d13'9a10, 0x1f25'9c22'991f'961d},
6075 {0x3b31'b82f'352b'b228, 0x373d'b43a'b137'ae35}},
6076 kVectorCalculationsSource);
6077 TestVectorInstruction(
6078 ExecVaaddvx,
6079 ExecMaskedVaaddvx,
6080 {{213, 150, 214, 151, 215, 152, 216, 153, 217, 154, 218, 155, 219, 156, 220, 157},
6081 {221, 158, 222, 159, 223, 160, 224, 161, 225, 162, 226, 163, 227, 164, 228, 165},
6082 {229, 166, 230, 167, 231, 168, 232, 169, 233, 170, 234, 171, 235, 172, 236, 173},
6083 {237, 174, 238, 175, 239, 176, 240, 177, 241, 178, 242, 179, 243, 180, 244, 181},
6084 {245, 182, 246, 183, 247, 184, 248, 185, 249, 186, 250, 187, 251, 188, 252, 189},
6085 {253, 190, 254, 191, 255, 192, 0, 193, 1, 194, 2, 195, 3, 196, 4, 197},
6086 {5, 198, 6, 199, 7, 200, 8, 201, 9, 202, 10, 203, 11, 204, 12, 205},
6087 {13, 206, 14, 207, 15, 208, 16, 209, 17, 210, 18, 211, 19, 212, 20, 213}},
6088 {{0x95d5, 0x96d6, 0x97d7, 0x98d8, 0x99d9, 0x9ada, 0x9bdb, 0x9cdc},
6089 {0x9ddd, 0x9ede, 0x9fdf, 0xa0e0, 0xa1e1, 0xa2e2, 0xa3e3, 0xa4e4},
6090 {0xa5e5, 0xa6e6, 0xa7e7, 0xa8e8, 0xa9e9, 0xaaea, 0xabeb, 0xacec},
6091 {0xaded, 0xaeee, 0xafef, 0xb0f0, 0xb1f1, 0xb2f2, 0xb3f3, 0xb4f4},
6092 {0xb5f5, 0xb6f6, 0xb7f7, 0xb8f8, 0xb9f9, 0xbafa, 0xbbfb, 0xbcfc},
6093 {0xbdfd, 0xbefe, 0xbfff, 0xc100, 0xc201, 0xc302, 0xc403, 0xc504},
6094 {0xc605, 0xc706, 0xc807, 0xc908, 0xca09, 0xcb0a, 0xcc0b, 0xcd0c},
6095 {0xce0d, 0xcf0e, 0xd00f, 0xd110, 0xd211, 0xd312, 0xd413, 0xd514}},
6096 {{0x96d6'95d5, 0x98d8'97d7, 0x9ada'99d9, 0x9cdc'9bdb},
6097 {0x9ede'9ddd, 0xa0e0'9fdf, 0xa2e2'a1e1, 0xa4e4'a3e3},
6098 {0xa6e6'a5e5, 0xa8e8'a7e7, 0xaaea'a9e9, 0xacec'abeb},
6099 {0xaeee'aded, 0xb0f0'afef, 0xb2f2'b1f1, 0xb4f4'b3f3},
6100 {0xb6f6'b5f5, 0xb8f8'b7f7, 0xbafa'b9f9, 0xbcfc'bbfb},
6101 {0xbefe'bdfd, 0xc100'bfff, 0xc302'c201, 0xc504'c403},
6102 {0xc706'c605, 0xc908'c807, 0xcb0a'ca09, 0xcd0c'cc0b},
6103 {0xcf0e'ce0d, 0xd110'd00f, 0xd312'd211, 0xd514'd413}},
6104 {{0x98d8'97d7'96d6'95d5, 0x9cdc'9bdb'9ada'99d9},
6105 {0xa0e0'9fdf'9ede'9ddd, 0xa4e4'a3e3'a2e2'a1e1},
6106 {0xa8e8'a7e7'a6e6'a5e5, 0xacec'abeb'aaea'a9e9},
6107 {0xb0f0'afef'aeee'aded, 0xb4f4'b3f3'b2f2'b1f1},
6108 {0xb8f8'b7f7'b6f6'b5f5, 0xbcfc'bbfb'bafa'b9f9},
6109 {0xc100'bfff'befe'bdfd, 0xc504'c403'c302'c201},
6110 {0xc908'c807'c706'c605, 0xcd0c'cc0b'cb0a'ca09},
6111 {0xd110'd00f'cf0e'ce0d, 0xd514'd413'd312'd211}},
6112 kVectorCalculationsSource);
6113 TestVectorInstruction(
6114 ExecVasubuvv,
6115 ExecMaskedVasubuvv,
6116 {{0, 248, 255, 247, 254, 246, 253, 245, 252, 4, 251, 3, 250, 2, 249, 1},
6117 {248, 240, 247, 239, 246, 238, 245, 237, 244, 252, 243, 251, 242, 250, 241, 249},
6118 {240, 232, 239, 231, 238, 230, 237, 229, 236, 244, 235, 243, 234, 242, 233, 241},
6119 {232, 224, 231, 223, 230, 222, 229, 221, 228, 236, 227, 235, 226, 234, 225, 233},
6120 {224, 88, 223, 87, 222, 86, 221, 85, 220, 100, 219, 99, 218, 98, 217, 97},
6121 {216, 80, 215, 79, 214, 78, 213, 77, 212, 92, 211, 91, 210, 90, 209, 89},
6122 {208, 72, 207, 71, 206, 70, 205, 69, 204, 84, 203, 83, 202, 82, 201, 81},
6123 {200, 64, 199, 63, 198, 62, 197, 61, 196, 76, 195, 75, 194, 74, 193, 73}},
6124 {{0xf780, 0xf67f, 0xf57e, 0xf47d, 0x037c, 0x027b, 0x017a, 0x0079},
6125 {0xef78, 0xee77, 0xed76, 0xec75, 0xfb74, 0xfa73, 0xf972, 0xf871},
6126 {0xe770, 0xe66f, 0xe56e, 0xe46d, 0xf36c, 0xf26b, 0xf16a, 0xf069},
6127 {0xdf68, 0xde67, 0xdd66, 0xdc65, 0xeb64, 0xea63, 0xe962, 0xe861},
6128 {0x5760, 0x565f, 0x555e, 0x545d, 0x635c, 0x625b, 0x615a, 0x6059},
6129 {0x4f58, 0x4e57, 0x4d56, 0x4c55, 0x5b54, 0x5a53, 0x5952, 0x5851},
6130 {0x4750, 0x464f, 0x454e, 0x444d, 0x534c, 0x524b, 0x514a, 0x5049},
6131 {0x3f48, 0x3e47, 0x3d46, 0x3c45, 0x4b44, 0x4a43, 0x4942, 0x4841}},
6132 {{0xf67e'f780, 0xf47c'f57e, 0x027b'037c, 0x0079'017a},
6133 {0xee76'ef78, 0xec74'ed76, 0xfa72'fb74, 0xf870'f972},
6134 {0xe66e'e770, 0xe46c'e56e, 0xf26a'f36c, 0xf068'f16a},
6135 {0xde66'df68, 0xdc64'dd66, 0xea62'eb64, 0xe860'e962},
6136 {0x565f'5760, 0x545d'555e, 0x625b'635c, 0x6059'615a},
6137 {0x4e57'4f58, 0x4c55'4d56, 0x5a53'5b54, 0x5851'5952},
6138 {0x464f'4750, 0x444d'454e, 0x524b'534c, 0x5049'514a},
6139 {0x3e47'3f48, 0x3c45'3d46, 0x4a43'4b44, 0x4841'4942}},
6140 {{0xf47c'f57d'767e'f780, 0x0079'017a'027b'037c},
6141 {0xec74'ed75'6e76'ef78, 0xf870'f971'fa72'fb74},
6142 {0xe46c'e56d'666e'e770, 0xf068'f169'f26a'f36c},
6143 {0xdc64'dd65'5e66'df68, 0xe860'e961'ea62'eb64},
6144 {0x545d'555d'd65f'5760, 0x6059'615a'625b'635c},
6145 {0x4c55'4d55'ce57'4f58, 0x5851'5952'5a53'5b54},
6146 {0x444d'454d'c64f'4750, 0x5049'514a'524b'534c},
6147 {0x3c45'3d45'be47'3f48, 0x4841'4942'4a43'4b44}},
6148 kVectorCalculationsSource);
6149 TestVectorInstruction(
6150 ExecVasubuvx,
6151 ExecMaskedVasubuvx,
6152 {{171, 236, 172, 237, 173, 238, 174, 239, 175, 240, 176, 241, 177, 242, 178, 243},
6153 {179, 244, 180, 245, 181, 246, 182, 247, 183, 248, 184, 249, 185, 250, 186, 251},
6154 {187, 252, 188, 253, 189, 254, 190, 255, 191, 0, 192, 1, 193, 2, 194, 3},
6155 {195, 4, 196, 5, 197, 6, 198, 7, 199, 8, 200, 9, 201, 10, 202, 11},
6156 {203, 12, 204, 13, 205, 14, 206, 15, 207, 16, 208, 17, 209, 18, 210, 19},
6157 {211, 20, 212, 21, 213, 22, 214, 23, 215, 24, 216, 25, 217, 26, 218, 27},
6158 {219, 28, 220, 29, 221, 30, 222, 31, 223, 32, 224, 33, 225, 34, 226, 35},
6159 {227, 36, 228, 37, 229, 38, 230, 39, 231, 40, 232, 41, 233, 42, 234, 43}},
6160 {{0xeb2b, 0xec2c, 0xed2d, 0xee2e, 0xef2f, 0xf030, 0xf131, 0xf232},
6161 {0xf333, 0xf434, 0xf535, 0xf636, 0xf737, 0xf838, 0xf939, 0xfa3a},
6162 {0xfb3b, 0xfc3c, 0xfd3d, 0xfe3e, 0xff3f, 0x0040, 0x0141, 0x0242},
6163 {0x0343, 0x0444, 0x0545, 0x0646, 0x0747, 0x0848, 0x0949, 0x0a4a},
6164 {0x0b4b, 0x0c4c, 0x0d4d, 0x0e4e, 0x0f4f, 0x1050, 0x1151, 0x1252},
6165 {0x1353, 0x1454, 0x1555, 0x1656, 0x1757, 0x1858, 0x1959, 0x1a5a},
6166 {0x1b5b, 0x1c5c, 0x1d5d, 0x1e5e, 0x1f5f, 0x2060, 0x2161, 0x2262},
6167 {0x2363, 0x2464, 0x2565, 0x2666, 0x2767, 0x2868, 0x2969, 0x2a6a}},
6168 {{0xec2b'eb2b, 0xee2d'ed2d, 0xf02f'ef2f, 0xf231'f131},
6169 {0xf433'f333, 0xf635'f535, 0xf837'f737, 0xfa39'f939},
6170 {0xfc3b'fb3b, 0xfe3d'fd3d, 0x003f'ff3f, 0x0242'0141},
6171 {0x0444'0343, 0x0646'0545, 0x0848'0747, 0x0a4a'0949},
6172 {0x0c4c'0b4b, 0x0e4e'0d4d, 0x1050'0f4f, 0x1252'1151},
6173 {0x1454'1353, 0x1656'1555, 0x1858'1757, 0x1a5a'1959},
6174 {0x1c5c'1b5b, 0x1e5e'1d5d, 0x2060'1f5f, 0x2262'2161},
6175 {0x2464'2363, 0x2666'2565, 0x2868'2767, 0x2a6a'2969}},
6176 {{0xee2d'ed2c'ec2b'eb2b, 0xf231'f130'f02f'ef2f},
6177 {0xf635'f534'f433'f333, 0xfa39'f938'f837'f737},
6178 {0xfe3d'fd3c'fc3b'fb3b, 0x0242'0141'003f'ff3f},
6179 {0x0646'0545'0444'0343, 0x0a4a'0949'0848'0747},
6180 {0x0e4e'0d4d'0c4c'0b4b, 0x1252'1151'1050'0f4f},
6181 {0x1656'1555'1454'1353, 0x1a5a'1959'1858'1757},
6182 {0x1e5e'1d5d'1c5c'1b5b, 0x2262'2161'2060'1f5f},
6183 {0x2666'2565'2464'2363, 0x2a6a'2969'2868'2767}},
6184 kVectorCalculationsSource);
6185 TestVectorInstruction(
6186 ExecVasubvv,
6187 ExecMaskedVasubvv,
6188 {{0, 248, 255, 247, 254, 246, 253, 245, 252, 4, 251, 3, 250, 2, 249, 1},
6189 {248, 240, 247, 239, 246, 238, 245, 237, 244, 252, 243, 251, 242, 250, 241, 249},
6190 {240, 232, 239, 231, 238, 230, 237, 229, 236, 244, 235, 243, 234, 242, 233, 241},
6191 {232, 224, 231, 223, 230, 222, 229, 221, 228, 236, 227, 235, 226, 234, 225, 233},
6192 {96, 216, 95, 215, 94, 214, 93, 213, 92, 228, 91, 227, 90, 226, 89, 225},
6193 {88, 208, 87, 207, 86, 206, 85, 205, 84, 220, 83, 219, 82, 218, 81, 217},
6194 {80, 200, 79, 199, 78, 198, 77, 197, 76, 212, 75, 211, 74, 210, 73, 209},
6195 {72, 192, 71, 191, 70, 190, 69, 189, 68, 204, 67, 203, 66, 202, 65, 201}},
6196 {{0xf780, 0xf67f, 0xf57e, 0xf47d, 0x037c, 0x027b, 0x017a, 0x0079},
6197 {0xef78, 0xee77, 0xed76, 0xec75, 0xfb74, 0xfa73, 0xf972, 0xf871},
6198 {0xe770, 0xe66f, 0xe56e, 0xe46d, 0xf36c, 0xf26b, 0xf16a, 0xf069},
6199 {0xdf68, 0xde67, 0xdd66, 0xdc65, 0xeb64, 0xea63, 0xe962, 0xe861},
6200 {0xd760, 0xd65f, 0xd55e, 0xd45d, 0xe35c, 0xe25b, 0xe15a, 0xe059},
6201 {0xcf58, 0xce57, 0xcd56, 0xcc55, 0xdb54, 0xda53, 0xd952, 0xd851},
6202 {0xc750, 0xc64f, 0xc54e, 0xc44d, 0xd34c, 0xd24b, 0xd14a, 0xd049},
6203 {0xbf48, 0xbe47, 0xbd46, 0xbc45, 0xcb44, 0xca43, 0xc942, 0xc841}},
6204 {{0xf67e'f780, 0xf47c'f57e, 0x027b'037c, 0x0079'017a},
6205 {0xee76'ef78, 0xec74'ed76, 0xfa72'fb74, 0xf870'f972},
6206 {0xe66e'e770, 0xe46c'e56e, 0xf26a'f36c, 0xf068'f16a},
6207 {0xde66'df68, 0xdc64'dd66, 0xea62'eb64, 0xe860'e962},
6208 {0xd65f'5760, 0xd45d'555e, 0xe25b'635c, 0xe059'615a},
6209 {0xce57'4f58, 0xcc55'4d56, 0xda53'5b54, 0xd851'5952},
6210 {0xc64f'4750, 0xc44d'454e, 0xd24b'534c, 0xd049'514a},
6211 {0xbe47'3f48, 0xbc45'3d46, 0xca43'4b44, 0xc841'4942}},
6212 {{0xf47c'f57d'767e'f780, 0x0079'017a'027b'037c},
6213 {0xec74'ed75'6e76'ef78, 0xf870'f971'fa72'fb74},
6214 {0xe46c'e56d'666e'e770, 0xf068'f169'f26a'f36c},
6215 {0xdc64'dd65'5e66'df68, 0xe860'e961'ea62'eb64},
6216 {0xd45d'555d'd65f'5760, 0xe059'615a'625b'635c},
6217 {0xcc55'4d55'ce57'4f58, 0xd851'5952'5a53'5b54},
6218 {0xc44d'454d'c64f'4750, 0xd049'514a'524b'534c},
6219 {0xbc45'3d45'be47'3f48, 0xc841'4942'4a43'4b44}},
6220 kVectorCalculationsSource);
6221 TestVectorInstruction(ExecVasubvx,
6222 ExecMaskedVasubvx,
6223 {{43, 236, 44, 237, 45, 238, 46, 239, 47, 240, 48, 241, 49, 242, 50, 243},
6224 {51, 244, 52, 245, 53, 246, 54, 247, 55, 248, 56, 249, 57, 250, 58, 251},
6225 {59, 252, 60, 253, 61, 254, 62, 255, 63, 0, 64, 1, 65, 2, 66, 3},
6226 {67, 4, 68, 5, 69, 6, 70, 7, 71, 8, 72, 9, 73, 10, 74, 11},
6227 {75, 12, 76, 13, 77, 14, 78, 15, 79, 16, 80, 17, 81, 18, 82, 19},
6228 {83, 20, 84, 21, 85, 22, 86, 23, 87, 24, 88, 25, 89, 26, 90, 27},
6229 {91, 28, 92, 29, 93, 30, 94, 31, 95, 32, 96, 33, 97, 34, 98, 35},
6230 {99, 36, 100, 37, 101, 38, 102, 39, 103, 40, 104, 41, 105, 42, 106, 43}},
6231 {{0xeb2b, 0xec2c, 0xed2d, 0xee2e, 0xef2f, 0xf030, 0xf131, 0xf232},
6232 {0xf333, 0xf434, 0xf535, 0xf636, 0xf737, 0xf838, 0xf939, 0xfa3a},
6233 {0xfb3b, 0xfc3c, 0xfd3d, 0xfe3e, 0xff3f, 0x0040, 0x0141, 0x0242},
6234 {0x0343, 0x0444, 0x0545, 0x0646, 0x0747, 0x0848, 0x0949, 0x0a4a},
6235 {0x0b4b, 0x0c4c, 0x0d4d, 0x0e4e, 0x0f4f, 0x1050, 0x1151, 0x1252},
6236 {0x1353, 0x1454, 0x1555, 0x1656, 0x1757, 0x1858, 0x1959, 0x1a5a},
6237 {0x1b5b, 0x1c5c, 0x1d5d, 0x1e5e, 0x1f5f, 0x2060, 0x2161, 0x2262},
6238 {0x2363, 0x2464, 0x2565, 0x2666, 0x2767, 0x2868, 0x2969, 0x2a6a}},
6239 {{0xec2b'eb2b, 0xee2d'ed2d, 0xf02f'ef2f, 0xf231'f131},
6240 {0xf433'f333, 0xf635'f535, 0xf837'f737, 0xfa39'f939},
6241 {0xfc3b'fb3b, 0xfe3d'fd3d, 0x003f'ff3f, 0x0242'0141},
6242 {0x0444'0343, 0x0646'0545, 0x0848'0747, 0x0a4a'0949},
6243 {0x0c4c'0b4b, 0x0e4e'0d4d, 0x1050'0f4f, 0x1252'1151},
6244 {0x1454'1353, 0x1656'1555, 0x1858'1757, 0x1a5a'1959},
6245 {0x1c5c'1b5b, 0x1e5e'1d5d, 0x2060'1f5f, 0x2262'2161},
6246 {0x2464'2363, 0x2666'2565, 0x2868'2767, 0x2a6a'2969}},
6247 {{0xee2d'ed2c'ec2b'eb2b, 0xf231'f130'f02f'ef2f},
6248 {0xf635'f534'f433'f333, 0xfa39'f938'f837'f737},
6249 {0xfe3d'fd3c'fc3b'fb3b, 0x0242'0141'003f'ff3f},
6250 {0x0646'0545'0444'0343, 0x0a4a'0949'0848'0747},
6251 {0x0e4e'0d4d'0c4c'0b4b, 0x1252'1151'1050'0f4f},
6252 {0x1656'1555'1454'1353, 0x1a5a'1959'1858'1757},
6253 {0x1e5e'1d5d'1c5c'1b5b, 0x2262'2161'2060'1f5f},
6254 {0x2666'2565'2464'2363, 0x2a6a'2969'2868'2767}},
6255 kVectorCalculationsSource);
6256 TestNarrowingVectorInstruction(ExecVnclipuwi,
6257 ExecMaskedVnclipuwi,
6258 {{32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37, 38, 38, 39, 39, 40},
6259 {40, 41, 41, 42, 42, 43, 43, 44, 44, 45, 45, 46, 46, 47, 47, 48},
6260 {48, 49, 49, 50, 50, 51, 51, 52, 52, 53, 53, 54, 54, 55, 55, 56},
6261 {56, 57, 57, 58, 58, 59, 59, 60, 60, 61, 61, 62, 62, 63, 63, 64}},
6262 {{0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
6263 {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
6264 {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
6265 {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff}},
6266 {{0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff},
6267 {0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff},
6268 {0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff},
6269 {0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff}},
6270 kVectorCalculationsSource);
6271 TestNarrowingVectorInstruction(
6272 ExecVnclipwi,
6273 ExecMaskedVnclipwi,
6274 {{224, 225, 225, 226, 226, 227, 227, 228, 228, 229, 229, 230, 230, 231, 231, 232},
6275 {232, 233, 233, 234, 234, 235, 235, 236, 236, 237, 237, 238, 238, 239, 239, 240},
6276 {240, 241, 241, 242, 242, 243, 243, 244, 244, 245, 245, 246, 246, 247, 247, 248},
6277 {248, 249, 249, 250, 250, 251, 251, 252, 252, 253, 253, 254, 254, 255, 255, 0}},
6278 {{0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000},
6279 {0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000},
6280 {0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000},
6281 {0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0xdfbf}},
6282 {{0x8000'0000, 0x8000'0000, 0x8000'0000, 0x8000'0000},
6283 {0x8000'0000, 0x8000'0000, 0x8000'0000, 0x8000'0000},
6284 {0x8000'0000, 0x8000'0000, 0x8000'0000, 0x8000'0000},
6285 {0x8000'0000, 0x8000'0000, 0x8000'0000, 0x8000'0000}},
6286 kVectorCalculationsSource);
6287
6288 TestNarrowingVectorInstruction(ExecVnclipuwx,
6289 ExecMaskedVnclipuwx,
6290 {{32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37, 38, 38, 39, 39, 40},
6291 {40, 41, 41, 42, 42, 43, 43, 44, 44, 45, 45, 46, 46, 47, 47, 48},
6292 {48, 49, 49, 50, 50, 51, 51, 52, 52, 53, 53, 54, 54, 55, 55, 56},
6293 {56, 57, 57, 58, 58, 59, 59, 60, 60, 61, 61, 62, 62, 63, 63, 64}},
6294 {{0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
6295 {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
6296 {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
6297 {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff}},
6298 {{0x0021'c1a1, 0x0023'c3a3, 0x0025'c5a5, 0x0027'c7a7},
6299 {0x0029'c9a9, 0x002b'cbab, 0x002d'cdad, 0x002f'cfaf},
6300 {0x0031'd1b1, 0x0033'd3b3, 0x0035'd5b5, 0x0037'd7b7},
6301 {0x0039'd9b9, 0x003b'dbbb, 0x003d'ddbd, 0x003f'dfbf}},
6302 kVectorCalculationsSource);
6303
6304 TestNarrowingVectorInstruction(
6305 ExecVnclipwx,
6306 ExecMaskedVnclipwx,
6307 {{224, 225, 225, 226, 226, 227, 227, 228, 228, 229, 229, 230, 230, 231, 231, 232},
6308 {232, 233, 233, 234, 234, 235, 235, 236, 236, 237, 237, 238, 238, 239, 239, 240},
6309 {240, 241, 241, 242, 242, 243, 243, 244, 244, 245, 245, 246, 246, 247, 247, 248},
6310 {248, 249, 249, 250, 250, 251, 251, 252, 252, 253, 253, 254, 254, 255, 255, 0}},
6311 {{0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000},
6312 {0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000},
6313 {0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000},
6314 {0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0xdfbf}},
6315 {{0xffe1'c1a1, 0xffe3'c3a3, 0xffe5'c5a5, 0xffe7'c7a7},
6316 {0xffe9'c9a9, 0xffeb'cbab, 0xffed'cdad, 0xffef'cfaf},
6317 {0xfff1'd1b1, 0xfff3'd3b3, 0xfff5'd5b5, 0xfff7'd7b7},
6318 {0xfff9'd9b9, 0xfffb'dbbb, 0xfffd'ddbd, 0xffff'dfbf}},
6319 kVectorCalculationsSource);
6320
6321 TestNarrowingVectorInstruction(
6322 ExecVnclipuwv,
6323 ExecMaskedVnclipuwv,
6324 {{255, 255, 255, 255, 69, 35, 9, 2, 255, 255, 255, 255, 153, 39, 10, 2},
6325 {255, 255, 255, 255, 85, 43, 11, 3, 255, 255, 255, 255, 185, 47, 12, 3},
6326 {255, 255, 255, 255, 101, 51, 13, 3, 255, 255, 255, 255, 217, 55, 14, 3},
6327 {255, 255, 255, 255, 117, 59, 15, 4, 255, 255, 255, 255, 249, 63, 16, 4}},
6328 {{0xffff, 0xffff, 0xffff, 0xffff, 0x4989, 0x0971, 0x009b, 0x000a},
6329 {0xffff, 0xffff, 0xffff, 0xffff, 0x5999, 0x0b73, 0x00bb, 0x000c},
6330 {0xffff, 0xffff, 0xffff, 0xffff, 0x69a9, 0x0d75, 0x00db, 0x000e},
6331 {0xffff, 0xffff, 0xffff, 0xffff, 0x79b9, 0x0f77, 0x00fb, 0x0010}},
6332 {{0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff},
6333 {0xa726'a525, 0x0057'9757, 0x0000'5b9b, 0x0000'00bf},
6334 {0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff},
6335 {0xe766'e565, 0x0077'b777, 0x0000'7bbb, 0x0000'00ff}},
6336 kVectorCalculationsSource);
6337
6338 TestNarrowingVectorInstruction(
6339 ExecVnclipwv,
6340 ExecMaskedVnclipwv,
6341 {{128, 128, 128, 128, 197, 227, 249, 254, 128, 128, 128, 128, 153, 231, 250, 254},
6342 {128, 128, 128, 128, 213, 235, 251, 255, 128, 128, 128, 128, 185, 239, 252, 255},
6343 {128, 128, 128, 128, 229, 243, 253, 255, 128, 128, 128, 128, 217, 247, 254, 255},
6344 {128, 128, 128, 158, 245, 251, 255, 0, 128, 128, 128, 222, 249, 255, 0, 0}},
6345 {{0x8000, 0x8000, 0x8000, 0x8000, 0xc989, 0xf971, 0xff9b, 0xfffa},
6346 {0x8000, 0x8000, 0x8000, 0x8000, 0xd999, 0xfb73, 0xffbb, 0xfffc},
6347 {0x8000, 0x8000, 0x8000, 0x8000, 0xe9a9, 0xfd75, 0xffdb, 0xfffe},
6348 {0x8000, 0x8000, 0x8000, 0x8000, 0xf9b9, 0xff77, 0xfffb, 0x0000}},
6349 {{0x8000'0000, 0x8000'0000, 0x8000'0000, 0x8000'0000},
6350 {0xa726'a525, 0xffd7'9757, 0xffff'db9b, 0xffff'ffbf},
6351 {0x8000'0000, 0x8000'0000, 0x8000'0000, 0x8000'0000},
6352 {0xe766'e565, 0xfff7'b777, 0xffff'fbbb, 0xffff'ffff}},
6353 kVectorCalculationsSource);
6354
6355 TestVectorInstruction(
6356 ExecVsmulvv,
6357 ExecMaskedVsmulvv,
6358 {{0, 109, 0, 104, 0, 98, 1, 93, 1, 117, 2, 112, 2, 106, 3, 101},
6359 {4, 68, 5, 63, 6, 59, 8, 54, 9, 76, 11, 71, 12, 67, 14, 62},
6360 {16, 34, 18, 31, 21, 27, 23, 24, 25, 42, 28, 39, 30, 35, 33, 32},
6361 {36, 9, 39, 6, 43, 4, 46, 1, 49, 17, 53, 14, 56, 12, 60, 9},
6362 {192, 247, 192, 246, 193, 244, 193, 243, 194, 255, 194, 254, 194, 252, 195, 251},
6363 {196, 238, 197, 237, 199, 237, 200, 236, 202, 246, 203, 245, 204, 245, 206, 244},
6364 {208, 236, 210, 237, 213, 237, 215, 238, 218, 244, 220, 245, 222, 245, 225, 246},
6365 {228, 243, 231, 244, 235, 246, 238, 247, 242, 251, 245, 252, 248, 254, 252, 255}},
6366 {{0x6d24, 0x677e, 0x61f8, 0x5c94, 0x750c, 0x6f68, 0x69e3, 0x647f},
6367 {0x437f, 0x3edb, 0x3a57, 0x35f5, 0x4b6b, 0x46c9, 0x4246, 0x3de3},
6368 {0x21e9, 0x1e48, 0x1ac5, 0x1765, 0x29da, 0x2639, 0x22b8, 0x1f58},
6369 {0x0864, 0x05c4, 0x0344, 0x00e6, 0x1058, 0x0dba, 0x0b3b, 0x08dd},
6370 {0xf6ee, 0xf551, 0xf3d3, 0xf276, 0xfee7, 0xfd4b, 0xfbce, 0xfa71},
6371 {0xed89, 0xeced, 0xec72, 0xec17, 0xf586, 0xf4eb, 0xf470, 0xf416},
6372 {0xec34, 0xec9a, 0xed21, 0xedc8, 0xf435, 0xf49c, 0xf523, 0xf5cb},
6373 {0xf2ee, 0xf457, 0xf5df, 0xf788, 0xfaf4, 0xfc5d, 0xfde6, 0xff8f}},
6374 {{0x677d'76af, 0x5c93'1931, 0x6f67'3831, 0x647d'dbb7},
6375 {0x3eda'09c6, 0x35f3'b250, 0x46c7'cf50, 0x3de2'78de},
6376 {0x1e46'b4fd, 0x1764'6390, 0x2638'7e90, 0x1f57'2e25},
6377 {0x05c3'7855, 0x00e5'2cef, 0x0db9'45ef, 0x08db'fb8d},
6378 {0xf550'cd47, 0xf276'7fe1, 0xfd4a'8eda, 0xfa71'4277},
6379 {0xeced'a0be, 0xec17'5961, 0xf4eb'6659, 0xf416'1ffe},
6380 {0xec9a'8c56, 0xedc8'4b01, 0xf49c'55f9, 0xf5cb'15a6},
6381 {0xf457'900e, 0xf789'54c1, 0xfc5d'5db9, 0xff90'236e}},
6382 {{0x5c93'192f'ccd4'7781, 0x647d'dbb5'bb66'23af},
6383 {0x35f3'b24f'43d0'aa38, 0x3de2'78dd'1a4e'4256},
6384 {0x1764'638e'e2fd'152f, 0x1f57'2e24'a166'993d},
6385 {0x00e5'2cee'aa59'b866, 0x08db'fb8c'50af'2865},
6386 {0xf276'7fe1'80cf'f441, 0xfa71'4276'eef1'1fff},
6387 {0xec17'5961'584c'a799, 0xf416'1ffe'ae59'bf47},
6388 {0xedc8'4b01'57f9'9330, 0xf5cb'15a6'95f2'96cf},
6389 {0xf789'54c1'7fd6'b708, 0xff90'236e'a5bb'a696}},
6390 kVectorCalculationsSource);
6391 TestVectorInstruction(ExecVsmulvx,
6392 ExecMaskedVsmulvx,
6393 {{0, 85, 255, 84, 253, 83, 252, 81, 251, 80, 249, 79, 248, 77, 247, 76},
6394 {245, 75, 244, 73, 243, 72, 241, 71, 240, 69, 239, 68, 237, 67, 236, 65},
6395 {235, 64, 233, 62, 232, 61, 230, 60, 229, 58, 228, 57, 226, 56, 225, 54},
6396 {224, 53, 222, 52, 221, 50, 220, 49, 218, 48, 217, 46, 216, 45, 214, 44},
6397 {213, 42, 212, 41, 210, 40, 209, 38, 208, 37, 206, 36, 205, 34, 204, 33},
6398 {202, 32, 201, 30, 200, 29, 198, 28, 197, 26, 196, 25, 194, 24, 193, 22},
6399 {192, 21, 190, 19, 189, 18, 187, 17, 186, 15, 185, 14, 183, 13, 182, 11},
6400 {181, 10, 179, 9, 178, 7, 177, 6, 175, 5, 174, 3, 173, 2, 171, 1}},
6401 {{0x54ab, 0x5355, 0x51fe, 0x50a7, 0x4f51, 0x4dfa, 0x4ca3, 0x4b4d},
6402 {0x49f6, 0x489f, 0x4749, 0x45f2, 0x449b, 0x4345, 0x41ee, 0x4097},
6403 {0x3f40, 0x3dea, 0x3c93, 0x3b3c, 0x39e6, 0x388f, 0x3738, 0x35e2},
6404 {0x348b, 0x3334, 0x31de, 0x3087, 0x2f30, 0x2dda, 0x2c83, 0x2b2c},
6405 {0x29d6, 0x287f, 0x2728, 0x25d2, 0x247b, 0x2324, 0x21ce, 0x2077},
6406 {0x1f20, 0x1dca, 0x1c73, 0x1b1c, 0x19c6, 0x186f, 0x1718, 0x15c2},
6407 {0x146b, 0x1314, 0x11bd, 0x1067, 0x0f10, 0x0db9, 0x0c63, 0x0b0c},
6408 {0x09b5, 0x085f, 0x0708, 0x05b1, 0x045b, 0x0304, 0x01ad, 0x0057}},
6409 {{0x5353'aa01, 0x50a6'51fe, 0x4df8'f9fb, 0x4b4b'a1f9},
6410 {0x489e'49f6, 0x45f0'f1f3, 0x4343'99f1, 0x4096'41ee},
6411 {0x3de8'e9eb, 0x3b3b'91e8, 0x388e'39e6, 0x35e0'e1e3},
6412 {0x3333'89e0, 0x3086'31de, 0x2dd8'd9db, 0x2b2b'81d8},
6413 {0x287e'29d6, 0x25d0'd1d3, 0x2323'79d0, 0x2076'21ce},
6414 {0x1dc8'c9cb, 0x1b1b'71c8, 0x186e'19c6, 0x15c0'c1c3},
6415 {0x1313'69c0, 0x1066'11bd, 0x0db8'b9bb, 0x0b0b'61b8},
6416 {0x085e'09b5, 0x05b0'b1b3, 0x0303'59b0, 0x0056'01ad}},
6417 {{0x50a6'51fc'fdfe'54ab, 0x4b4b'a1f7'a34e'4f51},
6418 {0x45f0'f1f2'489e'49f6, 0x4096'41ec'edee'449b},
6419 {0x3b3b'91e7'933e'3f40, 0x35e0'e1e2'388e'39e6},
6420 {0x3086'31dc'ddde'348b, 0x2b2b'81d7'832e'2f30},
6421 {0x25d0'd1d2'287e'29d6, 0x2076'21cc'cdce'247b},
6422 {0x1b1b'71c7'731e'1f20, 0x15c0'c1c2'186e'19c6},
6423 {0x1066'11bc'bdbe'146b, 0x0b0b'61b7'630e'0f10},
6424 {0x05b0'b1b2'085e'09b5, 0x0056'01ac'adae'045b}},
6425 kVectorCalculationsSource);
6426
6427 TestVectorInstruction(ExecVssrlvv,
6428 ExecMaskedVssrlvv,
6429 {{0, 32, 0, 2, 2, 33, 0, 2, 4, 34, 1, 2, 12, 35, 1, 2},
6430 {16, 36, 1, 2, 10, 37, 1, 2, 12, 38, 2, 2, 28, 39, 2, 2},
6431 {32, 40, 2, 3, 18, 41, 2, 3, 20, 42, 3, 3, 44, 43, 3, 3},
6432 {48, 44, 3, 3, 26, 45, 3, 3, 28, 46, 4, 3, 60, 47, 4, 3},
6433 {64, 48, 4, 3, 34, 49, 4, 3, 36, 50, 5, 3, 76, 51, 5, 3},
6434 {80, 52, 5, 3, 42, 53, 5, 3, 44, 54, 6, 3, 92, 55, 6, 3},
6435 {96, 56, 6, 4, 50, 57, 6, 4, 52, 58, 7, 4, 108, 59, 7, 4},
6436 {112, 60, 7, 4, 58, 61, 7, 4, 60, 62, 8, 4, 124, 63, 8, 4}},
6437 {{0x8100, 0x0830, 0x0043, 0x0008, 0x4484, 0x08b1, 0x008d, 0x0009},
6438 {0x9110, 0x0931, 0x004b, 0x0009, 0x4c8c, 0x09b2, 0x009d, 0x000a},
6439 {0xa120, 0x0a32, 0x0053, 0x000a, 0x5494, 0x0ab3, 0x00ad, 0x000b},
6440 {0xb130, 0x0b33, 0x005b, 0x000b, 0x5c9c, 0x0bb4, 0x00bd, 0x000c},
6441 {0xc140, 0x0c34, 0x0063, 0x000c, 0x64a4, 0x0cb5, 0x00cd, 0x000d},
6442 {0xd150, 0x0d35, 0x006b, 0x000d, 0x6cac, 0x0db6, 0x00dd, 0x000e},
6443 {0xe160, 0x0e36, 0x0073, 0x000e, 0x74b4, 0x0eb7, 0x00ed, 0x000f},
6444 {0xf170, 0x0f37, 0x007b, 0x000f, 0x7cbc, 0x0fb8, 0x00fd, 0x0010}},
6445 {{0x8302'8100, 0x0043'8343, 0x0000'4585, 0x0000'008f},
6446 {0x9312'9110, 0x004b'8b4b, 0x0000'4d8d, 0x0000'009f},
6447 {0xa322'a120, 0x0053'9353, 0x0000'5595, 0x0000'00af},
6448 {0xb332'b130, 0x005b'9b5b, 0x0000'5d9d, 0x0000'00bf},
6449 {0xc342'c140, 0x0063'a363, 0x0000'65a5, 0x0000'00cf},
6450 {0xd352'd150, 0x006b'ab6b, 0x0000'6dad, 0x0000'00df},
6451 {0xe362'e160, 0x0073'b373, 0x0000'75b5, 0x0000'00ef},
6452 {0xf372'f170, 0x007b'bb7b, 0x0000'7dbd, 0x0000'00ff}},
6453 {{0x8706'8504'8302'8100, 0x0000'4787'4686'4585},
6454 {0x0000'0000'9716'9515, 0x0000'0000'0000'4f8f},
6455 {0xa726'a524'a322'a120, 0x0000'5797'5696'5595},
6456 {0x0000'0000'b736'b535, 0x0000'0000'0000'5f9f},
6457 {0xc746'c544'c342'c140, 0x0000'67a7'66a6'65a5},
6458 {0x0000'0000'd756'd555, 0x0000'0000'0000'6faf},
6459 {0xe766'e564'e362'e160, 0x0000'77b7'76b6'75b5},
6460 {0x0000'0000'f776'f575, 0x0000'0000'0000'7fbf}},
6461 kVectorCalculationsSource);
6462
6463 TestVectorInstruction(ExecVssrlvx,
6464 ExecMaskedVssrlvx,
6465 {{0, 32, 1, 33, 1, 33, 2, 34, 2, 34, 3, 35, 3, 35, 4, 36},
6466 {4, 36, 5, 37, 5, 37, 6, 38, 6, 38, 7, 39, 7, 39, 8, 40},
6467 {8, 40, 9, 41, 9, 41, 10, 42, 10, 42, 11, 43, 11, 43, 12, 44},
6468 {12, 44, 13, 45, 13, 45, 14, 46, 14, 46, 15, 47, 15, 47, 16, 48},
6469 {16, 48, 17, 49, 17, 49, 18, 50, 18, 50, 19, 51, 19, 51, 20, 52},
6470 {20, 52, 21, 53, 21, 53, 22, 54, 22, 54, 23, 55, 23, 55, 24, 56},
6471 {24, 56, 25, 57, 25, 57, 26, 58, 26, 58, 27, 59, 27, 59, 28, 60},
6472 {28, 60, 29, 61, 29, 61, 30, 62, 30, 62, 31, 63, 31, 63, 32, 64}},
6473 {{0x0020, 0x0021, 0x0021, 0x0022, 0x0022, 0x0023, 0x0023, 0x0024},
6474 {0x0024, 0x0025, 0x0025, 0x0026, 0x0026, 0x0027, 0x0027, 0x0028},
6475 {0x0028, 0x0029, 0x0029, 0x002a, 0x002a, 0x002b, 0x002b, 0x002c},
6476 {0x002c, 0x002d, 0x002d, 0x002e, 0x002e, 0x002f, 0x002f, 0x0030},
6477 {0x0030, 0x0031, 0x0031, 0x0032, 0x0032, 0x0033, 0x0033, 0x0034},
6478 {0x0034, 0x0035, 0x0035, 0x0036, 0x0036, 0x0037, 0x0037, 0x0038},
6479 {0x0038, 0x0039, 0x0039, 0x003a, 0x003a, 0x003b, 0x003b, 0x003c},
6480 {0x003c, 0x003d, 0x003d, 0x003e, 0x003e, 0x003f, 0x003f, 0x0040}},
6481 {{0x0020'c0a0, 0x0021'c1a1, 0x0022'c2a2, 0x0023'c3a3},
6482 {0x0024'c4a4, 0x0025'c5a5, 0x0026'c6a6, 0x0027'c7a7},
6483 {0x0028'c8a8, 0x0029'c9a9, 0x002a'caaa, 0x002b'cbab},
6484 {0x002c'ccac, 0x002d'cdad, 0x002e'ceae, 0x002f'cfaf},
6485 {0x0030'd0b0, 0x0031'd1b1, 0x0032'd2b2, 0x0033'd3b3},
6486 {0x0034'd4b4, 0x0035'd5b5, 0x0036'd6b6, 0x0037'd7b7},
6487 {0x0038'd8b8, 0x0039'd9b9, 0x003a'daba, 0x003b'dbbb},
6488 {0x003c'dcbc, 0x003d'ddbd, 0x003e'debe, 0x003f'dfbf}},
6489 {{0x0000'0000'0021'c1a1, 0x0000'0000'0023'c3a3},
6490 {0x0000'0000'0025'c5a5, 0x0000'0000'0027'c7a7},
6491 {0x0000'0000'0029'c9a9, 0x0000'0000'002b'cbab},
6492 {0x0000'0000'002d'cdad, 0x0000'0000'002f'cfaf},
6493 {0x0000'0000'0031'd1b1, 0x0000'0000'0033'd3b3},
6494 {0x0000'0000'0035'd5b5, 0x0000'0000'0037'd7b7},
6495 {0x0000'0000'0039'd9b9, 0x0000'0000'003b'dbbb},
6496 {0x0000'0000'003d'ddbd, 0x0000'0000'003f'dfbf}},
6497 kVectorCalculationsSource);
6498
6499 TestVectorInstruction(ExecVssrlvi,
6500 ExecMaskedVssrlvi,
6501 {{0, 32, 1, 33, 1, 33, 2, 34, 2, 34, 3, 35, 3, 35, 4, 36},
6502 {4, 36, 5, 37, 5, 37, 6, 38, 6, 38, 7, 39, 7, 39, 8, 40},
6503 {8, 40, 9, 41, 9, 41, 10, 42, 10, 42, 11, 43, 11, 43, 12, 44},
6504 {12, 44, 13, 45, 13, 45, 14, 46, 14, 46, 15, 47, 15, 47, 16, 48},
6505 {16, 48, 17, 49, 17, 49, 18, 50, 18, 50, 19, 51, 19, 51, 20, 52},
6506 {20, 52, 21, 53, 21, 53, 22, 54, 22, 54, 23, 55, 23, 55, 24, 56},
6507 {24, 56, 25, 57, 25, 57, 26, 58, 26, 58, 27, 59, 27, 59, 28, 60},
6508 {28, 60, 29, 61, 29, 61, 30, 62, 30, 62, 31, 63, 31, 63, 32, 64}},
6509 {{0x0020, 0x0021, 0x0021, 0x0022, 0x0022, 0x0023, 0x0023, 0x0024},
6510 {0x0024, 0x0025, 0x0025, 0x0026, 0x0026, 0x0027, 0x0027, 0x0028},
6511 {0x0028, 0x0029, 0x0029, 0x002a, 0x002a, 0x002b, 0x002b, 0x002c},
6512 {0x002c, 0x002d, 0x002d, 0x002e, 0x002e, 0x002f, 0x002f, 0x0030},
6513 {0x0030, 0x0031, 0x0031, 0x0032, 0x0032, 0x0033, 0x0033, 0x0034},
6514 {0x0034, 0x0035, 0x0035, 0x0036, 0x0036, 0x0037, 0x0037, 0x0038},
6515 {0x0038, 0x0039, 0x0039, 0x003a, 0x003a, 0x003b, 0x003b, 0x003c},
6516 {0x003c, 0x003d, 0x003d, 0x003e, 0x003e, 0x003f, 0x003f, 0x0040}},
6517 {{0x0020'c0a0, 0x0021'c1a1, 0x0022'c2a2, 0x0023'c3a3},
6518 {0x0024'c4a4, 0x0025'c5a5, 0x0026'c6a6, 0x0027'c7a7},
6519 {0x0028'c8a8, 0x0029'c9a9, 0x002a'caaa, 0x002b'cbab},
6520 {0x002c'ccac, 0x002d'cdad, 0x002e'ceae, 0x002f'cfaf},
6521 {0x0030'd0b0, 0x0031'd1b1, 0x0032'd2b2, 0x0033'd3b3},
6522 {0x0034'd4b4, 0x0035'd5b5, 0x0036'd6b6, 0x0037'd7b7},
6523 {0x0038'd8b8, 0x0039'd9b9, 0x003a'daba, 0x003b'dbbb},
6524 {0x003c'dcbc, 0x003d'ddbd, 0x003e'debe, 0x003f'dfbf}},
6525 {{0x0021'c1a1'4120'c0a0, 0x0023'c3a3'4322'c2a2},
6526 {0x0025'c5a5'4524'c4a4, 0x0027'c7a7'4726'c6a6},
6527 {0x0029'c9a9'4928'c8a8, 0x002b'cbab'4b2a'caaa},
6528 {0x002d'cdad'4d2c'ccac, 0x002f'cfaf'4f2e'ceae},
6529 {0x0031'd1b1'5130'd0b0, 0x0033'd3b3'5332'd2b2},
6530 {0x0035'd5b5'5534'd4b4, 0x0037'd7b7'5736'd6b6},
6531 {0x0039'd9b9'5938'd8b8, 0x003b'dbbb'5b3a'daba},
6532 {0x003d'ddbd'5d3c'dcbc, 0x003f'dfbf'5f3e'debe}},
6533 kVectorCalculationsSource);
6534 TestVectorInstruction(ExecVssravv,
6535 ExecMaskedVssravv,
6536 {{0, 224, 0, 254, 2, 225, 0, 254, 4, 226, 1, 254, 12, 227, 1, 254},
6537 {16, 228, 1, 254, 10, 229, 1, 254, 12, 230, 2, 254, 28, 231, 2, 254},
6538 {32, 232, 2, 255, 18, 233, 2, 255, 20, 234, 3, 255, 44, 235, 3, 255},
6539 {48, 236, 3, 255, 26, 237, 3, 255, 28, 238, 4, 255, 60, 239, 4, 255},
6540 {64, 240, 4, 255, 34, 241, 4, 255, 36, 242, 5, 255, 76, 243, 5, 255},
6541 {80, 244, 5, 255, 42, 245, 5, 255, 44, 246, 6, 255, 92, 247, 6, 255},
6542 {96, 248, 6, 0, 50, 249, 6, 0, 52, 250, 7, 0, 108, 251, 7, 0},
6543 {112, 252, 7, 0, 58, 253, 7, 0, 60, 254, 8, 0, 124, 255, 8, 0}},
6544 {{0x8100, 0xf830, 0xffc3, 0xfff8, 0xc484, 0xf8b1, 0xff8d, 0xfff9},
6545 {0x9110, 0xf931, 0xffcb, 0xfff9, 0xcc8c, 0xf9b2, 0xff9d, 0xfffa},
6546 {0xa120, 0xfa32, 0xffd3, 0xfffa, 0xd494, 0xfab3, 0xffad, 0xfffb},
6547 {0xb130, 0xfb33, 0xffdb, 0xfffb, 0xdc9c, 0xfbb4, 0xffbd, 0xfffc},
6548 {0xc140, 0xfc34, 0xffe3, 0xfffc, 0xe4a4, 0xfcb5, 0xffcd, 0xfffd},
6549 {0xd150, 0xfd35, 0xffeb, 0xfffd, 0xecac, 0xfdb6, 0xffdd, 0xfffe},
6550 {0xe160, 0xfe36, 0xfff3, 0xfffe, 0xf4b4, 0xfeb7, 0xffed, 0xffff},
6551 {0xf170, 0xff37, 0xfffb, 0xffff, 0xfcbc, 0xffb8, 0xfffd, 0x0000}},
6552 {{0x8302'8100, 0xffc3'8343, 0xffff'c585, 0xffff'ff8f},
6553 {0x9312'9110, 0xffcb'8b4b, 0xffff'cd8d, 0xffff'ff9f},
6554 {0xa322'a120, 0xffd3'9353, 0xffff'd595, 0xffff'ffaf},
6555 {0xb332'b130, 0xffdb'9b5b, 0xffff'dd9d, 0xffff'ffbf},
6556 {0xc342'c140, 0xffe3'a363, 0xffff'e5a5, 0xffff'ffcf},
6557 {0xd352'd150, 0xffeb'ab6b, 0xffff'edad, 0xffff'ffdf},
6558 {0xe362'e160, 0xfff3'b373, 0xffff'f5b5, 0xffff'ffef},
6559 {0xf372'f170, 0xfffb'bb7b, 0xffff'fdbd, 0xffff'ffff}},
6560 {{0x8706'8504'8302'8100, 0xffff'c787'4686'4585},
6561 {0xffff'ffff'9716'9515, 0xffff'ffff'ffff'cf8f},
6562 {0xa726'a524'a322'a120, 0xffff'd797'5696'5595},
6563 {0xffff'ffff'b736'b535, 0xffff'ffff'ffff'df9f},
6564 {0xc746'c544'c342'c140, 0xffff'e7a7'66a6'65a5},
6565 {0xffff'ffff'd756'd555, 0xffff'ffff'ffff'efaf},
6566 {0xe766'e564'e362'e160, 0xffff'f7b7'76b6'75b5},
6567 {0xffff'ffff'f776'f575, 0xffff'ffff'ffff'ffbf}},
6568 kVectorCalculationsSource);
6569
6570 TestVectorInstruction(ExecVssravx,
6571 ExecMaskedVssravx,
6572 {{0, 224, 1, 225, 1, 225, 2, 226, 2, 226, 3, 227, 3, 227, 4, 228},
6573 {4, 228, 5, 229, 5, 229, 6, 230, 6, 230, 7, 231, 7, 231, 8, 232},
6574 {8, 232, 9, 233, 9, 233, 10, 234, 10, 234, 11, 235, 11, 235, 12, 236},
6575 {12, 236, 13, 237, 13, 237, 14, 238, 14, 238, 15, 239, 15, 239, 16, 240},
6576 {16, 240, 17, 241, 17, 241, 18, 242, 18, 242, 19, 243, 19, 243, 20, 244},
6577 {20, 244, 21, 245, 21, 245, 22, 246, 22, 246, 23, 247, 23, 247, 24, 248},
6578 {24, 248, 25, 249, 25, 249, 26, 250, 26, 250, 27, 251, 27, 251, 28, 252},
6579 {28, 252, 29, 253, 29, 253, 30, 254, 30, 254, 31, 255, 31, 255, 32, 0}},
6580 {{0xffe0, 0xffe1, 0xffe1, 0xffe2, 0xffe2, 0xffe3, 0xffe3, 0xffe4},
6581 {0xffe4, 0xffe5, 0xffe5, 0xffe6, 0xffe6, 0xffe7, 0xffe7, 0xffe8},
6582 {0xffe8, 0xffe9, 0xffe9, 0xffea, 0xffea, 0xffeb, 0xffeb, 0xffec},
6583 {0xffec, 0xffed, 0xffed, 0xffee, 0xffee, 0xffef, 0xffef, 0xfff0},
6584 {0xfff0, 0xfff1, 0xfff1, 0xfff2, 0xfff2, 0xfff3, 0xfff3, 0xfff4},
6585 {0xfff4, 0xfff5, 0xfff5, 0xfff6, 0xfff6, 0xfff7, 0xfff7, 0xfff8},
6586 {0xfff8, 0xfff9, 0xfff9, 0xfffa, 0xfffa, 0xfffb, 0xfffb, 0xfffc},
6587 {0xfffc, 0xfffd, 0xfffd, 0xfffe, 0xfffe, 0xffff, 0xffff, 0x0000}},
6588 {{0xffe0'c0a0, 0xffe1'c1a1, 0xffe2'c2a2, 0xffe3'c3a3},
6589 {0xffe4'c4a4, 0xffe5'c5a5, 0xffe6'c6a6, 0xffe7'c7a7},
6590 {0xffe8'c8a8, 0xffe9'c9a9, 0xffea'caaa, 0xffeb'cbab},
6591 {0xffec'ccac, 0xffed'cdad, 0xffee'ceae, 0xffef'cfaf},
6592 {0xfff0'd0b0, 0xfff1'd1b1, 0xfff2'd2b2, 0xfff3'd3b3},
6593 {0xfff4'd4b4, 0xfff5'd5b5, 0xfff6'd6b6, 0xfff7'd7b7},
6594 {0xfff8'd8b8, 0xfff9'd9b9, 0xfffa'daba, 0xfffb'dbbb},
6595 {0xfffc'dcbc, 0xfffd'ddbd, 0xfffe'debe, 0xffff'dfbf}},
6596 {{0xffff'ffff'ffe1'c1a1, 0xffff'ffff'ffe3'c3a3},
6597 {0xffff'ffff'ffe5'c5a5, 0xffff'ffff'ffe7'c7a7},
6598 {0xffff'ffff'ffe9'c9a9, 0xffff'ffff'ffeb'cbab},
6599 {0xffff'ffff'ffed'cdad, 0xffff'ffff'ffef'cfaf},
6600 {0xffff'ffff'fff1'd1b1, 0xffff'ffff'fff3'd3b3},
6601 {0xffff'ffff'fff5'd5b5, 0xffff'ffff'fff7'd7b7},
6602 {0xffff'ffff'fff9'd9b9, 0xffff'ffff'fffb'dbbb},
6603 {0xffff'ffff'fffd'ddbd, 0xffff'ffff'ffff'dfbf}},
6604 kVectorCalculationsSource);
6605
6606 TestVectorInstruction(ExecVssravi,
6607 ExecMaskedVssravi,
6608 {{0, 224, 1, 225, 1, 225, 2, 226, 2, 226, 3, 227, 3, 227, 4, 228},
6609 {4, 228, 5, 229, 5, 229, 6, 230, 6, 230, 7, 231, 7, 231, 8, 232},
6610 {8, 232, 9, 233, 9, 233, 10, 234, 10, 234, 11, 235, 11, 235, 12, 236},
6611 {12, 236, 13, 237, 13, 237, 14, 238, 14, 238, 15, 239, 15, 239, 16, 240},
6612 {16, 240, 17, 241, 17, 241, 18, 242, 18, 242, 19, 243, 19, 243, 20, 244},
6613 {20, 244, 21, 245, 21, 245, 22, 246, 22, 246, 23, 247, 23, 247, 24, 248},
6614 {24, 248, 25, 249, 25, 249, 26, 250, 26, 250, 27, 251, 27, 251, 28, 252},
6615 {28, 252, 29, 253, 29, 253, 30, 254, 30, 254, 31, 255, 31, 255, 32, 0}},
6616 {{0xffe0, 0xffe1, 0xffe1, 0xffe2, 0xffe2, 0xffe3, 0xffe3, 0xffe4},
6617 {0xffe4, 0xffe5, 0xffe5, 0xffe6, 0xffe6, 0xffe7, 0xffe7, 0xffe8},
6618 {0xffe8, 0xffe9, 0xffe9, 0xffea, 0xffea, 0xffeb, 0xffeb, 0xffec},
6619 {0xffec, 0xffed, 0xffed, 0xffee, 0xffee, 0xffef, 0xffef, 0xfff0},
6620 {0xfff0, 0xfff1, 0xfff1, 0xfff2, 0xfff2, 0xfff3, 0xfff3, 0xfff4},
6621 {0xfff4, 0xfff5, 0xfff5, 0xfff6, 0xfff6, 0xfff7, 0xfff7, 0xfff8},
6622 {0xfff8, 0xfff9, 0xfff9, 0xfffa, 0xfffa, 0xfffb, 0xfffb, 0xfffc},
6623 {0xfffc, 0xfffd, 0xfffd, 0xfffe, 0xfffe, 0xffff, 0xffff, 0x0000}},
6624 {{0xffe0'c0a0, 0xffe1'c1a1, 0xffe2'c2a2, 0xffe3'c3a3},
6625 {0xffe4'c4a4, 0xffe5'c5a5, 0xffe6'c6a6, 0xffe7'c7a7},
6626 {0xffe8'c8a8, 0xffe9'c9a9, 0xffea'caaa, 0xffeb'cbab},
6627 {0xffec'ccac, 0xffed'cdad, 0xffee'ceae, 0xffef'cfaf},
6628 {0xfff0'd0b0, 0xfff1'd1b1, 0xfff2'd2b2, 0xfff3'd3b3},
6629 {0xfff4'd4b4, 0xfff5'd5b5, 0xfff6'd6b6, 0xfff7'd7b7},
6630 {0xfff8'd8b8, 0xfff9'd9b9, 0xfffa'daba, 0xfffb'dbbb},
6631 {0xfffc'dcbc, 0xfffd'ddbd, 0xfffe'debe, 0xffff'dfbf}},
6632 {{0xffe1'c1a1'4120'c0a0, 0xffe3'c3a3'4322'c2a2},
6633 {0xffe5'c5a5'4524'c4a4, 0xffe7'c7a7'4726'c6a6},
6634 {0xffe9'c9a9'4928'c8a8, 0xffeb'cbab'4b2a'caaa},
6635 {0xffed'cdad'4d2c'ccac, 0xffef'cfaf'4f2e'ceae},
6636 {0xfff1'd1b1'5130'd0b0, 0xfff3'd3b3'5332'd2b2},
6637 {0xfff5'd5b5'5534'd4b4, 0xfff7'd7b7'5736'd6b6},
6638 {0xfff9'd9b9'5938'd8b8, 0xfffb'dbbb'5b3a'daba},
6639 {0xfffd'ddbd'5d3c'dcbc, 0xffff'dfbf'5f3e'debe}},
6640 kVectorCalculationsSource);
6641 asm volatile("csrw vxrm, %0\n\t" ::"r"(vxrm));
6642 }
6643
TEST(InlineAsmTestRiscv64,TestROD)6644 TEST(InlineAsmTestRiscv64, TestROD) {
6645 uint64_t vxrm;
6646 asm volatile(
6647 "csrr %0, vxrm\n\t"
6648 "csrwi vxrm, %c1\n\t"
6649 : "=r"(vxrm)
6650 : "i"(VXRMFlags::ROD));
6651 TestVectorInstruction(
6652 ExecVaadduvv,
6653 ExecMaskedVaadduvv,
6654 {{0, 137, 3, 141, 7, 143, 9, 147, 13, 133, 15, 137, 18, 139, 21, 143},
6655 {24, 161, 27, 165, 31, 167, 33, 171, 37, 157, 39, 161, 42, 163, 45, 167},
6656 {48, 185, 51, 189, 55, 191, 57, 195, 61, 181, 63, 185, 66, 187, 69, 191},
6657 {72, 209, 75, 213, 79, 215, 81, 219, 85, 205, 87, 209, 90, 211, 93, 215},
6658 {96, 105, 99, 109, 103, 111, 105, 115, 109, 101, 111, 105, 114, 107, 117, 111},
6659 {120, 129, 123, 133, 127, 135, 129, 139, 133, 125, 135, 129, 138, 131, 141, 135},
6660 {144, 153, 147, 157, 151, 159, 153, 163, 157, 149, 159, 153, 162, 155, 165, 159},
6661 {168, 177, 171, 181, 175, 183, 177, 187, 181, 173, 183, 177, 186, 179, 189, 183}},
6662 {{0x8980, 0x8c83, 0x8f87, 0x9289, 0x858d, 0x888f, 0x8b92, 0x8e95},
6663 {0xa198, 0xa49b, 0xa79f, 0xaaa1, 0x9da5, 0xa0a7, 0xa3aa, 0xa6ad},
6664 {0xb9b0, 0xbcb3, 0xbfb7, 0xc2b9, 0xb5bd, 0xb8bf, 0xbbc2, 0xbec5},
6665 {0xd1c8, 0xd4cb, 0xd7cf, 0xdad1, 0xcdd5, 0xd0d7, 0xd3da, 0xd6dd},
6666 {0x69e0, 0x6ce3, 0x6fe7, 0x72e9, 0x65ed, 0x68ef, 0x6bf2, 0x6ef5},
6667 {0x81f8, 0x84fb, 0x87ff, 0x8b01, 0x7e05, 0x8107, 0x840a, 0x870d},
6668 {0x9a10, 0x9d13, 0xa017, 0xa319, 0x961d, 0x991f, 0x9c22, 0x9f25},
6669 {0xb228, 0xb52b, 0xb82f, 0xbb31, 0xae35, 0xb137, 0xb43a, 0xb73d}},
6670 {{0x8c83'8980, 0x9289'8f87, 0x888f'858d, 0x8e95'8b92},
6671 {0xa49b'a198, 0xaaa1'a79f, 0xa0a7'9da5, 0xa6ad'a3aa},
6672 {0xbcb3'b9b0, 0xc2b9'bfb7, 0xb8bf'b5bd, 0xbec5'bbc2},
6673 {0xd4cb'd1c8, 0xdad1'd7cf, 0xd0d7'cdd5, 0xd6dd'd3da},
6674 {0x6ce3'69e0, 0x72e9'6fe7, 0x68ef'65ed, 0x6ef5'6bf2},
6675 {0x84fb'81f8, 0x8b01'87ff, 0x8107'7e05, 0x870d'840a},
6676 {0x9d13'9a10, 0xa319'a017, 0x991f'961d, 0x9f25'9c22},
6677 {0xb52b'b228, 0xbb31'b82f, 0xb137'ae35, 0xb73d'b43a}},
6678 {{0x9289'8f87'0c83'8980, 0x8e95'8b92'888f'858d},
6679 {0xaaa1'a79f'249b'a198, 0xa6ad'a3aa'a0a7'9da5},
6680 {0xc2b9'bfb7'3cb3'b9b0, 0xbec5'bbc2'b8bf'b5bd},
6681 {0xdad1'd7cf'54cb'd1c8, 0xd6dd'd3da'd0d7'cdd5},
6682 {0x72e9'6fe6'ece3'69e0, 0x6ef5'6bf2'68ef'65ed},
6683 {0x8b01'87ff'04fb'81f8, 0x870d'840a'8107'7e05},
6684 {0xa319'a017'1d13'9a10, 0x9f25'9c22'991f'961d},
6685 {0xbb31'b82f'352b'b228, 0xb73d'b43a'b137'ae35}},
6686 kVectorCalculationsSource);
6687 TestVectorInstruction(
6688 ExecVaadduvx,
6689 ExecMaskedVaadduvx,
6690 {{85, 149, 86, 151, 87, 151, 88, 153, 89, 153, 90, 155, 91, 155, 92, 157},
6691 {93, 157, 94, 159, 95, 159, 96, 161, 97, 161, 98, 163, 99, 163, 100, 165},
6692 {101, 165, 102, 167, 103, 167, 104, 169, 105, 169, 106, 171, 107, 171, 108, 173},
6693 {109, 173, 110, 175, 111, 175, 112, 177, 113, 177, 114, 179, 115, 179, 116, 181},
6694 {117, 181, 118, 183, 119, 183, 120, 185, 121, 185, 122, 187, 123, 187, 124, 189},
6695 {125, 189, 126, 191, 127, 191, 128, 193, 129, 193, 130, 195, 131, 195, 132, 197},
6696 {133, 197, 134, 199, 135, 199, 136, 201, 137, 201, 138, 203, 139, 203, 140, 205},
6697 {141, 205, 142, 207, 143, 207, 144, 209, 145, 209, 146, 211, 147, 211, 148, 213}},
6698 {{0x95d5, 0x96d6, 0x97d7, 0x98d8, 0x99d9, 0x9ada, 0x9bdb, 0x9cdc},
6699 {0x9ddd, 0x9ede, 0x9fdf, 0xa0e0, 0xa1e1, 0xa2e2, 0xa3e3, 0xa4e4},
6700 {0xa5e5, 0xa6e6, 0xa7e7, 0xa8e8, 0xa9e9, 0xaaea, 0xabeb, 0xacec},
6701 {0xaded, 0xaeee, 0xafef, 0xb0f0, 0xb1f1, 0xb2f2, 0xb3f3, 0xb4f4},
6702 {0xb5f5, 0xb6f6, 0xb7f7, 0xb8f8, 0xb9f9, 0xbafa, 0xbbfb, 0xbcfc},
6703 {0xbdfd, 0xbefe, 0xbfff, 0xc100, 0xc201, 0xc302, 0xc403, 0xc504},
6704 {0xc605, 0xc706, 0xc807, 0xc908, 0xca09, 0xcb0a, 0xcc0b, 0xcd0c},
6705 {0xce0d, 0xcf0e, 0xd00f, 0xd110, 0xd211, 0xd312, 0xd413, 0xd514}},
6706 {{0x96d6'95d5, 0x98d8'97d7, 0x9ada'99d9, 0x9cdc'9bdb},
6707 {0x9ede'9ddd, 0xa0e0'9fdf, 0xa2e2'a1e1, 0xa4e4'a3e3},
6708 {0xa6e6'a5e5, 0xa8e8'a7e7, 0xaaea'a9e9, 0xacec'abeb},
6709 {0xaeee'aded, 0xb0f0'afef, 0xb2f2'b1f1, 0xb4f4'b3f3},
6710 {0xb6f6'b5f5, 0xb8f8'b7f7, 0xbafa'b9f9, 0xbcfc'bbfb},
6711 {0xbefe'bdfd, 0xc100'bfff, 0xc302'c201, 0xc504'c403},
6712 {0xc706'c605, 0xc908'c807, 0xcb0a'ca09, 0xcd0c'cc0b},
6713 {0xcf0e'ce0d, 0xd110'd00f, 0xd312'd211, 0xd514'd413}},
6714 {{0x98d8'97d7'96d6'95d5, 0x9cdc'9bdb'9ada'99d9},
6715 {0xa0e0'9fdf'9ede'9ddd, 0xa4e4'a3e3'a2e2'a1e1},
6716 {0xa8e8'a7e7'a6e6'a5e5, 0xacec'abeb'aaea'a9e9},
6717 {0xb0f0'afef'aeee'aded, 0xb4f4'b3f3'b2f2'b1f1},
6718 {0xb8f8'b7f7'b6f6'b5f5, 0xbcfc'bbfb'bafa'b9f9},
6719 {0xc100'bfff'befe'bdfd, 0xc504'c403'c302'c201},
6720 {0xc908'c807'c706'c605, 0xcd0c'cc0b'cb0a'ca09},
6721 {0xd110'd00f'cf0e'ce0d, 0xd514'd413'd312'd211}},
6722 kVectorCalculationsSource);
6723 TestVectorInstruction(
6724 ExecVaaddvv,
6725 ExecMaskedVaaddvv,
6726 {{0, 137, 3, 141, 7, 143, 9, 147, 13, 133, 15, 137, 18, 139, 21, 143},
6727 {24, 161, 27, 165, 31, 167, 33, 171, 37, 157, 39, 161, 42, 163, 45, 167},
6728 {48, 185, 51, 189, 55, 191, 57, 195, 61, 181, 63, 185, 66, 187, 69, 191},
6729 {72, 209, 75, 213, 79, 215, 81, 219, 85, 205, 87, 209, 90, 211, 93, 215},
6730 {224, 233, 227, 237, 231, 239, 233, 243, 237, 229, 239, 233, 242, 235, 245, 239},
6731 {248, 1, 251, 5, 255, 7, 1, 11, 5, 253, 7, 1, 10, 3, 13, 7},
6732 {16, 25, 19, 29, 23, 31, 25, 35, 29, 21, 31, 25, 34, 27, 37, 31},
6733 {40, 49, 43, 53, 47, 55, 49, 59, 53, 45, 55, 49, 58, 51, 61, 55}},
6734 {{0x8980, 0x8c83, 0x8f87, 0x9289, 0x858d, 0x888f, 0x8b92, 0x8e95},
6735 {0xa198, 0xa49b, 0xa79f, 0xaaa1, 0x9da5, 0xa0a7, 0xa3aa, 0xa6ad},
6736 {0xb9b0, 0xbcb3, 0xbfb7, 0xc2b9, 0xb5bd, 0xb8bf, 0xbbc2, 0xbec5},
6737 {0xd1c8, 0xd4cb, 0xd7cf, 0xdad1, 0xcdd5, 0xd0d7, 0xd3da, 0xd6dd},
6738 {0xe9e0, 0xece3, 0xefe7, 0xf2e9, 0xe5ed, 0xe8ef, 0xebf2, 0xeef5},
6739 {0x01f8, 0x04fb, 0x07ff, 0x0b01, 0xfe05, 0x0107, 0x040a, 0x070d},
6740 {0x1a10, 0x1d13, 0x2017, 0x2319, 0x161d, 0x191f, 0x1c22, 0x1f25},
6741 {0x3228, 0x352b, 0x382f, 0x3b31, 0x2e35, 0x3137, 0x343a, 0x373d}},
6742 {{0x8c83'8980, 0x9289'8f87, 0x888f'858d, 0x8e95'8b92},
6743 {0xa49b'a198, 0xaaa1'a79f, 0xa0a7'9da5, 0xa6ad'a3aa},
6744 {0xbcb3'b9b0, 0xc2b9'bfb7, 0xb8bf'b5bd, 0xbec5'bbc2},
6745 {0xd4cb'd1c8, 0xdad1'd7cf, 0xd0d7'cdd5, 0xd6dd'd3da},
6746 {0xece3'69e0, 0xf2e9'6fe7, 0xe8ef'65ed, 0xeef5'6bf2},
6747 {0x04fb'81f8, 0x0b01'87ff, 0x0107'7e05, 0x070d'840a},
6748 {0x1d13'9a10, 0x2319'a017, 0x191f'961d, 0x1f25'9c22},
6749 {0x352b'b228, 0x3b31'b82f, 0x3137'ae35, 0x373d'b43a}},
6750 {{0x9289'8f87'0c83'8980, 0x8e95'8b92'888f'858d},
6751 {0xaaa1'a79f'249b'a198, 0xa6ad'a3aa'a0a7'9da5},
6752 {0xc2b9'bfb7'3cb3'b9b0, 0xbec5'bbc2'b8bf'b5bd},
6753 {0xdad1'd7cf'54cb'd1c8, 0xd6dd'd3da'd0d7'cdd5},
6754 {0xf2e9'6fe6'ece3'69e0, 0xeef5'6bf2'68ef'65ed},
6755 {0x0b01'87ff'04fb'81f8, 0x070d'840a'8107'7e05},
6756 {0x2319'a017'1d13'9a10, 0x1f25'9c22'991f'961d},
6757 {0x3b31'b82f'352b'b228, 0x373d'b43a'b137'ae35}},
6758 kVectorCalculationsSource);
6759 TestVectorInstruction(
6760 ExecVaaddvx,
6761 ExecMaskedVaaddvx,
6762 {{213, 149, 214, 151, 215, 151, 216, 153, 217, 153, 218, 155, 219, 155, 220, 157},
6763 {221, 157, 222, 159, 223, 159, 224, 161, 225, 161, 226, 163, 227, 163, 228, 165},
6764 {229, 165, 230, 167, 231, 167, 232, 169, 233, 169, 234, 171, 235, 171, 236, 173},
6765 {237, 173, 238, 175, 239, 175, 240, 177, 241, 177, 242, 179, 243, 179, 244, 181},
6766 {245, 181, 246, 183, 247, 183, 248, 185, 249, 185, 250, 187, 251, 187, 252, 189},
6767 {253, 189, 254, 191, 255, 191, 0, 193, 1, 193, 2, 195, 3, 195, 4, 197},
6768 {5, 197, 6, 199, 7, 199, 8, 201, 9, 201, 10, 203, 11, 203, 12, 205},
6769 {13, 205, 14, 207, 15, 207, 16, 209, 17, 209, 18, 211, 19, 211, 20, 213}},
6770 {{0x95d5, 0x96d6, 0x97d7, 0x98d8, 0x99d9, 0x9ada, 0x9bdb, 0x9cdc},
6771 {0x9ddd, 0x9ede, 0x9fdf, 0xa0e0, 0xa1e1, 0xa2e2, 0xa3e3, 0xa4e4},
6772 {0xa5e5, 0xa6e6, 0xa7e7, 0xa8e8, 0xa9e9, 0xaaea, 0xabeb, 0xacec},
6773 {0xaded, 0xaeee, 0xafef, 0xb0f0, 0xb1f1, 0xb2f2, 0xb3f3, 0xb4f4},
6774 {0xb5f5, 0xb6f6, 0xb7f7, 0xb8f8, 0xb9f9, 0xbafa, 0xbbfb, 0xbcfc},
6775 {0xbdfd, 0xbefe, 0xbfff, 0xc100, 0xc201, 0xc302, 0xc403, 0xc504},
6776 {0xc605, 0xc706, 0xc807, 0xc908, 0xca09, 0xcb0a, 0xcc0b, 0xcd0c},
6777 {0xce0d, 0xcf0e, 0xd00f, 0xd110, 0xd211, 0xd312, 0xd413, 0xd514}},
6778 {{0x96d6'95d5, 0x98d8'97d7, 0x9ada'99d9, 0x9cdc'9bdb},
6779 {0x9ede'9ddd, 0xa0e0'9fdf, 0xa2e2'a1e1, 0xa4e4'a3e3},
6780 {0xa6e6'a5e5, 0xa8e8'a7e7, 0xaaea'a9e9, 0xacec'abeb},
6781 {0xaeee'aded, 0xb0f0'afef, 0xb2f2'b1f1, 0xb4f4'b3f3},
6782 {0xb6f6'b5f5, 0xb8f8'b7f7, 0xbafa'b9f9, 0xbcfc'bbfb},
6783 {0xbefe'bdfd, 0xc100'bfff, 0xc302'c201, 0xc504'c403},
6784 {0xc706'c605, 0xc908'c807, 0xcb0a'ca09, 0xcd0c'cc0b},
6785 {0xcf0e'ce0d, 0xd110'd00f, 0xd312'd211, 0xd514'd413}},
6786 {{0x98d8'97d7'96d6'95d5, 0x9cdc'9bdb'9ada'99d9},
6787 {0xa0e0'9fdf'9ede'9ddd, 0xa4e4'a3e3'a2e2'a1e1},
6788 {0xa8e8'a7e7'a6e6'a5e5, 0xacec'abeb'aaea'a9e9},
6789 {0xb0f0'afef'aeee'aded, 0xb4f4'b3f3'b2f2'b1f1},
6790 {0xb8f8'b7f7'b6f6'b5f5, 0xbcfc'bbfb'bafa'b9f9},
6791 {0xc100'bfff'befe'bdfd, 0xc504'c403'c302'c201},
6792 {0xc908'c807'c706'c605, 0xcd0c'cc0b'cb0a'ca09},
6793 {0xd110'd00f'cf0e'ce0d, 0xd514'd413'd312'd211}},
6794 kVectorCalculationsSource);
6795 TestVectorInstruction(
6796 ExecVasubuvv,
6797 ExecMaskedVasubuvv,
6798 {{0, 247, 255, 247, 253, 245, 253, 245, 251, 3, 251, 3, 250, 1, 249, 1},
6799 {248, 239, 247, 239, 245, 237, 245, 237, 243, 251, 243, 251, 242, 249, 241, 249},
6800 {240, 231, 239, 231, 237, 229, 237, 229, 235, 243, 235, 243, 234, 241, 233, 241},
6801 {232, 223, 231, 223, 229, 221, 229, 221, 227, 235, 227, 235, 226, 233, 225, 233},
6802 {224, 87, 223, 87, 221, 85, 221, 85, 219, 99, 219, 99, 218, 97, 217, 97},
6803 {216, 79, 215, 79, 213, 77, 213, 77, 211, 91, 211, 91, 210, 89, 209, 89},
6804 {208, 71, 207, 71, 205, 69, 205, 69, 203, 83, 203, 83, 202, 81, 201, 81},
6805 {200, 63, 199, 63, 197, 61, 197, 61, 195, 75, 195, 75, 194, 73, 193, 73}},
6806 {{0xf780, 0xf67f, 0xf57d, 0xf47d, 0x037b, 0x027b, 0x017a, 0x0079},
6807 {0xef78, 0xee77, 0xed75, 0xec75, 0xfb73, 0xfa73, 0xf972, 0xf871},
6808 {0xe770, 0xe66f, 0xe56d, 0xe46d, 0xf36b, 0xf26b, 0xf16a, 0xf069},
6809 {0xdf68, 0xde67, 0xdd65, 0xdc65, 0xeb63, 0xea63, 0xe962, 0xe861},
6810 {0x5760, 0x565f, 0x555d, 0x545d, 0x635b, 0x625b, 0x615a, 0x6059},
6811 {0x4f58, 0x4e57, 0x4d55, 0x4c55, 0x5b53, 0x5a53, 0x5952, 0x5851},
6812 {0x4750, 0x464f, 0x454d, 0x444d, 0x534b, 0x524b, 0x514a, 0x5049},
6813 {0x3f48, 0x3e47, 0x3d45, 0x3c45, 0x4b43, 0x4a43, 0x4942, 0x4841}},
6814 {{0xf67e'f780, 0xf47c'f57d, 0x027b'037b, 0x0079'017a},
6815 {0xee76'ef78, 0xec74'ed75, 0xfa72'fb73, 0xf870'f972},
6816 {0xe66e'e770, 0xe46c'e56d, 0xf26a'f36b, 0xf068'f16a},
6817 {0xde66'df68, 0xdc64'dd65, 0xea62'eb63, 0xe860'e962},
6818 {0x565f'5760, 0x545d'555d, 0x625b'635b, 0x6059'615a},
6819 {0x4e57'4f58, 0x4c55'4d55, 0x5a53'5b53, 0x5851'5952},
6820 {0x464f'4750, 0x444d'454d, 0x524b'534b, 0x5049'514a},
6821 {0x3e47'3f48, 0x3c45'3d45, 0x4a43'4b43, 0x4841'4942}},
6822 {{0xf47c'f57d'767e'f780, 0x0079'017a'027b'037b},
6823 {0xec74'ed75'6e76'ef78, 0xf870'f971'fa72'fb73},
6824 {0xe46c'e56d'666e'e770, 0xf068'f169'f26a'f36b},
6825 {0xdc64'dd65'5e66'df68, 0xe860'e961'ea62'eb63},
6826 {0x545d'555d'd65f'5760, 0x6059'615a'625b'635b},
6827 {0x4c55'4d55'ce57'4f58, 0x5851'5952'5a53'5b53},
6828 {0x444d'454d'c64f'4750, 0x5049'514a'524b'534b},
6829 {0x3c45'3d45'be47'3f48, 0x4841'4942'4a43'4b43}},
6830 kVectorCalculationsSource);
6831 TestVectorInstruction(
6832 ExecVasubuvx,
6833 ExecMaskedVasubuvx,
6834 {{171, 235, 172, 237, 173, 237, 174, 239, 175, 239, 176, 241, 177, 241, 178, 243},
6835 {179, 243, 180, 245, 181, 245, 182, 247, 183, 247, 184, 249, 185, 249, 186, 251},
6836 {187, 251, 188, 253, 189, 253, 190, 255, 191, 255, 192, 1, 193, 1, 194, 3},
6837 {195, 3, 196, 5, 197, 5, 198, 7, 199, 7, 200, 9, 201, 9, 202, 11},
6838 {203, 11, 204, 13, 205, 13, 206, 15, 207, 15, 208, 17, 209, 17, 210, 19},
6839 {211, 19, 212, 21, 213, 21, 214, 23, 215, 23, 216, 25, 217, 25, 218, 27},
6840 {219, 27, 220, 29, 221, 29, 222, 31, 223, 31, 224, 33, 225, 33, 226, 35},
6841 {227, 35, 228, 37, 229, 37, 230, 39, 231, 39, 232, 41, 233, 41, 234, 43}},
6842 {{0xeb2b, 0xec2c, 0xed2d, 0xee2e, 0xef2f, 0xf030, 0xf131, 0xf232},
6843 {0xf333, 0xf434, 0xf535, 0xf636, 0xf737, 0xf838, 0xf939, 0xfa3a},
6844 {0xfb3b, 0xfc3c, 0xfd3d, 0xfe3e, 0xff3f, 0x0040, 0x0141, 0x0242},
6845 {0x0343, 0x0444, 0x0545, 0x0646, 0x0747, 0x0848, 0x0949, 0x0a4a},
6846 {0x0b4b, 0x0c4c, 0x0d4d, 0x0e4e, 0x0f4f, 0x1050, 0x1151, 0x1252},
6847 {0x1353, 0x1454, 0x1555, 0x1656, 0x1757, 0x1858, 0x1959, 0x1a5a},
6848 {0x1b5b, 0x1c5c, 0x1d5d, 0x1e5e, 0x1f5f, 0x2060, 0x2161, 0x2262},
6849 {0x2363, 0x2464, 0x2565, 0x2666, 0x2767, 0x2868, 0x2969, 0x2a6a}},
6850 {{0xec2b'eb2b, 0xee2d'ed2d, 0xf02f'ef2f, 0xf231'f131},
6851 {0xf433'f333, 0xf635'f535, 0xf837'f737, 0xfa39'f939},
6852 {0xfc3b'fb3b, 0xfe3d'fd3d, 0x003f'ff3f, 0x0242'0141},
6853 {0x0444'0343, 0x0646'0545, 0x0848'0747, 0x0a4a'0949},
6854 {0x0c4c'0b4b, 0x0e4e'0d4d, 0x1050'0f4f, 0x1252'1151},
6855 {0x1454'1353, 0x1656'1555, 0x1858'1757, 0x1a5a'1959},
6856 {0x1c5c'1b5b, 0x1e5e'1d5d, 0x2060'1f5f, 0x2262'2161},
6857 {0x2464'2363, 0x2666'2565, 0x2868'2767, 0x2a6a'2969}},
6858 {{0xee2d'ed2c'ec2b'eb2b, 0xf231'f130'f02f'ef2f},
6859 {0xf635'f534'f433'f333, 0xfa39'f938'f837'f737},
6860 {0xfe3d'fd3c'fc3b'fb3b, 0x0242'0141'003f'ff3f},
6861 {0x0646'0545'0444'0343, 0x0a4a'0949'0848'0747},
6862 {0x0e4e'0d4d'0c4c'0b4b, 0x1252'1151'1050'0f4f},
6863 {0x1656'1555'1454'1353, 0x1a5a'1959'1858'1757},
6864 {0x1e5e'1d5d'1c5c'1b5b, 0x2262'2161'2060'1f5f},
6865 {0x2666'2565'2464'2363, 0x2a6a'2969'2868'2767}},
6866 kVectorCalculationsSource);
6867 TestVectorInstruction(
6868 ExecVasubvv,
6869 ExecMaskedVasubvv,
6870 {{0, 247, 255, 247, 253, 245, 253, 245, 251, 3, 251, 3, 250, 1, 249, 1},
6871 {248, 239, 247, 239, 245, 237, 245, 237, 243, 251, 243, 251, 242, 249, 241, 249},
6872 {240, 231, 239, 231, 237, 229, 237, 229, 235, 243, 235, 243, 234, 241, 233, 241},
6873 {232, 223, 231, 223, 229, 221, 229, 221, 227, 235, 227, 235, 226, 233, 225, 233},
6874 {96, 215, 95, 215, 93, 213, 93, 213, 91, 227, 91, 227, 90, 225, 89, 225},
6875 {88, 207, 87, 207, 85, 205, 85, 205, 83, 219, 83, 219, 82, 217, 81, 217},
6876 {80, 199, 79, 199, 77, 197, 77, 197, 75, 211, 75, 211, 74, 209, 73, 209},
6877 {72, 191, 71, 191, 69, 189, 69, 189, 67, 203, 67, 203, 66, 201, 65, 201}},
6878 {{0xf780, 0xf67f, 0xf57d, 0xf47d, 0x037b, 0x027b, 0x017a, 0x0079},
6879 {0xef78, 0xee77, 0xed75, 0xec75, 0xfb73, 0xfa73, 0xf972, 0xf871},
6880 {0xe770, 0xe66f, 0xe56d, 0xe46d, 0xf36b, 0xf26b, 0xf16a, 0xf069},
6881 {0xdf68, 0xde67, 0xdd65, 0xdc65, 0xeb63, 0xea63, 0xe962, 0xe861},
6882 {0xd760, 0xd65f, 0xd55d, 0xd45d, 0xe35b, 0xe25b, 0xe15a, 0xe059},
6883 {0xcf58, 0xce57, 0xcd55, 0xcc55, 0xdb53, 0xda53, 0xd952, 0xd851},
6884 {0xc750, 0xc64f, 0xc54d, 0xc44d, 0xd34b, 0xd24b, 0xd14a, 0xd049},
6885 {0xbf48, 0xbe47, 0xbd45, 0xbc45, 0xcb43, 0xca43, 0xc942, 0xc841}},
6886 {{0xf67e'f780, 0xf47c'f57d, 0x027b'037b, 0x0079'017a},
6887 {0xee76'ef78, 0xec74'ed75, 0xfa72'fb73, 0xf870'f972},
6888 {0xe66e'e770, 0xe46c'e56d, 0xf26a'f36b, 0xf068'f16a},
6889 {0xde66'df68, 0xdc64'dd65, 0xea62'eb63, 0xe860'e962},
6890 {0xd65f'5760, 0xd45d'555d, 0xe25b'635b, 0xe059'615a},
6891 {0xce57'4f58, 0xcc55'4d55, 0xda53'5b53, 0xd851'5952},
6892 {0xc64f'4750, 0xc44d'454d, 0xd24b'534b, 0xd049'514a},
6893 {0xbe47'3f48, 0xbc45'3d45, 0xca43'4b43, 0xc841'4942}},
6894 {{0xf47c'f57d'767e'f780, 0x0079'017a'027b'037b},
6895 {0xec74'ed75'6e76'ef78, 0xf870'f971'fa72'fb73},
6896 {0xe46c'e56d'666e'e770, 0xf068'f169'f26a'f36b},
6897 {0xdc64'dd65'5e66'df68, 0xe860'e961'ea62'eb63},
6898 {0xd45d'555d'd65f'5760, 0xe059'615a'625b'635b},
6899 {0xcc55'4d55'ce57'4f58, 0xd851'5952'5a53'5b53},
6900 {0xc44d'454d'c64f'4750, 0xd049'514a'524b'534b},
6901 {0xbc45'3d45'be47'3f48, 0xc841'4942'4a43'4b43}},
6902 kVectorCalculationsSource);
6903 TestVectorInstruction(ExecVasubvx,
6904 ExecMaskedVasubvx,
6905 {{43, 235, 44, 237, 45, 237, 46, 239, 47, 239, 48, 241, 49, 241, 50, 243},
6906 {51, 243, 52, 245, 53, 245, 54, 247, 55, 247, 56, 249, 57, 249, 58, 251},
6907 {59, 251, 60, 253, 61, 253, 62, 255, 63, 255, 64, 1, 65, 1, 66, 3},
6908 {67, 3, 68, 5, 69, 5, 70, 7, 71, 7, 72, 9, 73, 9, 74, 11},
6909 {75, 11, 76, 13, 77, 13, 78, 15, 79, 15, 80, 17, 81, 17, 82, 19},
6910 {83, 19, 84, 21, 85, 21, 86, 23, 87, 23, 88, 25, 89, 25, 90, 27},
6911 {91, 27, 92, 29, 93, 29, 94, 31, 95, 31, 96, 33, 97, 33, 98, 35},
6912 {99, 35, 100, 37, 101, 37, 102, 39, 103, 39, 104, 41, 105, 41, 106, 43}},
6913 {{0xeb2b, 0xec2c, 0xed2d, 0xee2e, 0xef2f, 0xf030, 0xf131, 0xf232},
6914 {0xf333, 0xf434, 0xf535, 0xf636, 0xf737, 0xf838, 0xf939, 0xfa3a},
6915 {0xfb3b, 0xfc3c, 0xfd3d, 0xfe3e, 0xff3f, 0x0040, 0x0141, 0x0242},
6916 {0x0343, 0x0444, 0x0545, 0x0646, 0x0747, 0x0848, 0x0949, 0x0a4a},
6917 {0x0b4b, 0x0c4c, 0x0d4d, 0x0e4e, 0x0f4f, 0x1050, 0x1151, 0x1252},
6918 {0x1353, 0x1454, 0x1555, 0x1656, 0x1757, 0x1858, 0x1959, 0x1a5a},
6919 {0x1b5b, 0x1c5c, 0x1d5d, 0x1e5e, 0x1f5f, 0x2060, 0x2161, 0x2262},
6920 {0x2363, 0x2464, 0x2565, 0x2666, 0x2767, 0x2868, 0x2969, 0x2a6a}},
6921 {{0xec2b'eb2b, 0xee2d'ed2d, 0xf02f'ef2f, 0xf231'f131},
6922 {0xf433'f333, 0xf635'f535, 0xf837'f737, 0xfa39'f939},
6923 {0xfc3b'fb3b, 0xfe3d'fd3d, 0x003f'ff3f, 0x0242'0141},
6924 {0x0444'0343, 0x0646'0545, 0x0848'0747, 0x0a4a'0949},
6925 {0x0c4c'0b4b, 0x0e4e'0d4d, 0x1050'0f4f, 0x1252'1151},
6926 {0x1454'1353, 0x1656'1555, 0x1858'1757, 0x1a5a'1959},
6927 {0x1c5c'1b5b, 0x1e5e'1d5d, 0x2060'1f5f, 0x2262'2161},
6928 {0x2464'2363, 0x2666'2565, 0x2868'2767, 0x2a6a'2969}},
6929 {{0xee2d'ed2c'ec2b'eb2b, 0xf231'f130'f02f'ef2f},
6930 {0xf635'f534'f433'f333, 0xfa39'f938'f837'f737},
6931 {0xfe3d'fd3c'fc3b'fb3b, 0x0242'0141'003f'ff3f},
6932 {0x0646'0545'0444'0343, 0x0a4a'0949'0848'0747},
6933 {0x0e4e'0d4d'0c4c'0b4b, 0x1252'1151'1050'0f4f},
6934 {0x1656'1555'1454'1353, 0x1a5a'1959'1858'1757},
6935 {0x1e5e'1d5d'1c5c'1b5b, 0x2262'2161'2060'1f5f},
6936 {0x2666'2565'2464'2363, 0x2a6a'2969'2868'2767}},
6937 kVectorCalculationsSource);
6938 TestNarrowingVectorInstruction(ExecVnclipuwi,
6939 ExecMaskedVnclipuwi,
6940 {{33, 33, 33, 33, 35, 35, 35, 35, 37, 37, 37, 37, 39, 39, 39, 39},
6941 {41, 41, 41, 41, 43, 43, 43, 43, 45, 45, 45, 45, 47, 47, 47, 47},
6942 {49, 49, 49, 49, 51, 51, 51, 51, 53, 53, 53, 53, 55, 55, 55, 55},
6943 {57, 57, 57, 57, 59, 59, 59, 59, 61, 61, 61, 61, 63, 63, 63, 63}},
6944 {{0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
6945 {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
6946 {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
6947 {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff}},
6948 {{0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff},
6949 {0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff},
6950 {0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff},
6951 {0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff}},
6952 kVectorCalculationsSource);
6953 TestNarrowingVectorInstruction(
6954 ExecVnclipwi,
6955 ExecMaskedVnclipwi,
6956 {{225, 225, 225, 225, 227, 227, 227, 227, 229, 229, 229, 229, 231, 231, 231, 231},
6957 {233, 233, 233, 233, 235, 235, 235, 235, 237, 237, 237, 237, 239, 239, 239, 239},
6958 {241, 241, 241, 241, 243, 243, 243, 243, 245, 245, 245, 245, 247, 247, 247, 247},
6959 {249, 249, 249, 249, 251, 251, 251, 251, 253, 253, 253, 253, 255, 255, 255, 255}},
6960 {{0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000},
6961 {0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000},
6962 {0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000},
6963 {0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0xdfbf}},
6964 {{0x8000'0000, 0x8000'0000, 0x8000'0000, 0x8000'0000},
6965 {0x8000'0000, 0x8000'0000, 0x8000'0000, 0x8000'0000},
6966 {0x8000'0000, 0x8000'0000, 0x8000'0000, 0x8000'0000},
6967 {0x8000'0000, 0x8000'0000, 0x8000'0000, 0x8000'0000}},
6968 kVectorCalculationsSource);
6969
6970 TestNarrowingVectorInstruction(ExecVnclipuwx,
6971 ExecMaskedVnclipuwx,
6972 {{33, 33, 33, 33, 35, 35, 35, 35, 37, 37, 37, 37, 39, 39, 39, 39},
6973 {41, 41, 41, 41, 43, 43, 43, 43, 45, 45, 45, 45, 47, 47, 47, 47},
6974 {49, 49, 49, 49, 51, 51, 51, 51, 53, 53, 53, 53, 55, 55, 55, 55},
6975 {57, 57, 57, 57, 59, 59, 59, 59, 61, 61, 61, 61, 63, 63, 63, 63}},
6976 {{0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
6977 {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
6978 {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff},
6979 {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff}},
6980 {{0x0021'c1a1, 0x0023'c3a3, 0x0025'c5a5, 0x0027'c7a7},
6981 {0x0029'c9a9, 0x002b'cbab, 0x002d'cdad, 0x002f'cfaf},
6982 {0x0031'd1b1, 0x0033'd3b3, 0x0035'd5b5, 0x0037'd7b7},
6983 {0x0039'd9b9, 0x003b'dbbb, 0x003d'ddbd, 0x003f'dfbf}},
6984 kVectorCalculationsSource);
6985
6986 TestNarrowingVectorInstruction(
6987 ExecVnclipwx,
6988 ExecMaskedVnclipwx,
6989 {{225, 225, 225, 225, 227, 227, 227, 227, 229, 229, 229, 229, 231, 231, 231, 231},
6990 {233, 233, 233, 233, 235, 235, 235, 235, 237, 237, 237, 237, 239, 239, 239, 239},
6991 {241, 241, 241, 241, 243, 243, 243, 243, 245, 245, 245, 245, 247, 247, 247, 247},
6992 {249, 249, 249, 249, 251, 251, 251, 251, 253, 253, 253, 253, 255, 255, 255, 255}},
6993 {{0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000},
6994 {0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000},
6995 {0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000},
6996 {0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0xdfbf}},
6997 {{0xffe1'c1a1, 0xffe3'c3a3, 0xffe5'c5a5, 0xffe7'c7a7},
6998 {0xffe9'c9a9, 0xffeb'cbab, 0xffed'cdad, 0xffef'cfaf},
6999 {0xfff1'd1b1, 0xfff3'd3b3, 0xfff5'd5b5, 0xfff7'd7b7},
7000 {0xfff9'd9b9, 0xfffb'dbbb, 0xfffd'ddbd, 0xffff'dfbf}},
7001 kVectorCalculationsSource);
7002
7003 TestNarrowingVectorInstruction(
7004 ExecVnclipuwv,
7005 ExecMaskedVnclipuwv,
7006 {{255, 255, 255, 255, 69, 35, 9, 3, 255, 255, 255, 255, 153, 39, 9, 3},
7007 {255, 255, 255, 255, 85, 43, 11, 3, 255, 255, 255, 255, 185, 47, 11, 3},
7008 {255, 255, 255, 255, 101, 51, 13, 3, 255, 255, 255, 255, 217, 55, 13, 3},
7009 {255, 255, 255, 255, 117, 59, 15, 3, 255, 255, 255, 255, 249, 63, 15, 3}},
7010 {{0xffff, 0xffff, 0xffff, 0xffff, 0x4989, 0x0971, 0x009b, 0x0009},
7011 {0xffff, 0xffff, 0xffff, 0xffff, 0x5999, 0x0b73, 0x00bb, 0x000b},
7012 {0xffff, 0xffff, 0xffff, 0xffff, 0x69a9, 0x0d75, 0x00db, 0x000d},
7013 {0xffff, 0xffff, 0xffff, 0xffff, 0x79b9, 0x0f77, 0x00fb, 0x000f}},
7014 {{0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff},
7015 {0xa726'a525, 0x0057'9757, 0x0000'5b9b, 0x0000'00bf},
7016 {0xffff'ffff, 0xffff'ffff, 0xffff'ffff, 0xffff'ffff},
7017 {0xe766'e565, 0x0077'b777, 0x0000'7bbb, 0x0000'00ff}},
7018 kVectorCalculationsSource);
7019
7020 TestNarrowingVectorInstruction(
7021 ExecVnclipwv,
7022 ExecMaskedVnclipwv,
7023 {{128, 128, 128, 128, 197, 227, 249, 255, 128, 128, 128, 128, 153, 231, 249, 255},
7024 {128, 128, 128, 128, 213, 235, 251, 255, 128, 128, 128, 128, 185, 239, 251, 255},
7025 {128, 128, 128, 128, 229, 243, 253, 255, 128, 128, 128, 128, 217, 247, 253, 255},
7026 {128, 128, 128, 157, 245, 251, 255, 255, 128, 128, 128, 221, 249, 255, 255, 255}},
7027 {{0x8000, 0x8000, 0x8000, 0x8000, 0xc989, 0xf971, 0xff9b, 0xfff9},
7028 {0x8000, 0x8000, 0x8000, 0x8000, 0xd999, 0xfb73, 0xffbb, 0xfffb},
7029 {0x8000, 0x8000, 0x8000, 0x8000, 0xe9a9, 0xfd75, 0xffdb, 0xfffd},
7030 {0x8000, 0x8000, 0x8000, 0x8000, 0xf9b9, 0xff77, 0xfffb, 0xffff}},
7031 {{0x8000'0000, 0x8000'0000, 0x8000'0000, 0x8000'0000},
7032 {0xa726'a525, 0xffd7'9757, 0xffff'db9b, 0xffff'ffbf},
7033 {0x8000'0000, 0x8000'0000, 0x8000'0000, 0x8000'0000},
7034 {0xe766'e565, 0xfff7'b777, 0xffff'fbbb, 0xffff'ffff}},
7035 kVectorCalculationsSource);
7036
7037 TestVectorInstruction(
7038 ExecVsmulvv,
7039 ExecMaskedVsmulvv,
7040 {{0, 109, 1, 103, 1, 99, 1, 93, 1, 117, 1, 111, 3, 107, 3, 101},
7041 {4, 67, 5, 63, 7, 59, 7, 55, 9, 75, 11, 71, 13, 67, 15, 63},
7042 {16, 35, 19, 31, 21, 27, 23, 23, 25, 43, 27, 39, 31, 35, 33, 31},
7043 {36, 9, 39, 7, 43, 3, 45, 1, 49, 17, 53, 15, 57, 11, 61, 9},
7044 {192, 247, 193, 245, 193, 245, 193, 243, 193, 255, 193, 253, 195, 253, 195, 251},
7045 {196, 237, 197, 237, 199, 237, 199, 237, 201, 245, 203, 245, 205, 245, 207, 245},
7046 {208, 237, 211, 237, 213, 237, 215, 237, 217, 245, 219, 245, 223, 245, 225, 245},
7047 {228, 243, 231, 245, 235, 245, 237, 247, 241, 251, 245, 253, 249, 253, 253, 255}},
7048 {{0x6d24, 0x677f, 0x61f9, 0x5c95, 0x750d, 0x6f69, 0x69e3, 0x647f},
7049 {0x437f, 0x3edb, 0x3a57, 0x35f5, 0x4b6b, 0x46c9, 0x4245, 0x3de3},
7050 {0x21e9, 0x1e47, 0x1ac5, 0x1765, 0x29d9, 0x2639, 0x22b9, 0x1f57},
7051 {0x0863, 0x05c5, 0x0345, 0x00e5, 0x1059, 0x0db9, 0x0b3b, 0x08dd},
7052 {0xf6ef, 0xf551, 0xf3d3, 0xf277, 0xfee7, 0xfd4b, 0xfbcd, 0xfa71},
7053 {0xed89, 0xeced, 0xec71, 0xec17, 0xf585, 0xf4eb, 0xf471, 0xf415},
7054 {0xec33, 0xec9b, 0xed21, 0xedc7, 0xf435, 0xf49b, 0xf523, 0xf5cb},
7055 {0xf2ef, 0xf457, 0xf5df, 0xf789, 0xfaf3, 0xfc5d, 0xfde5, 0xff8f}},
7056 {{0x677d'76af, 0x5c93'1931, 0x6f67'3831, 0x647d'dbb7},
7057 {0x3eda'09c7, 0x35f3'b251, 0x46c7'cf51, 0x3de2'78dd},
7058 {0x1e46'b4fd, 0x1764'638f, 0x2638'7e8f, 0x1f57'2e25},
7059 {0x05c3'7855, 0x00e5'2cef, 0x0db9'45ef, 0x08db'fb8d},
7060 {0xf550'cd47, 0xf276'7fe1, 0xfd4a'8ed9, 0xfa71'4277},
7061 {0xeced'a0bf, 0xec17'5961, 0xf4eb'6659, 0xf416'1fff},
7062 {0xec9a'8c57, 0xedc8'4b01, 0xf49c'55f9, 0xf5cb'15a7},
7063 {0xf457'900d, 0xf789'54c1, 0xfc5d'5db9, 0xff90'236d}},
7064 {{0x5c93'192f'ccd4'7781, 0x647d'dbb5'bb66'23af},
7065 {0x35f3'b24f'43d0'aa39, 0x3de2'78dd'1a4e'4257},
7066 {0x1764'638e'e2fd'152f, 0x1f57'2e24'a166'993d},
7067 {0x00e5'2cee'aa59'b867, 0x08db'fb8c'50af'2865},
7068 {0xf276'7fe1'80cf'f441, 0xfa71'4276'eef1'1fff},
7069 {0xec17'5961'584c'a799, 0xf416'1ffe'ae59'bf47},
7070 {0xedc8'4b01'57f9'9331, 0xf5cb'15a6'95f2'96cf},
7071 {0xf789'54c1'7fd6'b709, 0xff90'236e'a5bb'a697}},
7072 kVectorCalculationsSource);
7073 TestVectorInstruction(ExecVsmulvx,
7074 ExecMaskedVsmulvx,
7075 {{0, 85, 255, 83, 253, 83, 251, 81, 251, 79, 249, 79, 247, 77, 247, 75},
7076 {245, 75, 243, 73, 243, 71, 241, 71, 239, 69, 239, 67, 237, 67, 235, 65},
7077 {235, 63, 233, 63, 231, 61, 231, 59, 229, 59, 227, 57, 227, 55, 225, 55},
7078 {223, 53, 223, 51, 221, 51, 219, 49, 219, 47, 217, 47, 215, 45, 215, 43},
7079 {213, 43, 211, 41, 211, 39, 209, 39, 207, 37, 207, 35, 205, 35, 203, 33},
7080 {203, 31, 201, 31, 199, 29, 199, 27, 197, 27, 195, 25, 195, 23, 193, 23},
7081 {191, 21, 191, 19, 189, 19, 187, 17, 187, 15, 185, 15, 183, 13, 183, 11},
7082 {181, 11, 179, 9, 179, 7, 177, 7, 175, 5, 175, 3, 173, 3, 171, 1}},
7083 {{0x54ab, 0x5355, 0x51fd, 0x50a7, 0x4f51, 0x4df9, 0x4ca3, 0x4b4d},
7084 {0x49f5, 0x489f, 0x4749, 0x45f1, 0x449b, 0x4345, 0x41ed, 0x4097},
7085 {0x3f41, 0x3de9, 0x3c93, 0x3b3d, 0x39e5, 0x388f, 0x3739, 0x35e1},
7086 {0x348b, 0x3335, 0x31dd, 0x3087, 0x2f31, 0x2dd9, 0x2c83, 0x2b2d},
7087 {0x29d5, 0x287f, 0x2729, 0x25d1, 0x247b, 0x2325, 0x21cd, 0x2077},
7088 {0x1f21, 0x1dc9, 0x1c73, 0x1b1d, 0x19c5, 0x186f, 0x1719, 0x15c1},
7089 {0x146b, 0x1315, 0x11bd, 0x1067, 0x0f11, 0x0db9, 0x0c63, 0x0b0d},
7090 {0x09b5, 0x085f, 0x0709, 0x05b1, 0x045b, 0x0305, 0x01ad, 0x0057}},
7091 {{0x5353'aa01, 0x50a6'51fd, 0x4df8'f9fb, 0x4b4b'a1f9},
7092 {0x489e'49f5, 0x45f0'f1f3, 0x4343'99f1, 0x4096'41ed},
7093 {0x3de8'e9eb, 0x3b3b'91e9, 0x388e'39e5, 0x35e0'e1e3},
7094 {0x3333'89e1, 0x3086'31dd, 0x2dd8'd9db, 0x2b2b'81d9},
7095 {0x287e'29d5, 0x25d0'd1d3, 0x2323'79d1, 0x2076'21cd},
7096 {0x1dc8'c9cb, 0x1b1b'71c9, 0x186e'19c5, 0x15c0'c1c3},
7097 {0x1313'69c1, 0x1066'11bd, 0x0db8'b9bb, 0x0b0b'61b9},
7098 {0x085e'09b5, 0x05b0'b1b3, 0x0303'59b1, 0x0056'01ad}},
7099 {{0x50a6'51fc'fdfe'54ab, 0x4b4b'a1f7'a34e'4f51},
7100 {0x45f0'f1f2'489e'49f5, 0x4096'41ec'edee'449b},
7101 {0x3b3b'91e7'933e'3f41, 0x35e0'e1e2'388e'39e5},
7102 {0x3086'31dc'ddde'348b, 0x2b2b'81d7'832e'2f31},
7103 {0x25d0'd1d2'287e'29d5, 0x2076'21cc'cdce'247b},
7104 {0x1b1b'71c7'731e'1f21, 0x15c0'c1c2'186e'19c5},
7105 {0x1066'11bc'bdbe'146b, 0x0b0b'61b7'630e'0f11},
7106 {0x05b0'b1b2'085e'09b5, 0x0056'01ac'adae'045b}},
7107 kVectorCalculationsSource);
7108
7109 TestVectorInstruction(ExecVssrlvv,
7110 ExecMaskedVssrlvv,
7111 {{0, 33, 1, 3, 2, 33, 1, 3, 4, 35, 1, 3, 12, 35, 1, 3},
7112 {16, 37, 1, 3, 10, 37, 1, 3, 12, 39, 1, 3, 28, 39, 1, 3},
7113 {32, 41, 3, 3, 18, 41, 3, 3, 20, 43, 3, 3, 44, 43, 3, 3},
7114 {48, 45, 3, 3, 26, 45, 3, 3, 28, 47, 3, 3, 60, 47, 3, 3},
7115 {64, 49, 5, 3, 34, 49, 5, 3, 36, 51, 5, 3, 76, 51, 5, 3},
7116 {80, 53, 5, 3, 42, 53, 5, 3, 44, 55, 5, 3, 92, 55, 5, 3},
7117 {96, 57, 7, 3, 50, 57, 7, 3, 52, 59, 7, 3, 108, 59, 7, 3},
7118 {112, 61, 7, 3, 58, 61, 7, 3, 60, 63, 7, 3, 124, 63, 7, 3}},
7119 {{0x8100, 0x0831, 0x0043, 0x0009, 0x4484, 0x08b1, 0x008d, 0x0009},
7120 {0x9110, 0x0931, 0x004b, 0x0009, 0x4c8c, 0x09b1, 0x009d, 0x0009},
7121 {0xa120, 0x0a33, 0x0053, 0x000b, 0x5494, 0x0ab3, 0x00ad, 0x000b},
7122 {0xb130, 0x0b33, 0x005b, 0x000b, 0x5c9c, 0x0bb3, 0x00bd, 0x000b},
7123 {0xc140, 0x0c35, 0x0063, 0x000d, 0x64a4, 0x0cb5, 0x00cd, 0x000d},
7124 {0xd150, 0x0d35, 0x006b, 0x000d, 0x6cac, 0x0db5, 0x00dd, 0x000d},
7125 {0xe160, 0x0e37, 0x0073, 0x000f, 0x74b4, 0x0eb7, 0x00ed, 0x000f},
7126 {0xf170, 0x0f37, 0x007b, 0x000f, 0x7cbc, 0x0fb7, 0x00fd, 0x000f}},
7127 {{0x8302'8100, 0x0043'8343, 0x0000'4585, 0x0000'008f},
7128 {0x9312'9110, 0x004b'8b4b, 0x0000'4d8d, 0x0000'009f},
7129 {0xa322'a120, 0x0053'9353, 0x0000'5595, 0x0000'00af},
7130 {0xb332'b130, 0x005b'9b5b, 0x0000'5d9d, 0x0000'00bf},
7131 {0xc342'c140, 0x0063'a363, 0x0000'65a5, 0x0000'00cf},
7132 {0xd352'd150, 0x006b'ab6b, 0x0000'6dad, 0x0000'00df},
7133 {0xe362'e160, 0x0073'b373, 0x0000'75b5, 0x0000'00ef},
7134 {0xf372'f170, 0x007b'bb7b, 0x0000'7dbd, 0x0000'00ff}},
7135 {{0x8706'8504'8302'8100, 0x0000'4787'4686'4585},
7136 {0x0000'0000'9716'9515, 0x0000'0000'0000'4f8f},
7137 {0xa726'a524'a322'a120, 0x0000'5797'5696'5595},
7138 {0x0000'0000'b736'b535, 0x0000'0000'0000'5f9f},
7139 {0xc746'c544'c342'c140, 0x0000'67a7'66a6'65a5},
7140 {0x0000'0000'd756'd555, 0x0000'0000'0000'6faf},
7141 {0xe766'e564'e362'e160, 0x0000'77b7'76b6'75b5},
7142 {0x0000'0000'f776'f575, 0x0000'0000'0000'7fbf}},
7143 kVectorCalculationsSource);
7144
7145 TestVectorInstruction(ExecVssrlvx,
7146 ExecMaskedVssrlvx,
7147 {{0, 33, 1, 33, 1, 33, 1, 33, 2, 35, 3, 35, 3, 35, 3, 35},
7148 {4, 37, 5, 37, 5, 37, 5, 37, 6, 39, 7, 39, 7, 39, 7, 39},
7149 {8, 41, 9, 41, 9, 41, 9, 41, 10, 43, 11, 43, 11, 43, 11, 43},
7150 {12, 45, 13, 45, 13, 45, 13, 45, 14, 47, 15, 47, 15, 47, 15, 47},
7151 {16, 49, 17, 49, 17, 49, 17, 49, 18, 51, 19, 51, 19, 51, 19, 51},
7152 {20, 53, 21, 53, 21, 53, 21, 53, 22, 55, 23, 55, 23, 55, 23, 55},
7153 {24, 57, 25, 57, 25, 57, 25, 57, 26, 59, 27, 59, 27, 59, 27, 59},
7154 {28, 61, 29, 61, 29, 61, 29, 61, 30, 63, 31, 63, 31, 63, 31, 63}},
7155 {{0x0021, 0x0021, 0x0021, 0x0021, 0x0023, 0x0023, 0x0023, 0x0023},
7156 {0x0025, 0x0025, 0x0025, 0x0025, 0x0027, 0x0027, 0x0027, 0x0027},
7157 {0x0029, 0x0029, 0x0029, 0x0029, 0x002b, 0x002b, 0x002b, 0x002b},
7158 {0x002d, 0x002d, 0x002d, 0x002d, 0x002f, 0x002f, 0x002f, 0x002f},
7159 {0x0031, 0x0031, 0x0031, 0x0031, 0x0033, 0x0033, 0x0033, 0x0033},
7160 {0x0035, 0x0035, 0x0035, 0x0035, 0x0037, 0x0037, 0x0037, 0x0037},
7161 {0x0039, 0x0039, 0x0039, 0x0039, 0x003b, 0x003b, 0x003b, 0x003b},
7162 {0x003d, 0x003d, 0x003d, 0x003d, 0x003f, 0x003f, 0x003f, 0x003f}},
7163 {{0x0020'c0a1, 0x0021'c1a1, 0x0022'c2a3, 0x0023'c3a3},
7164 {0x0024'c4a5, 0x0025'c5a5, 0x0026'c6a7, 0x0027'c7a7},
7165 {0x0028'c8a9, 0x0029'c9a9, 0x002a'caab, 0x002b'cbab},
7166 {0x002c'ccad, 0x002d'cdad, 0x002e'ceaf, 0x002f'cfaf},
7167 {0x0030'd0b1, 0x0031'd1b1, 0x0032'd2b3, 0x0033'd3b3},
7168 {0x0034'd4b5, 0x0035'd5b5, 0x0036'd6b7, 0x0037'd7b7},
7169 {0x0038'd8b9, 0x0039'd9b9, 0x003a'dabb, 0x003b'dbbb},
7170 {0x003c'dcbd, 0x003d'ddbd, 0x003e'debf, 0x003f'dfbf}},
7171 {{0x0000'0000'0021'c1a1, 0x0000'0000'0023'c3a3},
7172 {0x0000'0000'0025'c5a5, 0x0000'0000'0027'c7a7},
7173 {0x0000'0000'0029'c9a9, 0x0000'0000'002b'cbab},
7174 {0x0000'0000'002d'cdad, 0x0000'0000'002f'cfaf},
7175 {0x0000'0000'0031'd1b1, 0x0000'0000'0033'd3b3},
7176 {0x0000'0000'0035'd5b5, 0x0000'0000'0037'd7b7},
7177 {0x0000'0000'0039'd9b9, 0x0000'0000'003b'dbbb},
7178 {0x0000'0000'003d'ddbd, 0x0000'0000'003f'dfbf}},
7179 kVectorCalculationsSource);
7180
7181 TestVectorInstruction(ExecVssrlvi,
7182 ExecMaskedVssrlvi,
7183 {{0, 33, 1, 33, 1, 33, 1, 33, 2, 35, 3, 35, 3, 35, 3, 35},
7184 {4, 37, 5, 37, 5, 37, 5, 37, 6, 39, 7, 39, 7, 39, 7, 39},
7185 {8, 41, 9, 41, 9, 41, 9, 41, 10, 43, 11, 43, 11, 43, 11, 43},
7186 {12, 45, 13, 45, 13, 45, 13, 45, 14, 47, 15, 47, 15, 47, 15, 47},
7187 {16, 49, 17, 49, 17, 49, 17, 49, 18, 51, 19, 51, 19, 51, 19, 51},
7188 {20, 53, 21, 53, 21, 53, 21, 53, 22, 55, 23, 55, 23, 55, 23, 55},
7189 {24, 57, 25, 57, 25, 57, 25, 57, 26, 59, 27, 59, 27, 59, 27, 59},
7190 {28, 61, 29, 61, 29, 61, 29, 61, 30, 63, 31, 63, 31, 63, 31, 63}},
7191 {{0x0021, 0x0021, 0x0021, 0x0021, 0x0023, 0x0023, 0x0023, 0x0023},
7192 {0x0025, 0x0025, 0x0025, 0x0025, 0x0027, 0x0027, 0x0027, 0x0027},
7193 {0x0029, 0x0029, 0x0029, 0x0029, 0x002b, 0x002b, 0x002b, 0x002b},
7194 {0x002d, 0x002d, 0x002d, 0x002d, 0x002f, 0x002f, 0x002f, 0x002f},
7195 {0x0031, 0x0031, 0x0031, 0x0031, 0x0033, 0x0033, 0x0033, 0x0033},
7196 {0x0035, 0x0035, 0x0035, 0x0035, 0x0037, 0x0037, 0x0037, 0x0037},
7197 {0x0039, 0x0039, 0x0039, 0x0039, 0x003b, 0x003b, 0x003b, 0x003b},
7198 {0x003d, 0x003d, 0x003d, 0x003d, 0x003f, 0x003f, 0x003f, 0x003f}},
7199 {{0x0020'c0a1, 0x0021'c1a1, 0x0022'c2a3, 0x0023'c3a3},
7200 {0x0024'c4a5, 0x0025'c5a5, 0x0026'c6a7, 0x0027'c7a7},
7201 {0x0028'c8a9, 0x0029'c9a9, 0x002a'caab, 0x002b'cbab},
7202 {0x002c'ccad, 0x002d'cdad, 0x002e'ceaf, 0x002f'cfaf},
7203 {0x0030'd0b1, 0x0031'd1b1, 0x0032'd2b3, 0x0033'd3b3},
7204 {0x0034'd4b5, 0x0035'd5b5, 0x0036'd6b7, 0x0037'd7b7},
7205 {0x0038'd8b9, 0x0039'd9b9, 0x003a'dabb, 0x003b'dbbb},
7206 {0x003c'dcbd, 0x003d'ddbd, 0x003e'debf, 0x003f'dfbf}},
7207 {{0x0021'c1a1'4120'c0a1, 0x0023'c3a3'4322'c2a3},
7208 {0x0025'c5a5'4524'c4a5, 0x0027'c7a7'4726'c6a7},
7209 {0x0029'c9a9'4928'c8a9, 0x002b'cbab'4b2a'caab},
7210 {0x002d'cdad'4d2c'ccad, 0x002f'cfaf'4f2e'ceaf},
7211 {0x0031'd1b1'5130'd0b1, 0x0033'd3b3'5332'd2b3},
7212 {0x0035'd5b5'5534'd4b5, 0x0037'd7b7'5736'd6b7},
7213 {0x0039'd9b9'5938'd8b9, 0x003b'dbbb'5b3a'dabb},
7214 {0x003d'ddbd'5d3c'dcbd, 0x003f'dfbf'5f3e'debf}},
7215 kVectorCalculationsSource);
7216
7217 TestVectorInstruction(ExecVssravv,
7218 ExecMaskedVssravv,
7219 {{0, 225, 1, 255, 2, 225, 1, 255, 4, 227, 1, 255, 12, 227, 1, 255},
7220 {16, 229, 1, 255, 10, 229, 1, 255, 12, 231, 1, 255, 28, 231, 1, 255},
7221 {32, 233, 3, 255, 18, 233, 3, 255, 20, 235, 3, 255, 44, 235, 3, 255},
7222 {48, 237, 3, 255, 26, 237, 3, 255, 28, 239, 3, 255, 60, 239, 3, 255},
7223 {64, 241, 5, 255, 34, 241, 5, 255, 36, 243, 5, 255, 76, 243, 5, 255},
7224 {80, 245, 5, 255, 42, 245, 5, 255, 44, 247, 5, 255, 92, 247, 5, 255},
7225 {96, 249, 7, 255, 50, 249, 7, 255, 52, 251, 7, 255, 108, 251, 7, 255},
7226 {112, 253, 7, 255, 58, 253, 7, 255, 60, 255, 7, 255, 124, 255, 7, 255}},
7227 {{0x8100, 0xf831, 0xffc3, 0xfff9, 0xc484, 0xf8b1, 0xff8d, 0xfff9},
7228 {0x9110, 0xf931, 0xffcb, 0xfff9, 0xcc8c, 0xf9b1, 0xff9d, 0xfff9},
7229 {0xa120, 0xfa33, 0xffd3, 0xfffb, 0xd494, 0xfab3, 0xffad, 0xfffb},
7230 {0xb130, 0xfb33, 0xffdb, 0xfffb, 0xdc9c, 0xfbb3, 0xffbd, 0xfffb},
7231 {0xc140, 0xfc35, 0xffe3, 0xfffd, 0xe4a4, 0xfcb5, 0xffcd, 0xfffd},
7232 {0xd150, 0xfd35, 0xffeb, 0xfffd, 0xecac, 0xfdb5, 0xffdd, 0xfffd},
7233 {0xe160, 0xfe37, 0xfff3, 0xffff, 0xf4b4, 0xfeb7, 0xffed, 0xffff},
7234 {0xf170, 0xff37, 0xfffb, 0xffff, 0xfcbc, 0xffb7, 0xfffd, 0xffff}},
7235 {{0x8302'8100, 0xffc3'8343, 0xffff'c585, 0xffff'ff8f},
7236 {0x9312'9110, 0xffcb'8b4b, 0xffff'cd8d, 0xffff'ff9f},
7237 {0xa322'a120, 0xffd3'9353, 0xffff'd595, 0xffff'ffaf},
7238 {0xb332'b130, 0xffdb'9b5b, 0xffff'dd9d, 0xffff'ffbf},
7239 {0xc342'c140, 0xffe3'a363, 0xffff'e5a5, 0xffff'ffcf},
7240 {0xd352'd150, 0xffeb'ab6b, 0xffff'edad, 0xffff'ffdf},
7241 {0xe362'e160, 0xfff3'b373, 0xffff'f5b5, 0xffff'ffef},
7242 {0xf372'f170, 0xfffb'bb7b, 0xffff'fdbd, 0xffff'ffff}},
7243 {{0x8706'8504'8302'8100, 0xffff'c787'4686'4585},
7244 {0xffff'ffff'9716'9515, 0xffff'ffff'ffff'cf8f},
7245 {0xa726'a524'a322'a120, 0xffff'd797'5696'5595},
7246 {0xffff'ffff'b736'b535, 0xffff'ffff'ffff'df9f},
7247 {0xc746'c544'c342'c140, 0xffff'e7a7'66a6'65a5},
7248 {0xffff'ffff'd756'd555, 0xffff'ffff'ffff'efaf},
7249 {0xe766'e564'e362'e160, 0xffff'f7b7'76b6'75b5},
7250 {0xffff'ffff'f776'f575, 0xffff'ffff'ffff'ffbf}},
7251 kVectorCalculationsSource);
7252
7253 TestVectorInstruction(ExecVssravx,
7254 ExecMaskedVssravx,
7255 {{0, 225, 1, 225, 1, 225, 1, 225, 2, 227, 3, 227, 3, 227, 3, 227},
7256 {4, 229, 5, 229, 5, 229, 5, 229, 6, 231, 7, 231, 7, 231, 7, 231},
7257 {8, 233, 9, 233, 9, 233, 9, 233, 10, 235, 11, 235, 11, 235, 11, 235},
7258 {12, 237, 13, 237, 13, 237, 13, 237, 14, 239, 15, 239, 15, 239, 15, 239},
7259 {16, 241, 17, 241, 17, 241, 17, 241, 18, 243, 19, 243, 19, 243, 19, 243},
7260 {20, 245, 21, 245, 21, 245, 21, 245, 22, 247, 23, 247, 23, 247, 23, 247},
7261 {24, 249, 25, 249, 25, 249, 25, 249, 26, 251, 27, 251, 27, 251, 27, 251},
7262 {28, 253, 29, 253, 29, 253, 29, 253, 30, 255, 31, 255, 31, 255, 31, 255}},
7263 {{0xffe1, 0xffe1, 0xffe1, 0xffe1, 0xffe3, 0xffe3, 0xffe3, 0xffe3},
7264 {0xffe5, 0xffe5, 0xffe5, 0xffe5, 0xffe7, 0xffe7, 0xffe7, 0xffe7},
7265 {0xffe9, 0xffe9, 0xffe9, 0xffe9, 0xffeb, 0xffeb, 0xffeb, 0xffeb},
7266 {0xffed, 0xffed, 0xffed, 0xffed, 0xffef, 0xffef, 0xffef, 0xffef},
7267 {0xfff1, 0xfff1, 0xfff1, 0xfff1, 0xfff3, 0xfff3, 0xfff3, 0xfff3},
7268 {0xfff5, 0xfff5, 0xfff5, 0xfff5, 0xfff7, 0xfff7, 0xfff7, 0xfff7},
7269 {0xfff9, 0xfff9, 0xfff9, 0xfff9, 0xfffb, 0xfffb, 0xfffb, 0xfffb},
7270 {0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xffff, 0xffff, 0xffff, 0xffff}},
7271 {{0xffe0'c0a1, 0xffe1'c1a1, 0xffe2'c2a3, 0xffe3'c3a3},
7272 {0xffe4'c4a5, 0xffe5'c5a5, 0xffe6'c6a7, 0xffe7'c7a7},
7273 {0xffe8'c8a9, 0xffe9'c9a9, 0xffea'caab, 0xffeb'cbab},
7274 {0xffec'ccad, 0xffed'cdad, 0xffee'ceaf, 0xffef'cfaf},
7275 {0xfff0'd0b1, 0xfff1'd1b1, 0xfff2'd2b3, 0xfff3'd3b3},
7276 {0xfff4'd4b5, 0xfff5'd5b5, 0xfff6'd6b7, 0xfff7'd7b7},
7277 {0xfff8'd8b9, 0xfff9'd9b9, 0xfffa'dabb, 0xfffb'dbbb},
7278 {0xfffc'dcbd, 0xfffd'ddbd, 0xfffe'debf, 0xffff'dfbf}},
7279 {{0xffff'ffff'ffe1'c1a1, 0xffff'ffff'ffe3'c3a3},
7280 {0xffff'ffff'ffe5'c5a5, 0xffff'ffff'ffe7'c7a7},
7281 {0xffff'ffff'ffe9'c9a9, 0xffff'ffff'ffeb'cbab},
7282 {0xffff'ffff'ffed'cdad, 0xffff'ffff'ffef'cfaf},
7283 {0xffff'ffff'fff1'd1b1, 0xffff'ffff'fff3'd3b3},
7284 {0xffff'ffff'fff5'd5b5, 0xffff'ffff'fff7'd7b7},
7285 {0xffff'ffff'fff9'd9b9, 0xffff'ffff'fffb'dbbb},
7286 {0xffff'ffff'fffd'ddbd, 0xffff'ffff'ffff'dfbf}},
7287 kVectorCalculationsSource);
7288
7289 TestVectorInstruction(ExecVssravi,
7290 ExecMaskedVssravi,
7291 {{0, 225, 1, 225, 1, 225, 1, 225, 2, 227, 3, 227, 3, 227, 3, 227},
7292 {4, 229, 5, 229, 5, 229, 5, 229, 6, 231, 7, 231, 7, 231, 7, 231},
7293 {8, 233, 9, 233, 9, 233, 9, 233, 10, 235, 11, 235, 11, 235, 11, 235},
7294 {12, 237, 13, 237, 13, 237, 13, 237, 14, 239, 15, 239, 15, 239, 15, 239},
7295 {16, 241, 17, 241, 17, 241, 17, 241, 18, 243, 19, 243, 19, 243, 19, 243},
7296 {20, 245, 21, 245, 21, 245, 21, 245, 22, 247, 23, 247, 23, 247, 23, 247},
7297 {24, 249, 25, 249, 25, 249, 25, 249, 26, 251, 27, 251, 27, 251, 27, 251},
7298 {28, 253, 29, 253, 29, 253, 29, 253, 30, 255, 31, 255, 31, 255, 31, 255}},
7299 {{0xffe1, 0xffe1, 0xffe1, 0xffe1, 0xffe3, 0xffe3, 0xffe3, 0xffe3},
7300 {0xffe5, 0xffe5, 0xffe5, 0xffe5, 0xffe7, 0xffe7, 0xffe7, 0xffe7},
7301 {0xffe9, 0xffe9, 0xffe9, 0xffe9, 0xffeb, 0xffeb, 0xffeb, 0xffeb},
7302 {0xffed, 0xffed, 0xffed, 0xffed, 0xffef, 0xffef, 0xffef, 0xffef},
7303 {0xfff1, 0xfff1, 0xfff1, 0xfff1, 0xfff3, 0xfff3, 0xfff3, 0xfff3},
7304 {0xfff5, 0xfff5, 0xfff5, 0xfff5, 0xfff7, 0xfff7, 0xfff7, 0xfff7},
7305 {0xfff9, 0xfff9, 0xfff9, 0xfff9, 0xfffb, 0xfffb, 0xfffb, 0xfffb},
7306 {0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xffff, 0xffff, 0xffff, 0xffff}},
7307 {{0xffe0'c0a1, 0xffe1'c1a1, 0xffe2'c2a3, 0xffe3'c3a3},
7308 {0xffe4'c4a5, 0xffe5'c5a5, 0xffe6'c6a7, 0xffe7'c7a7},
7309 {0xffe8'c8a9, 0xffe9'c9a9, 0xffea'caab, 0xffeb'cbab},
7310 {0xffec'ccad, 0xffed'cdad, 0xffee'ceaf, 0xffef'cfaf},
7311 {0xfff0'd0b1, 0xfff1'd1b1, 0xfff2'd2b3, 0xfff3'd3b3},
7312 {0xfff4'd4b5, 0xfff5'd5b5, 0xfff6'd6b7, 0xfff7'd7b7},
7313 {0xfff8'd8b9, 0xfff9'd9b9, 0xfffa'dabb, 0xfffb'dbbb},
7314 {0xfffc'dcbd, 0xfffd'ddbd, 0xfffe'debf, 0xffff'dfbf}},
7315 {{0xffe1'c1a1'4120'c0a1, 0xffe3'c3a3'4322'c2a3},
7316 {0xffe5'c5a5'4524'c4a5, 0xffe7'c7a7'4726'c6a7},
7317 {0xffe9'c9a9'4928'c8a9, 0xffeb'cbab'4b2a'caab},
7318 {0xffed'cdad'4d2c'ccad, 0xffef'cfaf'4f2e'ceaf},
7319 {0xfff1'd1b1'5130'd0b1, 0xfff3'd3b3'5332'd2b3},
7320 {0xfff5'd5b5'5534'd4b5, 0xfff7'd7b7'5736'd6b7},
7321 {0xfff9'd9b9'5938'd8b9, 0xfffb'dbbb'5b3a'dabb},
7322 {0xfffd'ddbd'5d3c'dcbd, 0xffff'dfbf'5f3e'debf}},
7323 kVectorCalculationsSource);
7324 asm volatile("csrw vxrm, %0\n\t" ::"r"(vxrm));
7325 }
7326
ExecVfdivvv()7327 [[gnu::naked]] void ExecVfdivvv() {
7328 asm("vfdiv.vv v8, v16, v24\n\t"
7329 "ret\n\t");
7330 }
7331
ExecMaskedVfdivvv()7332 [[gnu::naked]] void ExecMaskedVfdivvv() {
7333 asm("vfdiv.vv v8, v16, v24, v0.t\n\t"
7334 "ret\n\t");
7335 }
7336
ExecVfdivvf()7337 [[gnu::naked]] void ExecVfdivvf() {
7338 asm("vfdiv.vf v8, v16, ft0\n\t"
7339 "ret\n\t");
7340 }
7341
ExecMaskedVfdivvf()7342 [[gnu::naked]] void ExecMaskedVfdivvf() {
7343 asm("vfdiv.vf v8, v16, ft0, v0.t\n\t"
7344 "ret\n\t");
7345 }
7346
ExecVfrdivvf()7347 [[gnu::naked]] void ExecVfrdivvf() {
7348 asm("vfrdiv.vf v8, v16, ft0\n\t"
7349 "ret\n\t");
7350 }
7351
ExecMaskedVfrdivvf()7352 [[gnu::naked]] void ExecMaskedVfrdivvf() {
7353 asm("vfrdiv.vf v8, v16, ft0, v0.t\n\t"
7354 "ret\n\t");
7355 }
7356
ExecVdivuvv()7357 [[gnu::naked]] void ExecVdivuvv() {
7358 asm("vdivu.vv v8, v16, v24\n\t"
7359 "ret\n\t");
7360 }
7361
ExecMaskedVdivuvv()7362 [[gnu::naked]] void ExecMaskedVdivuvv() {
7363 asm("vdivu.vv v8, v16, v24, v0.t\n\t"
7364 "ret\n\t");
7365 }
7366
ExecVdivvv()7367 [[gnu::naked]] void ExecVdivvv() {
7368 asm("vdiv.vv v8, v16, v24\n\t"
7369 "ret\n\t");
7370 }
7371
ExecMaskedVdivvv()7372 [[gnu::naked]] void ExecMaskedVdivvv() {
7373 asm("vdiv.vv v8, v16, v24, v0.t\n\t"
7374 "ret\n\t");
7375 }
7376
ExecVdivuvx()7377 [[gnu::naked]] void ExecVdivuvx() {
7378 asm("vdivu.vx v8, v16, t0\n\t"
7379 "ret\n\t");
7380 }
7381
ExecMaskedVdivuvx()7382 [[gnu::naked]] void ExecMaskedVdivuvx() {
7383 asm("vdivu.vx v8, v16, t0, v0.t\n\t"
7384 "ret\n\t");
7385 }
7386
ExecVdivvx()7387 [[gnu::naked]] void ExecVdivvx() {
7388 asm("vdiv.vx v8, v16, t0\n\t"
7389 "ret\n\t");
7390 }
7391
ExecMaskedVdivvx()7392 [[gnu::naked]] void ExecMaskedVdivvx() {
7393 asm("vdiv.vx v8, v16, t0, v0.t\n\t"
7394 "ret\n\t");
7395 }
7396
TEST(InlineAsmTestRiscv64,TestVdiv)7397 TEST(InlineAsmTestRiscv64, TestVdiv) {
7398 TestVectorFloatInstruction(ExecVfdivvv,
7399 ExecMaskedVfdivvv,
7400 {{0xbc7d'1561, 0xb875'e8eb, 0xb46f'83ae, 0xb069'c6ec},
7401 {0xac64'99e5, 0xa85f'e87d, 0xa45b'a22e, 0xa057'b943},
7402 {0x9c54'2241, 0x9850'd382, 0x944d'c4d2, 0x904a'ef31},
7403 {0x8c48'4c98, 0x8845'd7d4, 0x8443'8c62, 0x8060'b328},
7404 {0x7c3c'206f, 0x7835'0888, 0x742e'b4f5, 0x7029'0782},
7405 {0x6c23'e7dc, 0x681f'423a, 0x641b'0659, 0x6017'26b8},
7406 {0x5c13'980b, 0x5810'50ca, 0x540d'48e2, 0x500a'7968},
7407 {0x4c07'dc6c, 0x4805'6ccb, 0x4403'260f, 0x4001'0454}},
7408 {{0xb8e9'b361'617b'3332, 0xb0e1'64f5'e24e'7813},
7409 {0xa8d9'a850'c33d'b3c7, 0xa0d1'5a44'cf64'f786},
7410 {0x98c9'9d59'4646'6ce0, 0x90c1'4fab'f702'438e},
7411 {0x88b9'927a'9559'd99b, 0x80b1'452b'0727'cc70},
7412 {0x78a9'87b4'5cbc'33ee, 0x70a1'3ac1'af47'5dc7},
7413 {0x6899'7d06'4a29'0e6f, 0x6091'306f'a03b'130b},
7414 {0x5889'7270'0ccb'2650, 0x5081'2634'8c3d'81c9},
7415 {0x4879'67f1'5534'6be6, 0x4071'1c10'26e2'17fd}},
7416 kVectorCalculationsSourceLegacy);
7417 TestVectorFloatInstruction(ExecVfdivvf,
7418 ExecMaskedVfdivvf,
7419 {{0x81b9'9b06, 0x85bf'5117, 0x89c5'0728, 0x8dca'bd39},
7420 {0x91d0'734a, 0x95d6'295b, 0x99db'df6c, 0x9de1'957d},
7421 {0xa1e7'4b8e, 0xa5ed'019f, 0xa9f2'b7b0, 0xadf8'6dc1},
7422 {0xb1fe'23d2, 0xb601'ecf2, 0xba04'c7fa, 0xbe07'a303},
7423 {0xc20a'7e0b, 0xc60d'5914, 0xca10'341c, 0xce13'0f25},
7424 {0xd215'ea2e, 0xd618'c536, 0xda1b'a03f, 0xde1e'7b47},
7425 {0xe221'5650, 0xe624'3158, 0xea27'0c61, 0xee29'e769},
7426 {0xf22c'c272, 0xf62f'9d7a, 0xfa32'7883, 0xfe35'538b}},
7427 {{0x86e0'0391'6e3a'ab61, 0x8ee5'b9a2'8501'cd89},
7428 {0x96f0'0efd'9068'39a5, 0x9ef5'c50e'a72f'5bcd},
7429 {0xa700'1a69'b295'c7e9, 0xaf05'd07a'c95c'ea11},
7430 {0xb710'25d5'd4c3'562e, 0xbf15'dbe6'eb8a'7855},
7431 {0xc720'3141'f6f0'e472, 0xcf25'e753'0db8'069a},
7432 {0xd730'3cae'191e'72b6, 0xdf35'f2bf'2fe5'94de},
7433 {0xe740'481a'3b4c'00fa, 0xef45'fe2b'5213'2322},
7434 {0xf750'5386'5d79'8f3f, 0xff56'0997'7440'b166}},
7435 kVectorCalculationsSourceLegacy);
7436 TestVectorFloatInstruction(ExecVfrdivvf,
7437 ExecMaskedVfrdivvf,
7438 {{0xfd30'8be3, 0xf92b'46b3, 0xf526'4fba, 0xf121'a05c},
7439 {0xed1d'32b7, 0xe919'0189, 0xe515'081b, 0xe111'4231},
7440 {0xdd0d'abfb, 0xd90a'4206, 0xd507'0132, 0xd103'e6a8},
7441 {0xcd00'efd5, 0xc8fc'34b9, 0xc4f6'c831, 0xc0f1'9620},
7442 {0xbcec'9ae8, 0xb8e7'd337, 0xb4e3'3bfd, 0xb0de'd268},
7443 {0xacda'93da, 0xa8d6'7deb, 0xa4d2'8e5f, 0xa0ce'c322},
7444 {0x9ccb'1a46, 0x98c7'9200, 0x94c4'28a6, 0x90c0'dca6},
7445 {0x8cbd'ac8d, 0x88ba'96ff, 0x84b7'9ab5, 0x80b4'b67d}},
7446 {{0xf8ff'f8de'ba96'50ff, 0xf0f7'9132'204d'3f73},
7447 {0xe8ef'e220'dbd5'38e4, 0xe0e7'84d4'8fe3'51e3},
7448 {0xd8df'cb83'4048'7bb7, 0xd0d7'7883'f290'f6d8},
7449 {0xc8cf'b505'a379'43a3, 0xc0c7'6c40'3409'4932},
7450 {0xb8bf'9ea7'c1b1'e9b5, 0xb0b7'6009'4029'bc36},
7451 {0xa8af'8869'57fb'4e5c, 0xa0a7'53df'02f9'ad62},
7452 {0x989f'724a'241a'3d11, 0x9097'47c1'68a9'f793},
7453 {0x888f'5c49'e48c'db01, 0x8087'3bb0'5d94'877b}},
7454 kVectorCalculationsSourceLegacy);
7455
7456 TestVectorInstruction(ExecVdivuvv,
7457 ExecMaskedVdivuvv,
7458 {{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
7459 {10, 3, 10, 3, 15, 15, 15, 15, 0, 0, 10, 3, 15, 15, 15, 15},
7460 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
7461 {1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0},
7462 {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
7463 {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
7464 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
7465 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
7466 {{0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001},
7467 {0x0003, 0x0003, 0x000f, 0x000f, 0x0000, 0x0003, 0x000f, 0x000f},
7468 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
7469 {0x0001, 0x0001, 0x0001, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000},
7470 {0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001},
7471 {0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001},
7472 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
7473 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}},
7474 {{0x0000'0001, 0x0000'0001, 0x0000'0001, 0x0000'0001},
7475 {0x0000'0003, 0x0000'000f, 0x0000'0003, 0x0000'000f},
7476 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
7477 {0x0000'0001, 0x0000'0001, 0x0000'0000, 0x0000'0000},
7478 {0x0000'0001, 0x0000'0001, 0x0000'0001, 0x0000'0001},
7479 {0x0000'0001, 0x0000'0001, 0x0000'0001, 0x0000'0001},
7480 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
7481 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000}},
7482 {{0x0000'0000'0000'0001, 0x0000'0000'0000'0001},
7483 {0x0000'0000'0000'000e, 0x0000'0000'0000'000e},
7484 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
7485 {0x0000'0000'0000'0001, 0x0000'0000'0000'0000},
7486 {0x0000'0000'0000'0001, 0x0000'0000'0000'0001},
7487 {0x0000'0000'0000'0001, 0x0000'0000'0000'0001},
7488 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
7489 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000}},
7490 kVectorComparisonSource);
7491
7492 TestVectorInstruction(ExecVdivvv,
7493 ExecMaskedVdivvv,
7494 {{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
7495 {252, 3, 252, 3, 0, 0, 0, 0, 0, 0, 252, 3, 0, 0, 0, 0},
7496 {255, 192, 255, 192, 255, 192, 255, 192, 0, 0, 0, 0, 0, 128, 255, 192},
7497 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
7498 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
7499 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
7500 {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 2},
7501 {2, 2, 3, 3, 3, 3, 4, 4, 5, 6, 7, 8, 10, 14, 21, 43}},
7502 {{0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001},
7503 {0x0003, 0x0003, 0x0000, 0x0000, 0x0000, 0x0003, 0x0000, 0x0000},
7504 {0xfbbb, 0xfbbb, 0xfbbb, 0xfbbb, 0x0000, 0x0000, 0x0888, 0xfbbb},
7505 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
7506 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
7507 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
7508 {0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0002, 0x0001, 0x0002},
7509 {0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0009, 0x0011, 0x0055}},
7510 {{0x0000'0001, 0x0000'0001, 0x0000'0001, 0x0000'0001},
7511 {0x0000'0003, 0x0000'0000, 0x0000'0003, 0x0000'0000},
7512 {0xffff'fb6d, 0xffff'fb6d, 0x0000'0000, 0xffff'fb6d},
7513 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
7514 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
7515 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
7516 {0x0000'0001, 0x0000'0001, 0x0000'0002, 0x0000'0002},
7517 {0x0000'0003, 0x0000'0005, 0x0000'0009, 0x0000'0055}},
7518 {{0x0000'0000'0000'0001, 0x0000'0000'0000'0001},
7519 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
7520 {0xffff'ffff'ffff'fb6d, 0xffff'ffff'ffff'fb6d},
7521 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
7522 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
7523 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
7524 {0x0000'0000'0000'0001, 0x0000'0000'0000'0002},
7525 {0x0000'0000'0000'0005, 0x0000'0000'0000'0055}},
7526 kVectorComparisonSource);
7527
7528 TestVectorInstruction(ExecVdivuvx,
7529 ExecMaskedVdivuvx,
7530 {{0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1},
7531 {1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1},
7532 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
7533 {1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0},
7534 {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
7535 {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
7536 {1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0},
7537 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
7538 {{0x0001, 0x0001, 0x0001, 0x0001, 0x0000, 0x0000, 0x0001, 0x0001},
7539 {0x0000, 0x0000, 0x0001, 0x0001, 0x0000, 0x0000, 0x0001, 0x0001},
7540 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
7541 {0x0001, 0x0001, 0x0001, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000},
7542 {0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001},
7543 {0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001},
7544 {0x0001, 0x0000, 0x0001, 0x0000, 0x0001, 0x0000, 0x0001, 0x0000},
7545 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}},
7546 {{0x0000'0001, 0x0000'0001, 0x0000'0000, 0x0000'0001},
7547 {0x0000'0000, 0x0000'0001, 0x0000'0000, 0x0000'0001},
7548 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
7549 {0x0000'0001, 0x0000'0001, 0x0000'0000, 0x0000'0000},
7550 {0x0000'0001, 0x0000'0001, 0x0000'0001, 0x0000'0001},
7551 {0x0000'0001, 0x0000'0001, 0x0000'0001, 0x0000'0001},
7552 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
7553 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000}},
7554 {{0x0000'0000'0000'0001, 0x0000'0000'0000'0001},
7555 {0x0000'0000'0000'0001, 0x0000'0000'0000'0001},
7556 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
7557 {0x0000'0000'0000'0001, 0x0000'0000'0000'0000},
7558 {0x0000'0000'0000'0001, 0x0000'0000'0000'0001},
7559 {0x0000'0000'0000'0001, 0x0000'0000'0000'0001},
7560 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
7561 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000}},
7562 kVectorComparisonSource);
7563
7564 TestVectorInstruction(ExecVdivvx,
7565 ExecMaskedVdivvx,
7566 {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
7567 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
7568 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0},
7569 {1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0},
7570 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
7571 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
7572 {0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1},
7573 {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}},
7574 {{0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
7575 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
7576 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000},
7577 {0x0001, 0x0001, 0x0001, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000},
7578 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
7579 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
7580 {0x0000, 0x0001, 0x0000, 0x0001, 0x0000, 0x0001, 0x0000, 0x0001},
7581 {0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001}},
7582 {{0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
7583 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
7584 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
7585 {0x0000'0001, 0x0000'0001, 0x0000'0000, 0x0000'0000},
7586 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
7587 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
7588 {0x0000'0001, 0x0000'0001, 0x0000'0001, 0x0000'0001},
7589 {0x0000'0001, 0x0000'0001, 0x0000'0001, 0x0000'0001}},
7590 {{0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
7591 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
7592 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
7593 {0x0000'0000'0000'0001, 0x0000'0000'0000'0000},
7594 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
7595 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
7596 {0x0000'0000'0000'0001, 0x0000'0000'0000'0001},
7597 {0x0000'0000'0000'0001, 0x0000'0000'0000'0001}},
7598 kVectorComparisonSource);
7599 }
7600
ExecVmaccvv()7601 [[gnu::naked]] void ExecVmaccvv() {
7602 asm("vmacc.vv v8, v16, v24\n\t"
7603 "ret\n\t");
7604 }
7605
ExecMaskedVmaccvv()7606 [[gnu::naked]] void ExecMaskedVmaccvv() {
7607 asm("vmacc.vv v8, v16, v24, v0.t\n\t"
7608 "ret\n\t");
7609 }
7610
ExecVmaccvx()7611 [[gnu::naked]] void ExecVmaccvx() {
7612 asm("vmacc.vx v8, t0, v16\n\t"
7613 "ret\n\t");
7614 }
7615
ExecMaskedVmaccvx()7616 [[gnu::naked]] void ExecMaskedVmaccvx() {
7617 asm("vmacc.vx v8, t0, v16, v0.t\n\t"
7618 "ret\n\t");
7619 }
7620
ExecVwmaccuvv()7621 [[gnu::naked]] void ExecVwmaccuvv() {
7622 asm("vwmaccu.vv v8, v16, v24\n\t"
7623 "ret\n\t");
7624 }
7625
ExecMaskedVwmaccuvv()7626 [[gnu::naked]] void ExecMaskedVwmaccuvv() {
7627 asm("vwmaccu.vv v8, v16, v24, v0.t\n\t"
7628 "ret\n\t");
7629 }
7630
ExecVwmaccuvx()7631 [[gnu::naked]] void ExecVwmaccuvx() {
7632 asm("vwmaccu.vx v8, t0, v16\n\t"
7633 "ret\n\t");
7634 }
7635
ExecMaskedVwmaccuvx()7636 [[gnu::naked]] void ExecMaskedVwmaccuvx() {
7637 asm("vwmaccu.vx v8, t0, v16, v0.t\n\t"
7638 "ret\n\t");
7639 }
7640
ExecVwmaccvv()7641 [[gnu::naked]] void ExecVwmaccvv() {
7642 asm("vwmacc.vv v8, v16, v24\n\t"
7643 "ret\n\t");
7644 }
7645
ExecMaskedVwmaccvv()7646 [[gnu::naked]] void ExecMaskedVwmaccvv() {
7647 asm("vwmacc.vv v8, v16, v24, v0.t\n\t"
7648 "ret\n\t");
7649 }
7650
ExecVwmaccvx()7651 [[gnu::naked]] void ExecVwmaccvx() {
7652 asm("vwmacc.vx v8, t0, v16\n\t"
7653 "ret\n\t");
7654 }
7655
ExecMaskedVwmaccvx()7656 [[gnu::naked]] void ExecMaskedVwmaccvx() {
7657 asm("vwmacc.vx v8, t0, v16, v0.t\n\t"
7658 "ret\n\t");
7659 }
7660
ExecVwmaccusvx()7661 [[gnu::naked]] void ExecVwmaccusvx() {
7662 asm("vwmaccus.vx v8, t0, v16\n\t"
7663 "ret\n\t");
7664 }
7665
ExecMaskedVwmaccusvx()7666 [[gnu::naked]] void ExecMaskedVwmaccusvx() {
7667 asm("vwmaccus.vx v8, t0, v16, v0.t\n\t"
7668 "ret\n\t");
7669 }
7670
ExecVwmaccsuvv()7671 [[gnu::naked]] void ExecVwmaccsuvv() {
7672 asm("vwmaccsu.vv v8, v16, v24\n\t"
7673 "ret\n\t");
7674 }
7675
ExecMaskedVwmaccsuvv()7676 [[gnu::naked]] void ExecMaskedVwmaccsuvv() {
7677 asm("vwmaccsu.vv v8, v16, v24, v0.t\n\t"
7678 "ret\n\t");
7679 }
7680
ExecVwmaccsuvx()7681 [[gnu::naked]] void ExecVwmaccsuvx() {
7682 asm("vwmaccsu.vx v8, t0, v16\n\t"
7683 "ret\n\t");
7684 }
7685
ExecMaskedVwmaccsuvx()7686 [[gnu::naked]] void ExecMaskedVwmaccsuvx() {
7687 asm("vwmaccsu.vx v8, t0, v16, v0.t\n\t"
7688 "ret\n\t");
7689 }
7690
TEST(InlineAsmTestRiscv64,TestVmacc)7691 TEST(InlineAsmTestRiscv64, TestVmacc) {
7692 TestVectorInstruction(
7693 ExecVmaccvv,
7694 ExecMaskedVmaccvv,
7695 {{85, 231, 93, 23, 121, 87, 157, 167, 221, 231, 29, 23, 117, 87, 221, 167},
7696 {85, 39, 221, 215, 137, 151, 29, 103, 237, 39, 157, 215, 117, 151, 93, 103},
7697 {85, 103, 93, 151, 153, 215, 157, 39, 253, 103, 29, 151, 117, 215, 221, 39},
7698 {85, 167, 221, 87, 169, 23, 29, 231, 13, 167, 157, 87, 117, 23, 93, 231},
7699 {85, 231, 93, 23, 185, 87, 157, 167, 29, 231, 29, 23, 117, 87, 221, 167},
7700 {85, 39, 221, 215, 201, 151, 29, 103, 45, 39, 157, 215, 117, 151, 93, 103},
7701 {85, 103, 93, 151, 217, 215, 157, 39, 61, 103, 29, 151, 117, 215, 221, 39},
7702 {85, 167, 221, 87, 233, 23, 29, 231, 77, 167, 157, 87, 117, 23, 93, 231}},
7703 {{0x5555, 0x8d5d, 0x6a79, 0x5d9d, 0x7edd, 0x6e1d, 0x0675, 0xbedd},
7704 {0x9755, 0xcfdd, 0xbd89, 0xa11d, 0xd2ed, 0xb29d, 0x4b75, 0x045d},
7705 {0xdd55, 0x165d, 0x1499, 0xe89d, 0x2afd, 0xfb1d, 0x9475, 0x4ddd},
7706 {0x2755, 0x60dd, 0x6fa9, 0x341d, 0x870d, 0x479d, 0xe175, 0x9b5d},
7707 {0x7555, 0xaf5d, 0xceb9, 0x839d, 0xe71d, 0x981d, 0x3275, 0xecdd},
7708 {0xc755, 0x01dd, 0x31c9, 0xd71d, 0x4b2d, 0xec9d, 0x8775, 0x425d},
7709 {0x1d55, 0x585d, 0x98d9, 0x2e9d, 0xb33d, 0x451d, 0xe075, 0x9bdd},
7710 {0x7755, 0xb2dd, 0x03e9, 0x8a1d, 0x1f4d, 0xa19d, 0x3d75, 0xf95d}},
7711 {{0xc6e7'5555, 0xb4c4'6a79, 0xcf3e'7edd, 0xac0b'0675},
7712 {0x66c4'9755, 0x67b3'bd89, 0x832d'd2ed, 0x52ec'4b75},
7713 {0x12a9'dd55, 0x26ab'1499, 0x4325'2afd, 0x05d5'9475},
7714 {0xca97'2755, 0xf1aa'6fa9, 0x0f24'870d, 0xc4c6'e175},
7715 {0xcd4c'7555, 0x036d'ceb9, 0x1de3'e71d, 0xc274'3275},
7716 {0x8d39'c755, 0xd66d'31c9, 0xf1e3'4b2d, 0x8965'8775},
7717 {0x592f'1d55, 0xb574'98d9, 0xd1ea'b33d, 0x5c5e'e075},
7718 {0x312c'7755, 0xa084'03e9, 0xbdfa'1f4d, 0x3b60'3d75}},
7719 {{0xeeb7'f4ac'c6e7'5555, 0xf26a'9b12'cf3e'7edd},
7720 {0x5d63'0378'66c4'9755, 0x691b'afe2'832d'd2ed},
7721 {0xe826'2654'12a9'dd55, 0xfbe4'd8c2'4325'2afd},
7722 {0x8f01'5d3f'ca97'2755, 0xaac6'15b2'0f24'870d},
7723 {0x082d'23b8'cd4c'7555, 0x13df'd21f'1de3'e71d},
7724 {0xb708'62a4'8d39'c755, 0xcac1'170e'f1e3'4b2d},
7725 {0x81fb'b5a0'592f'1d55, 0x9dba'700e'd1ea'b33d},
7726 {0x6907'1cac'312c'7755, 0x8ccb'dd1e'bdfa'1f4d}},
7727 kVectorCalculationsSource);
7728 TestVectorInstruction(
7729 ExecVmaccvx,
7730 ExecMaskedVmaccvx,
7731 {{85, 255, 169, 83, 253, 167, 81, 251, 165, 79, 249, 163, 77, 247, 161, 75},
7732 {245, 159, 73, 243, 157, 71, 241, 155, 69, 239, 153, 67, 237, 151, 65, 235},
7733 {149, 63, 233, 147, 61, 231, 145, 59, 229, 143, 57, 227, 141, 55, 225, 139},
7734 {53, 223, 137, 51, 221, 135, 49, 219, 133, 47, 217, 131, 45, 215, 129, 43},
7735 {213, 127, 41, 211, 125, 39, 209, 123, 37, 207, 121, 35, 205, 119, 33, 203},
7736 {117, 31, 201, 115, 29, 199, 113, 27, 197, 111, 25, 195, 109, 23, 193, 107},
7737 {21, 191, 105, 19, 189, 103, 17, 187, 101, 15, 185, 99, 13, 183, 97, 11},
7738 {181, 95, 9, 179, 93, 7, 177, 91, 5, 175, 89, 3, 173, 87, 1, 171}},
7739 {{0xff55, 0xa8a9, 0x51fd, 0xfb51, 0xa4a5, 0x4df9, 0xf74d, 0xa0a1},
7740 {0x49f5, 0xf349, 0x9c9d, 0x45f1, 0xef45, 0x9899, 0x41ed, 0xeb41},
7741 {0x9495, 0x3de9, 0xe73d, 0x9091, 0x39e5, 0xe339, 0x8c8d, 0x35e1},
7742 {0xdf35, 0x8889, 0x31dd, 0xdb31, 0x8485, 0x2dd9, 0xd72d, 0x8081},
7743 {0x29d5, 0xd329, 0x7c7d, 0x25d1, 0xcf25, 0x7879, 0x21cd, 0xcb21},
7744 {0x7475, 0x1dc9, 0xc71d, 0x7071, 0x19c5, 0xc319, 0x6c6d, 0x15c1},
7745 {0xbf15, 0x6869, 0x11bd, 0xbb11, 0x6465, 0x0db9, 0xb70d, 0x6061},
7746 {0x09b5, 0xb309, 0x5c5d, 0x05b1, 0xaf05, 0x5859, 0x01ad, 0xab01}},
7747 {{0xa8a8'ff55, 0x50a6'51fd, 0xf8a3'a4a5, 0xa0a0'f74d},
7748 {0x489e'49f5, 0xf09b'9c9d, 0x9898'ef45, 0x4096'41ed},
7749 {0xe893'9495, 0x9090'e73d, 0x388e'39e5, 0xe08b'8c8d},
7750 {0x8888'df35, 0x3086'31dd, 0xd883'8485, 0x8080'd72d},
7751 {0x287e'29d5, 0xd07b'7c7d, 0x7878'cf25, 0x2076'21cd},
7752 {0xc873'7475, 0x7070'c71d, 0x186e'19c5, 0xc06b'6c6d},
7753 {0x6868'bf15, 0x1066'11bd, 0xb863'6465, 0x6060'b70d},
7754 {0x085e'09b5, 0xb05b'5c5d, 0x5858'af05, 0x0056'01ad}},
7755 {{0xfb50'fca7'a8a8'ff55, 0xa0a0'f74c'f8a3'a4a5},
7756 {0x45f0'f1f2'489e'49f5, 0xeb40'ec97'9898'ef45},
7757 {0x9090'e73c'e893'9495, 0x35e0'e1e2'388e'39e5},
7758 {0xdb30'dc87'8888'df35, 0x8080'd72c'd883'8485},
7759 {0x25d0'd1d2'287e'29d5, 0xcb20'cc77'7878'cf25},
7760 {0x7070'c71c'c873'7475, 0x15c0'c1c2'186e'19c5},
7761 {0xbb10'bc67'6868'bf15, 0x6060'b70c'b863'6465},
7762 {0x05b0'b1b2'085e'09b5, 0xab00'ac57'5858'af05}},
7763 kVectorCalculationsSource);
7764 TestWideningVectorInstruction(ExecVwmaccuvv,
7765 ExecMaskedVwmaccuvv,
7766 {{0x5555, 0x9ee7, 0x555d, 0xa217, 0x5579, 0xa557, 0x559d, 0xa8a7},
7767 {0x55dd, 0x9ae7, 0x561d, 0x9e17, 0x5675, 0xa157, 0x56dd, 0xa4a7},
7768 {0x5755, 0xba27, 0x57dd, 0xbdd7, 0x5889, 0xc197, 0x591d, 0xc567},
7769 {0x59ed, 0xb627, 0x5a9d, 0xb9d7, 0x5b75, 0xbd97, 0x5c5d, 0xc167},
7770 {0x5d55, 0xd967, 0x5e5d, 0xdd97, 0x5f99, 0xe1d7, 0x609d, 0xe627},
7771 {0x61fd, 0xd567, 0x631d, 0xd997, 0x6475, 0xddd7, 0x65dd, 0xe227},
7772 {0x6755, 0xfca7, 0x68dd, 0x0157, 0x6aa9, 0x0617, 0x6c1d, 0x0ae7},
7773 {0x6e0d, 0xf8a7, 0x6f9d, 0xfd57, 0x7175, 0x0217, 0x735d, 0x06e7}},
7774 {{0x9ee7'5555, 0xa21a'8d5d, 0xa55e'6a79, 0xa8b1'5d9d},
7775 {0x9af4'7edd, 0x9e27'6e1d, 0xa16b'0675, 0xa4be'bedd},
7776 {0xba44'9755, 0xbdf8'cfdd, 0xc1bd'bd89, 0xc591'a11d},
7777 {0xb653'd2ed, 0xba07'b29d, 0xbdcc'4b75, 0xc1a1'045d},
7778 {0xd9a9'dd55, 0xdddf'165d, 0xe225'1499, 0xe679'e89d},
7779 {0xd5bb'2afd, 0xd9ef'fb1d, 0xde35'9475, 0xe28b'4ddd},
7780 {0xfd17'2755, 0x01cd'60dd, 0x0694'6fa9, 0x0b6a'341d},
7781 {0xf92a'870d, 0xfde0'479d, 0x02a6'e175, 0x077d'9b5d}},
7782 {{0xa21b'23ac'c6e7'5555, 0xa8b2'00fa'b4c4'6a79},
7783 {0x9e27'fc86'cf3e'7edd, 0xa4bf'5a54'ac0b'0675},
7784 {0xbdf9'9d68'66c4'9755, 0xc592'7dba'67b3'bd89},
7785 {0xba08'7846'832d'd2ed, 0xc1a1'd918'52ec'4b75},
7786 {0xdde0'2334'12a9'dd55, 0xe67b'068a'26ab'1499},
7787 {0xd9f1'0016'4325'2afd, 0xe28c'63ec'05d5'9475},
7788 {0x01ce'b50f'ca97'2755, 0x0b6b'9b69'f1aa'6fa9},
7789 {0xfde1'93f6'0f24'870d, 0x077e'facf'c4c6'e175}},
7790 kVectorCalculationsSource);
7791 TestWideningVectorInstruction(ExecVwmaccuvx,
7792 ExecMaskedVwmaccuvx,
7793 {{0x5555, 0xaaff, 0x56a9, 0xac53, 0x57fd, 0xada7, 0x5951, 0xaefb},
7794 {0x5aa5, 0xb04f, 0x5bf9, 0xb1a3, 0x5d4d, 0xb2f7, 0x5ea1, 0xb44b},
7795 {0x5ff5, 0xb59f, 0x6149, 0xb6f3, 0x629d, 0xb847, 0x63f1, 0xb99b},
7796 {0x6545, 0xbaef, 0x6699, 0xbc43, 0x67ed, 0xbd97, 0x6941, 0xbeeb},
7797 {0x6a95, 0xc03f, 0x6be9, 0xc193, 0x6d3d, 0xc2e7, 0x6e91, 0xc43b},
7798 {0x6fe5, 0xc58f, 0x7139, 0xc6e3, 0x728d, 0xc837, 0x73e1, 0xc98b},
7799 {0x7535, 0xcadf, 0x7689, 0xcc33, 0x77dd, 0xcd87, 0x7931, 0xcedb},
7800 {0x7a85, 0xd02f, 0x7bd9, 0xd183, 0x7d2d, 0xd2d7, 0x7e81, 0xd42b}},
7801 {{0xab54'ff55, 0xacab'a8a9, 0xae02'51fd, 0xaf58'fb51},
7802 {0xb0af'a4a5, 0xb206'4df9, 0xb35c'f74d, 0xb4b3'a0a1},
7803 {0xb60a'49f5, 0xb760'f349, 0xb8b7'9c9d, 0xba0e'45f1},
7804 {0xbb64'ef45, 0xbcbb'9899, 0xbe12'41ed, 0xbf68'eb41},
7805 {0xc0bf'9495, 0xc216'3de9, 0xc36c'e73d, 0xc4c3'9091},
7806 {0xc61a'39e5, 0xc770'e339, 0xc8c7'8c8d, 0xca1e'35e1},
7807 {0xcb74'df35, 0xcccb'8889, 0xce22'31dd, 0xcf78'db31},
7808 {0xd0cf'8485, 0xd226'2dd9, 0xd37c'd72d, 0xd4d3'8081}},
7809 {{0xacac'55ff'a8a8'ff55, 0xaf59'ae02'50a6'51fd},
7810 {0xb207'0604'f8a3'a4a5, 0xb4b4'5e07'a0a0'f74d},
7811 {0xb761'b60a'489e'49f5, 0xba0f'0e0c'f09b'9c9d},
7812 {0xbcbc'660f'9898'ef45, 0xbf69'be12'4096'41ed},
7813 {0xc217'1614'e893'9495, 0xc4c4'6e17'9090'e73d},
7814 {0xc771'c61a'388e'39e5, 0xca1f'1e1c'e08b'8c8d},
7815 {0xcccc'761f'8888'df35, 0xcf79'ce22'3086'31dd},
7816 {0xd227'2624'd883'8485, 0xd4d4'7e27'8080'd72d}},
7817 kVectorCalculationsSource);
7818 TestWideningVectorInstruction(ExecVwmaccvv,
7819 ExecMaskedVwmaccvv,
7820 {{0x5555, 0x8be7, 0x555d, 0x8917, 0x5579, 0x8657, 0x559d, 0x83a7},
7821 {0x55dd, 0x8fe7, 0x561d, 0x8d17, 0x5675, 0x8a57, 0x56dd, 0x87a7},
7822 {0x5755, 0x7727, 0x57dd, 0x74d7, 0x5889, 0x7297, 0x591d, 0x7067},
7823 {0x59ed, 0x7b27, 0x5a9d, 0x78d7, 0x5b75, 0x7697, 0x5c5d, 0x7467},
7824 {0x5d55, 0x6667, 0x5e5d, 0x6497, 0x5f99, 0x62d7, 0x609d, 0x6127},
7825 {0x61fd, 0x6a67, 0x631d, 0x6897, 0x6475, 0x66d7, 0x65dd, 0x6527},
7826 {0x6755, 0x59a7, 0x68dd, 0x5857, 0x6aa9, 0x5717, 0x6c1d, 0x55e7},
7827 {0x6e0d, 0x5da7, 0x6f9d, 0x5c57, 0x7175, 0x5b17, 0x735d, 0x59e7}},
7828 {{0x8be7'5555, 0x8914'8d5d, 0x8651'6a79, 0x839f'5d9d},
7829 {0x8fdb'7edd, 0x8d09'6e1d, 0x8a47'0675, 0x8794'bedd},
7830 {0x7714'9755, 0x74c2'cfdd, 0x7280'bd89, 0x704f'a11d},
7831 {0x7b0a'd2ed, 0x78b9'b29d, 0x7678'4b75, 0x7447'045d},
7832 {0x6649'dd55, 0x6479'165d, 0x62b8'1499, 0x6107'e89d},
7833 {0x6a42'2afd, 0x6871'fb1d, 0x66b1'9475, 0x6501'4ddd},
7834 {0x5987'2755, 0x5837'60dd, 0x56f7'6fa9, 0x55c8'341d},
7835 {0x5d81'870d, 0x5c32'479d, 0x5af2'e175, 0x59c3'9b5d}},
7836 {{0x8914'10ac'c6e7'5555, 0x839e'e1ed'b4c4'6a79},
7837 {0x8d08'f16d'cf3e'7edd, 0x8794'4330'ac0b'0675},
7838 {0x74c2'5a38'66c4'9755, 0x704f'2e7d'67b3'bd89},
7839 {0x78b9'3cfd'832d'd2ed, 0x7446'91c4'52ec'4b75},
7840 {0x6478'afd4'12a9'dd55, 0x6107'871d'26ab'1499},
7841 {0x6871'949d'4325'2afd, 0x6500'ec68'05d5'9475},
7842 {0x5837'117f'ca97'2755, 0x55c7'ebcc'f1aa'6fa9},
7843 {0x5c31'f84d'0f24'870d, 0x59c3'531b'c4c6'e175}},
7844 kVectorCalculationsSource);
7845 TestWideningVectorInstruction(ExecVwmaccvx,
7846 ExecMaskedVwmaccvx,
7847 {{0x5555, 0x7fff, 0x54a9, 0x7f53, 0x53fd, 0x7ea7, 0x5351, 0x7dfb},
7848 {0x52a5, 0x7d4f, 0x51f9, 0x7ca3, 0x514d, 0x7bf7, 0x50a1, 0x7b4b},
7849 {0x4ff5, 0x7a9f, 0x4f49, 0x79f3, 0x4e9d, 0x7947, 0x4df1, 0x789b},
7850 {0x4d45, 0x77ef, 0x4c99, 0x7743, 0x4bed, 0x7697, 0x4b41, 0x75eb},
7851 {0x4a95, 0x753f, 0x49e9, 0x7493, 0x493d, 0x73e7, 0x4891, 0x733b},
7852 {0x47e5, 0x728f, 0x4739, 0x71e3, 0x468d, 0x7137, 0x45e1, 0x708b},
7853 {0x4535, 0x6fdf, 0x4489, 0x6f33, 0x43dd, 0x6e87, 0x4331, 0x6ddb},
7854 {0x4285, 0x6d2f, 0x41d9, 0x6c83, 0x412d, 0x6bd7, 0x4081, 0x6b2b}},
7855 {{0x7faa'ff55, 0x7eff'a8a9, 0x7e54'51fd, 0x7da8'fb51},
7856 {0x7cfd'a4a5, 0x7c52'4df9, 0x7ba6'f74d, 0x7afb'a0a1},
7857 {0x7a50'49f5, 0x79a4'f349, 0x78f9'9c9d, 0x784e'45f1},
7858 {0x77a2'ef45, 0x76f7'9899, 0x764c'41ed, 0x75a0'eb41},
7859 {0x74f5'9495, 0x744a'3de9, 0x739e'e73d, 0x72f3'9091},
7860 {0x7248'39e5, 0x719c'e339, 0x70f1'8c8d, 0x7046'35e1},
7861 {0x6f9a'df35, 0x6eef'8889, 0x6e44'31dd, 0x6d98'db31},
7862 {0x6ced'8485, 0x6c42'2dd9, 0x6b96'd72d, 0x6aeb'8081}},
7863 {{0x7eff'2a55'a8a8'ff55, 0x7da8'7e54'50a6'51fd},
7864 {0x7c51'd252'f8a3'a4a5, 0x7afb'2651'a0a0'f74d},
7865 {0x79a4'7a50'489e'49f5, 0x784d'ce4e'f09b'9c9d},
7866 {0x76f7'224d'9898'ef45, 0x75a0'764c'4096'41ed},
7867 {0x7449'ca4a'e893'9495, 0x72f3'1e49'9090'e73d},
7868 {0x719c'7248'388e'39e5, 0x7045'c646'e08b'8c8d},
7869 {0x6eef'1a45'8888'df35, 0x6d98'6e44'3086'31dd},
7870 {0x6c41'c242'd883'8485, 0x6aeb'1641'8080'd72d}},
7871 kVectorCalculationsSource);
7872 TestWideningVectorInstruction(ExecVwmaccusvx,
7873 ExecMaskedVwmaccusvx,
7874 {{0x5555, 0x00ff, 0x56a9, 0x0253, 0x57fd, 0x03a7, 0x5951, 0x04fb},
7875 {0x5aa5, 0x064f, 0x5bf9, 0x07a3, 0x5d4d, 0x08f7, 0x5ea1, 0x0a4b},
7876 {0x5ff5, 0x0b9f, 0x6149, 0x0cf3, 0x629d, 0x0e47, 0x63f1, 0x0f9b},
7877 {0x6545, 0x10ef, 0x6699, 0x1243, 0x67ed, 0x1397, 0x6941, 0x14eb},
7878 {0x6a95, 0x163f, 0x6be9, 0x1793, 0x6d3d, 0x18e7, 0x6e91, 0x1a3b},
7879 {0x6fe5, 0x1b8f, 0x7139, 0x1ce3, 0x728d, 0x1e37, 0x73e1, 0x1f8b},
7880 {0x7535, 0x20df, 0x7689, 0x2233, 0x77dd, 0x2387, 0x7931, 0x24db},
7881 {0x7a85, 0x262f, 0x7bd9, 0x2783, 0x7d2d, 0x28d7, 0x7e81, 0x2a2b}},
7882 {{0x00aa'ff55, 0x0201'a8a9, 0x0358'51fd, 0x04ae'fb51},
7883 {0x0605'a4a5, 0x075c'4df9, 0x08b2'f74d, 0x0a09'a0a1},
7884 {0x0b60'49f5, 0x0cb6'f349, 0x0e0d'9c9d, 0x0f64'45f1},
7885 {0x10ba'ef45, 0x1211'9899, 0x1368'41ed, 0x14be'eb41},
7886 {0x1615'9495, 0x176c'3de9, 0x18c2'e73d, 0x1a19'9091},
7887 {0x1b70'39e5, 0x1cc6'e339, 0x1e1d'8c8d, 0x1f74'35e1},
7888 {0x20ca'df35, 0x2221'8889, 0x2378'31dd, 0x24ce'db31},
7889 {0x2625'8485, 0x277c'2dd9, 0x28d2'd72d, 0x2a29'8081}},
7890 {{0x0201'ab55'a8a8'ff55, 0x04af'0358'50a6'51fd},
7891 {0x075c'5b5a'f8a3'a4a5, 0x0a09'b35d'a0a0'f74d},
7892 {0x0cb7'0b60'489e'49f5, 0x0f64'6362'f09b'9c9d},
7893 {0x1211'bb65'9898'ef45, 0x14bf'1368'4096'41ed},
7894 {0x176c'6b6a'e893'9495, 0x1a19'c36d'9090'e73d},
7895 {0x1cc7'1b70'388e'39e5, 0x1f74'7372'e08b'8c8d},
7896 {0x2221'cb75'8888'df35, 0x24cf'2378'3086'31dd},
7897 {0x277c'7b7a'd883'8485, 0x2a29'd37d'8080'd72d}},
7898 kVectorCalculationsSource);
7899 TestWideningVectorInstruction(ExecVwmaccsuvv,
7900 ExecMaskedVwmaccsuvv,
7901 {{0x5555, 0x0ce7, 0x555d, 0x0c17, 0x5579, 0x0b57, 0x559d, 0x0aa7},
7902 {0x55dd, 0x18e7, 0x561d, 0x1817, 0x5675, 0x1757, 0x56dd, 0x16a7},
7903 {0x5755, 0x0827, 0x57dd, 0x07d7, 0x5889, 0x0797, 0x591d, 0x0767},
7904 {0x59ed, 0x1427, 0x5a9d, 0x13d7, 0x5b75, 0x1397, 0x5c5d, 0x1367},
7905 {0x5d55, 0x0767, 0x5e5d, 0x0797, 0x5f99, 0x07d7, 0x609d, 0x0827},
7906 {0x61fd, 0x1367, 0x631d, 0x1397, 0x6475, 0x13d7, 0x65dd, 0x1427},
7907 {0x6755, 0x0aa7, 0x68dd, 0x0b57, 0x6aa9, 0x0c17, 0x6c1d, 0x0ce7},
7908 {0x6e0d, 0x16a7, 0x6f9d, 0x1757, 0x7175, 0x1817, 0x735d, 0x18e7}},
7909 {{0x0ce7'5555, 0x0c16'8d5d, 0x0b55'6a79, 0x0aa5'5d9d},
7910 {0x18e3'7edd, 0x1813'6e1d, 0x1753'0675, 0x16a2'bedd},
7911 {0x0824'9755, 0x07d4'cfdd, 0x0794'bd89, 0x0765'a11d},
7912 {0x1422'd2ed, 0x13d3'b29d, 0x1394'4b75, 0x1365'045d},
7913 {0x0769'dd55, 0x079b'165d, 0x07dc'1499, 0x082d'e89d},
7914 {0x136a'2afd, 0x139b'fb1d, 0x13dd'9475, 0x142f'4ddd},
7915 {0x0ab7'2755, 0x0b69'60dd, 0x0c2b'6fa9, 0x0cfe'341d},
7916 {0x16b9'870d, 0x176c'479d, 0x182e'e175, 0x1901'9b5d}},
7917 {{0x0c16'91ac'c6e7'5555, 0x0aa5'66f1'b4c4'6a79},
7918 {0x1813'7a75'cf3e'7edd, 0x16a2'd03c'ac0b'0675},
7919 {0x07d4'eb48'66c4'9755, 0x0765'c391'67b3'bd89},
7920 {0x13d3'd615'832d'd2ed, 0x1365'2ee0'52ec'4b75},
7921 {0x079b'50f4'12a9'dd55, 0x082e'2c41'26ab'1499},
7922 {0x139c'3dc5'4325'2afd, 0x142f'9994'05d5'9475},
7923 {0x0b69'c2af'ca97'2755, 0x0cfe'a100'f1aa'6fa9},
7924 {0x176c'b185'0f24'870d, 0x1902'1057'c4c6'e175}},
7925 kVectorCalculationsSource);
7926 TestWideningVectorInstruction(ExecVwmaccsuvx,
7927 ExecMaskedVwmaccsuvx,
7928 {{0x5555, 0x29ff, 0x54a9, 0x2953, 0x53fd, 0x28a7, 0x5351, 0x27fb},
7929 {0x52a5, 0x274f, 0x51f9, 0x26a3, 0x514d, 0x25f7, 0x50a1, 0x254b},
7930 {0x4ff5, 0x249f, 0x4f49, 0x23f3, 0x4e9d, 0x2347, 0x4df1, 0x229b},
7931 {0x4d45, 0x21ef, 0x4c99, 0x2143, 0x4bed, 0x2097, 0x4b41, 0x1feb},
7932 {0x4a95, 0x1f3f, 0x49e9, 0x1e93, 0x493d, 0x1de7, 0x4891, 0x1d3b},
7933 {0x47e5, 0x1c8f, 0x4739, 0x1be3, 0x468d, 0x1b37, 0x45e1, 0x1a8b},
7934 {0x4535, 0x19df, 0x4489, 0x1933, 0x43dd, 0x1887, 0x4331, 0x17db},
7935 {0x4285, 0x172f, 0x41d9, 0x1683, 0x412d, 0x15d7, 0x4081, 0x152b}},
7936 {{0x2a54'ff55, 0x29a9'a8a9, 0x28fe'51fd, 0x2852'fb51},
7937 {0x27a7'a4a5, 0x26fc'4df9, 0x2650'f74d, 0x25a5'a0a1},
7938 {0x24fa'49f5, 0x244e'f349, 0x23a3'9c9d, 0x22f8'45f1},
7939 {0x224c'ef45, 0x21a1'9899, 0x20f6'41ed, 0x204a'eb41},
7940 {0x1f9f'9495, 0x1ef4'3de9, 0x1e48'e73d, 0x1d9d'9091},
7941 {0x1cf2'39e5, 0x1c46'e339, 0x1b9b'8c8d, 0x1af0'35e1},
7942 {0x1a44'df35, 0x1999'8889, 0x18ee'31dd, 0x1842'db31},
7943 {0x1797'8485, 0x16ec'2dd9, 0x1640'd72d, 0x1595'8081}},
7944 {{0x29a9'd4ff'a8a8'ff55, 0x2853'28fe'50a6'51fd},
7945 {0x26fc'7cfc'f8a3'a4a5, 0x25a5'd0fb'a0a0'f74d},
7946 {0x244f'24fa'489e'49f5, 0x22f8'78f8'f09b'9c9d},
7947 {0x21a1'ccf7'9898'ef45, 0x204b'20f6'4096'41ed},
7948 {0x1ef4'74f4'e893'9495, 0x1d9d'c8f3'9090'e73d},
7949 {0x1c47'1cf2'388e'39e5, 0x1af0'70f0'e08b'8c8d},
7950 {0x1999'c4ef'8888'df35, 0x1843'18ee'3086'31dd},
7951 {0x16ec'6cec'd883'8485, 0x1595'c0eb'8080'd72d}},
7952 kVectorCalculationsSource);
7953 }
7954
ExecVmaddvv()7955 [[gnu::naked]] void ExecVmaddvv() {
7956 asm("vmadd.vv v8, v16, v24\n\t"
7957 "ret\n\t");
7958 }
7959
ExecMaskedVmaddvv()7960 [[gnu::naked]] void ExecMaskedVmaddvv() {
7961 asm("vmadd.vv v8, v16, v24, v0.t\n\t"
7962 "ret\n\t");
7963 }
7964
ExecVmaddvx()7965 [[gnu::naked]] void ExecVmaddvx() {
7966 asm("vmadd.vx v8, t0, v16\n\t"
7967 "ret\n\t");
7968 }
7969
ExecMaskedVmaddvx()7970 [[gnu::naked]] void ExecMaskedVmaddvx() {
7971 asm("vmadd.vx v8, t0, v16, v0.t\n\t"
7972 "ret\n\t");
7973 }
7974
TEST(InlineAsmTestRiscv64,TestVmadd)7975 TEST(InlineAsmTestRiscv64, TestVmadd) {
7976 TestVectorInstruction(
7977 ExecVmaddvv,
7978 ExecMaskedVmaddvv,
7979 {{0, 103, 174, 21, 93, 195, 10, 113, 185, 255, 102, 173, 20, 91, 194, 9},
7980 {112, 215, 30, 133, 205, 51, 122, 225, 41, 111, 214, 29, 132, 203, 50, 121},
7981 {224, 71, 142, 245, 61, 163, 234, 81, 153, 223, 70, 141, 244, 59, 162, 233},
7982 {80, 183, 254, 101, 173, 19, 90, 193, 9, 79, 182, 253, 100, 171, 18, 89},
7983 {192, 39, 110, 213, 29, 131, 202, 49, 121, 191, 38, 109, 212, 27, 130, 201},
7984 {48, 151, 222, 69, 141, 243, 58, 161, 233, 47, 150, 221, 68, 139, 242, 57},
7985 {160, 7, 78, 181, 253, 99, 170, 17, 89, 159, 6, 77, 180, 251, 98, 169},
7986 {16, 119, 190, 37, 109, 211, 26, 129, 201, 15, 118, 189, 36, 107, 210, 25}},
7987 {{0x6700, 0xbfae, 0x185d, 0x710a, 0xa9b9, 0x0266, 0x5b14, 0xb3c2},
7988 {0x2c70, 0x851e, 0xddcd, 0x367a, 0x6f29, 0xc7d6, 0x2084, 0x7932},
7989 {0xf1e0, 0x4a8e, 0xa33d, 0xfbea, 0x3499, 0x8d46, 0xe5f4, 0x3ea2},
7990 {0xb750, 0x0ffe, 0x68ad, 0xc15a, 0xfa09, 0x52b6, 0xab64, 0x0412},
7991 {0x7cc0, 0xd56e, 0x2e1d, 0x86ca, 0xbf79, 0x1826, 0x70d4, 0xc982},
7992 {0x4230, 0x9ade, 0xf38d, 0x4c3a, 0x84e9, 0xdd96, 0x3644, 0x8ef2},
7993 {0x07a0, 0x604e, 0xb8fd, 0x11aa, 0x4a59, 0xa306, 0xfbb4, 0x5462},
7994 {0xcd10, 0x25be, 0x7e6d, 0xd71a, 0x0fc9, 0x6876, 0xc124, 0x19d2}},
7995 {{0xbfae'6700, 0x1bb5'185d, 0x57bb'a9b9, 0xb3c2'5b14},
7996 {0x2fc9'2c70, 0x8bcf'ddcd, 0xc7d6'6f29, 0x23dd'2084},
7997 {0x9fe3'f1e0, 0xfbea'a33d, 0x37f1'3499, 0x93f7'e5f4},
7998 {0x0ffe'b750, 0x6c05'68ad, 0xa80b'fa09, 0x0412'ab64},
7999 {0x8018'7cc0, 0xdc1f'2e1d, 0x1825'bf79, 0x742c'70d4},
8000 {0xf033'4230, 0x4c39'f38d, 0x8840'84e9, 0xe447'3644},
8001 {0x604e'07a0, 0xbc54'b8fd, 0xf85b'4a59, 0x5461'fbb4},
8002 {0xd068'cd10, 0x2c6f'7e6d, 0x6876'0fc9, 0xc47c'c124}},
8003 {{0x710a'6db2'bfae'6700, 0xb3c2'5b14'57bb'a9b9},
8004 {0x367a'8878'2fc9'2c70, 0x7932'75d9'c7d6'6f29},
8005 {0xfbea'a33d'9fe3'f1e0, 0x3ea2'909f'37f1'3499},
8006 {0xc15a'be03'0ffe'b750, 0x0412'ab64'a80b'fa09},
8007 {0x86c9'd8c7'8018'7cc0, 0xc981'c629'1825'bf79},
8008 {0x4c39'f38c'f033'4230, 0x8ef1'e0ee'8840'84e9},
8009 {0x11aa'0e52'604e'07a0, 0x5461'fbb3'f85b'4a59},
8010 {0xd71a'2917'd068'cd10, 0x19d2'1679'6876'0fc9}},
8011 kVectorCalculationsSource);
8012 TestVectorInstruction(
8013 ExecVmaddvx,
8014 ExecMaskedVmaddvx,
8015 {{114, 243, 116, 245, 118, 247, 120, 249, 122, 251, 124, 253, 126, 255, 128, 1},
8016 {130, 3, 132, 5, 134, 7, 136, 9, 138, 11, 140, 13, 142, 15, 144, 17},
8017 {146, 19, 148, 21, 150, 23, 152, 25, 154, 27, 156, 29, 158, 31, 160, 33},
8018 {162, 35, 164, 37, 166, 39, 168, 41, 170, 43, 172, 45, 174, 47, 176, 49},
8019 {178, 51, 180, 53, 182, 55, 184, 57, 186, 59, 188, 61, 190, 63, 192, 65},
8020 {194, 67, 196, 69, 198, 71, 200, 73, 202, 75, 204, 77, 206, 79, 208, 81},
8021 {210, 83, 212, 85, 214, 87, 216, 89, 218, 91, 220, 93, 222, 95, 224, 97},
8022 {226, 99, 228, 101, 230, 103, 232, 105, 234, 107, 236, 109, 238, 111, 240, 113}},
8023 {{0x9d72, 0x9f74, 0xa176, 0xa378, 0xa57a, 0xa77c, 0xa97e, 0xab80},
8024 {0xad82, 0xaf84, 0xb186, 0xb388, 0xb58a, 0xb78c, 0xb98e, 0xbb90},
8025 {0xbd92, 0xbf94, 0xc196, 0xc398, 0xc59a, 0xc79c, 0xc99e, 0xcba0},
8026 {0xcda2, 0xcfa4, 0xd1a6, 0xd3a8, 0xd5aa, 0xd7ac, 0xd9ae, 0xdbb0},
8027 {0xddb2, 0xdfb4, 0xe1b6, 0xe3b8, 0xe5ba, 0xe7bc, 0xe9be, 0xebc0},
8028 {0xedc2, 0xefc4, 0xf1c6, 0xf3c8, 0xf5ca, 0xf7cc, 0xf9ce, 0xfbd0},
8029 {0xfdd2, 0xffd4, 0x01d6, 0x03d8, 0x05da, 0x07dc, 0x09de, 0x0be0},
8030 {0x0de2, 0x0fe4, 0x11e6, 0x13e8, 0x15ea, 0x17ec, 0x19ee, 0x1bf0}},
8031 {{0xf4c9'9d72, 0xf8cd'a176, 0xfcd1'a57a, 0x00d5'a97e},
8032 {0x04d9'ad82, 0x08dd'b186, 0x0ce1'b58a, 0x10e5'b98e},
8033 {0x14e9'bd92, 0x18ed'c196, 0x1cf1'c59a, 0x20f5'c99e},
8034 {0x24f9'cda2, 0x28fd'd1a6, 0x2d01'd5aa, 0x3105'd9ae},
8035 {0x3509'ddb2, 0x390d'e1b6, 0x3d11'e5ba, 0x4115'e9be},
8036 {0x4519'edc2, 0x491d'f1c6, 0x4d21'f5ca, 0x5125'f9ce},
8037 {0x5529'fdd2, 0x592e'01d6, 0x5d32'05da, 0x6136'09de},
8038 {0x653a'0de2, 0x693e'11e6, 0x6d42'15ea, 0x7146'19ee}},
8039 {{0xa378'4c20'f4c9'9d72, 0xab80'5428'fcd1'a57a},
8040 {0xb388'5c31'04d9'ad82, 0xbb90'6439'0ce1'b58a},
8041 {0xc398'6c41'14e9'bd92, 0xcba0'7449'1cf1'c59a},
8042 {0xd3a8'7c51'24f9'cda2, 0xdbb0'8459'2d01'd5aa},
8043 {0xe3b8'8c61'3509'ddb2, 0xebc0'9469'3d11'e5ba},
8044 {0xf3c8'9c71'4519'edc2, 0xfbd0'a479'4d21'f5ca},
8045 {0x03d8'ac81'5529'fdd2, 0x0be0'b489'5d32'05da},
8046 {0x13e8'bc91'653a'0de2, 0x1bf0'c499'6d42'15ea}},
8047 kVectorCalculationsSource);
8048 }
8049
ExecVmaxvv()8050 [[gnu::naked]] void ExecVmaxvv() {
8051 asm("vmax.vv v8, v16, v24\n\t"
8052 "ret\n\t");
8053 }
8054
ExecMaskedVmaxvv()8055 [[gnu::naked]] void ExecMaskedVmaxvv() {
8056 asm("vmax.vv v8, v16, v24, v0.t\n\t"
8057 "ret\n\t");
8058 }
8059
ExecVmaxvx()8060 [[gnu::naked]] void ExecVmaxvx() {
8061 asm("vmax.vx v8, v16, t0\n\t"
8062 "ret\n\t");
8063 }
8064
ExecMaskedVmaxvx()8065 [[gnu::naked]] void ExecMaskedVmaxvx() {
8066 asm("vmax.vx v8, v16, t0, v0.t\n\t"
8067 "ret\n\t");
8068 }
8069
TEST(InlineAsmTestRiscv64,TestVmax)8070 TEST(InlineAsmTestRiscv64, TestVmax) {
8071 TestVectorInstruction(
8072 ExecVmaxvv,
8073 ExecMaskedVmaxvv,
8074 {{0, 2, 4, 6, 9, 10, 12, 14, 17, 18, 20, 22, 24, 26, 28, 30},
8075 {32, 34, 36, 38, 41, 42, 44, 46, 49, 50, 52, 54, 56, 58, 60, 62},
8076 {64, 66, 68, 70, 73, 74, 76, 78, 81, 82, 84, 86, 88, 90, 92, 94},
8077 {96, 98, 100, 102, 105, 106, 108, 110, 113, 114, 116, 118, 120, 122, 124, 126},
8078 {64, 193, 66, 195, 68, 197, 70, 199, 72, 201, 74, 203, 76, 205, 78, 207},
8079 {80, 209, 82, 211, 84, 213, 86, 215, 88, 217, 90, 219, 92, 221, 94, 223},
8080 {96, 225, 98, 227, 100, 229, 102, 231, 104, 233, 106, 235, 108, 237, 110, 239},
8081 {112, 241, 114, 243, 116, 245, 118, 247, 120, 249, 122, 251, 124, 253, 126, 255}},
8082 {{0x0200, 0x0604, 0x0a09, 0x0e0c, 0x1211, 0x1614, 0x1a18, 0x1e1c},
8083 {0x2220, 0x2624, 0x2a29, 0x2e2c, 0x3231, 0x3634, 0x3a38, 0x3e3c},
8084 {0x4240, 0x4644, 0x4a49, 0x4e4c, 0x5251, 0x5654, 0x5a58, 0x5e5c},
8085 {0x6260, 0x6664, 0x6a69, 0x6e6c, 0x7271, 0x7674, 0x7a78, 0x7e7c},
8086 {0xc140, 0xc342, 0xc544, 0xc746, 0xc948, 0xcb4a, 0xcd4c, 0xcf4e},
8087 {0xd150, 0xd352, 0xd554, 0xd756, 0xd958, 0xdb5a, 0xdd5c, 0xdf5e},
8088 {0xe160, 0xe362, 0xe564, 0xe766, 0xe968, 0xeb6a, 0xed6c, 0xef6e},
8089 {0xf170, 0xf372, 0xf574, 0xf776, 0xf978, 0xfb7a, 0xfd7c, 0xff7e}},
8090 {{0x0604'0200, 0x0e0c'0a09, 0x1614'1211, 0x1e1c'1a18},
8091 {0x2624'2220, 0x2e2c'2a29, 0x3634'3231, 0x3e3c'3a38},
8092 {0x4644'4240, 0x4e4c'4a49, 0x5654'5251, 0x5e5c'5a58},
8093 {0x6664'6260, 0x6e6c'6a69, 0x7674'7271, 0x7e7c'7a78},
8094 {0xc342'c140, 0xc746'c544, 0xcb4a'c948, 0xcf4e'cd4c},
8095 {0xd352'd150, 0xd756'd554, 0xdb5a'd958, 0xdf5e'dd5c},
8096 {0xe362'e160, 0xe766'e564, 0xeb6a'e968, 0xef6e'ed6c},
8097 {0xf372'f170, 0xf776'f574, 0xfb7a'f978, 0xff7e'fd7c}},
8098 {{0x0e0c'0a09'0604'0200, 0x1e1c'1a18'1614'1211},
8099 {0x2e2c'2a29'2624'2220, 0x3e3c'3a38'3634'3231},
8100 {0x4e4c'4a49'4644'4240, 0x5e5c'5a58'5654'5251},
8101 {0x6e6c'6a69'6664'6260, 0x7e7c'7a78'7674'7271},
8102 {0xc746'c544'c342'c140, 0xcf4e'cd4c'cb4a'c948},
8103 {0xd756'd554'd352'd150, 0xdf5e'dd5c'db5a'd958},
8104 {0xe766'e564'e362'e160, 0xef6e'ed6c'eb6a'e968},
8105 {0xf776'f574'f372'f170, 0xff7e'fd7c'fb7a'f978}},
8106 kVectorCalculationsSourceLegacy);
8107 TestVectorInstruction(
8108 ExecVmaxvx,
8109 ExecMaskedVmaxvx,
8110 {{0, 170, 2, 170, 4, 170, 6, 170, 8, 170, 10, 170, 12, 170, 14, 170},
8111 {16, 170, 18, 170, 20, 170, 22, 170, 24, 170, 26, 170, 28, 170, 30, 170},
8112 {32, 170, 34, 170, 36, 170, 38, 170, 40, 170, 42, 171, 44, 173, 46, 175},
8113 {48, 177, 50, 179, 52, 181, 54, 183, 56, 185, 58, 187, 60, 189, 62, 191},
8114 {64, 193, 66, 195, 68, 197, 70, 199, 72, 201, 74, 203, 76, 205, 78, 207},
8115 {80, 209, 82, 211, 84, 213, 86, 215, 88, 217, 90, 219, 92, 221, 94, 223},
8116 {96, 225, 98, 227, 100, 229, 102, 231, 104, 233, 106, 235, 108, 237, 110, 239},
8117 {112, 241, 114, 243, 116, 245, 118, 247, 120, 249, 122, 251, 124, 253, 126, 255}},
8118 {{0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa},
8119 {0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa},
8120 {0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xab2a, 0xad2c, 0xaf2e},
8121 {0xb130, 0xb332, 0xb534, 0xb736, 0xb938, 0xbb3a, 0xbd3c, 0xbf3e},
8122 {0xc140, 0xc342, 0xc544, 0xc746, 0xc948, 0xcb4a, 0xcd4c, 0xcf4e},
8123 {0xd150, 0xd352, 0xd554, 0xd756, 0xd958, 0xdb5a, 0xdd5c, 0xdf5e},
8124 {0xe160, 0xe362, 0xe564, 0xe766, 0xe968, 0xeb6a, 0xed6c, 0xef6e},
8125 {0xf170, 0xf372, 0xf574, 0xf776, 0xf978, 0xfb7a, 0xfd7c, 0xff7e}},
8126 {{0xaaaa'aaaa, 0xaaaa'aaaa, 0xaaaa'aaaa, 0xaaaa'aaaa},
8127 {0xaaaa'aaaa, 0xaaaa'aaaa, 0xaaaa'aaaa, 0xaaaa'aaaa},
8128 {0xaaaa'aaaa, 0xaaaa'aaaa, 0xab2a'a928, 0xaf2e'ad2c},
8129 {0xb332'b130, 0xb736'b534, 0xbb3a'b938, 0xbf3e'bd3c},
8130 {0xc342'c140, 0xc746'c544, 0xcb4a'c948, 0xcf4e'cd4c},
8131 {0xd352'd150, 0xd756'd554, 0xdb5a'd958, 0xdf5e'dd5c},
8132 {0xe362'e160, 0xe766'e564, 0xeb6a'e968, 0xef6e'ed6c},
8133 {0xf372'f170, 0xf776'f574, 0xfb7a'f978, 0xff7e'fd7c}},
8134 {{0xaaaa'aaaa'aaaa'aaaa, 0xaaaa'aaaa'aaaa'aaaa},
8135 {0xaaaa'aaaa'aaaa'aaaa, 0xaaaa'aaaa'aaaa'aaaa},
8136 {0xaaaa'aaaa'aaaa'aaaa, 0xaf2e'ad2c'ab2a'a928},
8137 {0xb736'b534'b332'b130, 0xbf3e'bd3c'bb3a'b938},
8138 {0xc746'c544'c342'c140, 0xcf4e'cd4c'cb4a'c948},
8139 {0xd756'd554'd352'd150, 0xdf5e'dd5c'db5a'd958},
8140 {0xe766'e564'e362'e160, 0xef6e'ed6c'eb6a'e968},
8141 {0xf776'f574'f372'f170, 0xff7e'fd7c'fb7a'f978}},
8142 kVectorCalculationsSourceLegacy);
8143 }
8144
ExecVmaxuvv()8145 [[gnu::naked]] void ExecVmaxuvv() {
8146 asm("vmaxu.vv v8, v16, v24\n\t"
8147 "ret\n\t");
8148 }
8149
ExecMaskedVmaxuvv()8150 [[gnu::naked]] void ExecMaskedVmaxuvv() {
8151 asm("vmaxu.vv v8, v16, v24, v0.t\n\t"
8152 "ret\n\t");
8153 }
8154
ExecVmaxuvx()8155 [[gnu::naked]] void ExecVmaxuvx() {
8156 asm("vmaxu.vx v8, v16, t0\n\t"
8157 "ret\n\t");
8158 }
8159
ExecMaskedVmaxuvx()8160 [[gnu::naked]] void ExecMaskedVmaxuvx() {
8161 asm("vmaxu.vx v8, v16, t0, v0.t\n\t"
8162 "ret\n\t");
8163 }
8164
TEST(InlineAsmTestRiscv64,TestVmaxu)8165 TEST(InlineAsmTestRiscv64, TestVmaxu) {
8166 TestVectorInstruction(
8167 ExecVmaxuvv,
8168 ExecMaskedVmaxuvv,
8169 {{0, 129, 4, 131, 9, 133, 12, 135, 17, 137, 20, 139, 24, 141, 28, 143},
8170 {32, 145, 36, 147, 41, 149, 44, 151, 49, 153, 52, 155, 56, 157, 60, 159},
8171 {64, 161, 68, 163, 73, 165, 76, 167, 81, 169, 84, 171, 88, 173, 92, 175},
8172 {96, 177, 100, 179, 105, 181, 108, 183, 113, 185, 116, 187, 120, 189, 124, 191},
8173 {128, 193, 132, 195, 137, 197, 140, 199, 145, 201, 148, 203, 152, 205, 156, 207},
8174 {160, 209, 164, 211, 169, 213, 172, 215, 177, 217, 180, 219, 184, 221, 188, 223},
8175 {192, 225, 196, 227, 201, 229, 204, 231, 209, 233, 212, 235, 216, 237, 220, 239},
8176 {224, 241, 228, 243, 233, 245, 236, 247, 241, 249, 244, 251, 248, 253, 252, 255}},
8177 {{0x8100, 0x8302, 0x8504, 0x8706, 0x8908, 0x8b0a, 0x8d0c, 0x8f0e},
8178 {0x9110, 0x9312, 0x9514, 0x9716, 0x9918, 0x9b1a, 0x9d1c, 0x9f1e},
8179 {0xa120, 0xa322, 0xa524, 0xa726, 0xa928, 0xab2a, 0xad2c, 0xaf2e},
8180 {0xb130, 0xb332, 0xb534, 0xb736, 0xb938, 0xbb3a, 0xbd3c, 0xbf3e},
8181 {0xc140, 0xc342, 0xc544, 0xc746, 0xc948, 0xcb4a, 0xcd4c, 0xcf4e},
8182 {0xd150, 0xd352, 0xd554, 0xd756, 0xd958, 0xdb5a, 0xdd5c, 0xdf5e},
8183 {0xe160, 0xe362, 0xe564, 0xe766, 0xe968, 0xeb6a, 0xed6c, 0xef6e},
8184 {0xf170, 0xf372, 0xf574, 0xf776, 0xf978, 0xfb7a, 0xfd7c, 0xff7e}},
8185 {{0x8302'8100, 0x8706'8504, 0x8b0a'8908, 0x8f0e'8d0c},
8186 {0x9312'9110, 0x9716'9514, 0x9b1a'9918, 0x9f1e'9d1c},
8187 {0xa322'a120, 0xa726'a524, 0xab2a'a928, 0xaf2e'ad2c},
8188 {0xb332'b130, 0xb736'b534, 0xbb3a'b938, 0xbf3e'bd3c},
8189 {0xc342'c140, 0xc746'c544, 0xcb4a'c948, 0xcf4e'cd4c},
8190 {0xd352'd150, 0xd756'd554, 0xdb5a'd958, 0xdf5e'dd5c},
8191 {0xe362'e160, 0xe766'e564, 0xeb6a'e968, 0xef6e'ed6c},
8192 {0xf372'f170, 0xf776'f574, 0xfb7a'f978, 0xff7e'fd7c}},
8193 {{0x8706'8504'8302'8100, 0x8f0e'8d0c'8b0a'8908},
8194 {0x9716'9514'9312'9110, 0x9f1e'9d1c'9b1a'9918},
8195 {0xa726'a524'a322'a120, 0xaf2e'ad2c'ab2a'a928},
8196 {0xb736'b534'b332'b130, 0xbf3e'bd3c'bb3a'b938},
8197 {0xc746'c544'c342'c140, 0xcf4e'cd4c'cb4a'c948},
8198 {0xd756'd554'd352'd150, 0xdf5e'dd5c'db5a'd958},
8199 {0xe766'e564'e362'e160, 0xef6e'ed6c'eb6a'e968},
8200 {0xf776'f574'f372'f170, 0xff7e'fd7c'fb7a'f978}},
8201 kVectorCalculationsSourceLegacy);
8202 TestVectorInstruction(
8203 ExecVmaxuvx,
8204 ExecMaskedVmaxuvx,
8205 {{170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170},
8206 {170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170},
8207 {170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 171, 170, 173, 170, 175},
8208 {170, 177, 170, 179, 170, 181, 170, 183, 170, 185, 170, 187, 170, 189, 170, 191},
8209 {170, 193, 170, 195, 170, 197, 170, 199, 170, 201, 170, 203, 170, 205, 170, 207},
8210 {170, 209, 170, 211, 170, 213, 170, 215, 170, 217, 170, 219, 170, 221, 170, 223},
8211 {170, 225, 170, 227, 170, 229, 170, 231, 170, 233, 170, 235, 170, 237, 170, 239},
8212 {170, 241, 170, 243, 170, 245, 170, 247, 170, 249, 170, 251, 170, 253, 170, 255}},
8213 {{0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa},
8214 {0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa},
8215 {0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xab2a, 0xad2c, 0xaf2e},
8216 {0xb130, 0xb332, 0xb534, 0xb736, 0xb938, 0xbb3a, 0xbd3c, 0xbf3e},
8217 {0xc140, 0xc342, 0xc544, 0xc746, 0xc948, 0xcb4a, 0xcd4c, 0xcf4e},
8218 {0xd150, 0xd352, 0xd554, 0xd756, 0xd958, 0xdb5a, 0xdd5c, 0xdf5e},
8219 {0xe160, 0xe362, 0xe564, 0xe766, 0xe968, 0xeb6a, 0xed6c, 0xef6e},
8220 {0xf170, 0xf372, 0xf574, 0xf776, 0xf978, 0xfb7a, 0xfd7c, 0xff7e}},
8221 {{0xaaaa'aaaa, 0xaaaa'aaaa, 0xaaaa'aaaa, 0xaaaa'aaaa},
8222 {0xaaaa'aaaa, 0xaaaa'aaaa, 0xaaaa'aaaa, 0xaaaa'aaaa},
8223 {0xaaaa'aaaa, 0xaaaa'aaaa, 0xab2a'a928, 0xaf2e'ad2c},
8224 {0xb332'b130, 0xb736'b534, 0xbb3a'b938, 0xbf3e'bd3c},
8225 {0xc342'c140, 0xc746'c544, 0xcb4a'c948, 0xcf4e'cd4c},
8226 {0xd352'd150, 0xd756'd554, 0xdb5a'd958, 0xdf5e'dd5c},
8227 {0xe362'e160, 0xe766'e564, 0xeb6a'e968, 0xef6e'ed6c},
8228 {0xf372'f170, 0xf776'f574, 0xfb7a'f978, 0xff7e'fd7c}},
8229 {{0xaaaa'aaaa'aaaa'aaaa, 0xaaaa'aaaa'aaaa'aaaa},
8230 {0xaaaa'aaaa'aaaa'aaaa, 0xaaaa'aaaa'aaaa'aaaa},
8231 {0xaaaa'aaaa'aaaa'aaaa, 0xaf2e'ad2c'ab2a'a928},
8232 {0xb736'b534'b332'b130, 0xbf3e'bd3c'bb3a'b938},
8233 {0xc746'c544'c342'c140, 0xcf4e'cd4c'cb4a'c948},
8234 {0xd756'd554'd352'd150, 0xdf5e'dd5c'db5a'd958},
8235 {0xe766'e564'e362'e160, 0xef6e'ed6c'eb6a'e968},
8236 {0xf776'f574'f372'f170, 0xff7e'fd7c'fb7a'f978}},
8237 kVectorCalculationsSourceLegacy);
8238 }
8239
ExecVminvv()8240 [[gnu::naked]] void ExecVminvv() {
8241 asm("vmin.vv v8, v16, v24\n\t"
8242 "ret\n\t");
8243 }
8244
ExecMaskedVminvv()8245 [[gnu::naked]] void ExecMaskedVminvv() {
8246 asm("vmin.vv v8, v16, v24, v0.t\n\t"
8247 "ret\n\t");
8248 }
8249
ExecVminvx()8250 [[gnu::naked]] void ExecVminvx() {
8251 asm("vmin.vx v8, v16, t0\n\t"
8252 "ret\n\t");
8253 }
8254
ExecMaskedVminvx()8255 [[gnu::naked]] void ExecMaskedVminvx() {
8256 asm("vmin.vx v8, v16, t0, v0.t\n\t"
8257 "ret\n\t");
8258 }
8259
TEST(InlineAsmTestRiscv64,TestVmin)8260 TEST(InlineAsmTestRiscv64, TestVmin) {
8261 TestVectorInstruction(
8262 ExecVminvv,
8263 ExecMaskedVminvv,
8264 {{0, 129, 2, 131, 4, 133, 6, 135, 8, 137, 10, 139, 12, 141, 14, 143},
8265 {16, 145, 18, 147, 20, 149, 22, 151, 24, 153, 26, 155, 28, 157, 30, 159},
8266 {32, 161, 34, 163, 36, 165, 38, 167, 40, 169, 42, 171, 44, 173, 46, 175},
8267 {48, 177, 50, 179, 52, 181, 54, 183, 56, 185, 58, 187, 60, 189, 62, 191},
8268 {128, 130, 132, 134, 137, 138, 140, 142, 145, 146, 148, 150, 152, 154, 156, 158},
8269 {160, 162, 164, 166, 169, 170, 172, 174, 177, 178, 180, 182, 184, 186, 188, 190},
8270 {192, 194, 196, 198, 201, 202, 204, 206, 209, 210, 212, 214, 216, 218, 220, 222},
8271 {224, 226, 228, 230, 233, 234, 236, 238, 241, 242, 244, 246, 248, 250, 252, 254}},
8272 {{0x8100, 0x8302, 0x8504, 0x8706, 0x8908, 0x8b0a, 0x8d0c, 0x8f0e},
8273 {0x9110, 0x9312, 0x9514, 0x9716, 0x9918, 0x9b1a, 0x9d1c, 0x9f1e},
8274 {0xa120, 0xa322, 0xa524, 0xa726, 0xa928, 0xab2a, 0xad2c, 0xaf2e},
8275 {0xb130, 0xb332, 0xb534, 0xb736, 0xb938, 0xbb3a, 0xbd3c, 0xbf3e},
8276 {0x8280, 0x8684, 0x8a89, 0x8e8c, 0x9291, 0x9694, 0x9a98, 0x9e9c},
8277 {0xa2a0, 0xa6a4, 0xaaa9, 0xaeac, 0xb2b1, 0xb6b4, 0xbab8, 0xbebc},
8278 {0xc2c0, 0xc6c4, 0xcac9, 0xcecc, 0xd2d1, 0xd6d4, 0xdad8, 0xdedc},
8279 {0xe2e0, 0xe6e4, 0xeae9, 0xeeec, 0xf2f1, 0xf6f4, 0xfaf8, 0xfefc}},
8280 {{0x8302'8100, 0x8706'8504, 0x8b0a'8908, 0x8f0e'8d0c},
8281 {0x9312'9110, 0x9716'9514, 0x9b1a'9918, 0x9f1e'9d1c},
8282 {0xa322'a120, 0xa726'a524, 0xab2a'a928, 0xaf2e'ad2c},
8283 {0xb332'b130, 0xb736'b534, 0xbb3a'b938, 0xbf3e'bd3c},
8284 {0x8684'8280, 0x8e8c'8a89, 0x9694'9291, 0x9e9c'9a98},
8285 {0xa6a4'a2a0, 0xaeac'aaa9, 0xb6b4'b2b1, 0xbebc'bab8},
8286 {0xc6c4'c2c0, 0xcecc'cac9, 0xd6d4'd2d1, 0xdedc'dad8},
8287 {0xe6e4'e2e0, 0xeeec'eae9, 0xf6f4'f2f1, 0xfefc'faf8}},
8288 {{0x8706'8504'8302'8100, 0x8f0e'8d0c'8b0a'8908},
8289 {0x9716'9514'9312'9110, 0x9f1e'9d1c'9b1a'9918},
8290 {0xa726'a524'a322'a120, 0xaf2e'ad2c'ab2a'a928},
8291 {0xb736'b534'b332'b130, 0xbf3e'bd3c'bb3a'b938},
8292 {0x8e8c'8a89'8684'8280, 0x9e9c'9a98'9694'9291},
8293 {0xaeac'aaa9'a6a4'a2a0, 0xbebc'bab8'b6b4'b2b1},
8294 {0xcecc'cac9'c6c4'c2c0, 0xdedc'dad8'd6d4'd2d1},
8295 {0xeeec'eae9'e6e4'e2e0, 0xfefc'faf8'f6f4'f2f1}},
8296 kVectorCalculationsSourceLegacy);
8297 TestVectorInstruction(
8298 ExecVminvx,
8299 ExecMaskedVminvx,
8300 {{170, 129, 170, 131, 170, 133, 170, 135, 170, 137, 170, 139, 170, 141, 170, 143},
8301 {170, 145, 170, 147, 170, 149, 170, 151, 170, 153, 170, 155, 170, 157, 170, 159},
8302 {170, 161, 170, 163, 170, 165, 170, 167, 170, 169, 170, 170, 170, 170, 170, 170},
8303 {170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170},
8304 {170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170},
8305 {170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170},
8306 {170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170},
8307 {170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170}},
8308 {{0x8100, 0x8302, 0x8504, 0x8706, 0x8908, 0x8b0a, 0x8d0c, 0x8f0e},
8309 {0x9110, 0x9312, 0x9514, 0x9716, 0x9918, 0x9b1a, 0x9d1c, 0x9f1e},
8310 {0xa120, 0xa322, 0xa524, 0xa726, 0xa928, 0xaaaa, 0xaaaa, 0xaaaa},
8311 {0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa},
8312 {0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa},
8313 {0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa},
8314 {0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa},
8315 {0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa}},
8316 {{0x8302'8100, 0x8706'8504, 0x8b0a'8908, 0x8f0e'8d0c},
8317 {0x9312'9110, 0x9716'9514, 0x9b1a'9918, 0x9f1e'9d1c},
8318 {0xa322'a120, 0xa726'a524, 0xaaaa'aaaa, 0xaaaa'aaaa},
8319 {0xaaaa'aaaa, 0xaaaa'aaaa, 0xaaaa'aaaa, 0xaaaa'aaaa},
8320 {0xaaaa'aaaa, 0xaaaa'aaaa, 0xaaaa'aaaa, 0xaaaa'aaaa},
8321 {0xaaaa'aaaa, 0xaaaa'aaaa, 0xaaaa'aaaa, 0xaaaa'aaaa},
8322 {0xaaaa'aaaa, 0xaaaa'aaaa, 0xaaaa'aaaa, 0xaaaa'aaaa},
8323 {0xaaaa'aaaa, 0xaaaa'aaaa, 0xaaaa'aaaa, 0xaaaa'aaaa}},
8324 {{0x8706'8504'8302'8100, 0x8f0e'8d0c'8b0a'8908},
8325 {0x9716'9514'9312'9110, 0x9f1e'9d1c'9b1a'9918},
8326 {0xa726'a524'a322'a120, 0xaaaa'aaaa'aaaa'aaaa},
8327 {0xaaaa'aaaa'aaaa'aaaa, 0xaaaa'aaaa'aaaa'aaaa},
8328 {0xaaaa'aaaa'aaaa'aaaa, 0xaaaa'aaaa'aaaa'aaaa},
8329 {0xaaaa'aaaa'aaaa'aaaa, 0xaaaa'aaaa'aaaa'aaaa},
8330 {0xaaaa'aaaa'aaaa'aaaa, 0xaaaa'aaaa'aaaa'aaaa},
8331 {0xaaaa'aaaa'aaaa'aaaa, 0xaaaa'aaaa'aaaa'aaaa}},
8332 kVectorCalculationsSourceLegacy);
8333 }
8334
ExecVminuvv()8335 [[gnu::naked]] void ExecVminuvv() {
8336 asm("vminu.vv v8, v16, v24\n\t"
8337 "ret\n\t");
8338 }
8339
ExecMaskedVminuvv()8340 [[gnu::naked]] void ExecMaskedVminuvv() {
8341 asm("vminu.vv v8, v16, v24, v0.t\n\t"
8342 "ret\n\t");
8343 }
8344
ExecVminuvx()8345 [[gnu::naked]] void ExecVminuvx() {
8346 asm("vminu.vx v8, v16, t0\n\t"
8347 "ret\n\t");
8348 }
8349
ExecMaskedVminuvx()8350 [[gnu::naked]] void ExecMaskedVminuvx() {
8351 asm("vminu.vx v8, v16, t0, v0.t\n\t"
8352 "ret\n\t");
8353 }
8354
TEST(InlineAsmTestRiscv64,TestVminu)8355 TEST(InlineAsmTestRiscv64, TestVminu) {
8356 TestVectorInstruction(
8357 ExecVminuvv,
8358 ExecMaskedVminuvv,
8359 {{0, 2, 2, 6, 4, 10, 6, 14, 8, 18, 10, 22, 12, 26, 14, 30},
8360 {16, 34, 18, 38, 20, 42, 22, 46, 24, 50, 26, 54, 28, 58, 30, 62},
8361 {32, 66, 34, 70, 36, 74, 38, 78, 40, 82, 42, 86, 44, 90, 46, 94},
8362 {48, 98, 50, 102, 52, 106, 54, 110, 56, 114, 58, 118, 60, 122, 62, 126},
8363 {64, 130, 66, 134, 68, 138, 70, 142, 72, 146, 74, 150, 76, 154, 78, 158},
8364 {80, 162, 82, 166, 84, 170, 86, 174, 88, 178, 90, 182, 92, 186, 94, 190},
8365 {96, 194, 98, 198, 100, 202, 102, 206, 104, 210, 106, 214, 108, 218, 110, 222},
8366 {112, 226, 114, 230, 116, 234, 118, 238, 120, 242, 122, 246, 124, 250, 126, 254}},
8367 {{0x0200, 0x0604, 0x0a09, 0x0e0c, 0x1211, 0x1614, 0x1a18, 0x1e1c},
8368 {0x2220, 0x2624, 0x2a29, 0x2e2c, 0x3231, 0x3634, 0x3a38, 0x3e3c},
8369 {0x4240, 0x4644, 0x4a49, 0x4e4c, 0x5251, 0x5654, 0x5a58, 0x5e5c},
8370 {0x6260, 0x6664, 0x6a69, 0x6e6c, 0x7271, 0x7674, 0x7a78, 0x7e7c},
8371 {0x8280, 0x8684, 0x8a89, 0x8e8c, 0x9291, 0x9694, 0x9a98, 0x9e9c},
8372 {0xa2a0, 0xa6a4, 0xaaa9, 0xaeac, 0xb2b1, 0xb6b4, 0xbab8, 0xbebc},
8373 {0xc2c0, 0xc6c4, 0xcac9, 0xcecc, 0xd2d1, 0xd6d4, 0xdad8, 0xdedc},
8374 {0xe2e0, 0xe6e4, 0xeae9, 0xeeec, 0xf2f1, 0xf6f4, 0xfaf8, 0xfefc}},
8375 {{0x0604'0200, 0x0e0c'0a09, 0x1614'1211, 0x1e1c'1a18},
8376 {0x2624'2220, 0x2e2c'2a29, 0x3634'3231, 0x3e3c'3a38},
8377 {0x4644'4240, 0x4e4c'4a49, 0x5654'5251, 0x5e5c'5a58},
8378 {0x6664'6260, 0x6e6c'6a69, 0x7674'7271, 0x7e7c'7a78},
8379 {0x8684'8280, 0x8e8c'8a89, 0x9694'9291, 0x9e9c'9a98},
8380 {0xa6a4'a2a0, 0xaeac'aaa9, 0xb6b4'b2b1, 0xbebc'bab8},
8381 {0xc6c4'c2c0, 0xcecc'cac9, 0xd6d4'd2d1, 0xdedc'dad8},
8382 {0xe6e4'e2e0, 0xeeec'eae9, 0xf6f4'f2f1, 0xfefc'faf8}},
8383 {{0x0e0c'0a09'0604'0200, 0x1e1c'1a18'1614'1211},
8384 {0x2e2c'2a29'2624'2220, 0x3e3c'3a38'3634'3231},
8385 {0x4e4c'4a49'4644'4240, 0x5e5c'5a58'5654'5251},
8386 {0x6e6c'6a69'6664'6260, 0x7e7c'7a78'7674'7271},
8387 {0x8e8c'8a89'8684'8280, 0x9e9c'9a98'9694'9291},
8388 {0xaeac'aaa9'a6a4'a2a0, 0xbebc'bab8'b6b4'b2b1},
8389 {0xcecc'cac9'c6c4'c2c0, 0xdedc'dad8'd6d4'd2d1},
8390 {0xeeec'eae9'e6e4'e2e0, 0xfefc'faf8'f6f4'f2f1}},
8391 kVectorCalculationsSourceLegacy);
8392 TestVectorInstruction(
8393 ExecVminuvx,
8394 ExecMaskedVminuvx,
8395 {{0, 129, 2, 131, 4, 133, 6, 135, 8, 137, 10, 139, 12, 141, 14, 143},
8396 {16, 145, 18, 147, 20, 149, 22, 151, 24, 153, 26, 155, 28, 157, 30, 159},
8397 {32, 161, 34, 163, 36, 165, 38, 167, 40, 169, 42, 170, 44, 170, 46, 170},
8398 {48, 170, 50, 170, 52, 170, 54, 170, 56, 170, 58, 170, 60, 170, 62, 170},
8399 {64, 170, 66, 170, 68, 170, 70, 170, 72, 170, 74, 170, 76, 170, 78, 170},
8400 {80, 170, 82, 170, 84, 170, 86, 170, 88, 170, 90, 170, 92, 170, 94, 170},
8401 {96, 170, 98, 170, 100, 170, 102, 170, 104, 170, 106, 170, 108, 170, 110, 170},
8402 {112, 170, 114, 170, 116, 170, 118, 170, 120, 170, 122, 170, 124, 170, 126, 170}},
8403 {{0x8100, 0x8302, 0x8504, 0x8706, 0x8908, 0x8b0a, 0x8d0c, 0x8f0e},
8404 {0x9110, 0x9312, 0x9514, 0x9716, 0x9918, 0x9b1a, 0x9d1c, 0x9f1e},
8405 {0xa120, 0xa322, 0xa524, 0xa726, 0xa928, 0xaaaa, 0xaaaa, 0xaaaa},
8406 {0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa},
8407 {0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa},
8408 {0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa},
8409 {0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa},
8410 {0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa}},
8411 {{0x8302'8100, 0x8706'8504, 0x8b0a'8908, 0x8f0e'8d0c},
8412 {0x9312'9110, 0x9716'9514, 0x9b1a'9918, 0x9f1e'9d1c},
8413 {0xa322'a120, 0xa726'a524, 0xaaaa'aaaa, 0xaaaa'aaaa},
8414 {0xaaaa'aaaa, 0xaaaa'aaaa, 0xaaaa'aaaa, 0xaaaa'aaaa},
8415 {0xaaaa'aaaa, 0xaaaa'aaaa, 0xaaaa'aaaa, 0xaaaa'aaaa},
8416 {0xaaaa'aaaa, 0xaaaa'aaaa, 0xaaaa'aaaa, 0xaaaa'aaaa},
8417 {0xaaaa'aaaa, 0xaaaa'aaaa, 0xaaaa'aaaa, 0xaaaa'aaaa},
8418 {0xaaaa'aaaa, 0xaaaa'aaaa, 0xaaaa'aaaa, 0xaaaa'aaaa}},
8419 {{0x8706'8504'8302'8100, 0x8f0e'8d0c'8b0a'8908},
8420 {0x9716'9514'9312'9110, 0x9f1e'9d1c'9b1a'9918},
8421 {0xa726'a524'a322'a120, 0xaaaa'aaaa'aaaa'aaaa},
8422 {0xaaaa'aaaa'aaaa'aaaa, 0xaaaa'aaaa'aaaa'aaaa},
8423 {0xaaaa'aaaa'aaaa'aaaa, 0xaaaa'aaaa'aaaa'aaaa},
8424 {0xaaaa'aaaa'aaaa'aaaa, 0xaaaa'aaaa'aaaa'aaaa},
8425 {0xaaaa'aaaa'aaaa'aaaa, 0xaaaa'aaaa'aaaa'aaaa},
8426 {0xaaaa'aaaa'aaaa'aaaa, 0xaaaa'aaaa'aaaa'aaaa}},
8427 kVectorCalculationsSourceLegacy);
8428 }
8429
ExecVmulvv()8430 [[gnu::naked]] void ExecVmulvv() {
8431 asm("vmul.vv v8, v16, v24\n\t"
8432 "ret\n\t");
8433 }
8434
ExecMaskedVmulvv()8435 [[gnu::naked]] void ExecMaskedVmulvv() {
8436 asm("vmul.vv v8, v16, v24, v0.t\n\t"
8437 "ret\n\t");
8438 }
8439
ExecVmulvx()8440 [[gnu::naked]] void ExecVmulvx() {
8441 asm("vmul.vx v8, v16, t0\n\t"
8442 "ret\n\t");
8443 }
8444
ExecMaskedVmulvx()8445 [[gnu::naked]] void ExecMaskedVmulvx() {
8446 asm("vmul.vx v8, v16, t0, v0.t\n\t"
8447 "ret\n\t");
8448 }
8449
ExecVfmulvv()8450 [[gnu::naked]] void ExecVfmulvv() {
8451 asm("vfmul.vv v8, v16, v24\n\t"
8452 "ret\n\t");
8453 }
8454
ExecMaskedVfmulvv()8455 [[gnu::naked]] void ExecMaskedVfmulvv() {
8456 asm("vfmul.vv v8, v16, v24, v0.t\n\t"
8457 "ret\n\t");
8458 }
8459
ExecVfmulvf()8460 [[gnu::naked]] void ExecVfmulvf() {
8461 asm("vfmul.vf v8, v16, ft0\n\t"
8462 "ret\n\t");
8463 }
8464
ExecMaskedVfmulvf()8465 [[gnu::naked]] void ExecMaskedVfmulvf() {
8466 asm("vfmul.vf v8, v16, ft0, v0.t\n\t"
8467 "ret\n\t");
8468 }
8469
ExecVfwmulvv()8470 [[gnu::naked]] void ExecVfwmulvv() {
8471 asm("vfwmul.vv v8, v16, v24\n\t"
8472 "ret\n\t");
8473 }
8474
ExecMaskedVfwmulvv()8475 [[gnu::naked]] void ExecMaskedVfwmulvv() {
8476 asm("vfwmul.vv v8, v16, v24, v0.t\n\t"
8477 "ret\n\t");
8478 }
8479
ExecVfwmulvf()8480 [[gnu::naked]] void ExecVfwmulvf() {
8481 asm("vfwmul.vf v8, v16, ft0\n\t"
8482 "ret\n\t");
8483 }
8484
ExecMaskedVfwmulvf()8485 [[gnu::naked]] void ExecMaskedVfwmulvf() {
8486 asm("vfwmul.vf v8, v16, ft0, v0.t\n\t"
8487 "ret\n\t");
8488 }
8489
TEST(InlineAsmTestRiscv64,TestVmul)8490 TEST(InlineAsmTestRiscv64, TestVmul) {
8491 TestVectorInstruction(ExecVmulvv,
8492 ExecMaskedVmulvv,
8493 {{0, 2, 8, 18, 36, 50, 72, 98, 136, 162, 200, 242, 32, 82, 136, 194},
8494 {0, 66, 136, 210, 52, 114, 200, 34, 152, 226, 72, 178, 32, 146, 8, 130},
8495 {0, 130, 8, 146, 68, 178, 72, 226, 168, 34, 200, 114, 32, 210, 136, 66},
8496 {0, 194, 136, 82, 84, 242, 200, 162, 184, 98, 72, 50, 32, 18, 8, 2},
8497 {0, 2, 8, 18, 100, 50, 72, 98, 200, 162, 200, 242, 32, 82, 136, 194},
8498 {0, 66, 136, 210, 116, 114, 200, 34, 216, 226, 72, 178, 32, 146, 8, 130},
8499 {0, 130, 8, 146, 132, 178, 72, 226, 232, 34, 200, 114, 32, 210, 136, 66},
8500 {0, 194, 136, 82, 148, 242, 200, 162, 248, 98, 72, 50, 32, 18, 8, 2}},
8501 {{0x0000, 0x1808, 0xd524, 0xa848, 0xa988, 0xb8c8, 0x7120, 0x4988},
8502 {0x4200, 0x5a88, 0x2834, 0xebc8, 0xfd98, 0xfd48, 0xb620, 0x8f08},
8503 {0x8800, 0xa108, 0x7f44, 0x3348, 0x55a8, 0x45c8, 0xff20, 0xd888},
8504 {0xd200, 0xeb88, 0xda54, 0x7ec8, 0xb1b8, 0x9248, 0x4c20, 0x2608},
8505 {0x2000, 0x3a08, 0x3964, 0xce48, 0x11c8, 0xe2c8, 0x9d20, 0x7788},
8506 {0x7200, 0x8c88, 0x9c74, 0x21c8, 0x75d8, 0x3748, 0xf220, 0xcd08},
8507 {0xc800, 0xe308, 0x0384, 0x7948, 0xdde8, 0x8fc8, 0x4b20, 0x2688},
8508 {0x2200, 0x3d88, 0x6e94, 0xd4c8, 0x49f8, 0xec48, 0xa820, 0x8408}},
8509 {{0x0902'0000, 0x749c'd524, 0x5df5'a988, 0xb900'7120},
8510 {0x9fd6'4200, 0x1e83'2834, 0x0add'fd98, 0x58da'b620},
8511 {0x42b2'8800, 0xd471'7f44, 0xc3ce'55a8, 0x04bc'ff20},
8512 {0xf196'd200, 0x9667'da54, 0x88c6'b1b8, 0xbca7'4c20},
8513 {0xac83'2000, 0x6466'3964, 0x59c7'11c8, 0x8099'9d20},
8514 {0x7377'7200, 0x3e6c'9c74, 0x36cf'75d8, 0x5093'f220},
8515 {0x4673'c800, 0x247b'0384, 0x1fdf'dde8, 0x2c96'4b20},
8516 {0x2578'2200, 0x1691'6e94, 0x14f8'49f8, 0x14a0'a820}},
8517 {{0xfc4e'ad16'0902'0000, 0xa697'acf5'5df5'a988},
8518 {0x4fde'a9cf'9fd6'4200, 0x0833'b3b7'0add'fd98},
8519 {0xbf86'ba99'42b2'8800, 0x85e7'ce88'c3ce'55a8},
8520 {0x4b46'df72'f196'd200, 0x1fb3'fd6a'88c6'b1b8},
8521 {0xf31f'185c'ac83'2000, 0xd598'405c'59c7'11c8},
8522 {0xb70f'6556'7377'7200, 0xa794'975e'36cf'75d8},
8523 {0x9717'c660'4673'c800, 0x95a9'0270'1fdf'dde8},
8524 {0x9338'3b7a'2578'2200, 0x9fd5'8192'14f8'49f8}},
8525 kVectorCalculationsSourceLegacy);
8526 TestVectorInstruction(
8527 ExecVmulvx,
8528 ExecMaskedVmulvx,
8529 {{0, 170, 84, 254, 168, 82, 252, 166, 80, 250, 164, 78, 248, 162, 76, 246},
8530 {160, 74, 244, 158, 72, 242, 156, 70, 240, 154, 68, 238, 152, 66, 236, 150},
8531 {64, 234, 148, 62, 232, 146, 60, 230, 144, 58, 228, 142, 56, 226, 140, 54},
8532 {224, 138, 52, 222, 136, 50, 220, 134, 48, 218, 132, 46, 216, 130, 44, 214},
8533 {128, 42, 212, 126, 40, 210, 124, 38, 208, 122, 36, 206, 120, 34, 204, 118},
8534 {32, 202, 116, 30, 200, 114, 28, 198, 112, 26, 196, 110, 24, 194, 108, 22},
8535 {192, 106, 20, 190, 104, 18, 188, 102, 16, 186, 100, 14, 184, 98, 12, 182},
8536 {96, 10, 180, 94, 8, 178, 92, 6, 176, 90, 4, 174, 88, 2, 172, 86}},
8537 {{0xaa00, 0x5354, 0xfca8, 0xa5fc, 0x4f50, 0xf8a4, 0xa1f8, 0x4b4c},
8538 {0xf4a0, 0x9df4, 0x4748, 0xf09c, 0x99f0, 0x4344, 0xec98, 0x95ec},
8539 {0x3f40, 0xe894, 0x91e8, 0x3b3c, 0xe490, 0x8de4, 0x3738, 0xe08c},
8540 {0x89e0, 0x3334, 0xdc88, 0x85dc, 0x2f30, 0xd884, 0x81d8, 0x2b2c},
8541 {0xd480, 0x7dd4, 0x2728, 0xd07c, 0x79d0, 0x2324, 0xcc78, 0x75cc},
8542 {0x1f20, 0xc874, 0x71c8, 0x1b1c, 0xc470, 0x6dc4, 0x1718, 0xc06c},
8543 {0x69c0, 0x1314, 0xbc68, 0x65bc, 0x0f10, 0xb864, 0x61b8, 0x0b0c},
8544 {0xb460, 0x5db4, 0x0708, 0xb05c, 0x59b0, 0x0304, 0xac58, 0x55ac}},
8545 {{0x5353'aa00, 0xfb50'fca8, 0xa34e'4f50, 0x4b4b'a1f8},
8546 {0xf348'f4a0, 0x9b46'4748, 0x4343'99f0, 0xeb40'ec98},
8547 {0x933e'3f40, 0x3b3b'91e8, 0xe338'e490, 0x8b36'3738},
8548 {0x3333'89e0, 0xdb30'dc88, 0x832e'2f30, 0x2b2b'81d8},
8549 {0xd328'd480, 0x7b26'2728, 0x2323'79d0, 0xcb20'cc78},
8550 {0x731e'1f20, 0x1b1b'71c8, 0xc318'c470, 0x6b16'1718},
8551 {0x1313'69c0, 0xbb10'bc68, 0x630e'0f10, 0x0b0b'61b8},
8552 {0xb308'b460, 0x5b06'0708, 0x0303'59b0, 0xab00'ac58}},
8553 {{0xa5fb'a752'5353'aa00, 0x4b4b'a1f7'a34e'4f50},
8554 {0xf09b'9c9c'f348'f4a0, 0x95eb'9742'4343'99f0},
8555 {0x3b3b'91e7'933e'3f40, 0xe08b'8c8c'e338'e490},
8556 {0x85db'8732'3333'89e0, 0x2b2b'81d7'832e'2f30},
8557 {0xd07b'7c7c'd328'd480, 0x75cb'7722'2323'79d0},
8558 {0x1b1b'71c7'731e'1f20, 0xc06b'6c6c'c318'c470},
8559 {0x65bb'6712'1313'69c0, 0x0b0b'61b7'630e'0f10},
8560 {0xb05b'5c5c'b308'b460, 0x55ab'5702'0303'59b0}},
8561 kVectorCalculationsSourceLegacy);
8562 TestVectorFloatInstruction(ExecVfmulvv,
8563 ExecMaskedVfmulvv,
8564 {{0x8000'0000, 0x8000'0000, 0x8000'0000, 0x8000'0000},
8565 {0x8000'02f0, 0x85ca'89ec, 0x91d9'a3e9, 0x9de9'3ee6},
8566 {0xa9f9'5ae5, 0xb604'fbf4, 0xc20d'8af5, 0xce16'5a77},
8567 {0xda1f'6a7a, 0xe628'bafe, 0xf232'4c02, 0xfe3c'1d87},
8568 {0x0a49'9dd9, 0x165a'3ee4, 0x226b'60ef, 0x2e7d'03f9},
8569 {0x3a87'9403, 0x4690'e68c, 0x529a'7994, 0x5ea4'4d1d},
8570 {0x6aae'6126, 0x76b8'b5b2, 0x7f80'0000, 0x7f80'0000},
8571 {0x7f80'0000, 0x7f80'0000, 0x7f80'0000, 0x7f80'0000}},
8572 {{0x8000'0000'0000'0000, 0x8000'0000'0000'0000},
8573 {0x8553'e032'b59e'2bf7, 0x9d6b'012b'925d'8532},
8574 {0xb584'0511'cdec'af2c, 0xcd9b'2e22'd263'd03f},
8575 {0xe5b4'2a11'269b'b302, 0xfdcb'5b3a'52ca'9bed},
8576 {0x15e4'4f30'bfab'3779, 0x2dfb'8872'1391'e83b},
8577 {0x4614'7470'991b'3c90, 0x5e2b'b5ca'14b9'b52b},
8578 {0x7644'99d0'b2eb'c249, 0x7ff0'0000'0000'0000},
8579 {0x7ff0'0000'0000'0000, 0x7ff0'0000'0000'0000}},
8580 kVectorCalculationsSourceLegacy);
8581 TestVectorFloatInstruction(ExecVfmulvf,
8582 ExecMaskedVfmulvf,
8583 {{0x8437'8568, 0x883d'2b0e, 0x8c42'd0b3, 0x9048'7659},
8584 {0x944e'1bfe, 0x9853'c1a4, 0x9c59'674a, 0xa05f'0cef},
8585 {0xa464'b295, 0xa86a'583b, 0xac6f'fde0, 0xb075'a386},
8586 {0xb47b'492c, 0xb880'7769, 0xbc83'4a3b, 0xc086'1d0e},
8587 {0xc488'efe1, 0xc88b'c2b4, 0xcc8e'9587, 0xd091'6859},
8588 {0xd494'3b2c, 0xd897'0dff, 0xdc99'e0d2, 0xe09c'b3a5},
8589 {0xe49f'8678, 0xe8a2'594a, 0xeca5'2c1d, 0xf0a7'fef0},
8590 {0xf4aa'd1c3, 0xf8ad'a496, 0xfcb0'7768, 0xff80'0000}},
8591 {{0x872f'ab0e'583b'8568, 0x8f35'7b2c'd1c3'685a},
8592 {0x973f'c1a4'eed2'1bfe, 0x9f45'8678'1d0e'b3a5},
8593 {0xa74f'd83b'8568'b295, 0xaf55'91c3'6859'fef0},
8594 {0xb75f'eed2'1bff'492c, 0xbf65'9d0e'b3a5'4a3b},
8595 {0xc770'02b4'594a'efe1, 0xcf75'a859'fef0'9587},
8596 {0xd780'0dff'a496'3b2c, 0xdf85'b3a5'4a3b'e0d2},
8597 {0xe790'194a'efe1'8678, 0xef95'bef0'9587'2c1d},
8598 {0xf7a0'2496'3b2c'd1c3, 0xffa5'ca3b'e0d2'7768}},
8599 kVectorCalculationsSourceLegacy);
8600 TestWideningVectorFloatInstruction(ExecVfwmulvv,
8601 ExecMaskedVfwmulvv,
8602 {{0x3330'e53c'6480'0000, 0x34b2'786b'bbc5'4900},
8603 {0x3234'1766'da4a'6200, 0x33b5'cab6'2d6c'4800},
8604 {0x3937'92ba'5bd0'8000, 0x3ab9'666a'779a'0d00},
8605 {0x383b'4565'd61f'6600, 0x39bd'3935'e5bd'8800},
8606 {0x3f3f'423b'5522'0000, 0x40c0'ab36'1ab7'e880},
8607 {0x3e41'bab3'e9fa'b500, 0x3fc2'd4dc'5007'e400},
8608 {0x4543'f9df'a83a'4000, 0x46c5'2438'7aa3'4a80},
8609 {0x4446'53b6'69e6'3700, 0x45c7'8e1f'2e31'8400}},
8610 kVectorCalculationsSource);
8611 TestWideningVectorFloatInstruction(ExecVfwmulvf,
8612 ExecMaskedVfwmulvf,
8613 {{0xb886'f0ad'0000'0000, 0xb907'a561'b400'0000},
8614 {0xb988'5a16'6800'0000, 0xba09'0ecb'1c00'0000},
8615 {0xba89'c37f'd000'0000, 0xbb0a'7834'8400'0000},
8616 {0xbb8b'2ce9'3800'0000, 0xbc0b'e19d'ec00'0000},
8617 {0xbc8c'9652'a000'0000, 0xbd0d'4b07'5400'0000},
8618 {0xbd8d'ffbc'0800'0000, 0xbe0e'b470'bc00'0000},
8619 {0xbe8f'6925'7000'0000, 0xbf10'0eed'1200'0000},
8620 {0xbf90'6947'6c00'0000, 0xc010'c3a1'c600'0000}},
8621 kVectorCalculationsSource);
8622 }
8623
ExecVmulhvv()8624 [[gnu::naked]] void ExecVmulhvv() {
8625 asm("vmulh.vv v8, v16, v24\n\t"
8626 "ret\n\t");
8627 }
8628
ExecMaskedVmulhvv()8629 [[gnu::naked]] void ExecMaskedVmulhvv() {
8630 asm("vmulh.vv v8, v16, v24, v0.t\n\t"
8631 "ret\n\t");
8632 }
8633
ExecVmulhvx()8634 [[gnu::naked]] void ExecVmulhvx() {
8635 asm("vmulh.vx v8, v16, t0\n\t"
8636 "ret\n\t");
8637 }
8638
ExecMaskedVmulhvx()8639 [[gnu::naked]] void ExecMaskedVmulhvx() {
8640 asm("vmulh.vx v8, v16, t0, v0.t\n\t"
8641 "ret\n\t");
8642 }
8643
TEST(InlineAsmTestRiscv64,TestVmulh)8644 TEST(InlineAsmTestRiscv64, TestVmulh) {
8645 TestVectorInstruction(ExecVmulhvv,
8646 ExecMaskedVmulhvv,
8647 {{0, 255, 0, 253, 0, 251, 0, 249, 0, 247, 0, 245, 1, 244, 1, 242},
8648 {2, 241, 2, 239, 3, 238, 3, 237, 4, 235, 5, 234, 6, 233, 7, 232},
8649 {8, 231, 9, 230, 10, 229, 11, 228, 12, 228, 13, 227, 15, 226, 16, 226},
8650 {18, 225, 19, 225, 21, 224, 22, 224, 24, 224, 26, 224, 28, 224, 30, 224},
8651 {224, 31, 224, 29, 224, 27, 224, 25, 224, 23, 224, 21, 225, 20, 225, 18},
8652 {226, 17, 226, 15, 227, 14, 227, 13, 228, 11, 229, 10, 230, 9, 231, 8},
8653 {232, 7, 233, 6, 234, 5, 235, 4, 236, 4, 237, 3, 239, 2, 240, 2},
8654 {242, 1, 243, 1, 245, 0, 246, 0, 248, 0, 250, 0, 252, 0, 254, 0}},
8655 {{0xff02, 0xfd10, 0xfb2d, 0xf95c, 0xf79a, 0xf5e9, 0xf448, 0xf2b7},
8656 {0xf136, 0xefc5, 0xee64, 0xed13, 0xebd2, 0xeaa2, 0xe982, 0xe872},
8657 {0xe772, 0xe682, 0xe5a2, 0xe4d3, 0xe413, 0xe364, 0xe2c4, 0xe235},
8658 {0xe1b6, 0xe147, 0xe0e8, 0xe09a, 0xe05b, 0xe02d, 0xe00f, 0xe001},
8659 {0x1ec3, 0x1cd3, 0x1af3, 0x1923, 0x1764, 0x15b4, 0x1415, 0x1286},
8660 {0x1107, 0x0f98, 0x0e39, 0x0ceb, 0x0bac, 0x0a7e, 0x095f, 0x0851},
8661 {0x0753, 0x0665, 0x0588, 0x04ba, 0x03fc, 0x034f, 0x02b2, 0x0225},
8662 {0x01a8, 0x013b, 0x00de, 0x0091, 0x0055, 0x0028, 0x000c, 0x0000}},
8663 {{0xfd10'1a16, 0xf95c'aad6, 0xf5e9'bc58, 0xf2b7'4e9b},
8664 {0xefc5'619f, 0xed13'f564, 0xeaa3'09ea, 0xe872'9f31},
8665 {0xe682'b539, 0xe4d3'4c01, 0xe364'638b, 0xe235'fbd7},
8666 {0xe148'14e2, 0xe09a'aeaf, 0xe02d'c93d, 0xe001'648c},
8667 {0x1cd2'bf5c, 0x1923'5829, 0x15b4'71b7, 0x1286'0c06},
8668 {0x0f98'2716, 0x0cea'c2e7, 0x0a7d'df79, 0x0851'7ccc},
8669 {0x0665'9ae0, 0x04ba'39b5, 0x034f'594b, 0x0224'f9a2},
8670 {0x013b'1aba, 0x0091'bc93, 0x0028'df2d, 0x0000'8288}},
8671 {{0xf95c'aad6'78f5'63b8, 0xf2b7'4e9b'bf9d'55cb},
8672 {0xed13'f564'2968'6900, 0xe872'9f31'6a0c'5913},
8673 {0xe4d3'4c01'edf3'8a67, 0xe235'fbd7'2893'787a},
8674 {0xe09a'aeaf'c696'c7ef, 0xe001'648c'fb32'b402},
8675 {0x1923'5828'f00f'6056, 0x1286'0c06'169f'4261},
8676 {0x0cea'c2e6'e0d2'c60e, 0x0851'7ccc'015e'a619},
8677 {0x04ba'39b4'e5ae'47e6, 0x0224'f9a2'0036'25f1},
8678 {0x0091'bc92'fea1'e5de, 0x0000'8288'1325'c1e9}},
8679 kVectorCalculationsSourceLegacy);
8680 TestVectorInstruction(
8681 ExecVmulhvx,
8682 ExecMaskedVmulhvx,
8683 {{0, 42, 255, 41, 254, 41, 253, 40, 253, 39, 252, 39, 251, 38, 251, 37},
8684 {250, 37, 249, 36, 249, 35, 248, 35, 247, 34, 247, 33, 246, 33, 245, 32},
8685 {245, 31, 244, 31, 243, 30, 243, 29, 242, 29, 241, 28, 241, 27, 240, 27},
8686 {239, 26, 239, 25, 238, 25, 237, 24, 237, 23, 236, 23, 235, 22, 235, 21},
8687 {234, 21, 233, 20, 233, 19, 232, 19, 231, 18, 231, 17, 230, 17, 229, 16},
8688 {229, 15, 228, 15, 227, 14, 227, 13, 226, 13, 225, 12, 225, 11, 224, 11},
8689 {223, 10, 223, 9, 222, 9, 221, 8, 221, 7, 220, 7, 219, 6, 219, 5},
8690 {218, 5, 217, 4, 217, 3, 216, 3, 215, 2, 215, 1, 214, 1, 213, 0}},
8691 {{0x2a55, 0x29aa, 0x28fe, 0x2853, 0x27a8, 0x26fc, 0x2651, 0x25a6},
8692 {0x24fa, 0x244f, 0x23a4, 0x22f8, 0x224d, 0x21a2, 0x20f6, 0x204b},
8693 {0x1fa0, 0x1ef4, 0x1e49, 0x1d9e, 0x1cf2, 0x1c47, 0x1b9c, 0x1af0},
8694 {0x1a45, 0x199a, 0x18ee, 0x1843, 0x1798, 0x16ec, 0x1641, 0x1596},
8695 {0x14ea, 0x143f, 0x1394, 0x12e8, 0x123d, 0x1192, 0x10e6, 0x103b}, // NOTYPO
8696 {0x0f90, 0x0ee4, 0x0e39, 0x0d8e, 0x0ce2, 0x0c37, 0x0b8c, 0x0ae0},
8697 {0x0a35, 0x098a, 0x08de, 0x0833, 0x0788, 0x06dc, 0x0631, 0x0586},
8698 {0x04da, 0x042f, 0x0384, 0x02d8, 0x022d, 0x0182, 0x00d6, 0x002b}},
8699 {{0x29a9'd500, 0x2853'28fe, 0x26fc'7cfd, 0x25a5'd0fc},
8700 {0x244f'24fa, 0x22f8'78f9, 0x21a1'ccf8, 0x204b'20f6},
8701 {0x1ef4'74f5, 0x1d9d'c8f4, 0x1c47'1cf2, 0x1af0'70f1},
8702 {0x1999'c4f0, 0x1843'18ee, 0x16ec'6ced, 0x1595'c0ec},
8703 {0x143f'14ea, 0x12e8'68e9, 0x1191'bce8, 0x103b'10e6}, // NOTYPO
8704 {0x0ee4'64e5, 0x0d8d'b8e4, 0x0c37'0ce2, 0x0ae0'60e1},
8705 {0x0989'b4e0, 0x0833'08de, 0x06dc'5cdd, 0x0585'b0dc},
8706 {0x042f'04da, 0x02d8'58d9, 0x0181'acd8, 0x002b'00d6}},
8707 {{0x2853'28fe'7eff'2a55, 0x25a5'd0fb'd1a7'27a8},
8708 {0x22f8'78f9'244f'24fa, 0x204b'20f6'76f7'224d},
8709 {0x1d9d'c8f3'c99f'1fa0, 0x1af0'70f1'1c47'1cf2},
8710 {0x1843'18ee'6eef'1a45, 0x1595'c0eb'c197'1798},
8711 {0x12e8'68e9'143f'14ea, 0x103b'10e6'66e7'123d}, // NOTYPO
8712 {0x0d8d'b8e3'b98f'0f90, 0x0ae0'60e1'0c37'0ce2},
8713 {0x0833'08de'5edf'0a35, 0x0585'b0db'b187'0788},
8714 {0x02d8'58d9'042f'04da, 0x002b'00d6'56d7'022d}},
8715 kVectorCalculationsSourceLegacy);
8716 }
8717
ExecVmulhuvv()8718 [[gnu::naked]] void ExecVmulhuvv() {
8719 asm("vmulhu.vv v8, v16, v24\n\t"
8720 "ret\n\t");
8721 }
8722
ExecMaskedVmulhuvv()8723 [[gnu::naked]] void ExecMaskedVmulhuvv() {
8724 asm("vmulhu.vv v8, v16, v24, v0.t\n\t"
8725 "ret\n\t");
8726 }
8727
ExecVmulhuvx()8728 [[gnu::naked]] void ExecVmulhuvx() {
8729 asm("vmulhu.vx v8, v16, t0\n\t"
8730 "ret\n\t");
8731 }
8732
ExecMaskedVmulhuvx()8733 [[gnu::naked]] void ExecMaskedVmulhuvx() {
8734 asm("vmulhu.vx v8, v16, t0, v0.t\n\t"
8735 "ret\n\t");
8736 }
8737
TEST(InlineAsmTestRiscv64,TestVmulhu)8738 TEST(InlineAsmTestRiscv64, TestVmulhu) {
8739 TestVectorInstruction(
8740 ExecVmulhuvv,
8741 ExecMaskedVmulhuvv,
8742 {{0, 1, 0, 3, 0, 5, 0, 7, 0, 9, 0, 11, 1, 14, 1, 16},
8743 {2, 19, 2, 21, 3, 24, 3, 27, 4, 29, 5, 32, 6, 35, 7, 38},
8744 {8, 41, 9, 44, 10, 47, 11, 50, 12, 54, 13, 57, 15, 60, 16, 64},
8745 {18, 67, 19, 71, 21, 74, 22, 78, 24, 82, 26, 86, 28, 90, 30, 94},
8746 {32, 98, 34, 102, 36, 106, 38, 110, 40, 114, 42, 118, 45, 123, 47, 127},
8747 {50, 132, 52, 136, 55, 141, 57, 146, 60, 150, 63, 155, 66, 160, 69, 165},
8748 {72, 170, 75, 175, 78, 180, 81, 185, 84, 191, 87, 196, 91, 201, 94, 207},
8749 {98, 212, 101, 218, 105, 223, 108, 229, 112, 235, 116, 241, 120, 247, 124, 253}},
8750 {{0x0102, 0x0314, 0x0536, 0x0768, 0x09ab, 0x0bfd, 0x0e60, 0x10d3},
8751 {0x1356, 0x15e9, 0x188d, 0x1b3f, 0x1e03, 0x20d6, 0x23ba, 0x26ae},
8752 {0x29b2, 0x2cc6, 0x2feb, 0x331f, 0x3664, 0x39b8, 0x3d1c, 0x4091},
8753 {0x4416, 0x47ab, 0x4b51, 0x4f06, 0x52cc, 0x56a1, 0x5a87, 0x5e7d},
8754 {0x6283, 0x6699, 0x6ac0, 0x6ef5, 0x733d, 0x7792, 0x7bf9, 0x8070},
8755 {0x84f7, 0x898e, 0x8e36, 0x92ed, 0x97b5, 0x9c8c, 0xa173, 0xa66b},
8756 {0xab73, 0xb08b, 0xb5b5, 0xbaec, 0xc035, 0xc58d, 0xcaf6, 0xd06f},
8757 {0xd5f8, 0xdb91, 0xe13b, 0xe6f3, 0xecbe, 0xf296, 0xf880, 0xfe7a}},
8758 {{0x0314'1c16, 0x0768'b4df, 0x0bfd'ce69, 0x10d3'68b3},
8759 {0x15e9'83bf, 0x1b40'1f8d, 0x20d7'3c1b, 0x26ae'd969},
8760 {0x2cc6'f779, 0x331f'964a, 0x39b8'b5dc, 0x4092'562f},
8761 {0x47ac'7742, 0x4f07'1918, 0x56a2'3bae, 0x5e7d'df04},
8762 {0x669a'031c, 0x6ef6'a7f6, 0x7793'cd90, 0x8071'73ea},
8763 {0x898f'9b06, 0x92ee'42e4, 0x9c8d'6b82, 0xa66d'14e0},
8764 {0xb08d'3f00, 0xbaed'e9e2, 0xc58f'1584, 0xd070'c1e6},
8765 {0xdb92'ef0a, 0xe6f5'9cf0, 0xf298'cb96, 0xfe7c'7afc}},
8766 {{0x0768'b4df'7ef9'65b8, 0x10d3'68b3'd5b1'67dc},
8767 {0x1b40'1f8d'4f8c'8b20, 0x26ae'd969'a040'8b44},
8768 {0x331f'964b'3437'cca7, 0x4092'562f'7ee7'cacb},
8769 {0x4f07'1919'2cfb'2a4f, 0x5e7d'df05'71a7'2673},
8770 {0x6ef6'a7f7'39d6'a416, 0x8071'73eb'787e'9e3a},
8771 {0x92ee'42e5'5aca'39fe, 0xa66d'14e1'936e'3222},
8772 {0xbaed'e9e3'8fd5'ec06, 0xd070'c1e7'c275'e22a},
8773 {0xe6f5'9cf1'd8f9'ba2e, 0xfe7c'7afe'0595'ae52}},
8774 kVectorCalculationsSourceLegacy);
8775 TestVectorInstruction(ExecVmulhuvx,
8776 ExecMaskedVmulhuvx,
8777 {{0, 85, 1, 86, 2, 88, 3, 89, 5, 90, 6, 92, 7, 93, 9, 94},
8778 {10, 96, 11, 97, 13, 98, 14, 100, 15, 101, 17, 102, 18, 104, 19, 105},
8779 {21, 106, 22, 108, 23, 109, 25, 110, 26, 112, 27, 113, 29, 114, 30, 116},
8780 {31, 117, 33, 118, 34, 120, 35, 121, 37, 122, 38, 124, 39, 125, 41, 126},
8781 {42, 128, 43, 129, 45, 130, 46, 132, 47, 133, 49, 134, 50, 136, 51, 137},
8782 {53, 138, 54, 140, 55, 141, 57, 142, 58, 144, 59, 145, 61, 146, 62, 148},
8783 {63, 149, 65, 150, 66, 152, 67, 153, 69, 154, 70, 156, 71, 157, 73, 158},
8784 {74, 160, 75, 161, 77, 162, 78, 164, 79, 165, 81, 166, 82, 168, 83, 169}},
8785 {{0x55ff, 0x5756, 0x58ac, 0x5a03, 0x5b5a, 0x5cb0, 0x5e07, 0x5f5e},
8786 {0x60b4, 0x620b, 0x6362, 0x64b8, 0x660f, 0x6766, 0x68bc, 0x6a13},
8787 {0x6b6a, 0x6cc0, 0x6e17, 0x6f6e, 0x70c4, 0x721b, 0x7372, 0x74c8},
8788 {0x761f, 0x7776, 0x78cc, 0x7a23, 0x7b7a, 0x7cd0, 0x7e27, 0x7f7e},
8789 {0x80d4, 0x822b, 0x8382, 0x84d8, 0x862f, 0x8786, 0x88dc, 0x8a33},
8790 {0x8b8a, 0x8ce0, 0x8e37, 0x8f8e, 0x90e4, 0x923b, 0x9392, 0x94e8},
8791 {0x963f, 0x9796, 0x98ec, 0x9a43, 0x9b9a, 0x9cf0, 0x9e47, 0x9f9e},
8792 {0xa0f4, 0xa24b, 0xa3a2, 0xa4f8, 0xa64f, 0xa7a6, 0xa8fc, 0xaa53}},
8793 {{0x5757'00aa, 0x5a04'58ac, 0x5cb1'b0af, 0x5f5f'08b2},
8794 {0x620c'60b4, 0x64b9'b8b7, 0x6767'10ba, 0x6a14'68bc},
8795 {0x6cc1'c0bf, 0x6f6f'18c2, 0x721c'70c4, 0x74c9'c8c7},
8796 {0x7777'20ca, 0x7a24'78cc, 0x7cd1'd0cf, 0x7f7f'28d2},
8797 {0x822c'80d4, 0x84d9'd8d7, 0x8787'30da, 0x8a34'88dc},
8798 {0x8ce1'e0df, 0x8f8f'38e2, 0x923c'90e4, 0x94e9'e8e7},
8799 {0x9797'40ea, 0x9a44'98ec, 0x9cf1'f0ef, 0x9f9f'48f2},
8800 {0xa24c'a0f4, 0xa4f9'f8f7, 0xa7a7'50fa, 0xaa54'a8fc}},
8801 {{0x5a04'58ad'acac'55ff, 0x5f5f'08b3'075c'5b5a},
8802 {0x64b9'b8b8'620c'60b4, 0x6a14'68bd'bcbc'660f},
8803 {0x6f6f'18c3'176c'6b6a, 0x74c9'c8c8'721c'70c4},
8804 {0x7a24'78cd'cccc'761f, 0x7f7f'28d3'277c'7b7a},
8805 {0x84d9'd8d8'822c'80d4, 0x8a34'88dd'dcdc'862f},
8806 {0x8f8f'38e3'378c'8b8a, 0x94e9'e8e8'923c'90e4},
8807 {0x9a44'98ed'ecec'963f, 0x9f9f'48f3'479c'9b9a},
8808 {0xa4f9'f8f8'a24c'a0f4, 0xaa54'a8fd'fcfc'a64f}},
8809 kVectorCalculationsSourceLegacy);
8810 }
8811
ExecVnmsacvv()8812 [[gnu::naked]] void ExecVnmsacvv() {
8813 asm("vnmsac.vv v8, v16, v24\n\t"
8814 "ret\n\t");
8815 }
8816
ExecMaskedVnmsacvv()8817 [[gnu::naked]] void ExecMaskedVnmsacvv() {
8818 asm("vnmsac.vv v8, v16, v24, v0.t\n\t"
8819 "ret\n\t");
8820 }
8821
ExecVnmsacvx()8822 [[gnu::naked]] void ExecVnmsacvx() {
8823 asm("vnmsac.vx v8, t0, v16\n\t"
8824 "ret\n\t");
8825 }
8826
ExecMaskedVnmsacvx()8827 [[gnu::naked]] void ExecMaskedVnmsacvx() {
8828 asm("vnmsac.vx v8, t0, v16, v0.t\n\t"
8829 "ret\n\t");
8830 }
8831
TEST(InlineAsmTestRiscv64,TestVnmsac)8832 TEST(InlineAsmTestRiscv64, TestVnmsac) {
8833 TestVectorInstruction(ExecVnmsacvv,
8834 ExecMaskedVnmsacvv,
8835 {{85, 195, 77, 147, 49, 83, 13, 3, 205, 195, 141, 147, 53, 83, 205, 3},
8836 {85, 131, 205, 211, 33, 19, 141, 67, 189, 131, 13, 211, 53, 19, 77, 67},
8837 {85, 67, 77, 19, 17, 211, 13, 131, 173, 67, 141, 19, 53, 211, 205, 131},
8838 {85, 3, 205, 83, 1, 147, 141, 195, 157, 3, 13, 83, 53, 147, 77, 195},
8839 {85, 195, 77, 147, 241, 83, 13, 3, 141, 195, 141, 147, 53, 83, 205, 3},
8840 {85, 131, 205, 211, 225, 19, 141, 67, 125, 131, 13, 211, 53, 19, 77, 67},
8841 {85, 67, 77, 19, 209, 211, 13, 131, 109, 67, 141, 19, 53, 211, 205, 131},
8842 {85, 3, 205, 83, 193, 147, 141, 195, 93, 3, 13, 83, 53, 147, 77, 195}},
8843 {{0x5555, 0x1d4d, 0x4031, 0x4d0d, 0x2bcd, 0x3c8d, 0xa435, 0xebcd},
8844 {0x1355, 0xdacd, 0xed21, 0x098d, 0xd7bd, 0xf80d, 0x5f35, 0xa64d},
8845 {0xcd55, 0x944d, 0x9611, 0xc20d, 0x7fad, 0xaf8d, 0x1635, 0x5ccd},
8846 {0x8355, 0x49cd, 0x3b01, 0x768d, 0x239d, 0x630d, 0xc935, 0x0f4d},
8847 {0x3555, 0xfb4d, 0xdbf1, 0x270d, 0xc38d, 0x128d, 0x7835, 0xbdcd},
8848 {0xe355, 0xa8cd, 0x78e1, 0xd38d, 0x5f7d, 0xbe0d, 0x2335, 0x684d},
8849 {0x8d55, 0x524d, 0x11d1, 0x7c0d, 0xf76d, 0x658d, 0xca35, 0x0ecd},
8850 {0x3355, 0xf7cd, 0xa6c1, 0x208d, 0x8b5d, 0x090d, 0x6d35, 0xb14d}},
8851 {{0xe3c3'5555, 0xf5e6'4031, 0xdb6c'2bcd, 0xfe9f'a435},
8852 {0x43e6'1355, 0x42f6'ed21, 0x277c'd7bd, 0x57be'5f35},
8853 {0x9800'cd55, 0x83ff'9611, 0x6785'7fad, 0xa4d5'1635},
8854 {0xe013'8355, 0xb900'3b01, 0x9b86'239d, 0xe5e3'c935},
8855 {0xdd5e'3555, 0xa73c'dbf1, 0x8cc6'c38d, 0xe836'7835},
8856 {0x1d70'e355, 0xd43d'78e1, 0xb8c7'5f7d, 0x2145'2335},
8857 {0x517b'8d55, 0xf536'11d1, 0xd8bf'f76d, 0x4e4b'ca35},
8858 {0x797e'3355, 0x0a26'a6c1, 0xecb0'8b5d, 0x6f4a'6d35}},
8859 {{0xbbf2'b5fd'e3c3'5555, 0xb840'0f97'db6c'2bcd},
8860 {0x4d47'a732'43e6'1355, 0x418e'fac8'277c'd7bd},
8861 {0xc284'8456'9800'cd55, 0xaec5'd1e8'6785'7fad},
8862 {0x1ba9'4d6a'e013'8355, 0xffe4'94f8'9b86'239d},
8863 {0xa27d'86f1'dd5e'3555, 0x96ca'd88b'8cc6'c38d},
8864 {0xf3a2'4806'1d70'e355, 0xdfe9'939b'b8c7'5f7d},
8865 {0x28ae'f50a'517b'8d55, 0x0cf0'3a9b'd8bf'f76d},
8866 {0x41a3'8dfe'797e'3355, 0x1dde'cd8b'ecb0'8b5d}},
8867 kVectorCalculationsSource);
8868 TestVectorInstruction(
8869 ExecVnmsacvx,
8870 ExecMaskedVnmsacvx,
8871 {{85, 171, 1, 87, 173, 3, 89, 175, 5, 91, 177, 7, 93, 179, 9, 95},
8872 {181, 11, 97, 183, 13, 99, 185, 15, 101, 187, 17, 103, 189, 19, 105, 191},
8873 {21, 107, 193, 23, 109, 195, 25, 111, 197, 27, 113, 199, 29, 115, 201, 31},
8874 {117, 203, 33, 119, 205, 35, 121, 207, 37, 123, 209, 39, 125, 211, 41, 127},
8875 {213, 43, 129, 215, 45, 131, 217, 47, 133, 219, 49, 135, 221, 51, 137, 223},
8876 {53, 139, 225, 55, 141, 227, 57, 143, 229, 59, 145, 231, 61, 147, 233, 63},
8877 {149, 235, 65, 151, 237, 67, 153, 239, 69, 155, 241, 71, 157, 243, 73, 159},
8878 {245, 75, 161, 247, 77, 163, 249, 79, 165, 251, 81, 167, 253, 83, 169, 255}},
8879 {{0xab55, 0x0201, 0x58ad, 0xaf59, 0x0605, 0x5cb1, 0xb35d, 0x0a09},
8880 {0x60b5, 0xb761, 0x0e0d, 0x64b9, 0xbb65, 0x1211, 0x68bd, 0xbf69},
8881 {0x1615, 0x6cc1, 0xc36d, 0x1a19, 0x70c5, 0xc771, 0x1e1d, 0x74c9},
8882 {0xcb75, 0x2221, 0x78cd, 0xcf79, 0x2625, 0x7cd1, 0xd37d, 0x2a29},
8883 {0x80d5, 0xd781, 0x2e2d, 0x84d9, 0xdb85, 0x3231, 0x88dd, 0xdf89},
8884 {0x3635, 0x8ce1, 0xe38d, 0x3a39, 0x90e5, 0xe791, 0x3e3d, 0x94e9},
8885 {0xeb95, 0x4241, 0x98ed, 0xef99, 0x4645, 0x9cf1, 0xf39d, 0x4a49},
8886 {0xa0f5, 0xf7a1, 0x4e4d, 0xa4f9, 0xfba5, 0x5251, 0xa8fd, 0xffa9}},
8887 {{0x0201'ab55, 0x5a04'58ad, 0xb207'0605, 0x0a09'b35d},
8888 {0x620c'60b5, 0xba0f'0e0d, 0x1211'bb65, 0x6a14'68bd},
8889 {0xc217'1615, 0x1a19'c36d, 0x721c'70c5, 0xca1f'1e1d},
8890 {0x2221'cb75, 0x7a24'78cd, 0xd227'2625, 0x2a29'd37d},
8891 {0x822c'80d5, 0xda2f'2e2d, 0x3231'db85, 0x8a34'88dd},
8892 {0xe237'3635, 0x3a39'e38d, 0x923c'90e5, 0xea3f'3e3d},
8893 {0x4241'eb95, 0x9a44'98ed, 0xf247'4645, 0x4a49'f39d},
8894 {0xa24c'a0f5, 0xfa4f'4e4d, 0x5251'fba5, 0xaa54'a8fd}},
8895 {{0xaf59'ae03'0201'ab55, 0x0a09'b35d'b207'0605},
8896 {0x64b9'b8b8'620c'60b5, 0xbf69'be13'1211'bb65},
8897 {0x1a19'c36d'c217'1615, 0x74c9'c8c8'721c'70c5},
8898 {0xcf79'ce23'2221'cb75, 0x2a29'd37d'd227'2625},
8899 {0x84d9'd8d8'822c'80d5, 0xdf89'de33'3231'db85},
8900 {0x3a39'e38d'e237'3635, 0x94e9'e8e8'923c'90e5},
8901 {0xef99'ee43'4241'eb95, 0x4a49'f39d'f247'4645},
8902 {0xa4f9'f8f8'a24c'a0f5, 0xffa9'fe53'5251'fba5}},
8903 kVectorCalculationsSource);
8904 }
8905
ExecVnmsubvv()8906 [[gnu::naked]] void ExecVnmsubvv() {
8907 asm("vnmsub.vv v8, v16, v24\n\t"
8908 "ret\n\t");
8909 }
8910
ExecMaskedVnmsubvv()8911 [[gnu::naked]] void ExecMaskedVnmsubvv() {
8912 asm("vnmsub.vv v8, v16, v24, v0.t\n\t"
8913 "ret\n\t");
8914 }
8915
ExecVnmsubvx()8916 [[gnu::naked]] void ExecVnmsubvx() {
8917 asm("vnmsub.vx v8, t0, v16\n\t"
8918 "ret\n\t");
8919 }
8920
ExecMaskedVnmsubvx()8921 [[gnu::naked]] void ExecMaskedVnmsubvx() {
8922 asm("vnmsub.vx v8, t0, v16, v0.t\n\t"
8923 "ret\n\t");
8924 }
8925
TEST(InlineAsmTestRiscv64,TestVnmsub)8926 TEST(InlineAsmTestRiscv64, TestVnmsub) {
8927 TestVectorInstruction(
8928 ExecVnmsubvv,
8929 ExecMaskedVnmsubvv,
8930 {{0, 189, 90, 23, 181, 113, 14, 203, 105, 5, 194, 95, 28, 185, 118, 19},
8931 {208, 141, 42, 231, 133, 65, 222, 155, 57, 213, 146, 47, 236, 137, 70, 227},
8932 {160, 93, 250, 183, 85, 17, 174, 107, 9, 165, 98, 255, 188, 89, 22, 179},
8933 {112, 45, 202, 135, 37, 225, 126, 59, 217, 117, 50, 207, 140, 41, 230, 131},
8934 {64, 253, 154, 87, 245, 177, 78, 11, 169, 69, 2, 159, 92, 249, 182, 83},
8935 {16, 205, 106, 39, 197, 129, 30, 219, 121, 21, 210, 111, 44, 201, 134, 35},
8936 {224, 157, 58, 247, 149, 81, 238, 171, 73, 229, 162, 63, 252, 153, 86, 243},
8937 {176, 109, 10, 199, 101, 33, 190, 123, 25, 181, 114, 15, 204, 105, 38, 195}},
8938 {{0xbd00, 0x6c5a, 0x1bb5, 0xcb0e, 0x5a69, 0x09c2, 0xb91c, 0x6876},
8939 {0x37d0, 0xe72a, 0x9685, 0x45de, 0xd539, 0x8492, 0x33ec, 0xe346},
8940 {0xb2a0, 0x61fa, 0x1155, 0xc0ae, 0x5009, 0xff62, 0xaebc, 0x5e16},
8941 {0x2d70, 0xdcca, 0x8c25, 0x3b7e, 0xcad9, 0x7a32, 0x298c, 0xd8e6},
8942 {0xa840, 0x579a, 0x06f5, 0xb64e, 0x45a9, 0xf502, 0xa45c, 0x53b6},
8943 {0x2310, 0xd26a, 0x81c5, 0x311e, 0xc079, 0x6fd2, 0x1f2c, 0xce86},
8944 {0x9de0, 0x4d3a, 0xfc95, 0xabee, 0x3b49, 0xeaa2, 0x99fc, 0x4956},
8945 {0x18b0, 0xc80a, 0x7765, 0x26be, 0xb619, 0x6572, 0x14cc, 0xc426}},
8946 {{0x6c5a'bd00, 0x2064'1bb5, 0xb46d'5a69, 0x6876'b91c},
8947 {0x3c80'37d0, 0xf089'9685, 0x8492'd539, 0x389c'33ec},
8948 {0x0ca5'b2a0, 0xc0af'1155, 0x54b8'5009, 0x08c1'aebc},
8949 {0xdccb'2d70, 0x90d4'8c25, 0x24dd'cad9, 0xd8e7'298c},
8950 {0xacef'a840, 0x60f9'06f5, 0xf502'45a9, 0xa90b'a45c},
8951 {0x7d15'2310, 0x311e'81c5, 0xc527'c079, 0x7931'1f2c},
8952 {0x4d3a'9de0, 0x0143'fc95, 0x954d'3b49, 0x4956'99fc},
8953 {0x1d60'18b0, 0xd169'7765, 0x6572'b619, 0x197c'14cc}},
8954 {{0xcb0e'c660'6c5a'bd00, 0x6876'b91c'b46d'5a69},
8955 {0x45de'ebdb'3c80'37d0, 0xe346'de97'8492'd539},
8956 {0xc0af'1156'0ca5'b2a0, 0x5e17'0412'54b8'5009},
8957 {0x3b7f'36d0'dccb'2d70, 0xd8e7'298d'24dd'cad9},
8958 {0xb64e'5c4a'acef'a840, 0x53b6'4f06'f502'45a9},
8959 {0x311e'81c5'7d15'2310, 0xce86'7481'c527'c079},
8960 {0xabee'a740'4d3a'9de0, 0x4956'99fc'954d'3b49},
8961 {0x26be'ccbb'1d60'18b0, 0xc426'bf77'6572'b619}},
8962 kVectorCalculationsSource);
8963 TestVectorInstruction(
8964 ExecVnmsubvx,
8965 ExecMaskedVnmsubvx,
8966 {{142, 15, 144, 17, 146, 19, 148, 21, 150, 23, 152, 25, 154, 27, 156, 29},
8967 {158, 31, 160, 33, 162, 35, 164, 37, 166, 39, 168, 41, 170, 43, 172, 45},
8968 {174, 47, 176, 49, 178, 51, 180, 53, 182, 55, 184, 57, 186, 59, 188, 61},
8969 {190, 63, 192, 65, 194, 67, 196, 69, 198, 71, 200, 73, 202, 75, 204, 77},
8970 {206, 79, 208, 81, 210, 83, 212, 85, 214, 87, 216, 89, 218, 91, 220, 93},
8971 {222, 95, 224, 97, 226, 99, 228, 101, 230, 103, 232, 105, 234, 107, 236, 109},
8972 {238, 111, 240, 113, 242, 115, 244, 117, 246, 119, 248, 121, 250, 123, 252, 125},
8973 {254, 127, 0, 129, 2, 131, 4, 133, 6, 135, 8, 137, 10, 139, 12, 141}},
8974 {{0x648e, 0x6690, 0x6892, 0x6a94, 0x6c96, 0x6e98, 0x709a, 0x729c},
8975 {0x749e, 0x76a0, 0x78a2, 0x7aa4, 0x7ca6, 0x7ea8, 0x80aa, 0x82ac},
8976 {0x84ae, 0x86b0, 0x88b2, 0x8ab4, 0x8cb6, 0x8eb8, 0x90ba, 0x92bc},
8977 {0x94be, 0x96c0, 0x98c2, 0x9ac4, 0x9cc6, 0x9ec8, 0xa0ca, 0xa2cc},
8978 {0xa4ce, 0xa6d0, 0xa8d2, 0xaad4, 0xacd6, 0xaed8, 0xb0da, 0xb2dc},
8979 {0xb4de, 0xb6e0, 0xb8e2, 0xbae4, 0xbce6, 0xbee8, 0xc0ea, 0xc2ec},
8980 {0xc4ee, 0xc6f0, 0xc8f2, 0xcaf4, 0xccf6, 0xcef8, 0xd0fa, 0xd2fc},
8981 {0xd4fe, 0xd700, 0xd902, 0xdb04, 0xdd06, 0xdf08, 0xe10a, 0xe30c}},
8982 {{0x113b'648e, 0x153f'6892, 0x1943'6c96, 0x1d47'709a},
8983 {0x214b'749e, 0x254f'78a2, 0x2953'7ca6, 0x2d57'80aa},
8984 {0x315b'84ae, 0x355f'88b2, 0x3963'8cb6, 0x3d67'90ba},
8985 {0x416b'94be, 0x456f'98c2, 0x4973'9cc6, 0x4d77'a0ca},
8986 {0x517b'a4ce, 0x557f'a8d2, 0x5983'acd6, 0x5d87'b0da},
8987 {0x618b'b4de, 0x658f'b8e2, 0x6993'bce6, 0x6d97'c0ea},
8988 {0x719b'c4ee, 0x759f'c8f2, 0x79a3'ccf6, 0x7da7'd0fa},
8989 {0x81ab'd4fe, 0x85af'd902, 0x89b3'dd06, 0x8db7'e10a}},
8990 {{0x6a94'bde8'113b'648e, 0x729c'c5f0'1943'6c96},
8991 {0x7aa4'cdf8'214b'749e, 0x82ac'd600'2953'7ca6},
8992 {0x8ab4'de08'315b'84ae, 0x92bc'e610'3963'8cb6},
8993 {0x9ac4'ee18'416b'94be, 0xa2cc'f620'4973'9cc6},
8994 {0xaad4'fe28'517b'a4ce, 0xb2dd'0630'5983'acd6},
8995 {0xbae5'0e38'618b'b4de, 0xc2ed'1640'6993'bce6},
8996 {0xcaf5'1e48'719b'c4ee, 0xd2fd'2650'79a3'ccf6},
8997 {0xdb05'2e58'81ab'd4fe, 0xe30d'3660'89b3'dd06}},
8998 kVectorCalculationsSource);
8999 }
9000
ExecVnsrawi()9001 [[gnu::naked]] void ExecVnsrawi() {
9002 asm("vnsra.wi v8, v16, 3\n\t"
9003 "ret\n\t");
9004 }
9005
ExecMaskedVnsrawi()9006 [[gnu::naked]] void ExecMaskedVnsrawi() {
9007 asm("vnsra.wi v8, v16, 3, v0.t\n\t"
9008 "ret\n\t");
9009 }
9010
ExecVnsrawx()9011 [[gnu::naked]] void ExecVnsrawx() {
9012 asm("vnsra.wx v8, v16, t0\n\t"
9013 "ret\n\t");
9014 }
9015
ExecMaskedVnsrawx()9016 [[gnu::naked]] void ExecMaskedVnsrawx() {
9017 asm("vnsra.wx v8, v16, t0, v0.t\n\t"
9018 "ret\n\t");
9019 }
9020
ExecVnsrawv()9021 [[gnu::naked]] void ExecVnsrawv() {
9022 asm("vnsra.wv v8, v16, v24\n\t"
9023 "ret\n\t");
9024 }
9025
ExecMaskedVnsrawv()9026 [[gnu::naked]] void ExecMaskedVnsrawv() {
9027 asm("vnsra.wv v8, v16, v24, v0.t\n\t"
9028 "ret\n\t");
9029 }
9030
TEST(InlineAsmTestRiscv64,TestVnsra)9031 TEST(InlineAsmTestRiscv64, TestVnsra) {
9032 TestNarrowingVectorInstruction(
9033 ExecVnsrawi,
9034 ExecMaskedVnsrawi,
9035 {{32, 96, 160, 224, 33, 97, 161, 225, 34, 98, 162, 226, 35, 99, 163, 227},
9036 {36, 100, 164, 228, 37, 101, 165, 229, 38, 102, 166, 230, 39, 103, 167, 231},
9037 {40, 104, 168, 232, 41, 105, 169, 233, 42, 106, 170, 234, 43, 107, 171, 235},
9038 {44, 108, 172, 236, 45, 109, 173, 237, 46, 110, 174, 238, 47, 111, 175, 239}},
9039 {{0x5020, 0xd0a0, 0x5121, 0xd1a1, 0x5222, 0xd2a2, 0x5323, 0xd3a3},
9040 {0x5424, 0xd4a4, 0x5525, 0xd5a5, 0x5626, 0xd6a6, 0x5727, 0xd7a7},
9041 {0x5828, 0xd8a8, 0x5929, 0xd9a9, 0x5a2a, 0xdaaa, 0x5b2b, 0xdbab},
9042 {0x5c2c, 0xdcac, 0x5d2d, 0xddad, 0x5e2e, 0xdeae, 0x5f2f, 0xdfaf}},
9043 {{0x9060'5020, 0x9161'5121, 0x9262'5222, 0x9363'5323},
9044 {0x9464'5424, 0x9565'5525, 0x9666'5626, 0x9767'5727},
9045 {0x9868'5828, 0x9969'5929, 0x9a6a'5a2a, 0x9b6b'5b2b},
9046 {0x9c6c'5c2c, 0x9d6d'5d2d, 0x9e6e'5e2e, 0x9f6f'5f2f}},
9047 kVectorCalculationsSourceLegacy);
9048 TestNarrowingVectorInstruction(
9049 ExecVnsrawx,
9050 ExecMaskedVnsrawx,
9051 {{224, 224, 225, 225, 226, 226, 227, 227, 228, 228, 229, 229, 230, 230, 231, 231},
9052 {232, 232, 233, 233, 234, 234, 235, 235, 236, 236, 237, 237, 238, 238, 239, 239},
9053 {240, 240, 241, 241, 242, 242, 243, 243, 244, 244, 245, 245, 246, 246, 247, 247},
9054 {248, 248, 249, 249, 250, 250, 251, 251, 252, 252, 253, 253, 254, 254, 255, 255}},
9055 {{0xc0a0, 0xc1a1, 0xc2a2, 0xc3a3, 0xc4a4, 0xc5a5, 0xc6a6, 0xc7a7},
9056 {0xc8a8, 0xc9a9, 0xcaaa, 0xcbab, 0xccac, 0xcdad, 0xceae, 0xcfaf},
9057 {0xd0b0, 0xd1b1, 0xd2b2, 0xd3b3, 0xd4b4, 0xd5b5, 0xd6b6, 0xd7b7},
9058 {0xd8b8, 0xd9b9, 0xdaba, 0xdbbb, 0xdcbc, 0xddbd, 0xdebe, 0xdfbf}},
9059 {{0xffe1'c1a1, 0xffe3'c3a3, 0xffe5'c5a5, 0xffe7'c7a7},
9060 {0xffe9'c9a9, 0xffeb'cbab, 0xffed'cdad, 0xffef'cfaf},
9061 {0xfff1'd1b1, 0xfff3'd3b3, 0xfff5'd5b5, 0xfff7'd7b7},
9062 {0xfff9'd9b9, 0xfffb'dbbb, 0xfffd'ddbd, 0xffff'dfbf}},
9063 kVectorCalculationsSourceLegacy);
9064 TestNarrowingVectorInstruction(
9065 ExecVnsrawv,
9066 ExecMaskedVnsrawv,
9067 {{0, 192, 80, 28, 196, 226, 248, 254, 136, 196, 81, 92, 153, 230, 249, 254},
9068 {32, 200, 82, 156, 212, 234, 250, 254, 152, 204, 83, 220, 185, 238, 251, 254},
9069 {64, 208, 84, 29, 228, 242, 252, 255, 168, 212, 85, 93, 217, 246, 253, 255},
9070 {96, 216, 86, 157, 244, 250, 254, 255, 184, 220, 87, 221, 249, 254, 255, 255}},
9071 {{0x8100, 0x6850, 0x8544, 0xf0e8, 0xc989, 0xf971, 0xff9b, 0xfff9},
9072 {0xa120, 0x6a52, 0x9554, 0xf2ea, 0xd999, 0xfb73, 0xffbb, 0xfffb},
9073 {0xc140, 0x6c54, 0xa564, 0xf4ec, 0xe9a9, 0xfd75, 0xffdb, 0xfffd},
9074 {0xe160, 0x6e56, 0xb574, 0xf6ee, 0xf9b9, 0xff77, 0xfffb, 0xffff}},
9075 {{0x8302'8100, 0x8645'8544, 0x4a8a'4989, 0x1e9d'1c9b},
9076 {0xa726'a524, 0xffd7'9756, 0xffff'db9b, 0xffff'ffbf},
9077 {0xc342'c140, 0xa665'a564, 0x6aaa'69a9, 0x5edd'5cdb},
9078 {0xe766'e564, 0xfff7'b776, 0xffff'fbbb, 0xffff'ffff}},
9079 kVectorCalculationsSourceLegacy);
9080 }
9081
ExecVnsrlwi()9082 [[gnu::naked]] void ExecVnsrlwi() {
9083 asm("vnsrl.wi v8, v16, 3\n\t"
9084 "ret\n\t");
9085 }
9086
ExecMaskedVnsrlwi()9087 [[gnu::naked]] void ExecMaskedVnsrlwi() {
9088 asm("vnsrl.wi v8, v16, 3, v0.t\n\t"
9089 "ret\n\t");
9090 }
9091
ExecVnsrlwx()9092 [[gnu::naked]] void ExecVnsrlwx() {
9093 asm("vnsrl.wx v8, v16, t0\n\t"
9094 "ret\n\t");
9095 }
9096
ExecMaskedVnsrlwx()9097 [[gnu::naked]] void ExecMaskedVnsrlwx() {
9098 asm("vnsrl.wx v8, v16, t0, v0.t\n\t"
9099 "ret\n\t");
9100 }
9101
ExecVnsrlwv()9102 [[gnu::naked]] void ExecVnsrlwv() {
9103 asm("vnsrl.wv v8, v16, v24\n\t"
9104 "ret\n\t");
9105 }
9106
ExecMaskedVnsrlwv()9107 [[gnu::naked]] void ExecMaskedVnsrlwv() {
9108 asm("vnsrl.wv v8, v16, v24, v0.t\n\t"
9109 "ret\n\t");
9110 }
9111
TEST(InlineAsmTestRiscv64,TestVnsrl)9112 TEST(InlineAsmTestRiscv64, TestVnsrl) {
9113 TestNarrowingVectorInstruction(
9114 ExecVnsrlwi,
9115 ExecMaskedVnsrlwi,
9116 {{32, 96, 160, 224, 33, 97, 161, 225, 34, 98, 162, 226, 35, 99, 163, 227},
9117 {36, 100, 164, 228, 37, 101, 165, 229, 38, 102, 166, 230, 39, 103, 167, 231},
9118 {40, 104, 168, 232, 41, 105, 169, 233, 42, 106, 170, 234, 43, 107, 171, 235},
9119 {44, 108, 172, 236, 45, 109, 173, 237, 46, 110, 174, 238, 47, 111, 175, 239}},
9120 {{0x5020, 0xd0a0, 0x5121, 0xd1a1, 0x5222, 0xd2a2, 0x5323, 0xd3a3},
9121 {0x5424, 0xd4a4, 0x5525, 0xd5a5, 0x5626, 0xd6a6, 0x5727, 0xd7a7},
9122 {0x5828, 0xd8a8, 0x5929, 0xd9a9, 0x5a2a, 0xdaaa, 0x5b2b, 0xdbab},
9123 {0x5c2c, 0xdcac, 0x5d2d, 0xddad, 0x5e2e, 0xdeae, 0x5f2f, 0xdfaf}},
9124 {{0x9060'5020, 0x9161'5121, 0x9262'5222, 0x9363'5323},
9125 {0x9464'5424, 0x9565'5525, 0x9666'5626, 0x9767'5727},
9126 {0x9868'5828, 0x9969'5929, 0x9a6a'5a2a, 0x9b6b'5b2b},
9127 {0x9c6c'5c2c, 0x9d6d'5d2d, 0x9e6e'5e2e, 0x9f6f'5f2f}},
9128 kVectorCalculationsSourceLegacy);
9129 TestNarrowingVectorInstruction(ExecVnsrlwx,
9130 ExecMaskedVnsrlwx,
9131 {{32, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37, 38, 38, 39, 39},
9132 {40, 40, 41, 41, 42, 42, 43, 43, 44, 44, 45, 45, 46, 46, 47, 47},
9133 {48, 48, 49, 49, 50, 50, 51, 51, 52, 52, 53, 53, 54, 54, 55, 55},
9134 {56, 56, 57, 57, 58, 58, 59, 59, 60, 60, 61, 61, 62, 62, 63, 63}},
9135 {{0xc0a0, 0xc1a1, 0xc2a2, 0xc3a3, 0xc4a4, 0xc5a5, 0xc6a6, 0xc7a7},
9136 {0xc8a8, 0xc9a9, 0xcaaa, 0xcbab, 0xccac, 0xcdad, 0xceae, 0xcfaf},
9137 {0xd0b0, 0xd1b1, 0xd2b2, 0xd3b3, 0xd4b4, 0xd5b5, 0xd6b6, 0xd7b7},
9138 {0xd8b8, 0xd9b9, 0xdaba, 0xdbbb, 0xdcbc, 0xddbd, 0xdebe, 0xdfbf}},
9139 {{0x0021'c1a1, 0x0023'c3a3, 0x0025'c5a5, 0x0027'c7a7},
9140 {0x0029'c9a9, 0x002b'cbab, 0x002d'cdad, 0x002f'cfaf},
9141 {0x0031'd1b1, 0x0033'd3b3, 0x0035'd5b5, 0x0037'd7b7},
9142 {0x0039'd9b9, 0x003b'dbbb, 0x003d'ddbd, 0x003f'dfbf}},
9143 kVectorCalculationsSourceLegacy);
9144 TestNarrowingVectorInstruction(
9145 ExecVnsrlwv,
9146 ExecMaskedVnsrlwv,
9147 {{0, 192, 80, 28, 68, 34, 8, 2, 136, 196, 81, 92, 153, 38, 9, 2},
9148 {32, 200, 82, 156, 84, 42, 10, 2, 152, 204, 83, 220, 185, 46, 11, 2},
9149 {64, 208, 84, 29, 100, 50, 12, 3, 168, 212, 85, 93, 217, 54, 13, 3},
9150 {96, 216, 86, 157, 116, 58, 14, 3, 184, 220, 87, 221, 249, 62, 15, 3}},
9151 {{0x8100, 0x6850, 0x8544, 0xf0e8, 0x4989, 0x0971, 0x009b, 0x0009},
9152 {0xa120, 0x6a52, 0x9554, 0xf2ea, 0x5999, 0x0b73, 0x00bb, 0x000b},
9153 {0xc140, 0x6c54, 0xa564, 0xf4ec, 0x69a9, 0x0d75, 0x00db, 0x000d},
9154 {0xe160, 0x6e56, 0xb574, 0xf6ee, 0x79b9, 0x0f77, 0x00fb, 0x000f}},
9155 {{0x8302'8100, 0x8645'8544, 0x4a8a'4989, 0x1e9d'1c9b},
9156 {0xa726'a524, 0x0057'9756, 0x0000'5b9b, 0x0000'00bf},
9157 {0xc342'c140, 0xa665'a564, 0x6aaa'69a9, 0x5edd'5cdb},
9158 {0xe766'e564, 0x0077'b776, 0x0000'7bbb, 0x0000'00ff}},
9159 kVectorCalculationsSourceLegacy);
9160 }
9161
ExecVremuvv()9162 [[gnu::naked]] void ExecVremuvv() {
9163 asm("vremu.vv v8, v16, v24\n\t"
9164 "ret\n\t");
9165 }
9166
ExecMaskedVremuvv()9167 [[gnu::naked]] void ExecMaskedVremuvv() {
9168 asm("vremu.vv v8, v16, v24, v0.t\n\t"
9169 "ret\n\t");
9170 }
9171
ExecVremuvx()9172 [[gnu::naked]] void ExecVremuvx() {
9173 asm("vremu.vx v8, v16, t0\n\t"
9174 "ret\n\t");
9175 }
9176
ExecMaskedVremuvx()9177 [[gnu::naked]] void ExecMaskedVremuvx() {
9178 asm("vremu.vx v8, v16, t0, v0.t\n\t"
9179 "ret\n\t");
9180 }
9181
ExecVremvv()9182 [[gnu::naked]] void ExecVremvv() {
9183 asm("vrem.vv v8, v16, v24\n\t"
9184 "ret\n\t");
9185 }
9186
ExecMaskedVremvv()9187 [[gnu::naked]] void ExecMaskedVremvv() {
9188 asm("vrem.vv v8, v16, v24, v0.t\n\t"
9189 "ret\n\t");
9190 }
9191
ExecVremvx()9192 [[gnu::naked]] void ExecVremvx() {
9193 asm("vrem.vx v8, v16, t0\n\t"
9194 "ret\n\t");
9195 }
9196
ExecMaskedVremvx()9197 [[gnu::naked]] void ExecMaskedVremvx() {
9198 asm("vrem.vx v8, v16, t0, v0.t\n\t"
9199 "ret\n\t");
9200 }
9201
TEST(InlineAsmTestRiscv64,TestVrem)9202 TEST(InlineAsmTestRiscv64, TestVrem) {
9203 TestVectorInstruction(
9204 ExecVremuvv,
9205 ExecMaskedVremuvv,
9206 {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
9207 {10, 13, 10, 13, 0, 0, 0, 0, 0, 0, 10, 13, 0, 0, 0, 0},
9208 {22, 64, 22, 64, 22, 64, 22, 64, 0, 0, 0, 0, 0, 128, 22, 64},
9209 {74, 72, 70, 68, 65, 64, 62, 60, 17, 17, 17, 17, 17, 17, 17, 17},
9210 {116, 125, 112, 121, 107, 117, 104, 113, 101, 109, 98, 105, 94, 101, 90, 97},
9211 {84, 93, 80, 89, 79, 85, 76, 81, 68, 77, 65, 73, 61, 69, 57, 65},
9212 {187, 187, 187, 169, 187, 187, 187, 169, 187, 187, 187, 169, 187, 187, 187, 169},
9213 {169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169}},
9214 {{0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
9215 {0x0d81, 0x0d81, 0x0000, 0x0000, 0x0000, 0x0d81, 0x0000, 0x0000},
9216 {0x4016, 0x4016, 0x4016, 0x4016, 0x0000, 0x0000, 0x8000, 0x4016},
9217 {0x484a, 0x4446, 0x4041, 0x3c3e, 0x1111, 0x1111, 0x1111, 0x1111},
9218 {0x7d74, 0x7970, 0x756b, 0x7168, 0x6d65, 0x6962, 0x655e, 0x615a},
9219 {0x5d54, 0x5950, 0x554f, 0x514c, 0x4d44, 0x4941, 0x453d, 0x4139},
9220 {0xbbbb, 0xa9bb, 0xbbbb, 0xa9bb, 0xbbbb, 0xa9bb, 0xbbbb, 0xa9bb},
9221 {0xa9a9, 0xa9a9, 0xa9a9, 0xa9a9, 0xa9a9, 0xa9a9, 0xa9a9, 0xa9a9}},
9222 {{0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
9223 {0x0d81'0d81, 0x0000'0000, 0x0d80'cccd, 0x0000'0000},
9224 {0x4016'4016, 0x4016'4016, 0x0000'0000, 0x4016'8000},
9225 {0x4446'484a, 0x3c3e'4041, 0x1111'1111, 0x1111'1111},
9226 {0x7970'7d74, 0x7168'756b, 0x6962'6d65, 0x615a'655e},
9227 {0x5950'5d54, 0x514c'554f, 0x4941'4d44, 0x4139'453d},
9228 {0xa9bb'bbbb, 0xa9bb'bbbb, 0xa9bb'bbbb, 0xa9bb'bbbb},
9229 {0xa9a9'a9a9, 0xa9a9'a9a9, 0xa9a9'a9a9, 0xa9a9'a9a9}},
9230 {{0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
9231 {0x1111'1110'51c5'51c6, 0x1111'1110'51c5'1112},
9232 {0x4016'4016'4016'4016, 0x4016'8000'0000'0000},
9233 {0x3c3e'4041'4446'484a, 0x1111'1111'1111'1111},
9234 {0x7168'756b'7970'7d74, 0x615a'655e'6962'6d65},
9235 {0x514c'554f'5950'5d54, 0x4139'453d'4941'4d44},
9236 {0xa9bb'bbbb'a9bb'bbbb, 0xa9bb'bbbb'a9bb'bbbb},
9237 {0xa9a9'a9a9'a9a9'a9a9, 0xa9a9'a9a9'a9a9'a9a9}},
9238 kVectorComparisonSource);
9239
9240 TestVectorInstruction(
9241 ExecVremuvx,
9242 ExecMaskedVremuvx,
9243 {{5, 70, 5, 70, 5, 70, 5, 70, 64, 64, 64, 64, 85, 85, 85, 85},
9244 {10, 64, 10, 64, 85, 85, 85, 85, 0, 0, 10, 64, 85, 85, 85, 85},
9245 {22, 64, 22, 64, 22, 64, 22, 64, 0, 0, 0, 0, 0, 128, 22, 64},
9246 {0, 0, 0, 0, 0, 0, 0, 0, 17, 17, 17, 17, 17, 17, 17, 17},
9247 {74, 85, 74, 85, 74, 85, 74, 85, 76, 85, 76, 85, 76, 85, 76, 85},
9248 {74, 85, 74, 85, 78, 85, 78, 85, 75, 85, 75, 85, 75, 85, 75, 85},
9249 {17, 17, 17, 169, 17, 17, 17, 169, 17, 17, 17, 169, 17, 17, 17, 169},
9250 {169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169}},
9251 {{0x455b, 0x455b, 0x455b, 0x455b, 0x4040, 0x4040, 0x5555, 0x5555},
9252 {0x40b4, 0x40b4, 0x5555, 0x5555, 0x0000, 0x40b4, 0x5555, 0x5555},
9253 {0x4016, 0x4016, 0x4016, 0x4016, 0x0000, 0x0000, 0x8000, 0x4016},
9254 {0x0000, 0x0000, 0x0000, 0x0000, 0x1111, 0x1111, 0x1111, 0x1111},
9255 {0x554a, 0x554a, 0x554a, 0x554a, 0x554c, 0x554c, 0x554c, 0x554c},
9256 {0x554a, 0x554a, 0x554e, 0x554e, 0x554b, 0x554b, 0x554b, 0x554b},
9257 {0x1111, 0xa9bb, 0x1111, 0xa9bb, 0x1111, 0xa9bb, 0x1111, 0xa9bb},
9258 {0xa9a9, 0xa9a9, 0xa9a9, 0xa9a9, 0xa9a9, 0xa9a9, 0xa9a9, 0xa9a9}},
9259 {{0x455b'455b, 0x455b'455b, 0x4040'4040, 0x5555'5555},
9260 {0x40b4'40b4, 0x5555'5555, 0x40b4'0000, 0x5555'5555},
9261 {0x4016'4016, 0x4016'4016, 0x0000'0000, 0x4016'8000},
9262 {0x0000'0000, 0x0000'0000, 0x1111'1111, 0x1111'1111},
9263 {0x554a'554a, 0x554a'554a, 0x554c'554c, 0x554c'554c},
9264 {0x554a'554a, 0x554e'554e, 0x554b'554b, 0x554b'554b},
9265 {0xa9bb'bbbb, 0xa9bb'bbbb, 0xa9bb'bbbb, 0xa9bb'bbbb},
9266 {0xa9a9'a9a9, 0xa9a9'a9a9, 0xa9a9'a9a9, 0xa9a9'a9a9}},
9267 {{0x455b'455b'455b'455b, 0x5555'5554'9595'9596},
9268 {0x5555'5554'9609'960a, 0x5555'5554'9609'5556},
9269 {0x4016'4016'4016'4016, 0x4016'8000'0000'0000},
9270 {0x0000'0000'0000'0000, 0x1111'1111'1111'1111},
9271 {0x554a'554a'554a'554a, 0x554c'554c'554c'554c},
9272 {0x554e'554e'554a'554a, 0x554b'554b'554b'554b},
9273 {0xa9bb'bbbb'a9bb'bbbb, 0xa9bb'bbbb'a9bb'bbbb},
9274 {0xa9a9'a9a9'a9a9'a9a9, 0xa9a9'a9a9'a9a9'a9a9}},
9275 kVectorComparisonSource);
9276
9277 TestVectorInstruction(
9278 ExecVremvv,
9279 ExecMaskedVremvv,
9280 {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
9281 {248, 13, 248, 13, 255, 255, 255, 255, 0, 0, 248, 13, 255, 255, 255, 255},
9282 {7, 0, 7, 0, 7, 0, 7, 0, 0, 0, 0, 0, 0, 0, 7, 0},
9283 {170, 170, 170, 170, 170, 170, 170, 170, 17, 17, 17, 17, 17, 17, 17, 17},
9284 {244, 255, 244, 255, 244, 255, 244, 255, 246, 255, 246, 255, 246, 255, 246, 255},
9285 {244, 255, 244, 255, 248, 255, 248, 255, 245, 255, 245, 255, 245, 255, 245, 255},
9286 {251, 249, 247, 227, 242, 241, 239, 219, 234, 233, 231, 253, 227, 225, 223, 237},
9287 {233, 229, 253, 247, 238, 235, 249, 241, 244, 253, 253, 249, 249, 253, 253, 255}},
9288 {{0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
9289 {0x0d81, 0x0d81, 0xffff, 0xffff, 0x0000, 0x0d81, 0xffff, 0xffff},
9290 {0x000b, 0x000b, 0x000b, 0x000b, 0x0000, 0x0000, 0xfff8, 0x000b},
9291 {0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0x1111, 0x1111, 0x1111, 0x1111},
9292 {0xfff4, 0xfff4, 0xfff4, 0xfff4, 0xfff6, 0xfff6, 0xfff6, 0xfff6},
9293 {0xfff4, 0xfff4, 0xfff8, 0xfff8, 0xfff5, 0xfff5, 0xfff5, 0xfff5},
9294 {0xf8fb, 0xe2f7, 0xf0f2, 0xdaef, 0xe8ea, 0xfc13, 0xe0e3, 0xec03},
9295 {0xe3e9, 0xf4fd, 0xfe05, 0xff0d, 0xf803, 0xfb15, 0xff31, 0xfffd}},
9296 {{0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
9297 {0x0d81'0d81, 0xffff'ffff, 0x0d80'cccd, 0xffff'ffff},
9298 {0x000b'fb79, 0x000b'fb79, 0x0000'0000, 0x000c'3b63},
9299 {0xaaaa'aaaa, 0xaaaa'aaaa, 0x1111'1111, 0x1111'1111},
9300 {0xfff4'fff4, 0xfff4'fff4, 0xfff6'fff6, 0xfff6'fff6},
9301 {0xfff4'fff4, 0xfff8'fff8, 0xfff5'fff5, 0xfff5'fff5},
9302 {0xe2f6'f8fb, 0xdaee'f0f2, 0xfc12'1619, 0xec02'060b},
9303 {0xf4fb'0109, 0xff09'131c, 0xfb0d'1f30, 0xffaa'5551}},
9304 {{0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
9305 {0xffff'ffff'40b4'40b4, 0xffff'ffff'40b4'0000},
9306 {0x000c'000c'000b'fb79, 0x000c'3ff5'bff5'bb63},
9307 {0xaaaa'aaaa'aaaa'aaaa, 0x1111'1111'1111'1111},
9308 {0xfff4'fff4'fff4'fff4, 0xfff6'fff6'fff6'fff6},
9309 {0xfff8'fff8'fff4'fff4, 0xfff5'fff5'fff5'fff5},
9310 {0xdaee'f0f1'e2f6'f8fb, 0xec02'0609'fc12'1619},
9311 {0xff09'1318'2731'3b49, 0xffaa'54ff'aa54'ffa4}},
9312 kVectorComparisonSource);
9313
9314 TestVectorInstruction(
9315 ExecVremvx,
9316 ExecMaskedVremvx,
9317 {{5, 240, 5, 240, 5, 240, 5, 240, 64, 64, 64, 64, 255, 255, 255, 255},
9318 {180, 64, 180, 64, 255, 255, 255, 255, 0, 0, 180, 64, 255, 255, 255, 255},
9319 {22, 64, 22, 64, 22, 64, 22, 64, 0, 0, 0, 0, 0, 214, 22, 64},
9320 {0, 0, 0, 0, 0, 0, 0, 0, 17, 17, 17, 17, 17, 17, 17, 17},
9321 {244, 255, 244, 255, 244, 255, 244, 255, 246, 255, 246, 255, 246, 255, 246, 255},
9322 {244, 255, 244, 255, 248, 255, 248, 255, 245, 255, 245, 255, 245, 255, 245, 255},
9323 {187, 187, 187, 255, 187, 187, 187, 255, 187, 187, 187, 255, 187, 187, 187, 255},
9324 {255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}},
9325 {{0xf005, 0xf005, 0xf005, 0xf005, 0x4040, 0x4040, 0xffff, 0xffff},
9326 {0x40b4, 0x40b4, 0xffff, 0xffff, 0x0000, 0x40b4, 0xffff, 0xffff},
9327 {0x4016, 0x4016, 0x4016, 0x4016, 0x0000, 0x0000, 0xd556, 0x4016},
9328 {0x0000, 0x0000, 0x0000, 0x0000, 0x1111, 0x1111, 0x1111, 0x1111},
9329 {0xfff4, 0xfff4, 0xfff4, 0xfff4, 0xfff6, 0xfff6, 0xfff6, 0xfff6},
9330 {0xfff4, 0xfff4, 0xfff8, 0xfff8, 0xfff5, 0xfff5, 0xfff5, 0xfff5},
9331 {0xbbbb, 0xff11, 0xbbbb, 0xff11, 0xbbbb, 0xff11, 0xbbbb, 0xff11},
9332 {0xfeff, 0xfeff, 0xfeff, 0xfeff, 0xfeff, 0xfeff, 0xfeff, 0xfeff}},
9333 {{0xf005'f005, 0xf005'f005, 0x4040'4040, 0xffff'ffff},
9334 {0x40b4'40b4, 0xffff'ffff, 0x40b4'0000, 0xffff'ffff},
9335 {0x4016'4016, 0x4016'4016, 0x0000'0000, 0x4016'8000},
9336 {0x0000'0000, 0x0000'0000, 0x1111'1111, 0x1111'1111},
9337 {0xfff4'fff4, 0xfff4'fff4, 0xfff6'fff6, 0xfff6'fff6},
9338 {0xfff4'fff4, 0xfff8'fff8, 0xfff5'fff5, 0xfff5'fff5},
9339 {0xff11'1111, 0xff11'1111, 0xff11'1111, 0xff11'1111},
9340 {0xfefe'feff, 0xfefe'feff, 0xfefe'feff, 0xfefe'feff}},
9341 {{0xf005'f005'f005'f005, 0xffff'ffff'4040'4040},
9342 {0xffff'ffff'40b4'40b4, 0xffff'ffff'40b4'0000},
9343 {0x4016'4016'4016'4016, 0x4016'8000'0000'0000},
9344 {0x0000'0000'0000'0000, 0x1111'1111'1111'1111},
9345 {0xfff4'fff4'fff4'fff4, 0xfff6'fff6'fff6'fff6},
9346 {0xfff8'fff8'fff4'fff4, 0xfff5'fff5'fff5'fff5},
9347 {0xff11'1110'ff11'1111, 0xff11'1110'ff11'1111},
9348 {0xfefe'fefe'fefe'feff, 0xfefe'fefe'fefe'feff}},
9349 kVectorComparisonSource);
9350 }
9351
ExecVslide1upvx()9352 [[gnu::naked]] void ExecVslide1upvx() {
9353 asm("vslide1up.vx v8, v24, t0\n\t"
9354 "ret\n\t");
9355 }
9356
ExecMaskedVslide1upvx()9357 [[gnu::naked]] void ExecMaskedVslide1upvx() {
9358 asm("vslide1up.vx v8, v24, t0, v0.t\n\t"
9359 "ret\n\t");
9360 }
9361
TEST(InlineAsmTestRiscv64,TestVslide1up)9362 TEST(InlineAsmTestRiscv64, TestVslide1up) {
9363 TestVectorInstruction(
9364 ExecVslide1upvx,
9365 ExecMaskedVslide1upvx,
9366 {{0xaa, 0, 2, 4, 6, 9, 10, 12, 14, 17, 18, 20, 22, 24, 26, 28},
9367 {30, 32, 34, 36, 38, 41, 42, 44, 46, 49, 50, 52, 54, 56, 58, 60},
9368 {62, 64, 66, 68, 70, 73, 74, 76, 78, 81, 82, 84, 86, 88, 90, 92},
9369 {94, 96, 98, 100, 102, 105, 106, 108, 110, 113, 114, 116, 118, 120, 122, 124},
9370 {126, 128, 130, 132, 134, 137, 138, 140, 142, 145, 146, 148, 150, 152, 154, 156},
9371 {158, 160, 162, 164, 166, 169, 170, 172, 174, 177, 178, 180, 182, 184, 186, 188},
9372 {190, 192, 194, 196, 198, 201, 202, 204, 206, 209, 210, 212, 214, 216, 218, 220},
9373 {222, 224, 226, 228, 230, 233, 234, 236, 238, 241, 242, 244, 246, 248, 250, 252}},
9374 {{0xaaaa, 0x0200, 0x0604, 0x0a09, 0x0e0c, 0x1211, 0x1614, 0x1a18},
9375 {0x1e1c, 0x2220, 0x2624, 0x2a29, 0x2e2c, 0x3231, 0x3634, 0x3a38},
9376 {0x3e3c, 0x4240, 0x4644, 0x4a49, 0x4e4c, 0x5251, 0x5654, 0x5a58},
9377 {0x5e5c, 0x6260, 0x6664, 0x6a69, 0x6e6c, 0x7271, 0x7674, 0x7a78},
9378 {0x7e7c, 0x8280, 0x8684, 0x8a89, 0x8e8c, 0x9291, 0x9694, 0x9a98},
9379 {0x9e9c, 0xa2a0, 0xa6a4, 0xaaa9, 0xaeac, 0xb2b1, 0xb6b4, 0xbab8},
9380 {0xbebc, 0xc2c0, 0xc6c4, 0xcac9, 0xcecc, 0xd2d1, 0xd6d4, 0xdad8},
9381 {0xdedc, 0xe2e0, 0xe6e4, 0xeae9, 0xeeec, 0xf2f1, 0xf6f4, 0xfaf8}},
9382 {{0xaaaa'aaaa, 0x0604'0200, 0x0e0c'0a09, 0x1614'1211},
9383 {0x1e1c'1a18, 0x2624'2220, 0x2e2c'2a29, 0x3634'3231},
9384 {0x3e3c'3a38, 0x4644'4240, 0x4e4c'4a49, 0x5654'5251},
9385 {0x5e5c'5a58, 0x6664'6260, 0x6e6c'6a69, 0x7674'7271},
9386 {0x7e7c'7a78, 0x8684'8280, 0x8e8c'8a89, 0x9694'9291},
9387 {0x9e9c'9a98, 0xa6a4'a2a0, 0xaeac'aaa9, 0xb6b4'b2b1},
9388 {0xbebc'bab8, 0xc6c4'c2c0, 0xcecc'cac9, 0xd6d4'd2d1},
9389 {0xdedc'dad8, 0xe6e4'e2e0, 0xeeec'eae9, 0xf6f4'f2f1}},
9390 {{0xaaaa'aaaa'aaaa'aaaa, 0x0e0c'0a09'0604'0200},
9391 {0x1e1c'1a18'1614'1211, 0x2e2c'2a29'2624'2220},
9392 {0x3e3c'3a38'3634'3231, 0x4e4c'4a49'4644'4240},
9393 {0x5e5c'5a58'5654'5251, 0x6e6c'6a69'6664'6260},
9394 {0x7e7c'7a78'7674'7271, 0x8e8c'8a89'8684'8280},
9395 {0x9e9c'9a98'9694'9291, 0xaeac'aaa9'a6a4'a2a0},
9396 {0xbebc'bab8'b6b4'b2b1, 0xcecc'cac9'c6c4'c2c0},
9397 {0xdedc'dad8'd6d4'd2d1, 0xeeec'eae9'e6e4'e2e0}},
9398 kVectorCalculationsSourceLegacy);
9399 }
9400
ExecVsllvv()9401 [[gnu::naked]] void ExecVsllvv() {
9402 asm("vsll.vv v8, v16, v24\n\t"
9403 "ret\n\t");
9404 }
9405
ExecMaskedVsllvv()9406 [[gnu::naked]] void ExecMaskedVsllvv() {
9407 asm("vsll.vv v8, v16, v24, v0.t\n\t"
9408 "ret\n\t");
9409 }
9410
ExecVsllvx()9411 [[gnu::naked]] void ExecVsllvx() {
9412 asm("vsll.vx v8, v16, t0\n\t"
9413 "ret\n\t");
9414 }
9415
ExecMaskedVsllvx()9416 [[gnu::naked]] void ExecMaskedVsllvx() {
9417 asm("vsll.vx v8, v16, t0, v0.t\n\t"
9418 "ret\n\t");
9419 }
9420
ExecVsllvi()9421 [[gnu::naked]] void ExecVsllvi() {
9422 asm("vsll.vi v8, v16, 0xb\n\t"
9423 "ret\n\t");
9424 }
9425
ExecMaskedVsllvi()9426 [[gnu::naked]] void ExecMaskedVsllvi() {
9427 asm("vsll.vi v8, v16, 0xb, v0.t\n\t"
9428 "ret\n\t");
9429 }
9430
TEST(InlineAsmTestRiscv64,TestVsll)9431 TEST(InlineAsmTestRiscv64, TestVsll) {
9432 TestVectorInstruction(
9433 ExecVsllvv,
9434 ExecMaskedVsllvv,
9435 {{0, 4, 32, 192, 8, 20, 96, 192, 16, 36, 160, 192, 12, 52, 224, 192},
9436 {16, 68, 32, 192, 40, 84, 96, 192, 48, 100, 160, 192, 28, 116, 224, 192},
9437 {32, 132, 32, 192, 72, 148, 96, 192, 80, 164, 160, 192, 44, 180, 224, 192},
9438 {48, 196, 32, 192, 104, 212, 96, 192, 112, 228, 160, 192, 60, 244, 224, 192},
9439 {64, 4, 32, 192, 136, 20, 96, 192, 144, 36, 160, 192, 76, 52, 224, 192},
9440 {80, 68, 32, 192, 168, 84, 96, 192, 176, 100, 160, 192, 92, 116, 224, 192},
9441 {96, 132, 32, 192, 200, 148, 96, 192, 208, 164, 160, 192, 108, 180, 224, 192},
9442 {112, 196, 32, 192, 232, 212, 96, 192, 240, 228, 160, 192, 124, 244, 224, 192}},
9443 {{0x8100, 0x3020, 0x0800, 0x6000, 0x1210, 0xb0a0, 0x0c00, 0xe000},
9444 {0x9110, 0x3120, 0x2800, 0x6000, 0x3230, 0xb1a0, 0x1c00, 0xe000},
9445 {0xa120, 0x3220, 0x4800, 0x6000, 0x5250, 0xb2a0, 0x2c00, 0xe000},
9446 {0xb130, 0x3320, 0x6800, 0x6000, 0x7270, 0xb3a0, 0x3c00, 0xe000},
9447 {0xc140, 0x3420, 0x8800, 0x6000, 0x9290, 0xb4a0, 0x4c00, 0xe000},
9448 {0xd150, 0x3520, 0xa800, 0x6000, 0xb2b0, 0xb5a0, 0x5c00, 0xe000},
9449 {0xe160, 0x3620, 0xc800, 0x6000, 0xd2d0, 0xb6a0, 0x6c00, 0xe000},
9450 {0xf170, 0x3720, 0xe800, 0x6000, 0xf2f0, 0xb7a0, 0x7c00, 0xe000}},
9451 {{0x8302'8100, 0x0d0a'0800, 0x1210'0000, 0x0c00'0000},
9452 {0x9312'9110, 0x2d2a'2800, 0x3230'0000, 0x1c00'0000},
9453 {0xa322'a120, 0x4d4a'4800, 0x5250'0000, 0x2c00'0000},
9454 {0xb332'b130, 0x6d6a'6800, 0x7270'0000, 0x3c00'0000},
9455 {0xc342'c140, 0x8d8a'8800, 0x9290'0000, 0x4c00'0000},
9456 {0xd352'd150, 0xadaa'a800, 0xb2b0'0000, 0x5c00'0000},
9457 {0xe362'e160, 0xcdca'c800, 0xd2d0'0000, 0x6c00'0000},
9458 {0xf372'f170, 0xedea'e800, 0xf2f0'0000, 0x7c00'0000}},
9459 {{0x8706'8504'8302'8100, 0x1a19'1615'1210'0000},
9460 {0x9312'9110'0000'0000, 0x3230'0000'0000'0000},
9461 {0xa726'a524'a322'a120, 0x5a59'5655'5250'0000},
9462 {0xb332'b130'0000'0000, 0x7270'0000'0000'0000},
9463 {0xc746'c544'c342'c140, 0x9a99'9695'9290'0000},
9464 {0xd352'd150'0000'0000, 0xb2b0'0000'0000'0000},
9465 {0xe766'e564'e362'e160, 0xdad9'd6d5'd2d0'0000},
9466 {0xf372'f170'0000'0000, 0xf2f0'0000'0000'0000}},
9467 kVectorCalculationsSourceLegacy);
9468 TestVectorInstruction(
9469 ExecVsllvx,
9470 ExecMaskedVsllvx,
9471 {{0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 60},
9472 {64, 68, 72, 76, 80, 84, 88, 92, 96, 100, 104, 108, 112, 116, 120, 124},
9473 {128, 132, 136, 140, 144, 148, 152, 156, 160, 164, 168, 172, 176, 180, 184, 188},
9474 {192, 196, 200, 204, 208, 212, 216, 220, 224, 228, 232, 236, 240, 244, 248, 252},
9475 {0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 60},
9476 {64, 68, 72, 76, 80, 84, 88, 92, 96, 100, 104, 108, 112, 116, 120, 124},
9477 {128, 132, 136, 140, 144, 148, 152, 156, 160, 164, 168, 172, 176, 180, 184, 188},
9478 {192, 196, 200, 204, 208, 212, 216, 220, 224, 228, 232, 236, 240, 244, 248, 252}},
9479 {{0x0000, 0x0800, 0x1000, 0x1800, 0x2000, 0x2800, 0x3000, 0x3800},
9480 {0x4000, 0x4800, 0x5000, 0x5800, 0x6000, 0x6800, 0x7000, 0x7800},
9481 {0x8000, 0x8800, 0x9000, 0x9800, 0xa000, 0xa800, 0xb000, 0xb800},
9482 {0xc000, 0xc800, 0xd000, 0xd800, 0xe000, 0xe800, 0xf000, 0xf800},
9483 {0x0000, 0x0800, 0x1000, 0x1800, 0x2000, 0x2800, 0x3000, 0x3800},
9484 {0x4000, 0x4800, 0x5000, 0x5800, 0x6000, 0x6800, 0x7000, 0x7800},
9485 {0x8000, 0x8800, 0x9000, 0x9800, 0xa000, 0xa800, 0xb000, 0xb800},
9486 {0xc000, 0xc800, 0xd000, 0xd800, 0xe000, 0xe800, 0xf000, 0xf800}},
9487 {{0x0a04'0000, 0x1a14'1000, 0x2a24'2000, 0x3a34'3000},
9488 {0x4a44'4000, 0x5a54'5000, 0x6a64'6000, 0x7a74'7000},
9489 {0x8a84'8000, 0x9a94'9000, 0xaaa4'a000, 0xbab4'b000},
9490 {0xcac4'c000, 0xdad4'd000, 0xeae4'e000, 0xfaf4'f000},
9491 {0x0b05'0000, 0x1b15'1000, 0x2b25'2000, 0x3b35'3000},
9492 {0x4b45'4000, 0x5b55'5000, 0x6b65'6000, 0x7b75'7000},
9493 {0x8b85'8000, 0x9b95'9000, 0xaba5'a000, 0xbbb5'b000},
9494 {0xcbc5'c000, 0xdbd5'd000, 0xebe5'e000, 0xfbf5'f000}},
9495 {{0x0a04'0000'0000'0000, 0x2a24'2000'0000'0000},
9496 {0x4a44'4000'0000'0000, 0x6a64'6000'0000'0000},
9497 {0x8a84'8000'0000'0000, 0xaaa4'a000'0000'0000},
9498 {0xcac4'c000'0000'0000, 0xeae4'e000'0000'0000},
9499 {0x0b05'0000'0000'0000, 0x2b25'2000'0000'0000},
9500 {0x4b45'4000'0000'0000, 0x6b65'6000'0000'0000},
9501 {0x8b85'8000'0000'0000, 0xaba5'a000'0000'0000},
9502 {0xcbc5'c000'0000'0000, 0xebe5'e000'0000'0000}},
9503 kVectorCalculationsSourceLegacy);
9504 TestVectorInstruction(
9505 ExecVsllvi,
9506 ExecMaskedVsllvi,
9507 {{0, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120},
9508 {128, 136, 144, 152, 160, 168, 176, 184, 192, 200, 208, 216, 224, 232, 240, 248},
9509 {0, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120},
9510 {128, 136, 144, 152, 160, 168, 176, 184, 192, 200, 208, 216, 224, 232, 240, 248},
9511 {0, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120},
9512 {128, 136, 144, 152, 160, 168, 176, 184, 192, 200, 208, 216, 224, 232, 240, 248},
9513 {0, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120},
9514 {128, 136, 144, 152, 160, 168, 176, 184, 192, 200, 208, 216, 224, 232, 240, 248}},
9515 {{0x0000, 0x1000, 0x2000, 0x3000, 0x4000, 0x5000, 0x6000, 0x7000},
9516 {0x8000, 0x9000, 0xa000, 0xb000, 0xc000, 0xd000, 0xe000, 0xf000},
9517 {0x0000, 0x1000, 0x2000, 0x3000, 0x4000, 0x5000, 0x6000, 0x7000},
9518 {0x8000, 0x9000, 0xa000, 0xb000, 0xc000, 0xd000, 0xe000, 0xf000},
9519 {0x0000, 0x1000, 0x2000, 0x3000, 0x4000, 0x5000, 0x6000, 0x7000},
9520 {0x8000, 0x9000, 0xa000, 0xb000, 0xc000, 0xd000, 0xe000, 0xf000},
9521 {0x0000, 0x1000, 0x2000, 0x3000, 0x4000, 0x5000, 0x6000, 0x7000},
9522 {0x8000, 0x9000, 0xa000, 0xb000, 0xc000, 0xd000, 0xe000, 0xf000}},
9523 {{0x1408'0000, 0x3428'2000, 0x5448'4000, 0x7468'6000},
9524 {0x9488'8000, 0xb4a8'a000, 0xd4c8'c000, 0xf4e8'e000},
9525 {0x1509'0000, 0x3529'2000, 0x5549'4000, 0x7569'6000},
9526 {0x9589'8000, 0xb5a9'a000, 0xd5c9'c000, 0xf5e9'e000},
9527 {0x160a'0000, 0x362a'2000, 0x564a'4000, 0x766a'6000},
9528 {0x968a'8000, 0xb6aa'a000, 0xd6ca'c000, 0xf6ea'e000},
9529 {0x170b'0000, 0x372b'2000, 0x574b'4000, 0x776b'6000},
9530 {0x978b'8000, 0xb7ab'a000, 0xd7cb'c000, 0xf7eb'e000}},
9531 {{0x3428'2418'1408'0000, 0x7468'6458'5448'4000},
9532 {0xb4a8'a498'9488'8000, 0xf4e8'e4d8'd4c8'c000},
9533 {0x3529'2519'1509'0000, 0x7569'6559'5549'4000},
9534 {0xb5a9'a599'9589'8000, 0xf5e9'e5d9'd5c9'c000},
9535 {0x362a'261a'160a'0000, 0x766a'665a'564a'4000},
9536 {0xb6aa'a69a'968a'8000, 0xf6ea'e6da'd6ca'c000},
9537 {0x372b'271b'170b'0000, 0x776b'675b'574b'4000},
9538 {0xb7ab'a79b'978b'8000, 0xf7eb'e7db'd7cb'c000}},
9539 kVectorCalculationsSourceLegacy);
9540 }
9541
ExecVsravv()9542 [[gnu::naked]] void ExecVsravv() {
9543 asm("vsra.vv v8, v16, v24\n\t"
9544 "ret\n\t");
9545 }
9546
ExecMaskedVsravv()9547 [[gnu::naked]] void ExecMaskedVsravv() {
9548 asm("vsra.vv v8, v16, v24, v0.t\n\t"
9549 "ret\n\t");
9550 }
9551
ExecVsravx()9552 [[gnu::naked]] void ExecVsravx() {
9553 asm("vsra.vx v8, v16, t0\n\t"
9554 "ret\n\t");
9555 }
9556
ExecMaskedVsravx()9557 [[gnu::naked]] void ExecMaskedVsravx() {
9558 asm("vsra.vx v8, v16, t0, v0.t\n\t"
9559 "ret\n\t");
9560 }
9561
ExecVsravi()9562 [[gnu::naked]] void ExecVsravi() {
9563 asm("vsra.vi v8, v16, 0x3\n\t"
9564 "ret\n\t");
9565 }
9566
ExecMaskedVsravi()9567 [[gnu::naked]] void ExecMaskedVsravi() {
9568 asm("vsra.vi v8, v16, 0x3, v0.t\n\t"
9569 "ret\n\t");
9570 }
9571
TEST(InlineAsmTestRiscv64,TestVsra)9572 TEST(InlineAsmTestRiscv64, TestVsra) {
9573 TestVectorInstruction(ExecVsravv,
9574 ExecMaskedVsravv,
9575 {{0, 224, 0, 254, 2, 225, 0, 254, 4, 226, 0, 254, 12, 227, 0, 254},
9576 {16, 228, 1, 254, 10, 229, 1, 254, 12, 230, 1, 254, 28, 231, 1, 254},
9577 {32, 232, 2, 254, 18, 233, 2, 254, 20, 234, 2, 254, 44, 235, 2, 254},
9578 {48, 236, 3, 254, 26, 237, 3, 254, 28, 238, 3, 254, 60, 239, 3, 254},
9579 {64, 240, 4, 255, 34, 241, 4, 255, 36, 242, 4, 255, 76, 243, 4, 255},
9580 {80, 244, 5, 255, 42, 245, 5, 255, 44, 246, 5, 255, 92, 247, 5, 255},
9581 {96, 248, 6, 255, 50, 249, 6, 255, 52, 250, 6, 255, 108, 251, 6, 255},
9582 {112, 252, 7, 255, 58, 253, 7, 255, 60, 254, 7, 255, 124, 255, 7, 255}},
9583 {{0x8100, 0xf830, 0xffc2, 0xfff8, 0xc484, 0xf8b0, 0xff8d, 0xfff8},
9584 {0x9110, 0xf931, 0xffca, 0xfff9, 0xcc8c, 0xf9b1, 0xff9d, 0xfff9},
9585 {0xa120, 0xfa32, 0xffd2, 0xfffa, 0xd494, 0xfab2, 0xffad, 0xfffa},
9586 {0xb130, 0xfb33, 0xffda, 0xfffb, 0xdc9c, 0xfbb3, 0xffbd, 0xfffb},
9587 {0xc140, 0xfc34, 0xffe2, 0xfffc, 0xe4a4, 0xfcb4, 0xffcd, 0xfffc},
9588 {0xd150, 0xfd35, 0xffea, 0xfffd, 0xecac, 0xfdb5, 0xffdd, 0xfffd},
9589 {0xe160, 0xfe36, 0xfff2, 0xfffe, 0xf4b4, 0xfeb6, 0xffed, 0xfffe},
9590 {0xf170, 0xff37, 0xfffa, 0xffff, 0xfcbc, 0xffb7, 0xfffd, 0xffff}},
9591 {{0x8302'8100, 0xffc3'8342, 0xffff'c585, 0xffff'ff8f},
9592 {0x9312'9110, 0xffcb'8b4a, 0xffff'cd8d, 0xffff'ff9f},
9593 {0xa322'a120, 0xffd3'9352, 0xffff'd595, 0xffff'ffaf},
9594 {0xb332'b130, 0xffdb'9b5a, 0xffff'dd9d, 0xffff'ffbf},
9595 {0xc342'c140, 0xffe3'a362, 0xffff'e5a5, 0xffff'ffcf},
9596 {0xd352'd150, 0xffeb'ab6a, 0xffff'edad, 0xffff'ffdf},
9597 {0xe362'e160, 0xfff3'b372, 0xffff'f5b5, 0xffff'ffef},
9598 {0xf372'f170, 0xfffb'bb7a, 0xffff'fdbd, 0xffff'ffff}},
9599 {{0x8706'8504'8302'8100, 0xffff'c787'4686'4585},
9600 {0xffff'ffff'9716'9514, 0xffff'ffff'ffff'cf8f},
9601 {0xa726'a524'a322'a120, 0xffff'd797'5696'5595},
9602 {0xffff'ffff'b736'b534, 0xffff'ffff'ffff'df9f},
9603 {0xc746'c544'c342'c140, 0xffff'e7a7'66a6'65a5},
9604 {0xffff'ffff'd756'd554, 0xffff'ffff'ffff'efaf},
9605 {0xe766'e564'e362'e160, 0xffff'f7b7'76b6'75b5},
9606 {0xffff'ffff'f776'f574, 0xffff'ffff'ffff'ffbf}},
9607 kVectorCalculationsSourceLegacy);
9608 TestVectorInstruction(ExecVsravx,
9609 ExecMaskedVsravx,
9610 {{0, 224, 0, 224, 1, 225, 1, 225, 2, 226, 2, 226, 3, 227, 3, 227},
9611 {4, 228, 4, 228, 5, 229, 5, 229, 6, 230, 6, 230, 7, 231, 7, 231},
9612 {8, 232, 8, 232, 9, 233, 9, 233, 10, 234, 10, 234, 11, 235, 11, 235},
9613 {12, 236, 12, 236, 13, 237, 13, 237, 14, 238, 14, 238, 15, 239, 15, 239},
9614 {16, 240, 16, 240, 17, 241, 17, 241, 18, 242, 18, 242, 19, 243, 19, 243},
9615 {20, 244, 20, 244, 21, 245, 21, 245, 22, 246, 22, 246, 23, 247, 23, 247},
9616 {24, 248, 24, 248, 25, 249, 25, 249, 26, 250, 26, 250, 27, 251, 27, 251},
9617 {28, 252, 28, 252, 29, 253, 29, 253, 30, 254, 30, 254, 31, 255, 31, 255}},
9618 {{0xffe0, 0xffe0, 0xffe1, 0xffe1, 0xffe2, 0xffe2, 0xffe3, 0xffe3},
9619 {0xffe4, 0xffe4, 0xffe5, 0xffe5, 0xffe6, 0xffe6, 0xffe7, 0xffe7},
9620 {0xffe8, 0xffe8, 0xffe9, 0xffe9, 0xffea, 0xffea, 0xffeb, 0xffeb},
9621 {0xffec, 0xffec, 0xffed, 0xffed, 0xffee, 0xffee, 0xffef, 0xffef},
9622 {0xfff0, 0xfff0, 0xfff1, 0xfff1, 0xfff2, 0xfff2, 0xfff3, 0xfff3},
9623 {0xfff4, 0xfff4, 0xfff5, 0xfff5, 0xfff6, 0xfff6, 0xfff7, 0xfff7},
9624 {0xfff8, 0xfff8, 0xfff9, 0xfff9, 0xfffa, 0xfffa, 0xfffb, 0xfffb},
9625 {0xfffc, 0xfffc, 0xfffd, 0xfffd, 0xfffe, 0xfffe, 0xffff, 0xffff}},
9626 {{0xffe0'c0a0, 0xffe1'c1a1, 0xffe2'c2a2, 0xffe3'c3a3},
9627 {0xffe4'c4a4, 0xffe5'c5a5, 0xffe6'c6a6, 0xffe7'c7a7},
9628 {0xffe8'c8a8, 0xffe9'c9a9, 0xffea'caaa, 0xffeb'cbab},
9629 {0xffec'ccac, 0xffed'cdad, 0xffee'ceae, 0xffef'cfaf},
9630 {0xfff0'd0b0, 0xfff1'd1b1, 0xfff2'd2b2, 0xfff3'd3b3},
9631 {0xfff4'd4b4, 0xfff5'd5b5, 0xfff6'd6b6, 0xfff7'd7b7},
9632 {0xfff8'd8b8, 0xfff9'd9b9, 0xfffa'daba, 0xfffb'dbbb},
9633 {0xfffc'dcbc, 0xfffd'ddbd, 0xfffe'debe, 0xffff'dfbf}},
9634 {{0xffff'ffff'ffe1'c1a1, 0xffff'ffff'ffe3'c3a3},
9635 {0xffff'ffff'ffe5'c5a5, 0xffff'ffff'ffe7'c7a7},
9636 {0xffff'ffff'ffe9'c9a9, 0xffff'ffff'ffeb'cbab},
9637 {0xffff'ffff'ffed'cdad, 0xffff'ffff'ffef'cfaf},
9638 {0xffff'ffff'fff1'd1b1, 0xffff'ffff'fff3'd3b3},
9639 {0xffff'ffff'fff5'd5b5, 0xffff'ffff'fff7'd7b7},
9640 {0xffff'ffff'fff9'd9b9, 0xffff'ffff'fffb'dbbb},
9641 {0xffff'ffff'fffd'ddbd, 0xffff'ffff'ffff'dfbf}},
9642 kVectorCalculationsSourceLegacy);
9643 TestVectorInstruction(ExecVsravi,
9644 ExecMaskedVsravi,
9645 {{0, 240, 0, 240, 0, 240, 0, 240, 1, 241, 1, 241, 1, 241, 1, 241},
9646 {2, 242, 2, 242, 2, 242, 2, 242, 3, 243, 3, 243, 3, 243, 3, 243},
9647 {4, 244, 4, 244, 4, 244, 4, 244, 5, 245, 5, 245, 5, 245, 5, 245},
9648 {6, 246, 6, 246, 6, 246, 6, 246, 7, 247, 7, 247, 7, 247, 7, 247},
9649 {8, 248, 8, 248, 8, 248, 8, 248, 9, 249, 9, 249, 9, 249, 9, 249},
9650 {10, 250, 10, 250, 10, 250, 10, 250, 11, 251, 11, 251, 11, 251, 11, 251},
9651 {12, 252, 12, 252, 12, 252, 12, 252, 13, 253, 13, 253, 13, 253, 13, 253},
9652 {14, 254, 14, 254, 14, 254, 14, 254, 15, 255, 15, 255, 15, 255, 15, 255}},
9653 {{0xf020, 0xf060, 0xf0a0, 0xf0e0, 0xf121, 0xf161, 0xf1a1, 0xf1e1},
9654 {0xf222, 0xf262, 0xf2a2, 0xf2e2, 0xf323, 0xf363, 0xf3a3, 0xf3e3},
9655 {0xf424, 0xf464, 0xf4a4, 0xf4e4, 0xf525, 0xf565, 0xf5a5, 0xf5e5},
9656 {0xf626, 0xf666, 0xf6a6, 0xf6e6, 0xf727, 0xf767, 0xf7a7, 0xf7e7},
9657 {0xf828, 0xf868, 0xf8a8, 0xf8e8, 0xf929, 0xf969, 0xf9a9, 0xf9e9},
9658 {0xfa2a, 0xfa6a, 0xfaaa, 0xfaea, 0xfb2b, 0xfb6b, 0xfbab, 0xfbeb},
9659 {0xfc2c, 0xfc6c, 0xfcac, 0xfcec, 0xfd2d, 0xfd6d, 0xfdad, 0xfded},
9660 {0xfe2e, 0xfe6e, 0xfeae, 0xfeee, 0xff2f, 0xff6f, 0xffaf, 0xffef}},
9661 {{0xf060'5020, 0xf0e0'd0a0, 0xf161'5121, 0xf1e1'd1a1},
9662 {0xf262'5222, 0xf2e2'd2a2, 0xf363'5323, 0xf3e3'd3a3},
9663 {0xf464'5424, 0xf4e4'd4a4, 0xf565'5525, 0xf5e5'd5a5},
9664 {0xf666'5626, 0xf6e6'd6a6, 0xf767'5727, 0xf7e7'd7a7},
9665 {0xf868'5828, 0xf8e8'd8a8, 0xf969'5929, 0xf9e9'd9a9},
9666 {0xfa6a'5a2a, 0xfaea'daaa, 0xfb6b'5b2b, 0xfbeb'dbab},
9667 {0xfc6c'5c2c, 0xfcec'dcac, 0xfd6d'5d2d, 0xfded'ddad},
9668 {0xfe6e'5e2e, 0xfeee'deae, 0xff6f'5f2f, 0xffef'dfaf}},
9669 {{0xf0e0'd0a0'9060'5020, 0xf1e1'd1a1'9161'5121},
9670 {0xf2e2'd2a2'9262'5222, 0xf3e3'd3a3'9363'5323},
9671 {0xf4e4'd4a4'9464'5424, 0xf5e5'd5a5'9565'5525},
9672 {0xf6e6'd6a6'9666'5626, 0xf7e7'd7a7'9767'5727},
9673 {0xf8e8'd8a8'9868'5828, 0xf9e9'd9a9'9969'5929},
9674 {0xfaea'daaa'9a6a'5a2a, 0xfbeb'dbab'9b6b'5b2b},
9675 {0xfcec'dcac'9c6c'5c2c, 0xfded'ddad'9d6d'5d2d},
9676 {0xfeee'deae'9e6e'5e2e, 0xffef'dfaf'9f6f'5f2f}},
9677 kVectorCalculationsSourceLegacy);
9678 }
9679
ExecVsrlvv()9680 [[gnu::naked]] void ExecVsrlvv() {
9681 asm("vsrl.vv v8, v16, v24\n\t"
9682 "ret\n\t");
9683 }
9684
ExecMaskedVsrlvv()9685 [[gnu::naked]] void ExecMaskedVsrlvv() {
9686 asm("vsrl.vv v8, v16, v24, v0.t\n\t"
9687 "ret\n\t");
9688 }
9689
ExecVsrlvx()9690 [[gnu::naked]] void ExecVsrlvx() {
9691 asm("vsrl.vx v8, v16, t0\n\t"
9692 "ret\n\t");
9693 }
9694
ExecMaskedVsrlvx()9695 [[gnu::naked]] void ExecMaskedVsrlvx() {
9696 asm("vsrl.vx v8, v16, t0, v0.t\n\t"
9697 "ret\n\t");
9698 }
9699
ExecVsrlvi()9700 [[gnu::naked]] void ExecVsrlvi() {
9701 asm("vsrl.vi v8, v16, 0x3\n\t"
9702 "ret\n\t");
9703 }
9704
ExecMaskedVsrlvi()9705 [[gnu::naked]] void ExecMaskedVsrlvi() {
9706 asm("vsrl.vi v8, v16, 0x3, v0.t\n\t"
9707 "ret\n\t");
9708 }
9709
TEST(InlineAsmTestRiscv64,TestVsrl)9710 TEST(InlineAsmTestRiscv64, TestVsrl) {
9711 TestVectorInstruction(ExecVsrlvv,
9712 ExecMaskedVsrlvv,
9713 {{0, 32, 0, 2, 2, 33, 0, 2, 4, 34, 0, 2, 12, 35, 0, 2},
9714 {16, 36, 1, 2, 10, 37, 1, 2, 12, 38, 1, 2, 28, 39, 1, 2},
9715 {32, 40, 2, 2, 18, 41, 2, 2, 20, 42, 2, 2, 44, 43, 2, 2},
9716 {48, 44, 3, 2, 26, 45, 3, 2, 28, 46, 3, 2, 60, 47, 3, 2},
9717 {64, 48, 4, 3, 34, 49, 4, 3, 36, 50, 4, 3, 76, 51, 4, 3},
9718 {80, 52, 5, 3, 42, 53, 5, 3, 44, 54, 5, 3, 92, 55, 5, 3},
9719 {96, 56, 6, 3, 50, 57, 6, 3, 52, 58, 6, 3, 108, 59, 6, 3},
9720 {112, 60, 7, 3, 58, 61, 7, 3, 60, 62, 7, 3, 124, 63, 7, 3}},
9721 {{0x8100, 0x0830, 0x0042, 0x0008, 0x4484, 0x08b0, 0x008d, 0x0008},
9722 {0x9110, 0x0931, 0x004a, 0x0009, 0x4c8c, 0x09b1, 0x009d, 0x0009},
9723 {0xa120, 0x0a32, 0x0052, 0x000a, 0x5494, 0x0ab2, 0x00ad, 0x000a},
9724 {0xb130, 0x0b33, 0x005a, 0x000b, 0x5c9c, 0x0bb3, 0x00bd, 0x000b},
9725 {0xc140, 0x0c34, 0x0062, 0x000c, 0x64a4, 0x0cb4, 0x00cd, 0x000c},
9726 {0xd150, 0x0d35, 0x006a, 0x000d, 0x6cac, 0x0db5, 0x00dd, 0x000d},
9727 {0xe160, 0x0e36, 0x0072, 0x000e, 0x74b4, 0x0eb6, 0x00ed, 0x000e},
9728 {0xf170, 0x0f37, 0x007a, 0x000f, 0x7cbc, 0x0fb7, 0x00fd, 0x000f}},
9729 {{0x8302'8100, 0x0043'8342, 0x0000'4585, 0x0000'008f},
9730 {0x9312'9110, 0x004b'8b4a, 0x0000'4d8d, 0x0000'009f},
9731 {0xa322'a120, 0x0053'9352, 0x0000'5595, 0x0000'00af},
9732 {0xb332'b130, 0x005b'9b5a, 0x0000'5d9d, 0x0000'00bf},
9733 {0xc342'c140, 0x0063'a362, 0x0000'65a5, 0x0000'00cf},
9734 {0xd352'd150, 0x006b'ab6a, 0x0000'6dad, 0x0000'00df},
9735 {0xe362'e160, 0x0073'b372, 0x0000'75b5, 0x0000'00ef},
9736 {0xf372'f170, 0x007b'bb7a, 0x0000'7dbd, 0x0000'00ff}},
9737 {{0x8706'8504'8302'8100, 0x0000'4787'4686'4585},
9738 {0x0000'0000'9716'9514, 0x0000'0000'0000'4f8f},
9739 {0xa726'a524'a322'a120, 0x0000'5797'5696'5595},
9740 {0x0000'0000'b736'b534, 0x0000'0000'0000'5f9f},
9741 {0xc746'c544'c342'c140, 0x0000'67a7'66a6'65a5},
9742 {0x0000'0000'd756'd554, 0x0000'0000'0000'6faf},
9743 {0xe766'e564'e362'e160, 0x0000'77b7'76b6'75b5},
9744 {0x0000'0000'f776'f574, 0x0000'0000'0000'7fbf}},
9745 kVectorCalculationsSourceLegacy);
9746 TestVectorInstruction(ExecVsrlvx,
9747 ExecMaskedVsrlvx,
9748 {{0, 32, 0, 32, 1, 33, 1, 33, 2, 34, 2, 34, 3, 35, 3, 35},
9749 {4, 36, 4, 36, 5, 37, 5, 37, 6, 38, 6, 38, 7, 39, 7, 39},
9750 {8, 40, 8, 40, 9, 41, 9, 41, 10, 42, 10, 42, 11, 43, 11, 43},
9751 {12, 44, 12, 44, 13, 45, 13, 45, 14, 46, 14, 46, 15, 47, 15, 47},
9752 {16, 48, 16, 48, 17, 49, 17, 49, 18, 50, 18, 50, 19, 51, 19, 51},
9753 {20, 52, 20, 52, 21, 53, 21, 53, 22, 54, 22, 54, 23, 55, 23, 55},
9754 {24, 56, 24, 56, 25, 57, 25, 57, 26, 58, 26, 58, 27, 59, 27, 59},
9755 {28, 60, 28, 60, 29, 61, 29, 61, 30, 62, 30, 62, 31, 63, 31, 63}},
9756 {{0x0020, 0x0020, 0x0021, 0x0021, 0x0022, 0x0022, 0x0023, 0x0023},
9757 {0x0024, 0x0024, 0x0025, 0x0025, 0x0026, 0x0026, 0x0027, 0x0027},
9758 {0x0028, 0x0028, 0x0029, 0x0029, 0x002a, 0x002a, 0x002b, 0x002b},
9759 {0x002c, 0x002c, 0x002d, 0x002d, 0x002e, 0x002e, 0x002f, 0x002f},
9760 {0x0030, 0x0030, 0x0031, 0x0031, 0x0032, 0x0032, 0x0033, 0x0033},
9761 {0x0034, 0x0034, 0x0035, 0x0035, 0x0036, 0x0036, 0x0037, 0x0037},
9762 {0x0038, 0x0038, 0x0039, 0x0039, 0x003a, 0x003a, 0x003b, 0x003b},
9763 {0x003c, 0x003c, 0x003d, 0x003d, 0x003e, 0x003e, 0x003f, 0x003f}},
9764 {{0x0020'c0a0, 0x0021'c1a1, 0x0022'c2a2, 0x0023'c3a3},
9765 {0x0024'c4a4, 0x0025'c5a5, 0x0026'c6a6, 0x0027'c7a7},
9766 {0x0028'c8a8, 0x0029'c9a9, 0x002a'caaa, 0x002b'cbab},
9767 {0x002c'ccac, 0x002d'cdad, 0x002e'ceae, 0x002f'cfaf},
9768 {0x0030'd0b0, 0x0031'd1b1, 0x0032'd2b2, 0x0033'd3b3},
9769 {0x0034'd4b4, 0x0035'd5b5, 0x0036'd6b6, 0x0037'd7b7},
9770 {0x0038'd8b8, 0x0039'd9b9, 0x003a'daba, 0x003b'dbbb},
9771 {0x003c'dcbc, 0x003d'ddbd, 0x003e'debe, 0x003f'dfbf}},
9772 {{0x0000'0000'0021'c1a1, 0x0000'0000'0023'c3a3},
9773 {0x0000'0000'0025'c5a5, 0x0000'0000'0027'c7a7},
9774 {0x0000'0000'0029'c9a9, 0x0000'0000'002b'cbab},
9775 {0x0000'0000'002d'cdad, 0x0000'0000'002f'cfaf},
9776 {0x0000'0000'0031'd1b1, 0x0000'0000'0033'd3b3},
9777 {0x0000'0000'0035'd5b5, 0x0000'0000'0037'd7b7},
9778 {0x0000'0000'0039'd9b9, 0x0000'0000'003b'dbbb},
9779 {0x0000'0000'003d'ddbd, 0x0000'0000'003f'dfbf}},
9780 kVectorCalculationsSourceLegacy);
9781 TestVectorInstruction(ExecVsrlvi,
9782 ExecMaskedVsrlvi,
9783 {{0, 16, 0, 16, 0, 16, 0, 16, 1, 17, 1, 17, 1, 17, 1, 17},
9784 {2, 18, 2, 18, 2, 18, 2, 18, 3, 19, 3, 19, 3, 19, 3, 19},
9785 {4, 20, 4, 20, 4, 20, 4, 20, 5, 21, 5, 21, 5, 21, 5, 21},
9786 {6, 22, 6, 22, 6, 22, 6, 22, 7, 23, 7, 23, 7, 23, 7, 23},
9787 {8, 24, 8, 24, 8, 24, 8, 24, 9, 25, 9, 25, 9, 25, 9, 25},
9788 {10, 26, 10, 26, 10, 26, 10, 26, 11, 27, 11, 27, 11, 27, 11, 27},
9789 {12, 28, 12, 28, 12, 28, 12, 28, 13, 29, 13, 29, 13, 29, 13, 29},
9790 {14, 30, 14, 30, 14, 30, 14, 30, 15, 31, 15, 31, 15, 31, 15, 31}},
9791 {{0x1020, 0x1060, 0x10a0, 0x10e0, 0x1121, 0x1161, 0x11a1, 0x11e1},
9792 {0x1222, 0x1262, 0x12a2, 0x12e2, 0x1323, 0x1363, 0x13a3, 0x13e3},
9793 {0x1424, 0x1464, 0x14a4, 0x14e4, 0x1525, 0x1565, 0x15a5, 0x15e5},
9794 {0x1626, 0x1666, 0x16a6, 0x16e6, 0x1727, 0x1767, 0x17a7, 0x17e7},
9795 {0x1828, 0x1868, 0x18a8, 0x18e8, 0x1929, 0x1969, 0x19a9, 0x19e9},
9796 {0x1a2a, 0x1a6a, 0x1aaa, 0x1aea, 0x1b2b, 0x1b6b, 0x1bab, 0x1beb},
9797 {0x1c2c, 0x1c6c, 0x1cac, 0x1cec, 0x1d2d, 0x1d6d, 0x1dad, 0x1ded},
9798 {0x1e2e, 0x1e6e, 0x1eae, 0x1eee, 0x1f2f, 0x1f6f, 0x1faf, 0x1fef}},
9799 {{0x1060'5020, 0x10e0'd0a0, 0x1161'5121, 0x11e1'd1a1},
9800 {0x1262'5222, 0x12e2'd2a2, 0x1363'5323, 0x13e3'd3a3},
9801 {0x1464'5424, 0x14e4'd4a4, 0x1565'5525, 0x15e5'd5a5},
9802 {0x1666'5626, 0x16e6'd6a6, 0x1767'5727, 0x17e7'd7a7},
9803 {0x1868'5828, 0x18e8'd8a8, 0x1969'5929, 0x19e9'd9a9},
9804 {0x1a6a'5a2a, 0x1aea'daaa, 0x1b6b'5b2b, 0x1beb'dbab},
9805 {0x1c6c'5c2c, 0x1cec'dcac, 0x1d6d'5d2d, 0x1ded'ddad},
9806 {0x1e6e'5e2e, 0x1eee'deae, 0x1f6f'5f2f, 0x1fef'dfaf}},
9807 {{0x10e0'd0a0'9060'5020, 0x11e1'd1a1'9161'5121},
9808 {0x12e2'd2a2'9262'5222, 0x13e3'd3a3'9363'5323},
9809 {0x14e4'd4a4'9464'5424, 0x15e5'd5a5'9565'5525},
9810 {0x16e6'd6a6'9666'5626, 0x17e7'd7a7'9767'5727},
9811 {0x18e8'd8a8'9868'5828, 0x19e9'd9a9'9969'5929},
9812 {0x1aea'daaa'9a6a'5a2a, 0x1beb'dbab'9b6b'5b2b},
9813 {0x1cec'dcac'9c6c'5c2c, 0x1ded'ddad'9d6d'5d2d},
9814 {0x1eee'deae'9e6e'5e2e, 0x1fef'dfaf'9f6f'5f2f}},
9815 kVectorCalculationsSourceLegacy);
9816 }
9817
ExecVwaddvv()9818 [[gnu::naked]] void ExecVwaddvv() {
9819 asm("vwadd.vv v8, v16, v24\n\t"
9820 "ret\n\t");
9821 }
9822
ExecMaskedVwaddvv()9823 [[gnu::naked]] void ExecMaskedVwaddvv() {
9824 asm("vwadd.vv v8, v16, v24, v0.t\n\t"
9825 "ret\n\t");
9826 }
9827
TEST(InlineAsmTestRiscv64,TestVwadd)9828 TEST(InlineAsmTestRiscv64, TestVwadd) {
9829 TestWideningVectorInstruction(ExecVwaddvv,
9830 ExecMaskedVwaddvv,
9831 {{0x0000, 0xff13, 0x0006, 0xff19, 0x000d, 0xff1f, 0x0012, 0xff25},
9832 {0x0019, 0xff0b, 0x001e, 0xff11, 0x0024, 0xff17, 0x002a, 0xff1d},
9833 {0x0030, 0xff43, 0x0036, 0xff49, 0x003d, 0xff4f, 0x0042, 0xff55},
9834 {0x0049, 0xff3b, 0x004e, 0xff41, 0x0054, 0xff47, 0x005a, 0xff4d},
9835 {0x0060, 0xff73, 0x0066, 0xff79, 0x006d, 0xff7f, 0x0072, 0xff85},
9836 {0x0079, 0xff6b, 0x007e, 0xff71, 0x0084, 0xff77, 0x008a, 0xff7d},
9837 {0x0090, 0xffa3, 0x0096, 0xffa9, 0x009d, 0xffaf, 0x00a2, 0xffb5},
9838 {0x00a9, 0xff9b, 0x00ae, 0xffa1, 0x00b4, 0xffa7, 0x00ba, 0xffad}},
9839 {{0xffff'1300, 0xffff'1906, 0xffff'1f0d, 0xffff'2512},
9840 {0xffff'0b19, 0xffff'111e, 0xffff'1724, 0xffff'1d2a},
9841 {0xffff'4330, 0xffff'4936, 0xffff'4f3d, 0xffff'5542},
9842 {0xffff'3b49, 0xffff'414e, 0xffff'4754, 0xffff'4d5a},
9843 {0xffff'7360, 0xffff'7966, 0xffff'7f6d, 0xffff'8572},
9844 {0xffff'6b79, 0xffff'717e, 0xffff'7784, 0xffff'7d8a},
9845 {0xffff'a390, 0xffff'a996, 0xffff'af9d, 0xffff'b5a2},
9846 {0xffff'9ba9, 0xffff'a1ae, 0xffff'a7b4, 0xffff'adba}},
9847 {{0xffff'ffff'1907'1300, 0xffff'ffff'2513'1f0d},
9848 {0xffff'ffff'111f'0b19, 0xffff'ffff'1d2b'1724},
9849 {0xffff'ffff'4937'4330, 0xffff'ffff'5543'4f3d},
9850 {0xffff'ffff'414f'3b49, 0xffff'ffff'4d5b'4754},
9851 {0xffff'ffff'7967'7360, 0xffff'ffff'8573'7f6d},
9852 {0xffff'ffff'717f'6b79, 0xffff'ffff'7d8b'7784},
9853 {0xffff'ffff'a997'a390, 0xffff'ffff'b5a3'af9d},
9854 {0xffff'ffff'a1af'9ba9, 0xffff'ffff'adbb'a7b4}},
9855 kVectorCalculationsSource);
9856 }
9857
ExecVwadduvv()9858 [[gnu::naked]] void ExecVwadduvv() {
9859 asm("vwaddu.vv v8, v16, v24\n\t"
9860 "ret\n\t");
9861 }
9862
ExecMaskedVwadduvv()9863 [[gnu::naked]] void ExecMaskedVwadduvv() {
9864 asm("vwaddu.vv v8, v16, v24, v0.t\n\t"
9865 "ret\n\t");
9866 }
9867
TEST(InlineAsmTestRiscv64,TestVwaddu)9868 TEST(InlineAsmTestRiscv64, TestVwaddu) {
9869 TestWideningVectorInstruction(ExecVwadduvv,
9870 ExecMaskedVwadduvv,
9871 {{0x0000, 0x0113, 0x0006, 0x0119, 0x000d, 0x011f, 0x0012, 0x0125},
9872 {0x0019, 0x010b, 0x001e, 0x0111, 0x0024, 0x0117, 0x002a, 0x011d},
9873 {0x0030, 0x0143, 0x0036, 0x0149, 0x003d, 0x014f, 0x0042, 0x0155},
9874 {0x0049, 0x013b, 0x004e, 0x0141, 0x0054, 0x0147, 0x005a, 0x014d},
9875 {0x0060, 0x0173, 0x0066, 0x0179, 0x006d, 0x017f, 0x0072, 0x0185},
9876 {0x0079, 0x016b, 0x007e, 0x0171, 0x0084, 0x0177, 0x008a, 0x017d},
9877 {0x0090, 0x01a3, 0x0096, 0x01a9, 0x009d, 0x01af, 0x00a2, 0x01b5},
9878 {0x00a9, 0x019b, 0x00ae, 0x01a1, 0x00b4, 0x01a7, 0x00ba, 0x01ad}},
9879 {{0x0001'1300, 0x0001'1906, 0x0001'1f0d, 0x0001'2512},
9880 {0x0001'0b19, 0x0001'111e, 0x0001'1724, 0x0001'1d2a},
9881 {0x0001'4330, 0x0001'4936, 0x0001'4f3d, 0x0001'5542},
9882 {0x0001'3b49, 0x0001'414e, 0x0001'4754, 0x0001'4d5a},
9883 {0x0001'7360, 0x0001'7966, 0x0001'7f6d, 0x0001'8572},
9884 {0x0001'6b79, 0x0001'717e, 0x0001'7784, 0x0001'7d8a},
9885 {0x0001'a390, 0x0001'a996, 0x0001'af9d, 0x0001'b5a2},
9886 {0x0001'9ba9, 0x0001'a1ae, 0x0001'a7b4, 0x0001'adba}},
9887 {{0x0000'0001'1907'1300, 0x0000'0001'2513'1f0d},
9888 {0x0000'0001'111f'0b19, 0x0000'0001'1d2b'1724},
9889 {0x0000'0001'4937'4330, 0x0000'0001'5543'4f3d},
9890 {0x0000'0001'414f'3b49, 0x0000'0001'4d5b'4754},
9891 {0x0000'0001'7967'7360, 0x0000'0001'8573'7f6d},
9892 {0x0000'0001'717f'6b79, 0x0000'0001'7d8b'7784},
9893 {0x0000'0001'a997'a390, 0x0000'0001'b5a3'af9d},
9894 {0x0000'0001'a1af'9ba9, 0x0000'0001'adbb'a7b4}},
9895 kVectorCalculationsSource);
9896 }
9897
ExecVwadduvx()9898 [[gnu::naked]] void ExecVwadduvx() {
9899 asm("vwaddu.vx v8, v16, t0\n\t"
9900 "ret\n\t");
9901 }
9902
ExecMaskedVwadduvx()9903 [[gnu::naked]] void ExecMaskedVwadduvx() {
9904 asm("vwaddu.vx v8, v16, t0, v0.t\n\t"
9905 "ret\n\t");
9906 }
9907
TEST(InlineAsmTestRiscv64,TestVwadduvx)9908 TEST(InlineAsmTestRiscv64, TestVwadduvx) {
9909 TestWideningVectorInstruction(ExecVwadduvx,
9910 ExecMaskedVwadduvx,
9911 {{0x00aa, 0x012b, 0x00ac, 0x012d, 0x00ae, 0x012f, 0x00b0, 0x0131},
9912 {0x00b2, 0x0133, 0x00b4, 0x0135, 0x00b6, 0x0137, 0x00b8, 0x0139},
9913 {0x00ba, 0x013b, 0x00bc, 0x013d, 0x00be, 0x013f, 0x00c0, 0x0141},
9914 {0x00c2, 0x0143, 0x00c4, 0x0145, 0x00c6, 0x0147, 0x00c8, 0x0149},
9915 {0x00ca, 0x014b, 0x00cc, 0x014d, 0x00ce, 0x014f, 0x00d0, 0x0151},
9916 {0x00d2, 0x0153, 0x00d4, 0x0155, 0x00d6, 0x0157, 0x00d8, 0x0159},
9917 {0x00da, 0x015b, 0x00dc, 0x015d, 0x00de, 0x015f, 0x00e0, 0x0161},
9918 {0x00e2, 0x0163, 0x00e4, 0x0165, 0x00e6, 0x0167, 0x00e8, 0x0169}},
9919 {{0x0001'2baa, 0x0001'2dac, 0x0001'2fae, 0x0001'31b0},
9920 {0x0001'33b2, 0x0001'35b4, 0x0001'37b6, 0x0001'39b8},
9921 {0x0001'3bba, 0x0001'3dbc, 0x0001'3fbe, 0x0001'41c0},
9922 {0x0001'43c2, 0x0001'45c4, 0x0001'47c6, 0x0001'49c8},
9923 {0x0001'4bca, 0x0001'4dcc, 0x0001'4fce, 0x0001'51d0},
9924 {0x0001'53d2, 0x0001'55d4, 0x0001'57d6, 0x0001'59d8},
9925 {0x0001'5bda, 0x0001'5ddc, 0x0001'5fde, 0x0001'61e0},
9926 {0x0001'63e2, 0x0001'65e4, 0x0001'67e6, 0x0001'69e8}},
9927 {{0x0000'0001'2dad'2baa, 0x0000'0001'31b1'2fae},
9928 {0x0000'0001'35b5'33b2, 0x0000'0001'39b9'37b6},
9929 {0x0000'0001'3dbd'3bba, 0x0000'0001'41c1'3fbe},
9930 {0x0000'0001'45c5'43c2, 0x0000'0001'49c9'47c6},
9931 {0x0000'0001'4dcd'4bca, 0x0000'0001'51d1'4fce},
9932 {0x0000'0001'55d5'53d2, 0x0000'0001'59d9'57d6},
9933 {0x0000'0001'5ddd'5bda, 0x0000'0001'61e1'5fde},
9934 {0x0000'0001'65e5'63e2, 0x0000'0001'69e9'67e6}},
9935 kVectorCalculationsSource);
9936 }
9937
ExecVwadduwv()9938 [[gnu::naked]] void ExecVwadduwv() {
9939 asm("vwaddu.wv v8, v16, v24\n\t"
9940 "ret\n\t");
9941 }
9942
ExecMaskedVwadduwv()9943 [[gnu::naked]] void ExecMaskedVwadduwv() {
9944 asm("vwaddu.wv v8, v16, v24, v0.t\n\t"
9945 "ret\n\t");
9946 }
9947
TEST(InlineAsmTestRiscv64,TestVwadduwv)9948 TEST(InlineAsmTestRiscv64, TestVwadduwv) {
9949 TestWideningVectorInstruction(ExecVwadduwv,
9950 ExecMaskedVwadduwv,
9951 {{0x8100, 0x8394, 0x8508, 0x879c, 0x8911, 0x8ba4, 0x8d18, 0x8fac},
9952 {0x9121, 0x9394, 0x9528, 0x979c, 0x9930, 0x9ba4, 0x9d38, 0x9fac},
9953 {0xa140, 0xa3d4, 0xa548, 0xa7dc, 0xa951, 0xabe4, 0xad58, 0xafec},
9954 {0xb161, 0xb3d4, 0xb568, 0xb7dc, 0xb970, 0xbbe4, 0xbd78, 0xbfec},
9955 {0xc180, 0xc414, 0xc588, 0xc81c, 0xc991, 0xcc24, 0xcd98, 0xd02c},
9956 {0xd1a1, 0xd414, 0xd5a8, 0xd81c, 0xd9b0, 0xdc24, 0xddb8, 0xe02c},
9957 {0xe1c0, 0xe454, 0xe5c8, 0xe85c, 0xe9d1, 0xec64, 0xedd8, 0xf06c},
9958 {0xf1e1, 0xf454, 0xf5e8, 0xf85c, 0xf9f0, 0xfc64, 0xfdf8, 0x006c}},
9959 {{0x8303'1300, 0x8707'1b08, 0x8b0b'2311, 0x8f0f'2b18},
9960 {0x9313'1321, 0x9717'1b28, 0x9b1b'2330, 0x9f1f'2b38},
9961 {0xa323'5340, 0xa727'5b48, 0xab2b'6351, 0xaf2f'6b58},
9962 {0xb333'5361, 0xb737'5b68, 0xbb3b'6370, 0xbf3f'6b78},
9963 {0xc343'9380, 0xc747'9b88, 0xcb4b'a391, 0xcf4f'ab98},
9964 {0xd353'93a1, 0xd757'9ba8, 0xdb5b'a3b0, 0xdf5f'abb8},
9965 {0xe363'd3c0, 0xe767'dbc8, 0xeb6b'e3d1, 0xef6f'ebd8},
9966 {0xf373'd3e1, 0xf777'dbe8, 0xfb7b'e3f0, 0xff7f'ebf8}},
9967 {{0x8706'8505'1907'1300, 0x8f0e'8d0d'2917'2311},
9968 {0x9716'9515'1927'1321, 0x9f1e'9d1d'2937'2330},
9969 {0xa726'a525'5947'5340, 0xaf2e'ad2d'6957'6351},
9970 {0xb736'b535'5967'5361, 0xbf3e'bd3d'6977'6370},
9971 {0xc746'c545'9987'9380, 0xcf4e'cd4d'a997'a391},
9972 {0xd756'd555'99a7'93a1, 0xdf5e'dd5d'a9b7'a3b0},
9973 {0xe766'e565'd9c7'd3c0, 0xef6e'ed6d'e9d7'e3d1},
9974 {0xf776'f575'd9e7'd3e1, 0xff7e'fd7d'e9f7'e3f0}},
9975 kVectorCalculationsSource);
9976 }
9977
ExecVwadduwx()9978 [[gnu::naked]] void ExecVwadduwx() {
9979 asm("vwaddu.wx v8, v16, t0\n\t"
9980 "ret\n\t");
9981 }
9982
ExecMaskedVwadduwx()9983 [[gnu::naked]] void ExecMaskedVwadduwx() {
9984 asm("vwaddu.wx v8, v16, t0, v0.t\n\t"
9985 "ret\n\t");
9986 }
9987
TEST(InlineAsmTestRiscv64,TestVwadduwx)9988 TEST(InlineAsmTestRiscv64, TestVwadduwx) {
9989 TestWideningVectorInstruction(ExecVwadduwx,
9990 ExecMaskedVwadduwx,
9991 {{0x81aa, 0x83ac, 0x85ae, 0x87b0, 0x89b2, 0x8bb4, 0x8db6, 0x8fb8},
9992 {0x91ba, 0x93bc, 0x95be, 0x97c0, 0x99c2, 0x9bc4, 0x9dc6, 0x9fc8},
9993 {0xa1ca, 0xa3cc, 0xa5ce, 0xa7d0, 0xa9d2, 0xabd4, 0xadd6, 0xafd8},
9994 {0xb1da, 0xb3dc, 0xb5de, 0xb7e0, 0xb9e2, 0xbbe4, 0xbde6, 0xbfe8},
9995 {0xc1ea, 0xc3ec, 0xc5ee, 0xc7f0, 0xc9f2, 0xcbf4, 0xcdf6, 0xcff8},
9996 {0xd1fa, 0xd3fc, 0xd5fe, 0xd800, 0xda02, 0xdc04, 0xde06, 0xe008},
9997 {0xe20a, 0xe40c, 0xe60e, 0xe810, 0xea12, 0xec14, 0xee16, 0xf018},
9998 {0xf21a, 0xf41c, 0xf61e, 0xf820, 0xfa22, 0xfc24, 0xfe26, 0x0028}},
9999 {{0x8303'2baa, 0x8707'2fae, 0x8b0b'33b2, 0x8f0f'37b6},
10000 {0x9313'3bba, 0x9717'3fbe, 0x9b1b'43c2, 0x9f1f'47c6},
10001 {0xa323'4bca, 0xa727'4fce, 0xab2b'53d2, 0xaf2f'57d6},
10002 {0xb333'5bda, 0xb737'5fde, 0xbb3b'63e2, 0xbf3f'67e6},
10003 {0xc343'6bea, 0xc747'6fee, 0xcb4b'73f2, 0xcf4f'77f6},
10004 {0xd353'7bfa, 0xd757'7ffe, 0xdb5b'8402, 0xdf5f'8806},
10005 {0xe363'8c0a, 0xe767'900e, 0xeb6b'9412, 0xef6f'9816},
10006 {0xf373'9c1a, 0xf777'a01e, 0xfb7b'a422, 0xff7f'a826}},
10007 {{0x8706'8505'2dad'2baa, 0x8f0e'8d0d'35b5'33b2},
10008 {0x9716'9515'3dbd'3bba, 0x9f1e'9d1d'45c5'43c2},
10009 {0xa726'a525'4dcd'4bca, 0xaf2e'ad2d'55d5'53d2},
10010 {0xb736'b535'5ddd'5bda, 0xbf3e'bd3d'65e5'63e2},
10011 {0xc746'c545'6ded'6bea, 0xcf4e'cd4d'75f5'73f2},
10012 {0xd756'd555'7dfd'7bfa, 0xdf5e'dd5d'8605'8402},
10013 {0xe766'e565'8e0d'8c0a, 0xef6e'ed6d'9615'9412},
10014 {0xf776'f575'9e1d'9c1a, 0xff7e'fd7d'a625'a422}},
10015 kVectorCalculationsSource);
10016 }
10017
ExecVwaddvx()10018 [[gnu::naked]] void ExecVwaddvx() {
10019 asm("vwadd.vx v8, v16, t0\n\t"
10020 "ret\n\t");
10021 }
10022
ExecMaskedVwaddvx()10023 [[gnu::naked]] void ExecMaskedVwaddvx() {
10024 asm("vwadd.vx v8, v16, t0, v0.t\n\t"
10025 "ret\n\t");
10026 }
10027
TEST(InlineAsmTestRiscv64,TestVwaddvx)10028 TEST(InlineAsmTestRiscv64, TestVwaddvx) {
10029 TestWideningVectorInstruction(ExecVwaddvx,
10030 ExecMaskedVwaddvx,
10031 {{0xffaa, 0xff2b, 0xffac, 0xff2d, 0xffae, 0xff2f, 0xffb0, 0xff31},
10032 {0xffb2, 0xff33, 0xffb4, 0xff35, 0xffb6, 0xff37, 0xffb8, 0xff39},
10033 {0xffba, 0xff3b, 0xffbc, 0xff3d, 0xffbe, 0xff3f, 0xffc0, 0xff41},
10034 {0xffc2, 0xff43, 0xffc4, 0xff45, 0xffc6, 0xff47, 0xffc8, 0xff49},
10035 {0xffca, 0xff4b, 0xffcc, 0xff4d, 0xffce, 0xff4f, 0xffd0, 0xff51},
10036 {0xffd2, 0xff53, 0xffd4, 0xff55, 0xffd6, 0xff57, 0xffd8, 0xff59},
10037 {0xffda, 0xff5b, 0xffdc, 0xff5d, 0xffde, 0xff5f, 0xffe0, 0xff61},
10038 {0xffe2, 0xff63, 0xffe4, 0xff65, 0xffe6, 0xff67, 0xffe8, 0xff69}},
10039 {{0xffff'2baa, 0xffff'2dac, 0xffff'2fae, 0xffff'31b0},
10040 {0xffff'33b2, 0xffff'35b4, 0xffff'37b6, 0xffff'39b8},
10041 {0xffff'3bba, 0xffff'3dbc, 0xffff'3fbe, 0xffff'41c0},
10042 {0xffff'43c2, 0xffff'45c4, 0xffff'47c6, 0xffff'49c8},
10043 {0xffff'4bca, 0xffff'4dcc, 0xffff'4fce, 0xffff'51d0},
10044 {0xffff'53d2, 0xffff'55d4, 0xffff'57d6, 0xffff'59d8},
10045 {0xffff'5bda, 0xffff'5ddc, 0xffff'5fde, 0xffff'61e0},
10046 {0xffff'63e2, 0xffff'65e4, 0xffff'67e6, 0xffff'69e8}},
10047 {{0xffff'ffff'2dad'2baa, 0xffff'ffff'31b1'2fae},
10048 {0xffff'ffff'35b5'33b2, 0xffff'ffff'39b9'37b6},
10049 {0xffff'ffff'3dbd'3bba, 0xffff'ffff'41c1'3fbe},
10050 {0xffff'ffff'45c5'43c2, 0xffff'ffff'49c9'47c6},
10051 {0xffff'ffff'4dcd'4bca, 0xffff'ffff'51d1'4fce},
10052 {0xffff'ffff'55d5'53d2, 0xffff'ffff'59d9'57d6},
10053 {0xffff'ffff'5ddd'5bda, 0xffff'ffff'61e1'5fde},
10054 {0xffff'ffff'65e5'63e2, 0xffff'ffff'69e9'67e6}},
10055 kVectorCalculationsSource);
10056 }
10057
ExecVwaddwv()10058 [[gnu::naked]] void ExecVwaddwv() {
10059 asm("vwadd.wv v8, v16, v24\n\t"
10060 "ret\n\t");
10061 }
10062
ExecMaskedVwaddwv()10063 [[gnu::naked]] void ExecMaskedVwaddwv() {
10064 asm("vwadd.wv v8, v16, v24, v0.t\n\t"
10065 "ret\n\t");
10066 }
10067
TEST(InlineAsmTestRiscv64,TestVwaddwv)10068 TEST(InlineAsmTestRiscv64, TestVwaddwv) {
10069 TestWideningVectorInstruction(ExecVwaddwv,
10070 ExecMaskedVwaddwv,
10071 {{0x8100, 0x8294, 0x8508, 0x869c, 0x8911, 0x8aa4, 0x8d18, 0x8eac},
10072 {0x9121, 0x9294, 0x9528, 0x969c, 0x9930, 0x9aa4, 0x9d38, 0x9eac},
10073 {0xa140, 0xa2d4, 0xa548, 0xa6dc, 0xa951, 0xaae4, 0xad58, 0xaeec},
10074 {0xb161, 0xb2d4, 0xb568, 0xb6dc, 0xb970, 0xbae4, 0xbd78, 0xbeec},
10075 {0xc180, 0xc314, 0xc588, 0xc71c, 0xc991, 0xcb24, 0xcd98, 0xcf2c},
10076 {0xd1a1, 0xd314, 0xd5a8, 0xd71c, 0xd9b0, 0xdb24, 0xddb8, 0xdf2c},
10077 {0xe1c0, 0xe354, 0xe5c8, 0xe75c, 0xe9d1, 0xeb64, 0xedd8, 0xef6c},
10078 {0xf1e1, 0xf354, 0xf5e8, 0xf75c, 0xf9f0, 0xfb64, 0xfdf8, 0xff6c}},
10079 {{0x8302'1300, 0x8706'1b08, 0x8b0a'2311, 0x8f0e'2b18},
10080 {0x9312'1321, 0x9716'1b28, 0x9b1a'2330, 0x9f1e'2b38},
10081 {0xa322'5340, 0xa726'5b48, 0xab2a'6351, 0xaf2e'6b58},
10082 {0xb332'5361, 0xb736'5b68, 0xbb3a'6370, 0xbf3e'6b78},
10083 {0xc342'9380, 0xc746'9b88, 0xcb4a'a391, 0xcf4e'ab98},
10084 {0xd352'93a1, 0xd756'9ba8, 0xdb5a'a3b0, 0xdf5e'abb8},
10085 {0xe362'd3c0, 0xe766'dbc8, 0xeb6a'e3d1, 0xef6e'ebd8},
10086 {0xf372'd3e1, 0xf776'dbe8, 0xfb7a'e3f0, 0xff7e'ebf8}},
10087 {{0x8706'8504'1907'1300, 0x8f0e'8d0c'2917'2311},
10088 {0x9716'9514'1927'1321, 0x9f1e'9d1c'2937'2330},
10089 {0xa726'a524'5947'5340, 0xaf2e'ad2c'6957'6351},
10090 {0xb736'b534'5967'5361, 0xbf3e'bd3c'6977'6370},
10091 {0xc746'c544'9987'9380, 0xcf4e'cd4c'a997'a391},
10092 {0xd756'd554'99a7'93a1, 0xdf5e'dd5c'a9b7'a3b0},
10093 {0xe766'e564'd9c7'd3c0, 0xef6e'ed6c'e9d7'e3d1},
10094 {0xf776'f574'd9e7'd3e1, 0xff7e'fd7c'e9f7'e3f0}},
10095 kVectorCalculationsSource);
10096 }
10097
ExecVwaddwx()10098 [[gnu::naked]] void ExecVwaddwx() {
10099 asm("vwadd.wx v8, v16, t0\n\t"
10100 "ret\n\t");
10101 }
10102
ExecMaskedVwaddwx()10103 [[gnu::naked]] void ExecMaskedVwaddwx() {
10104 asm("vwadd.wx v8, v16, t0, v0.t\n\t"
10105 "ret\n\t");
10106 }
10107
TEST(InlineAsmTestRiscv64,TestVwaddwx)10108 TEST(InlineAsmTestRiscv64, TestVwaddwx) {
10109 TestWideningVectorInstruction(ExecVwaddwx,
10110 ExecMaskedVwaddwx,
10111 {{0x80aa, 0x82ac, 0x84ae, 0x86b0, 0x88b2, 0x8ab4, 0x8cb6, 0x8eb8},
10112 {0x90ba, 0x92bc, 0x94be, 0x96c0, 0x98c2, 0x9ac4, 0x9cc6, 0x9ec8},
10113 {0xa0ca, 0xa2cc, 0xa4ce, 0xa6d0, 0xa8d2, 0xaad4, 0xacd6, 0xaed8},
10114 {0xb0da, 0xb2dc, 0xb4de, 0xb6e0, 0xb8e2, 0xbae4, 0xbce6, 0xbee8},
10115 {0xc0ea, 0xc2ec, 0xc4ee, 0xc6f0, 0xc8f2, 0xcaf4, 0xccf6, 0xcef8},
10116 {0xd0fa, 0xd2fc, 0xd4fe, 0xd700, 0xd902, 0xdb04, 0xdd06, 0xdf08},
10117 {0xe10a, 0xe30c, 0xe50e, 0xe710, 0xe912, 0xeb14, 0xed16, 0xef18},
10118 {0xf11a, 0xf31c, 0xf51e, 0xf720, 0xf922, 0xfb24, 0xfd26, 0xff28}},
10119 {{0x8302'2baa, 0x8706'2fae, 0x8b0a'33b2, 0x8f0e'37b6},
10120 {0x9312'3bba, 0x9716'3fbe, 0x9b1a'43c2, 0x9f1e'47c6},
10121 {0xa322'4bca, 0xa726'4fce, 0xab2a'53d2, 0xaf2e'57d6},
10122 {0xb332'5bda, 0xb736'5fde, 0xbb3a'63e2, 0xbf3e'67e6},
10123 {0xc342'6bea, 0xc746'6fee, 0xcb4a'73f2, 0xcf4e'77f6},
10124 {0xd352'7bfa, 0xd756'7ffe, 0xdb5a'8402, 0xdf5e'8806},
10125 {0xe362'8c0a, 0xe766'900e, 0xeb6a'9412, 0xef6e'9816},
10126 {0xf372'9c1a, 0xf776'a01e, 0xfb7a'a422, 0xff7e'a826}},
10127 {{0x8706'8504'2dad'2baa, 0x8f0e'8d0c'35b5'33b2},
10128 {0x9716'9514'3dbd'3bba, 0x9f1e'9d1c'45c5'43c2},
10129 {0xa726'a524'4dcd'4bca, 0xaf2e'ad2c'55d5'53d2},
10130 {0xb736'b534'5ddd'5bda, 0xbf3e'bd3c'65e5'63e2},
10131 {0xc746'c544'6ded'6bea, 0xcf4e'cd4c'75f5'73f2},
10132 {0xd756'd554'7dfd'7bfa, 0xdf5e'dd5c'8605'8402},
10133 {0xe766'e564'8e0d'8c0a, 0xef6e'ed6c'9615'9412},
10134 {0xf776'f574'9e1d'9c1a, 0xff7e'fd7c'a625'a422}},
10135 kVectorCalculationsSource);
10136 }
10137
ExecVwmulvv()10138 [[gnu::naked]] void ExecVwmulvv() {
10139 asm("vwmul.vv v8, v16, v24\n\t"
10140 "ret\n\t");
10141 }
10142
ExecMaskedVwmulvv()10143 [[gnu::naked]] void ExecMaskedVwmulvv() {
10144 asm("vwmul.vv v8, v16, v24, v0.t\n\t"
10145 "ret\n\t");
10146 }
10147
TEST(InlineAsmTestRiscv64,TestVwmul)10148 TEST(InlineAsmTestRiscv64, TestVwmul) {
10149 TestWideningVectorInstruction(ExecVwmulvv,
10150 ExecMaskedVwmulvv,
10151 {{0x0000, 0x3692, 0x0008, 0x33c2, 0x0024, 0x3102, 0x0048, 0x2e52},
10152 {0x0088, 0x3a92, 0x00c8, 0x37c2, 0x0120, 0x3502, 0x0188, 0x3252},
10153 {0x0200, 0x21d2, 0x0288, 0x1f82, 0x0334, 0x1d42, 0x03c8, 0x1b12},
10154 {0x0498, 0x25d2, 0x0548, 0x2382, 0x0620, 0x2142, 0x0708, 0x1f12},
10155 {0x0800, 0x1112, 0x0908, 0x0f42, 0x0a44, 0x0d82, 0x0b48, 0x0bd2},
10156 {0x0ca8, 0x1512, 0x0dc8, 0x1342, 0x0f20, 0x1182, 0x1088, 0x0fd2},
10157 {0x1200, 0x0452, 0x1388, 0x0302, 0x1554, 0x01c2, 0x16c8, 0x0092},
10158 {0x18b8, 0x0852, 0x1a48, 0x0702, 0x1c20, 0x05c2, 0x1e08, 0x0492}},
10159 {{0x3692'0000, 0x33bf'3808, 0x30fc'1524, 0x2e4a'0848},
10160 {0x3a86'2988, 0x37b4'18c8, 0x34f1'b120, 0x323f'6988},
10161 {0x21bf'4200, 0x1f6d'7a88, 0x1d2b'6834, 0x1afa'4bc8},
10162 {0x25b5'7d98, 0x2364'5d48, 0x2122'f620, 0x1ef1'af08},
10163 {0x10f4'8800, 0x0f23'c108, 0x0d62'bf44, 0x0bb2'9348},
10164 {0x14ec'd5a8, 0x131c'a5c8, 0x115c'3f20, 0x0fab'f888},
10165 {0x0431'd200, 0x02e2'0b88, 0x01a2'1a54, 0x0072'dec8},
10166 {0x082c'31b8, 0x06dc'f248, 0x059d'8c20, 0x046e'4608}},
10167 {{0x33be'bb57'7192'0000, 0x2e49'8c98'5f6f'1524},
10168 {0x37b3'9c18'79e9'2988, 0x323e'eddb'56b5'b120},
10169 {0x1f6d'04e3'116f'4200, 0x1af9'd928'125e'6834},
10170 {0x2363'e7a8'2dd8'7d98, 0x1ef1'3c6e'fd96'f620},
10171 {0x0f23'5a7e'bd54'8800, 0x0bb2'31c7'd155'bf44},
10172 {0x131c'3f47'edcf'd5a8, 0x0fab'9712'b080'3f20},
10173 {0x02e1'bc2a'7541'd200, 0x0072'9677'9c55'1a54},
10174 {0x06dc'a2f7'b9cf'31b8, 0x046d'fdc6'6f71'8c20}},
10175 kVectorCalculationsSource);
10176 }
10177
ExecVwmulsuvv()10178 [[gnu::naked]] void ExecVwmulsuvv() {
10179 asm("vwmulsu.vv v8, v16, v24\n\t"
10180 "ret\n\t");
10181 }
10182
ExecMaskedVwmulsuvv()10183 [[gnu::naked]] void ExecMaskedVwmulsuvv() {
10184 asm("vwmulsu.vv v8, v16, v24, v0.t\n\t"
10185 "ret\n\t");
10186 }
10187
TEST(InlineAsmTestRiscv64,TestVwmulsu)10188 TEST(InlineAsmTestRiscv64, TestVwmulsu) {
10189 TestWideningVectorInstruction(ExecVwmulsuvv,
10190 ExecMaskedVwmulsuvv,
10191 {{0x0000, 0xb792, 0x0008, 0xb6c2, 0x0024, 0xb602, 0x0048, 0xb552},
10192 {0x0088, 0xc392, 0x00c8, 0xc2c2, 0x0120, 0xc202, 0x0188, 0xc152},
10193 {0x0200, 0xb2d2, 0x0288, 0xb282, 0x0334, 0xb242, 0x03c8, 0xb212},
10194 {0x0498, 0xbed2, 0x0548, 0xbe82, 0x0620, 0xbe42, 0x0708, 0xbe12},
10195 {0x0800, 0xb212, 0x0908, 0xb242, 0x0a44, 0xb282, 0x0b48, 0xb2d2},
10196 {0x0ca8, 0xbe12, 0x0dc8, 0xbe42, 0x0f20, 0xbe82, 0x1088, 0xbed2},
10197 {0x1200, 0xb552, 0x1388, 0xb602, 0x1554, 0xb6c2, 0x16c8, 0xb792},
10198 {0x18b8, 0xc152, 0x1a48, 0xc202, 0x1c20, 0xc2c2, 0x1e08, 0xc392}},
10199 {{0xb792'0000, 0xb6c1'3808, 0xb600'1524, 0xb550'0848},
10200 {0xc38e'2988, 0xc2be'18c8, 0xc1fd'b120, 0xc14d'6988},
10201 {0xb2cf'4200, 0xb27f'7a88, 0xb23f'6834, 0xb210'4bc8},
10202 {0xbecd'7d98, 0xbe7e'5d48, 0xbe3e'f620, 0xbe0f'af08},
10203 {0xb214'8800, 0xb245'c108, 0xb286'bf44, 0xb2d8'9348},
10204 {0xbe14'd5a8, 0xbe46'a5c8, 0xbe88'3f20, 0xbed9'f888},
10205 {0xb561'd200, 0xb614'0b88, 0xb6d6'1a54, 0xb7a8'dec8},
10206 {0xc164'31b8, 0xc216'f248, 0xc2d9'8c20, 0xc3ac'4608}},
10207 {{0xb6c1'3c57'7192'0000, 0xb550'119c'5f6f'1524},
10208 {0xc2be'2520'79e9'2988, 0xc14d'7ae7'56b5'b120},
10209 {0xb27f'95f3'116f'4200, 0xb210'6e3c'125e'6834},
10210 {0xbe7e'80c0'2dd8'7d98, 0xbe0f'd98a'fd96'f620},
10211 {0xb245'fb9e'bd54'8800, 0xb2d8'd6eb'd155'bf44},
10212 {0xbe46'e86f'edcf'd5a8, 0xbeda'443e'b080'3f20},
10213 {0xb614'6d5a'7541'd200, 0xb7a9'4bab'9c55'1a54},
10214 {0xc217'5c2f'b9cf'31b8, 0xc3ac'bb02'6f71'8c20}},
10215 kVectorCalculationsSource);
10216 }
10217
ExecVwmulsuvx()10218 [[gnu::naked]] void ExecVwmulsuvx() {
10219 asm("vwmulsu.vx v8, v16, t0\n\t"
10220 "ret\n\t");
10221 }
10222
ExecMaskedVwmulsuvx()10223 [[gnu::naked]] void ExecMaskedVwmulsuvx() {
10224 asm("vwmulsu.vx v8, v16, t0, v0.t\n\t"
10225 "ret\n\t");
10226 }
10227
TEST(InlineAsmTestRiscv64,TestVwmulsuvx)10228 TEST(InlineAsmTestRiscv64, TestVwmulsuvx) {
10229 TestWideningVectorInstruction(ExecVwmulsuvx,
10230 ExecMaskedVwmulsuvx,
10231 {{0x0000, 0xabaa, 0x0154, 0xacfe, 0x02a8, 0xae52, 0x03fc, 0xafa6},
10232 {0x0550, 0xb0fa, 0x06a4, 0xb24e, 0x07f8, 0xb3a2, 0x094c, 0xb4f6},
10233 {0x0aa0, 0xb64a, 0x0bf4, 0xb79e, 0x0d48, 0xb8f2, 0x0e9c, 0xba46},
10234 {0x0ff0, 0xbb9a, 0x1144, 0xbcee, 0x1298, 0xbe42, 0x13ec, 0xbf96},
10235 {0x1540, 0xc0ea, 0x1694, 0xc23e, 0x17e8, 0xc392, 0x193c, 0xc4e6},
10236 {0x1a90, 0xc63a, 0x1be4, 0xc78e, 0x1d38, 0xc8e2, 0x1e8c, 0xca36},
10237 {0x1fe0, 0xcb8a, 0x2134, 0xccde, 0x2288, 0xce32, 0x23dc, 0xcf86},
10238 {0x2530, 0xd0da, 0x2684, 0xd22e, 0x27d8, 0xd382, 0x292c, 0xd4d6}},
10239 {{0xab55'aa00, 0xacac'5354, 0xae02'fca8, 0xaf59'a5fc},
10240 {0xb0b0'4f50, 0xb206'f8a4, 0xb35d'a1f8, 0xb4b4'4b4c},
10241 {0xb60a'f4a0, 0xb761'9df4, 0xb8b8'4748, 0xba0e'f09c},
10242 {0xbb65'99f0, 0xbcbc'4344, 0xbe12'ec98, 0xbf69'95ec},
10243 {0xc0c0'3f40, 0xc216'e894, 0xc36d'91e8, 0xc4c4'3b3c},
10244 {0xc61a'e490, 0xc771'8de4, 0xc8c8'3738, 0xca1e'e08c},
10245 {0xcb75'89e0, 0xcccc'3334, 0xce22'dc88, 0xcf79'85dc},
10246 {0xd0d0'2f30, 0xd226'd884, 0xd37d'81d8, 0xd4d4'2b2c}},
10247 {{0xacac'5600'5353'aa00, 0xaf59'ae02'fb50'fca8},
10248 {0xb207'0605'a34e'4f50, 0xb4b4'5e08'4b4b'a1f8},
10249 {0xb761'b60a'f348'f4a0, 0xba0f'0e0d'9b46'4748},
10250 {0xbcbc'6610'4343'99f0, 0xbf69'be12'eb40'ec98},
10251 {0xc217'1615'933e'3f40, 0xc4c4'6e18'3b3b'91e8},
10252 {0xc771'c61a'e338'e490, 0xca1f'1e1d'8b36'3738},
10253 {0xcccc'7620'3333'89e0, 0xcf79'ce22'db30'dc88},
10254 {0xd227'2625'832e'2f30, 0xd4d4'7e28'2b2b'81d8}},
10255 kVectorCalculationsSource);
10256 }
10257
ExecVwmuluvv()10258 [[gnu::naked]] void ExecVwmuluvv() {
10259 asm("vwmulu.vv v8, v16, v24\n\t"
10260 "ret\n\t");
10261 }
10262
ExecMaskedVwmuluvv()10263 [[gnu::naked]] void ExecMaskedVwmuluvv() {
10264 asm("vwmulu.vv v8, v16, v24, v0.t\n\t"
10265 "ret\n\t");
10266 }
10267
TEST(InlineAsmTestRiscv64,TestVwmulu)10268 TEST(InlineAsmTestRiscv64, TestVwmulu) {
10269 TestWideningVectorInstruction(ExecVwmuluvv,
10270 ExecMaskedVwmuluvv,
10271 {{0x0000, 0x4992, 0x0008, 0x4cc2, 0x0024, 0x5002, 0x0048, 0x5352},
10272 {0x0088, 0x4592, 0x00c8, 0x48c2, 0x0120, 0x4c02, 0x0188, 0x4f52},
10273 {0x0200, 0x64d2, 0x0288, 0x6882, 0x0334, 0x6c42, 0x03c8, 0x7012},
10274 {0x0498, 0x60d2, 0x0548, 0x6482, 0x0620, 0x6842, 0x0708, 0x6c12},
10275 {0x0800, 0x8412, 0x0908, 0x8842, 0x0a44, 0x8c82, 0x0b48, 0x90d2},
10276 {0x0ca8, 0x8012, 0x0dc8, 0x8442, 0x0f20, 0x8882, 0x1088, 0x8cd2},
10277 {0x1200, 0xa752, 0x1388, 0xac02, 0x1554, 0xb0c2, 0x16c8, 0xb592},
10278 {0x18b8, 0xa352, 0x1a48, 0xa802, 0x1c20, 0xacc2, 0x1e08, 0xb192}},
10279 {{0x4992'0000, 0x4cc5'3808, 0x5009'1524, 0x535c'0848},
10280 {0x459f'2988, 0x48d2'18c8, 0x4c15'b120, 0x4f69'6988},
10281 {0x64ef'4200, 0x68a3'7a88, 0x6c68'6834, 0x703c'4bc8},
10282 {0x60fe'7d98, 0x64b2'5d48, 0x6876'f620, 0x6c4b'af08},
10283 {0x8454'8800, 0x8889'c108, 0x8ccf'bf44, 0x9124'9348},
10284 {0x8065'd5a8, 0x849a'a5c8, 0x88e0'3f20, 0x8d35'f888},
10285 {0xa7c1'd200, 0xac78'0b88, 0xb13f'1a54, 0xb614'dec8},
10286 {0xa3d5'31b8, 0xa88a'f248, 0xad51'8c20, 0xb228'4608}},
10287 {{0x4cc5'ce57'7192'0000, 0x535c'aba5'5f6f'1524},
10288 {0x48d2'a731'79e9'2988, 0x4f6a'04ff'56b5'b120},
10289 {0x68a4'4813'116f'4200, 0x703d'2865'125e'6834},
10290 {0x64b3'22f1'2dd8'7d98, 0x6c4c'83c2'fd96'f620},
10291 {0x888a'cdde'bd54'8800, 0x9125'b134'd155'bf44},
10292 {0x849b'aac0'edcf'd5a8, 0x8d37'0e96'b080'3f20},
10293 {0xac79'5fba'7541'd200, 0xb616'4614'9c55'1a54},
10294 {0xa88c'3ea0'b9cf'31b8, 0xb229'a57a'6f71'8c20}},
10295 kVectorCalculationsSource);
10296 }
10297
ExecVwmuluvx()10298 [[gnu::naked]] void ExecVwmuluvx() {
10299 asm("vwmulu.vx v8, v16, t0\n\t"
10300 "ret\n\t");
10301 }
10302
ExecMaskedVwmuluvx()10303 [[gnu::naked]] void ExecMaskedVwmuluvx() {
10304 asm("vwmulu.vx v8, v16, t0, v0.t\n\t"
10305 "ret\n\t");
10306 }
10307
TEST(InlineAsmTestRiscv64,TestVwmuluvx)10308 TEST(InlineAsmTestRiscv64, TestVwmuluvx) {
10309 TestWideningVectorInstruction(ExecVwmuluvx,
10310 ExecMaskedVwmuluvx,
10311 {{0x0000, 0x55aa, 0x0154, 0x56fe, 0x02a8, 0x5852, 0x03fc, 0x59a6},
10312 {0x0550, 0x5afa, 0x06a4, 0x5c4e, 0x07f8, 0x5da2, 0x094c, 0x5ef6},
10313 {0x0aa0, 0x604a, 0x0bf4, 0x619e, 0x0d48, 0x62f2, 0x0e9c, 0x6446},
10314 {0x0ff0, 0x659a, 0x1144, 0x66ee, 0x1298, 0x6842, 0x13ec, 0x6996},
10315 {0x1540, 0x6aea, 0x1694, 0x6c3e, 0x17e8, 0x6d92, 0x193c, 0x6ee6},
10316 {0x1a90, 0x703a, 0x1be4, 0x718e, 0x1d38, 0x72e2, 0x1e8c, 0x7436},
10317 {0x1fe0, 0x758a, 0x2134, 0x76de, 0x2288, 0x7832, 0x23dc, 0x7986},
10318 {0x2530, 0x7ada, 0x2684, 0x7c2e, 0x27d8, 0x7d82, 0x292c, 0x7ed6}},
10319 {{0x55ff'aa00, 0x5756'5354, 0x58ac'fca8, 0x5a03'a5fc},
10320 {0x5b5a'4f50, 0x5cb0'f8a4, 0x5e07'a1f8, 0x5f5e'4b4c},
10321 {0x60b4'f4a0, 0x620b'9df4, 0x6362'4748, 0x64b8'f09c},
10322 {0x660f'99f0, 0x6766'4344, 0x68bc'ec98, 0x6a13'95ec},
10323 {0x6b6a'3f40, 0x6cc0'e894, 0x6e17'91e8, 0x6f6e'3b3c},
10324 {0x70c4'e490, 0x721b'8de4, 0x7372'3738, 0x74c8'e08c},
10325 {0x761f'89e0, 0x7776'3334, 0x78cc'dc88, 0x7a23'85dc},
10326 {0x7b7a'2f30, 0x7cd0'd884, 0x7e27'81d8, 0x7f7e'2b2c}},
10327 {{0x5757'00aa'5353'aa00, 0x5a04'58ac'fb50'fca8},
10328 {0x5cb1'b0af'a34e'4f50, 0x5f5f'08b2'4b4b'a1f8},
10329 {0x620c'60b4'f348'f4a0, 0x64b9'b8b7'9b46'4748},
10330 {0x6767'10ba'4343'99f0, 0x6a14'68bc'eb40'ec98},
10331 {0x6cc1'c0bf'933e'3f40, 0x6f6f'18c2'3b3b'91e8},
10332 {0x721c'70c4'e338'e490, 0x74c9'c8c7'8b36'3738},
10333 {0x7777'20ca'3333'89e0, 0x7a24'78cc'db30'dc88},
10334 {0x7cd1'd0cf'832e'2f30, 0x7f7f'28d2'2b2b'81d8}},
10335 kVectorCalculationsSource);
10336 }
10337
ExecVwmulvx()10338 [[gnu::naked]] void ExecVwmulvx() {
10339 asm("vwmul.vx v8, v16, t0\n\t"
10340 "ret\n\t");
10341 }
10342
ExecMaskedVwmulvx()10343 [[gnu::naked]] void ExecMaskedVwmulvx() {
10344 asm("vwmul.vx v8, v16, t0, v0.t\n\t"
10345 "ret\n\t");
10346 }
10347
TEST(InlineAsmTestRiscv64,TestVwmulvx)10348 TEST(InlineAsmTestRiscv64, TestVwmulvx) {
10349 TestWideningVectorInstruction(ExecVwmulvx,
10350 ExecMaskedVwmulvx,
10351 {{0x0000, 0x2aaa, 0xff54, 0x29fe, 0xfea8, 0x2952, 0xfdfc, 0x28a6},
10352 {0xfd50, 0x27fa, 0xfca4, 0x274e, 0xfbf8, 0x26a2, 0xfb4c, 0x25f6},
10353 {0xfaa0, 0x254a, 0xf9f4, 0x249e, 0xf948, 0x23f2, 0xf89c, 0x2346},
10354 {0xf7f0, 0x229a, 0xf744, 0x21ee, 0xf698, 0x2142, 0xf5ec, 0x2096},
10355 {0xf540, 0x1fea, 0xf494, 0x1f3e, 0xf3e8, 0x1e92, 0xf33c, 0x1de6},
10356 {0xf290, 0x1d3a, 0xf1e4, 0x1c8e, 0xf138, 0x1be2, 0xf08c, 0x1b36},
10357 {0xefe0, 0x1a8a, 0xef34, 0x19de, 0xee88, 0x1932, 0xeddc, 0x1886},
10358 {0xed30, 0x17da, 0xec84, 0x172e, 0xebd8, 0x1682, 0xeb2c, 0x15d6}},
10359 {{0x2a55'aa00, 0x29aa'5354, 0x28fe'fca8, 0x2853'a5fc},
10360 {0x27a8'4f50, 0x26fc'f8a4, 0x2651'a1f8, 0x25a6'4b4c},
10361 {0x24fa'f4a0, 0x244f'9df4, 0x23a4'4748, 0x22f8'f09c},
10362 {0x224d'99f0, 0x21a2'4344, 0x20f6'ec98, 0x204b'95ec},
10363 {0x1fa0'3f40, 0x1ef4'e894, 0x1e49'91e8, 0x1d9e'3b3c},
10364 {0x1cf2'e490, 0x1c47'8de4, 0x1b9c'3738, 0x1af0'e08c},
10365 {0x1a45'89e0, 0x199a'3334, 0x18ee'dc88, 0x1843'85dc},
10366 {0x1798'2f30, 0x16ec'd884, 0x1641'81d8, 0x1596'2b2c}},
10367 {{0x29a9'd500'5353'aa00, 0x2853'28fe'fb50'fca8},
10368 {0x26fc'7cfd'a34e'4f50, 0x25a5'd0fc'4b4b'a1f8},
10369 {0x244f'24fa'f348'f4a0, 0x22f8'78f9'9b46'4748},
10370 {0x21a1'ccf8'4343'99f0, 0x204b'20f6'eb40'ec98},
10371 {0x1ef4'74f5'933e'3f40, 0x1d9d'c8f4'3b3b'91e8},
10372 {0x1c47'1cf2'e338'e490, 0x1af0'70f1'8b36'3738},
10373 {0x1999'c4f0'3333'89e0, 0x1843'18ee'db30'dc88},
10374 {0x16ec'6ced'832e'2f30, 0x1595'c0ec'2b2b'81d8}},
10375 kVectorCalculationsSource);
10376 }
10377
ExecVwsubuvv()10378 [[gnu::naked]] void ExecVwsubuvv() {
10379 asm("vwsubu.vv v8, v16, v24\n\t"
10380 "ret\n\t");
10381 }
10382
ExecMaskedVwsubuvv()10383 [[gnu::naked]] void ExecMaskedVwsubuvv() {
10384 asm("vwsubu.vv v8, v16, v24, v0.t\n\t"
10385 "ret\n\t");
10386 }
10387
TEST(InlineAsmTestRiscv64,TestVwsubuvv)10388 TEST(InlineAsmTestRiscv64, TestVwsubuvv) {
10389 TestWideningVectorInstruction(ExecVwsubuvv,
10390 ExecMaskedVwsubuvv,
10391 {{0x0000, 0xffef, 0xfffe, 0xffed, 0xfffb, 0xffeb, 0xfffa, 0xffe9},
10392 {0xfff7, 0x0007, 0xfff6, 0x0005, 0xfff4, 0x0003, 0xfff2, 0x0001},
10393 {0xfff0, 0xffdf, 0xffee, 0xffdd, 0xffeb, 0xffdb, 0xffea, 0xffd9},
10394 {0xffe7, 0xfff7, 0xffe6, 0xfff5, 0xffe4, 0xfff3, 0xffe2, 0xfff1},
10395 {0xffe0, 0xffcf, 0xffde, 0xffcd, 0xffdb, 0xffcb, 0xffda, 0xffc9},
10396 {0xffd7, 0xffe7, 0xffd6, 0xffe5, 0xffd4, 0xffe3, 0xffd2, 0xffe1},
10397 {0xffd0, 0xffbf, 0xffce, 0xffbd, 0xffcb, 0xffbb, 0xffca, 0xffb9},
10398 {0xffc7, 0xffd7, 0xffc6, 0xffd5, 0xffc4, 0xffd3, 0xffc2, 0xffd1}},
10399 {{0xffff'ef00, 0xffff'ecfe, 0xffff'eafb, 0xffff'e8fa},
10400 {0x0000'06f7, 0x0000'04f6, 0x0000'02f4, 0x0000'00f2},
10401 {0xffff'def0, 0xffff'dcee, 0xffff'daeb, 0xffff'd8ea},
10402 {0xffff'f6e7, 0xffff'f4e6, 0xffff'f2e4, 0xffff'f0e2},
10403 {0xffff'cee0, 0xffff'ccde, 0xffff'cadb, 0xffff'c8da},
10404 {0xffff'e6d7, 0xffff'e4d6, 0xffff'e2d4, 0xffff'e0d2},
10405 {0xffff'bed0, 0xffff'bcce, 0xffff'bacb, 0xffff'b8ca},
10406 {0xffff'd6c7, 0xffff'd4c6, 0xffff'd2c4, 0xffff'd0c2}},
10407 {{0xffff'ffff'ecfd'ef00, 0xffff'ffff'e8f9'eafb},
10408 {0x0000'0000'04f6'06f7, 0x0000'0000'00f2'02f4},
10409 {0xffff'ffff'dced'def0, 0xffff'ffff'd8e9'daeb},
10410 {0xffff'ffff'f4e5'f6e7, 0xffff'ffff'f0e1'f2e4},
10411 {0xffff'ffff'ccdd'cee0, 0xffff'ffff'c8d9'cadb},
10412 {0xffff'ffff'e4d5'e6d7, 0xffff'ffff'e0d1'e2d4},
10413 {0xffff'ffff'bccd'bed0, 0xffff'ffff'b8c9'bacb},
10414 {0xffff'ffff'd4c5'd6c7, 0xffff'ffff'd0c1'd2c4}},
10415 kVectorCalculationsSource);
10416 }
10417
ExecVwsubuvx()10418 [[gnu::naked]] void ExecVwsubuvx() {
10419 asm("vwsubu.vx v8, v16, t0\n\t"
10420 "ret\n\t");
10421 }
10422
ExecMaskedVwsubuvx()10423 [[gnu::naked]] void ExecMaskedVwsubuvx() {
10424 asm("vwsubu.vx v8, v16, t0, v0.t\n\t"
10425 "ret\n\t");
10426 }
10427
TEST(InlineAsmTestRiscv64,TestVwsubuvx)10428 TEST(InlineAsmTestRiscv64, TestVwsubuvx) {
10429 TestWideningVectorInstruction(ExecVwsubuvx,
10430 ExecMaskedVwsubuvx,
10431 {{0xff56, 0xffd7, 0xff58, 0xffd9, 0xff5a, 0xffdb, 0xff5c, 0xffdd},
10432 {0xff5e, 0xffdf, 0xff60, 0xffe1, 0xff62, 0xffe3, 0xff64, 0xffe5},
10433 {0xff66, 0xffe7, 0xff68, 0xffe9, 0xff6a, 0xffeb, 0xff6c, 0xffed},
10434 {0xff6e, 0xffef, 0xff70, 0xfff1, 0xff72, 0xfff3, 0xff74, 0xfff5},
10435 {0xff76, 0xfff7, 0xff78, 0xfff9, 0xff7a, 0xfffb, 0xff7c, 0xfffd},
10436 {0xff7e, 0xffff, 0xff80, 0x0001, 0xff82, 0x0003, 0xff84, 0x0005},
10437 {0xff86, 0x0007, 0xff88, 0x0009, 0xff8a, 0x000b, 0xff8c, 0x000d},
10438 {0xff8e, 0x000f, 0xff90, 0x0011, 0xff92, 0x0013, 0xff94, 0x0015}},
10439 {{0xffff'd656, 0xffff'd858, 0xffff'da5a, 0xffff'dc5c},
10440 {0xffff'de5e, 0xffff'e060, 0xffff'e262, 0xffff'e464},
10441 {0xffff'e666, 0xffff'e868, 0xffff'ea6a, 0xffff'ec6c},
10442 {0xffff'ee6e, 0xffff'f070, 0xffff'f272, 0xffff'f474},
10443 {0xffff'f676, 0xffff'f878, 0xffff'fa7a, 0xffff'fc7c},
10444 {0xffff'fe7e, 0x0000'0080, 0x0000'0282, 0x0000'0484},
10445 {0x0000'0686, 0x0000'0888, 0x0000'0a8a, 0x0000'0c8c},
10446 {0x0000'0e8e, 0x0000'1090, 0x0000'1292, 0x0000'1494}},
10447 {{0xffff'ffff'd857'd656, 0xffff'ffff'dc5b'da5a},
10448 {0xffff'ffff'e05f'de5e, 0xffff'ffff'e463'e262},
10449 {0xffff'ffff'e867'e666, 0xffff'ffff'ec6b'ea6a},
10450 {0xffff'ffff'f06f'ee6e, 0xffff'ffff'f473'f272},
10451 {0xffff'ffff'f877'f676, 0xffff'ffff'fc7b'fa7a},
10452 {0x0000'0000'007f'fe7e, 0x0000'0000'0484'0282},
10453 {0x0000'0000'0888'0686, 0x0000'0000'0c8c'0a8a},
10454 {0x0000'0000'1090'0e8e, 0x0000'0000'1494'1292}},
10455 kVectorCalculationsSource);
10456 }
10457
ExecVwsubuwv()10458 [[gnu::naked]] void ExecVwsubuwv() {
10459 asm("vwsubu.wv v8, v16, v24\n\t"
10460 "ret\n\t");
10461 }
10462
ExecMaskedVwsubuwv()10463 [[gnu::naked]] void ExecMaskedVwsubuwv() {
10464 asm("vwsubu.wv v8, v16, v24, v0.t\n\t"
10465 "ret\n\t");
10466 }
10467
TEST(InlineAsmTestRiscv64,TestVwsubuwv)10468 TEST(InlineAsmTestRiscv64, TestVwsubuwv) {
10469 TestWideningVectorInstruction(ExecVwsubuwv,
10470 ExecMaskedVwsubuwv,
10471 {{0x8100, 0x8270, 0x8500, 0x8670, 0x88ff, 0x8a70, 0x8d00, 0x8e70},
10472 {0x90ff, 0x9290, 0x9500, 0x9690, 0x9900, 0x9a90, 0x9d00, 0x9e90},
10473 {0xa100, 0xa270, 0xa500, 0xa670, 0xa8ff, 0xaa70, 0xad00, 0xae70},
10474 {0xb0ff, 0xb290, 0xb500, 0xb690, 0xb900, 0xba90, 0xbd00, 0xbe90},
10475 {0xc100, 0xc270, 0xc500, 0xc670, 0xc8ff, 0xca70, 0xcd00, 0xce70},
10476 {0xd0ff, 0xd290, 0xd500, 0xd690, 0xd900, 0xda90, 0xdd00, 0xde90},
10477 {0xe100, 0xe270, 0xe500, 0xe670, 0xe8ff, 0xea70, 0xed00, 0xee70},
10478 {0xf0ff, 0xf290, 0xf500, 0xf690, 0xf900, 0xfa90, 0xfd00, 0xfe90}},
10479 {{0x8301'ef00, 0x8705'ef00, 0x8b09'eeff, 0x8f0d'ef00},
10480 {0x9312'0eff, 0x9716'0f00, 0x9b1a'0f00, 0x9f1e'0f00},
10481 {0xa321'ef00, 0xa725'ef00, 0xab29'eeff, 0xaf2d'ef00},
10482 {0xb332'0eff, 0xb736'0f00, 0xbb3a'0f00, 0xbf3e'0f00},
10483 {0xc341'ef00, 0xc745'ef00, 0xcb49'eeff, 0xcf4d'ef00},
10484 {0xd352'0eff, 0xd756'0f00, 0xdb5a'0f00, 0xdf5e'0f00},
10485 {0xe361'ef00, 0xe765'ef00, 0xeb69'eeff, 0xef6d'ef00},
10486 {0xf372'0eff, 0xf776'0f00, 0xfb7a'0f00, 0xff7e'0f00}},
10487 {{0x8706'8503'ecfd'ef00, 0x8f0e'8d0b'ecfd'eeff},
10488 {0x9716'9514'0cfe'0eff, 0x9f1e'9d1c'0cfe'0f00},
10489 {0xa726'a523'ecfd'ef00, 0xaf2e'ad2b'ecfd'eeff},
10490 {0xb736'b534'0cfe'0eff, 0xbf3e'bd3c'0cfe'0f00},
10491 {0xc746'c543'ecfd'ef00, 0xcf4e'cd4b'ecfd'eeff},
10492 {0xd756'd554'0cfe'0eff, 0xdf5e'dd5c'0cfe'0f00},
10493 {0xe766'e563'ecfd'ef00, 0xef6e'ed6b'ecfd'eeff},
10494 {0xf776'f574'0cfe'0eff, 0xff7e'fd7c'0cfe'0f00}},
10495 kVectorCalculationsSource);
10496 }
10497
ExecVwsubuwx()10498 [[gnu::naked]] void ExecVwsubuwx() {
10499 asm("vwsubu.wx v8, v16, t0\n\t"
10500 "ret\n\t");
10501 }
10502
ExecMaskedVwsubuwx()10503 [[gnu::naked]] void ExecMaskedVwsubuwx() {
10504 asm("vwsubu.wx v8, v16, t0, v0.t\n\t"
10505 "ret\n\t");
10506 }
10507
TEST(InlineAsmTestRiscv64,TestVwsubuwx)10508 TEST(InlineAsmTestRiscv64, TestVwsubuwx) {
10509 TestWideningVectorInstruction(ExecVwsubuwx,
10510 ExecMaskedVwsubuwx,
10511 {{0x8056, 0x8258, 0x845a, 0x865c, 0x885e, 0x8a60, 0x8c62, 0x8e64},
10512 {0x9066, 0x9268, 0x946a, 0x966c, 0x986e, 0x9a70, 0x9c72, 0x9e74},
10513 {0xa076, 0xa278, 0xa47a, 0xa67c, 0xa87e, 0xaa80, 0xac82, 0xae84},
10514 {0xb086, 0xb288, 0xb48a, 0xb68c, 0xb88e, 0xba90, 0xbc92, 0xbe94},
10515 {0xc096, 0xc298, 0xc49a, 0xc69c, 0xc89e, 0xcaa0, 0xcca2, 0xcea4},
10516 {0xd0a6, 0xd2a8, 0xd4aa, 0xd6ac, 0xd8ae, 0xdab0, 0xdcb2, 0xdeb4},
10517 {0xe0b6, 0xe2b8, 0xe4ba, 0xe6bc, 0xe8be, 0xeac0, 0xecc2, 0xeec4},
10518 {0xf0c6, 0xf2c8, 0xf4ca, 0xf6cc, 0xf8ce, 0xfad0, 0xfcd2, 0xfed4}},
10519 {{0x8301'd656, 0x8705'da5a, 0x8b09'de5e, 0x8f0d'e262},
10520 {0x9311'e666, 0x9715'ea6a, 0x9b19'ee6e, 0x9f1d'f272},
10521 {0xa321'f676, 0xa725'fa7a, 0xab29'fe7e, 0xaf2e'0282},
10522 {0xb332'0686, 0xb736'0a8a, 0xbb3a'0e8e, 0xbf3e'1292},
10523 {0xc342'1696, 0xc746'1a9a, 0xcb4a'1e9e, 0xcf4e'22a2},
10524 {0xd352'26a6, 0xd756'2aaa, 0xdb5a'2eae, 0xdf5e'32b2},
10525 {0xe362'36b6, 0xe766'3aba, 0xeb6a'3ebe, 0xef6e'42c2},
10526 {0xf372'46c6, 0xf776'4aca, 0xfb7a'4ece, 0xff7e'52d2}},
10527 {{0x8706'8503'd857'd656, 0x8f0e'8d0b'e05f'de5e},
10528 {0x9716'9513'e867'e666, 0x9f1e'9d1b'f06f'ee6e},
10529 {0xa726'a523'f877'f676, 0xaf2e'ad2c'007f'fe7e},
10530 {0xb736'b534'0888'0686, 0xbf3e'bd3c'1090'0e8e},
10531 {0xc746'c544'1898'1696, 0xcf4e'cd4c'20a0'1e9e},
10532 {0xd756'd554'28a8'26a6, 0xdf5e'dd5c'30b0'2eae},
10533 {0xe766'e564'38b8'36b6, 0xef6e'ed6c'40c0'3ebe},
10534 {0xf776'f574'48c8'46c6, 0xff7e'fd7c'50d0'4ece}},
10535 kVectorCalculationsSource);
10536 }
10537
ExecVwsubvv()10538 [[gnu::naked]] void ExecVwsubvv() {
10539 asm("vwsub.vv v8, v16, v24\n\t"
10540 "ret\n\t");
10541 }
10542
ExecMaskedVwsubvv()10543 [[gnu::naked]] void ExecMaskedVwsubvv() {
10544 asm("vwsub.vv v8, v16, v24, v0.t\n\t"
10545 "ret\n\t");
10546 }
10547
TEST(InlineAsmTestRiscv64,TestVwsubvv)10548 TEST(InlineAsmTestRiscv64, TestVwsubvv) {
10549 TestWideningVectorInstruction(ExecVwsubvv,
10550 ExecMaskedVwsubvv,
10551 {{0x0000, 0xffef, 0xfffe, 0xffed, 0xfffb, 0xffeb, 0xfffa, 0xffe9},
10552 {0xfff7, 0x0007, 0xfff6, 0x0005, 0xfff4, 0x0003, 0xfff2, 0x0001},
10553 {0xfff0, 0xffdf, 0xffee, 0xffdd, 0xffeb, 0xffdb, 0xffea, 0xffd9},
10554 {0xffe7, 0xfff7, 0xffe6, 0xfff5, 0xffe4, 0xfff3, 0xffe2, 0xfff1},
10555 {0xffe0, 0xffcf, 0xffde, 0xffcd, 0xffdb, 0xffcb, 0xffda, 0xffc9},
10556 {0xffd7, 0xffe7, 0xffd6, 0xffe5, 0xffd4, 0xffe3, 0xffd2, 0xffe1},
10557 {0xffd0, 0xffbf, 0xffce, 0xffbd, 0xffcb, 0xffbb, 0xffca, 0xffb9},
10558 {0xffc7, 0xffd7, 0xffc6, 0xffd5, 0xffc4, 0xffd3, 0xffc2, 0xffd1}},
10559 {{0xffff'ef00, 0xffff'ecfe, 0xffff'eafb, 0xffff'e8fa},
10560 {0x0000'06f7, 0x0000'04f6, 0x0000'02f4, 0x0000'00f2},
10561 {0xffff'def0, 0xffff'dcee, 0xffff'daeb, 0xffff'd8ea},
10562 {0xffff'f6e7, 0xffff'f4e6, 0xffff'f2e4, 0xffff'f0e2},
10563 {0xffff'cee0, 0xffff'ccde, 0xffff'cadb, 0xffff'c8da},
10564 {0xffff'e6d7, 0xffff'e4d6, 0xffff'e2d4, 0xffff'e0d2},
10565 {0xffff'bed0, 0xffff'bcce, 0xffff'bacb, 0xffff'b8ca},
10566 {0xffff'd6c7, 0xffff'd4c6, 0xffff'd2c4, 0xffff'd0c2}},
10567 {{0xffff'ffff'ecfd'ef00, 0xffff'ffff'e8f9'eafb},
10568 {0x0000'0000'04f6'06f7, 0x0000'0000'00f2'02f4},
10569 {0xffff'ffff'dced'def0, 0xffff'ffff'd8e9'daeb},
10570 {0xffff'ffff'f4e5'f6e7, 0xffff'ffff'f0e1'f2e4},
10571 {0xffff'ffff'ccdd'cee0, 0xffff'ffff'c8d9'cadb},
10572 {0xffff'ffff'e4d5'e6d7, 0xffff'ffff'e0d1'e2d4},
10573 {0xffff'ffff'bccd'bed0, 0xffff'ffff'b8c9'bacb},
10574 {0xffff'ffff'd4c5'd6c7, 0xffff'ffff'd0c1'd2c4}},
10575 kVectorCalculationsSource);
10576 }
10577
ExecVwsubvx()10578 [[gnu::naked]] void ExecVwsubvx() {
10579 asm("vwsub.vx v8, v16, t0\n\t"
10580 "ret\n\t");
10581 }
10582
ExecMaskedVwsubvx()10583 [[gnu::naked]] void ExecMaskedVwsubvx() {
10584 asm("vwsub.vx v8, v16, t0, v0.t\n\t"
10585 "ret\n\t");
10586 }
10587
TEST(InlineAsmTestRiscv64,TestVwsubvx)10588 TEST(InlineAsmTestRiscv64, TestVwsubvx) {
10589 TestWideningVectorInstruction(ExecVwsubvx,
10590 ExecMaskedVwsubvx,
10591 {{0x0056, 0xffd7, 0x0058, 0xffd9, 0x005a, 0xffdb, 0x005c, 0xffdd},
10592 {0x005e, 0xffdf, 0x0060, 0xffe1, 0x0062, 0xffe3, 0x0064, 0xffe5},
10593 {0x0066, 0xffe7, 0x0068, 0xffe9, 0x006a, 0xffeb, 0x006c, 0xffed},
10594 {0x006e, 0xffef, 0x0070, 0xfff1, 0x0072, 0xfff3, 0x0074, 0xfff5},
10595 {0x0076, 0xfff7, 0x0078, 0xfff9, 0x007a, 0xfffb, 0x007c, 0xfffd},
10596 {0x007e, 0xffff, 0x0080, 0x0001, 0x0082, 0x0003, 0x0084, 0x0005},
10597 {0x0086, 0x0007, 0x0088, 0x0009, 0x008a, 0x000b, 0x008c, 0x000d},
10598 {0x008e, 0x000f, 0x0090, 0x0011, 0x0092, 0x0013, 0x0094, 0x0015}},
10599 {{0xffff'd656, 0xffff'd858, 0xffff'da5a, 0xffff'dc5c},
10600 {0xffff'de5e, 0xffff'e060, 0xffff'e262, 0xffff'e464},
10601 {0xffff'e666, 0xffff'e868, 0xffff'ea6a, 0xffff'ec6c},
10602 {0xffff'ee6e, 0xffff'f070, 0xffff'f272, 0xffff'f474},
10603 {0xffff'f676, 0xffff'f878, 0xffff'fa7a, 0xffff'fc7c},
10604 {0xffff'fe7e, 0x0000'0080, 0x0000'0282, 0x0000'0484},
10605 {0x0000'0686, 0x0000'0888, 0x0000'0a8a, 0x0000'0c8c},
10606 {0x0000'0e8e, 0x0000'1090, 0x0000'1292, 0x0000'1494}},
10607 {{0xffff'ffff'd857'd656, 0xffff'ffff'dc5b'da5a},
10608 {0xffff'ffff'e05f'de5e, 0xffff'ffff'e463'e262},
10609 {0xffff'ffff'e867'e666, 0xffff'ffff'ec6b'ea6a},
10610 {0xffff'ffff'f06f'ee6e, 0xffff'ffff'f473'f272},
10611 {0xffff'ffff'f877'f676, 0xffff'ffff'fc7b'fa7a},
10612 {0x0000'0000'007f'fe7e, 0x0000'0000'0484'0282},
10613 {0x0000'0000'0888'0686, 0x0000'0000'0c8c'0a8a},
10614 {0x0000'0000'1090'0e8e, 0x0000'0000'1494'1292}},
10615 kVectorCalculationsSource);
10616 }
10617
ExecVwsubwv()10618 [[gnu::naked]] void ExecVwsubwv() {
10619 asm("vwsub.wv v8, v16, v24\n\t"
10620 "ret\n\t");
10621 }
10622
ExecMaskedVwsubwv()10623 [[gnu::naked]] void ExecMaskedVwsubwv() {
10624 asm("vwsub.wv v8, v16, v24, v0.t\n\t"
10625 "ret\n\t");
10626 }
10627
TEST(InlineAsmTestRiscv64,TestVwsubwv)10628 TEST(InlineAsmTestRiscv64, TestVwsubwv) {
10629 TestWideningVectorInstruction(ExecVwsubwv,
10630 ExecMaskedVwsubwv,
10631 {{0x8100, 0x8370, 0x8500, 0x8770, 0x88ff, 0x8b70, 0x8d00, 0x8f70},
10632 {0x90ff, 0x9390, 0x9500, 0x9790, 0x9900, 0x9b90, 0x9d00, 0x9f90},
10633 {0xa100, 0xa370, 0xa500, 0xa770, 0xa8ff, 0xab70, 0xad00, 0xaf70},
10634 {0xb0ff, 0xb390, 0xb500, 0xb790, 0xb900, 0xbb90, 0xbd00, 0xbf90},
10635 {0xc100, 0xc370, 0xc500, 0xc770, 0xc8ff, 0xcb70, 0xcd00, 0xcf70},
10636 {0xd0ff, 0xd390, 0xd500, 0xd790, 0xd900, 0xdb90, 0xdd00, 0xdf90},
10637 {0xe100, 0xe370, 0xe500, 0xe770, 0xe8ff, 0xeb70, 0xed00, 0xef70},
10638 {0xf0ff, 0xf390, 0xf500, 0xf790, 0xf900, 0xfb90, 0xfd00, 0xff90}},
10639 {{0x8302'ef00, 0x8706'ef00, 0x8b0a'eeff, 0x8f0e'ef00},
10640 {0x9313'0eff, 0x9717'0f00, 0x9b1b'0f00, 0x9f1f'0f00},
10641 {0xa322'ef00, 0xa726'ef00, 0xab2a'eeff, 0xaf2e'ef00},
10642 {0xb333'0eff, 0xb737'0f00, 0xbb3b'0f00, 0xbf3f'0f00},
10643 {0xc342'ef00, 0xc746'ef00, 0xcb4a'eeff, 0xcf4e'ef00},
10644 {0xd353'0eff, 0xd757'0f00, 0xdb5b'0f00, 0xdf5f'0f00},
10645 {0xe362'ef00, 0xe766'ef00, 0xeb6a'eeff, 0xef6e'ef00},
10646 {0xf373'0eff, 0xf777'0f00, 0xfb7b'0f00, 0xff7f'0f00}},
10647 {{0x8706'8504'ecfd'ef00, 0x8f0e'8d0c'ecfd'eeff},
10648 {0x9716'9515'0cfe'0eff, 0x9f1e'9d1d'0cfe'0f00},
10649 {0xa726'a524'ecfd'ef00, 0xaf2e'ad2c'ecfd'eeff},
10650 {0xb736'b535'0cfe'0eff, 0xbf3e'bd3d'0cfe'0f00},
10651 {0xc746'c544'ecfd'ef00, 0xcf4e'cd4c'ecfd'eeff},
10652 {0xd756'd555'0cfe'0eff, 0xdf5e'dd5d'0cfe'0f00},
10653 {0xe766'e564'ecfd'ef00, 0xef6e'ed6c'ecfd'eeff},
10654 {0xf776'f575'0cfe'0eff, 0xff7e'fd7d'0cfe'0f00}},
10655 kVectorCalculationsSource);
10656 }
10657
ExecVwsubwx()10658 [[gnu::naked]] void ExecVwsubwx() {
10659 asm("vwsub.wx v8, v16, t0\n\t"
10660 "ret\n\t");
10661 }
10662
ExecMaskedVwsubwx()10663 [[gnu::naked]] void ExecMaskedVwsubwx() {
10664 asm("vwsub.wx v8, v16, t0, v0.t\n\t"
10665 "ret\n\t");
10666 }
10667
TEST(InlineAsmTestRiscv64,TestVwsubwx)10668 TEST(InlineAsmTestRiscv64, TestVwsubwx) {
10669 TestWideningVectorInstruction(ExecVwsubwx,
10670 ExecMaskedVwsubwx,
10671 {{0x8156, 0x8358, 0x855a, 0x875c, 0x895e, 0x8b60, 0x8d62, 0x8f64},
10672 {0x9166, 0x9368, 0x956a, 0x976c, 0x996e, 0x9b70, 0x9d72, 0x9f74},
10673 {0xa176, 0xa378, 0xa57a, 0xa77c, 0xa97e, 0xab80, 0xad82, 0xaf84},
10674 {0xb186, 0xb388, 0xb58a, 0xb78c, 0xb98e, 0xbb90, 0xbd92, 0xbf94},
10675 {0xc196, 0xc398, 0xc59a, 0xc79c, 0xc99e, 0xcba0, 0xcda2, 0xcfa4},
10676 {0xd1a6, 0xd3a8, 0xd5aa, 0xd7ac, 0xd9ae, 0xdbb0, 0xddb2, 0xdfb4},
10677 {0xe1b6, 0xe3b8, 0xe5ba, 0xe7bc, 0xe9be, 0xebc0, 0xedc2, 0xefc4},
10678 {0xf1c6, 0xf3c8, 0xf5ca, 0xf7cc, 0xf9ce, 0xfbd0, 0xfdd2, 0xffd4}},
10679 {{0x8302'd656, 0x8706'da5a, 0x8b0a'de5e, 0x8f0e'e262},
10680 {0x9312'e666, 0x9716'ea6a, 0x9b1a'ee6e, 0x9f1e'f272},
10681 {0xa322'f676, 0xa726'fa7a, 0xab2a'fe7e, 0xaf2f'0282},
10682 {0xb333'0686, 0xb737'0a8a, 0xbb3b'0e8e, 0xbf3f'1292},
10683 {0xc343'1696, 0xc747'1a9a, 0xcb4b'1e9e, 0xcf4f'22a2},
10684 {0xd353'26a6, 0xd757'2aaa, 0xdb5b'2eae, 0xdf5f'32b2},
10685 {0xe363'36b6, 0xe767'3aba, 0xeb6b'3ebe, 0xef6f'42c2},
10686 {0xf373'46c6, 0xf777'4aca, 0xfb7b'4ece, 0xff7f'52d2}},
10687 {{0x8706'8504'd857'd656, 0x8f0e'8d0c'e05f'de5e},
10688 {0x9716'9514'e867'e666, 0x9f1e'9d1c'f06f'ee6e},
10689 {0xa726'a524'f877'f676, 0xaf2e'ad2d'007f'fe7e},
10690 {0xb736'b535'0888'0686, 0xbf3e'bd3d'1090'0e8e},
10691 {0xc746'c545'1898'1696, 0xcf4e'cd4d'20a0'1e9e},
10692 {0xd756'd555'28a8'26a6, 0xdf5e'dd5d'30b0'2eae},
10693 {0xe766'e565'38b8'36b6, 0xef6e'ed6d'40c0'3ebe},
10694 {0xf776'f575'48c8'46c6, 0xff7e'fd7d'50d0'4ece}},
10695 kVectorCalculationsSource);
10696 }
10697
ExecVzextvf8()10698 [[gnu::naked]] void ExecVzextvf8() {
10699 asm("vzext.vf8 v8, v16\n\t"
10700 "ret\n\t");
10701 }
10702
ExecMaskedVzextvf8()10703 [[gnu::naked]] void ExecMaskedVzextvf8() {
10704 asm("vzext.vf8 v8, v16, v0.t\n\t"
10705 "ret\n\t");
10706 }
10707
ExecVsextvf8()10708 [[gnu::naked]] void ExecVsextvf8() {
10709 asm("vsext.vf8 v8, v16\n\t"
10710 "ret\n\t");
10711 }
10712
ExecMaskedVsextvf8()10713 [[gnu::naked]] void ExecMaskedVsextvf8() {
10714 asm("vsext.vf8 v8, v16, v0.t\n\t"
10715 "ret\n\t");
10716 }
10717
ExecVzextvf4()10718 [[gnu::naked]] void ExecVzextvf4() {
10719 asm("vzext.vf4 v8, v16\n\t"
10720 "ret\n\t");
10721 }
10722
ExecMaskedVzextvf4()10723 [[gnu::naked]] void ExecMaskedVzextvf4() {
10724 asm("vzext.vf4 v8, v16, v0.t\n\t"
10725 "ret\n\t");
10726 }
10727
ExecVsextvf4()10728 [[gnu::naked]] void ExecVsextvf4() {
10729 asm("vsext.vf4 v8, v16\n\t"
10730 "ret\n\t");
10731 }
10732
ExecMaskedVsextvf4()10733 [[gnu::naked]] void ExecMaskedVsextvf4() {
10734 asm("vsext.vf4 v8, v16, v0.t\n\t"
10735 "ret\n\t");
10736 }
10737
ExecVzextvf2()10738 [[gnu::naked]] void ExecVzextvf2() {
10739 asm("vzext.vf2 v8, v16\n\t"
10740 "ret\n\t");
10741 }
10742
ExecMaskedVzextvf2()10743 [[gnu::naked]] void ExecMaskedVzextvf2() {
10744 asm("vzext.vf2 v8, v16, v0.t\n\t"
10745 "ret\n\t");
10746 }
10747
ExecVsextvf2()10748 [[gnu::naked]] void ExecVsextvf2() {
10749 asm("vsext.vf2 v8, v16\n\t"
10750 "ret\n\t");
10751 }
10752
ExecMaskedVsextvf2()10753 [[gnu::naked]] void ExecMaskedVsextvf2() {
10754 asm("vsext.vf2 v8, v16, v0.t\n\t"
10755 "ret\n\t");
10756 }
10757
TEST(InlineAsmTestRiscv64,TestVXext)10758 TEST(InlineAsmTestRiscv64, TestVXext) {
10759 TestExtendingVectorInstruction(ExecVzextvf8,
10760 ExecMaskedVzextvf8,
10761 {},
10762 {},
10763 {{0x0000'0000'0000'0000, 0x0000'0000'0000'0081},
10764 {0x0000'0000'0000'0002, 0x0000'0000'0000'0083},
10765 {0x0000'0000'0000'0004, 0x0000'0000'0000'0085},
10766 {0x0000'0000'0000'0006, 0x0000'0000'0000'0087},
10767 {0x0000'0000'0000'0008, 0x0000'0000'0000'0089},
10768 {0x0000'0000'0000'000a, 0x0000'0000'0000'008b},
10769 {0x0000'0000'0000'000c, 0x0000'0000'0000'008d},
10770 {0x0000'0000'0000'000e, 0x0000'0000'0000'008f}},
10771 kVectorCalculationsSource,
10772 8);
10773
10774 TestExtendingVectorInstruction(ExecVsextvf8,
10775 ExecMaskedVsextvf8,
10776 {},
10777 {},
10778 {{0x0000'0000'0000'0000, 0xffff'ffff'ffff'ff81},
10779 {0x0000'0000'0000'0002, 0xffff'ffff'ffff'ff83},
10780 {0x0000'0000'0000'0004, 0xffff'ffff'ffff'ff85},
10781 {0x0000'0000'0000'0006, 0xffff'ffff'ffff'ff87},
10782 {0x0000'0000'0000'0008, 0xffff'ffff'ffff'ff89},
10783 {0x0000'0000'0000'000a, 0xffff'ffff'ffff'ff8b},
10784 {0x0000'0000'0000'000c, 0xffff'ffff'ffff'ff8d},
10785 {0x0000'0000'0000'000e, 0xffff'ffff'ffff'ff8f}},
10786 kVectorCalculationsSource,
10787 8);
10788
10789 TestExtendingVectorInstruction(ExecVzextvf4,
10790 ExecMaskedVzextvf4,
10791 {},
10792 {{0x0000'0000, 0x0000'0081, 0x0000'0002, 0x0000'0083},
10793 {0x0000'0004, 0x0000'0085, 0x0000'0006, 0x0000'0087},
10794 {0x0000'0008, 0x0000'0089, 0x0000'000a, 0x0000'008b},
10795 {0x0000'000c, 0x0000'008d, 0x0000'000e, 0x0000'008f},
10796 {0x0000'0010, 0x0000'0091, 0x0000'0012, 0x0000'0093},
10797 {0x0000'0014, 0x0000'0095, 0x0000'0016, 0x0000'0097},
10798 {0x0000'0018, 0x0000'0099, 0x0000'001a, 0x0000'009b},
10799 {0x0000'001c, 0x0000'009d, 0x0000'001e, 0x0000'009f}},
10800 {{0x0000'0000'0000'8100, 0x0000'0000'0000'8302},
10801 {0x0000'0000'0000'8504, 0x0000'0000'0000'8706},
10802 {0x0000'0000'0000'8908, 0x0000'0000'0000'8b0a},
10803 {0x0000'0000'0000'8d0c, 0x0000'0000'0000'8f0e},
10804 {0x0000'0000'0000'9110, 0x0000'0000'0000'9312},
10805 {0x0000'0000'0000'9514, 0x0000'0000'0000'9716},
10806 {0x0000'0000'0000'9918, 0x0000'0000'0000'9b1a},
10807 {0x0000'0000'0000'9d1c, 0x0000'0000'0000'9f1e}},
10808 kVectorCalculationsSource,
10809 4);
10810
10811 TestExtendingVectorInstruction(ExecVsextvf4,
10812 ExecMaskedVsextvf4,
10813 {},
10814 {{0x0000'0000, 0xffff'ff81, 0x0000'0002, 0xffff'ff83},
10815 {0x0000'0004, 0xffff'ff85, 0x0000'0006, 0xffff'ff87},
10816 {0x0000'0008, 0xffff'ff89, 0x0000'000a, 0xffff'ff8b},
10817 {0x0000'000c, 0xffff'ff8d, 0x0000'000e, 0xffff'ff8f},
10818 {0x0000'0010, 0xffff'ff91, 0x0000'0012, 0xffff'ff93},
10819 {0x0000'0014, 0xffff'ff95, 0x0000'0016, 0xffff'ff97},
10820 {0x0000'0018, 0xffff'ff99, 0x0000'001a, 0xffff'ff9b},
10821 {0x0000'001c, 0xffff'ff9d, 0x0000'001e, 0xffff'ff9f}},
10822 {{0xffff'ffff'ffff'8100, 0xffff'ffff'ffff'8302},
10823 {0xffff'ffff'ffff'8504, 0xffff'ffff'ffff'8706},
10824 {0xffff'ffff'ffff'8908, 0xffff'ffff'ffff'8b0a},
10825 {0xffff'ffff'ffff'8d0c, 0xffff'ffff'ffff'8f0e},
10826 {0xffff'ffff'ffff'9110, 0xffff'ffff'ffff'9312},
10827 {0xffff'ffff'ffff'9514, 0xffff'ffff'ffff'9716},
10828 {0xffff'ffff'ffff'9918, 0xffff'ffff'ffff'9b1a},
10829 {0xffff'ffff'ffff'9d1c, 0xffff'ffff'ffff'9f1e}},
10830 kVectorCalculationsSource,
10831 4);
10832
10833 TestExtendingVectorInstruction(ExecVzextvf2,
10834 ExecMaskedVzextvf2,
10835 {{0x0000, 0x0081, 0x0002, 0x0083, 0x0004, 0x0085, 0x0006, 0x0087},
10836 {0x0008, 0x0089, 0x000a, 0x008b, 0x000c, 0x008d, 0x000e, 0x008f},
10837 {0x0010, 0x0091, 0x0012, 0x0093, 0x0014, 0x0095, 0x0016, 0x0097},
10838 {0x0018, 0x0099, 0x001a, 0x009b, 0x001c, 0x009d, 0x001e, 0x009f},
10839 {0x0020, 0x00a1, 0x0022, 0x00a3, 0x0024, 0x00a5, 0x0026, 0x00a7},
10840 {0x0028, 0x00a9, 0x002a, 0x00ab, 0x002c, 0x00ad, 0x002e, 0x00af},
10841 {0x0030, 0x00b1, 0x0032, 0x00b3, 0x0034, 0x00b5, 0x0036, 0x00b7},
10842 {0x0038, 0x00b9, 0x003a, 0x00bb, 0x003c, 0x00bd, 0x003e, 0x00bf}},
10843 {{0x0000'8100, 0x0000'8302, 0x0000'8504, 0x0000'8706},
10844 {0x0000'8908, 0x0000'8b0a, 0x0000'8d0c, 0x0000'8f0e},
10845 {0x0000'9110, 0x0000'9312, 0x0000'9514, 0x0000'9716},
10846 {0x0000'9918, 0x0000'9b1a, 0x0000'9d1c, 0x0000'9f1e},
10847 {0x0000'a120, 0x0000'a322, 0x0000'a524, 0x0000'a726},
10848 {0x0000'a928, 0x0000'ab2a, 0x0000'ad2c, 0x0000'af2e},
10849 {0x0000'b130, 0x0000'b332, 0x0000'b534, 0x0000'b736},
10850 {0x0000'b938, 0x0000'bb3a, 0x0000'bd3c, 0x0000'bf3e}},
10851 {{0x0000'0000'8302'8100, 0x0000'0000'8706'8504},
10852 {0x0000'0000'8b0a'8908, 0x0000'0000'8f0e'8d0c},
10853 {0x0000'0000'9312'9110, 0x0000'0000'9716'9514},
10854 {0x0000'0000'9b1a'9918, 0x0000'0000'9f1e'9d1c},
10855 {0x0000'0000'a322'a120, 0x0000'0000'a726'a524},
10856 {0x0000'0000'ab2a'a928, 0x0000'0000'af2e'ad2c},
10857 {0x0000'0000'b332'b130, 0x0000'0000'b736'b534},
10858 {0x0000'0000'bb3a'b938, 0x0000'0000'bf3e'bd3c}},
10859 kVectorCalculationsSource,
10860 2);
10861
10862 TestExtendingVectorInstruction(ExecVsextvf2,
10863 ExecMaskedVsextvf2,
10864 {{0x0000, 0xff81, 0x0002, 0xff83, 0x0004, 0xff85, 0x0006, 0xff87},
10865 {0x0008, 0xff89, 0x000a, 0xff8b, 0x000c, 0xff8d, 0x000e, 0xff8f},
10866 {0x0010, 0xff91, 0x0012, 0xff93, 0x0014, 0xff95, 0x0016, 0xff97},
10867 {0x0018, 0xff99, 0x001a, 0xff9b, 0x001c, 0xff9d, 0x001e, 0xff9f},
10868 {0x0020, 0xffa1, 0x0022, 0xffa3, 0x0024, 0xffa5, 0x0026, 0xffa7},
10869 {0x0028, 0xffa9, 0x002a, 0xffab, 0x002c, 0xffad, 0x002e, 0xffaf},
10870 {0x0030, 0xffb1, 0x0032, 0xffb3, 0x0034, 0xffb5, 0x0036, 0xffb7},
10871 {0x0038, 0xffb9, 0x003a, 0xffbb, 0x003c, 0xffbd, 0x003e, 0xffbf}},
10872 {{0xffff'8100, 0xffff'8302, 0xffff'8504, 0xffff'8706},
10873 {0xffff'8908, 0xffff'8b0a, 0xffff'8d0c, 0xffff'8f0e},
10874 {0xffff'9110, 0xffff'9312, 0xffff'9514, 0xffff'9716},
10875 {0xffff'9918, 0xffff'9b1a, 0xffff'9d1c, 0xffff'9f1e},
10876 {0xffff'a120, 0xffff'a322, 0xffff'a524, 0xffff'a726},
10877 {0xffff'a928, 0xffff'ab2a, 0xffff'ad2c, 0xffff'af2e},
10878 {0xffff'b130, 0xffff'b332, 0xffff'b534, 0xffff'b736},
10879 {0xffff'b938, 0xffff'bb3a, 0xffff'bd3c, 0xffff'bf3e}},
10880 {{0xffff'ffff'8302'8100, 0xffff'ffff'8706'8504},
10881 {0xffff'ffff'8b0a'8908, 0xffff'ffff'8f0e'8d0c},
10882 {0xffff'ffff'9312'9110, 0xffff'ffff'9716'9514},
10883 {0xffff'ffff'9b1a'9918, 0xffff'ffff'9f1e'9d1c},
10884 {0xffff'ffff'a322'a120, 0xffff'ffff'a726'a524},
10885 {0xffff'ffff'ab2a'a928, 0xffff'ffff'af2e'ad2c},
10886 {0xffff'ffff'b332'b130, 0xffff'ffff'b736'b534},
10887 {0xffff'ffff'bb3a'b938, 0xffff'ffff'bf3e'bd3c}},
10888 kVectorCalculationsSource,
10889 2);
10890 }
10891
ExecVmulhsuvv()10892 [[gnu::naked]] void ExecVmulhsuvv() {
10893 asm("vmulhsu.vv v8, v16, v24\n\t"
10894 "ret\n\t");
10895 }
10896
ExecMaskedVmulhsuvv()10897 [[gnu::naked]] void ExecMaskedVmulhsuvv() {
10898 asm("vmulhsu.vv v8, v16, v24, v0.t\n\t"
10899 "ret\n\t");
10900 }
10901
ExecVmulhsuvx()10902 [[gnu::naked]] void ExecVmulhsuvx() {
10903 asm("vmulhsu.vx v8, v16, t0\n\t"
10904 "ret\n\t");
10905 }
10906
ExecMaskedVmulhsuvx()10907 [[gnu::naked]] void ExecMaskedVmulhsuvx() {
10908 asm("vmulhsu.vx v8, v16, t0, v0.t\n\t"
10909 "ret\n\t");
10910 }
10911
TEST(InlineAsmTestRiscv64,TestVmulhsu)10912 TEST(InlineAsmTestRiscv64, TestVmulhsu) {
10913 TestVectorInstruction(
10914 ExecVmulhsuvv,
10915 ExecMaskedVmulhsuvv,
10916 {{0, 255, 0, 253, 0, 251, 0, 249, 0, 247, 0, 245, 1, 244, 1, 242},
10917 {2, 241, 2, 239, 3, 238, 3, 237, 4, 235, 5, 234, 6, 233, 7, 232},
10918 {8, 231, 9, 230, 10, 229, 11, 228, 12, 228, 13, 227, 15, 226, 16, 226},
10919 {18, 225, 19, 225, 21, 224, 22, 224, 24, 224, 26, 224, 28, 224, 30, 224},
10920 {32, 224, 34, 224, 36, 224, 38, 224, 40, 224, 42, 224, 45, 225, 47, 225},
10921 {50, 226, 52, 226, 55, 227, 57, 228, 60, 228, 63, 229, 66, 230, 69, 231},
10922 {72, 232, 75, 233, 78, 234, 81, 235, 84, 237, 87, 238, 91, 239, 94, 241},
10923 {98, 242, 101, 244, 105, 245, 108, 247, 112, 249, 116, 251, 120, 253, 124, 255}},
10924 {{0xff02, 0xfd10, 0xfb2d, 0xf95c, 0xf79a, 0xf5e9, 0xf448, 0xf2b7},
10925 {0xf136, 0xefc5, 0xee64, 0xed13, 0xebd2, 0xeaa2, 0xe982, 0xe872},
10926 {0xe772, 0xe682, 0xe5a2, 0xe4d3, 0xe413, 0xe364, 0xe2c4, 0xe235},
10927 {0xe1b6, 0xe147, 0xe0e8, 0xe09a, 0xe05b, 0xe02d, 0xe00f, 0xe001},
10928 {0xe003, 0xe015, 0xe037, 0xe069, 0xe0ac, 0xe0fe, 0xe161, 0xe1d4},
10929 {0xe257, 0xe2ea, 0xe38d, 0xe441, 0xe504, 0xe5d8, 0xe6bb, 0xe7af},
10930 {0xe8b3, 0xe9c7, 0xeaec, 0xec20, 0xed64, 0xeeb9, 0xf01e, 0xf193},
10931 {0xf318, 0xf4ad, 0xf652, 0xf807, 0xf9cd, 0xfba2, 0xfd88, 0xff7e}},
10932 {{0xfd10'1a16, 0xf95c'aad6, 0xf5e9'bc58, 0xf2b7'4e9b},
10933 {0xefc5'619f, 0xed13'f564, 0xeaa3'09ea, 0xe872'9f31},
10934 {0xe682'b539, 0xe4d3'4c01, 0xe364'638b, 0xe235'fbd7},
10935 {0xe148'14e2, 0xe09a'aeaf, 0xe02d'c93d, 0xe001'648c},
10936 {0xe015'809c, 0xe06a'1d6d, 0xe0ff'3aff, 0xe1d4'd952},
10937 {0xe2ea'f866, 0xe441'983b, 0xe5d8'b8d1, 0xe7b0'5a28},
10938 {0xe9c8'7c40, 0xec21'1f19, 0xeeba'42b3, 0xf193'e70e},
10939 {0xf4ae'0c2a, 0xf808'b207, 0xfba3'd8a5, 0xff7f'8004}},
10940 {{0xf95c'aad6'78f5'63b8, 0xf2b7'4e9b'bf9d'55cb},
10941 {0xed13'f564'2968'6900, 0xe872'9f31'6a0c'5913},
10942 {0xe4d3'4c01'edf3'8a67, 0xe235'fbd7'2893'787a},
10943 {0xe09a'aeaf'c696'c7ef, 0xe001'648c'fb32'b402},
10944 {0xe06a'1d6d'b352'2196, 0xe1d4'd952'e1ea'0ba9},
10945 {0xe441'983b'b425'975e, 0xe7b0'5a28'dcb9'7f71},
10946 {0xec21'1f19'c911'2946, 0xf193'e70e'eba1'0f59},
10947 {0xf808'b207'f214'd74e, 0xff7f'8005'0ea0'bb61}},
10948 kVectorCalculationsSourceLegacy);
10949 TestVectorInstruction(ExecVmulhsuvx,
10950 ExecMaskedVmulhsuvx,
10951 {{0, 171, 1, 172, 2, 174, 3, 175, 5, 176, 6, 178, 7, 179, 9, 180},
10952 {10, 182, 11, 183, 13, 184, 14, 186, 15, 187, 17, 188, 18, 190, 19, 191},
10953 {21, 192, 22, 194, 23, 195, 25, 196, 26, 198, 27, 199, 29, 200, 30, 202},
10954 {31, 203, 33, 204, 34, 206, 35, 207, 37, 208, 38, 210, 39, 211, 41, 212},
10955 {42, 214, 43, 215, 45, 216, 46, 218, 47, 219, 49, 220, 50, 222, 51, 223},
10956 {53, 224, 54, 226, 55, 227, 57, 228, 58, 230, 59, 231, 61, 232, 62, 234},
10957 {63, 235, 65, 236, 66, 238, 67, 239, 69, 240, 70, 242, 71, 243, 73, 244},
10958 {74, 246, 75, 247, 77, 248, 78, 250, 79, 251, 81, 252, 82, 254, 83, 255}},
10959 {{0xab55, 0xacac, 0xae02, 0xaf59, 0xb0b0, 0xb206, 0xb35d, 0xb4b4},
10960 {0xb60a, 0xb761, 0xb8b8, 0xba0e, 0xbb65, 0xbcbc, 0xbe12, 0xbf69},
10961 {0xc0c0, 0xc216, 0xc36d, 0xc4c4, 0xc61a, 0xc771, 0xc8c8, 0xca1e},
10962 {0xcb75, 0xcccc, 0xce22, 0xcf79, 0xd0d0, 0xd226, 0xd37d, 0xd4d4},
10963 {0xd62a, 0xd781, 0xd8d8, 0xda2e, 0xdb85, 0xdcdc, 0xde32, 0xdf89},
10964 {0xe0e0, 0xe236, 0xe38d, 0xe4e4, 0xe63a, 0xe791, 0xe8e8, 0xea3e},
10965 {0xeb95, 0xecec, 0xee42, 0xef99, 0xf0f0, 0xf246, 0xf39d, 0xf4f4},
10966 {0xf64a, 0xf7a1, 0xf8f8, 0xfa4e, 0xfba5, 0xfcfc, 0xfe52, 0xffa9}},
10967 {{0xacac'5600, 0xaf59'ae02, 0xb207'0605, 0xb4b4'5e08},
10968 {0xb761'b60a, 0xba0f'0e0d, 0xbcbc'6610, 0xbf69'be12},
10969 {0xc217'1615, 0xc4c4'6e18, 0xc771'c61a, 0xca1f'1e1d},
10970 {0xcccc'7620, 0xcf79'ce22, 0xd227'2625, 0xd4d4'7e28},
10971 {0xd781'd62a, 0xda2f'2e2d, 0xdcdc'8630, 0xdf89'de32},
10972 {0xe237'3635, 0xe4e4'8e38, 0xe791'e63a, 0xea3f'3e3d},
10973 {0xecec'9640, 0xef99'ee42, 0xf247'4645, 0xf4f4'9e48},
10974 {0xf7a1'f64a, 0xfa4f'4e4d, 0xfcfc'a650, 0xffa9'fe52}},
10975 {{0xaf59'ae03'0201'ab55, 0xb4b4'5e08'5cb1'b0b0},
10976 {0xba0f'0e0d'b761'b60a, 0xbf69'be13'1211'bb65},
10977 {0xc4c4'6e18'6cc1'c0c0, 0xca1f'1e1d'c771'c61a},
10978 {0xcf79'ce23'2221'cb75, 0xd4d4'7e28'7cd1'd0d0},
10979 {0xda2f'2e2d'd781'd62a, 0xdf89'de33'3231'db85},
10980 {0xe4e4'8e38'8ce1'e0e0, 0xea3f'3e3d'e791'e63a},
10981 {0xef99'ee43'4241'eb95, 0xf4f4'9e48'9cf1'f0f0},
10982 {0xfa4f'4e4d'f7a1'f64a, 0xffa9'fe53'5251'fba5}},
10983 kVectorCalculationsSourceLegacy);
10984 }
10985
10986 // TODO(b/301577077): Add vi tests with non-zero shift.
ExecVslidedownvi()10987 [[gnu::naked]] void ExecVslidedownvi() {
10988 asm("vslidedown.vi v8, v24, 0\n\t"
10989 "ret\n\t");
10990 }
10991
ExecMaskedVslidedownvi()10992 [[gnu::naked]] void ExecMaskedVslidedownvi() {
10993 asm("vslidedown.vi v8, v24, 0, v0.t\n\t"
10994 "ret\n\t");
10995 }
10996
ExecVslidedownvx()10997 [[gnu::naked]] void ExecVslidedownvx() {
10998 asm("vslidedown.vx v8, v24, t0\n\t"
10999 "ret\n\t");
11000 }
11001
ExecMaskedVslidedownvx()11002 [[gnu::naked]] void ExecMaskedVslidedownvx() {
11003 asm("vslidedown.vx v8, v24, t0, v0.t\n\t"
11004 "ret\n\t");
11005 }
11006
TEST(InlineAsmTestRiscv64,TestVslidedown)11007 TEST(InlineAsmTestRiscv64, TestVslidedown) {
11008 // With slide offset equal zero, this is equivalent to Vmv.
11009 TestVectorInstruction(
11010 ExecVslidedownvi,
11011 ExecMaskedVslidedownvi,
11012 {{0, 2, 4, 6, 9, 10, 12, 14, 17, 18, 20, 22, 24, 26, 28, 30},
11013 {32, 34, 36, 38, 41, 42, 44, 46, 49, 50, 52, 54, 56, 58, 60, 62},
11014 {64, 66, 68, 70, 73, 74, 76, 78, 81, 82, 84, 86, 88, 90, 92, 94},
11015 {96, 98, 100, 102, 105, 106, 108, 110, 113, 114, 116, 118, 120, 122, 124, 126},
11016 {128, 130, 132, 134, 137, 138, 140, 142, 145, 146, 148, 150, 152, 154, 156, 158},
11017 {160, 162, 164, 166, 169, 170, 172, 174, 177, 178, 180, 182, 184, 186, 188, 190},
11018 {192, 194, 196, 198, 201, 202, 204, 206, 209, 210, 212, 214, 216, 218, 220, 222},
11019 {224, 226, 228, 230, 233, 234, 236, 238, 241, 242, 244, 246, 248, 250, 252, 254}},
11020 {{0x0200, 0x0604, 0x0a09, 0x0e0c, 0x1211, 0x1614, 0x1a18, 0x1e1c},
11021 {0x2220, 0x2624, 0x2a29, 0x2e2c, 0x3231, 0x3634, 0x3a38, 0x3e3c},
11022 {0x4240, 0x4644, 0x4a49, 0x4e4c, 0x5251, 0x5654, 0x5a58, 0x5e5c},
11023 {0x6260, 0x6664, 0x6a69, 0x6e6c, 0x7271, 0x7674, 0x7a78, 0x7e7c},
11024 {0x8280, 0x8684, 0x8a89, 0x8e8c, 0x9291, 0x9694, 0x9a98, 0x9e9c},
11025 {0xa2a0, 0xa6a4, 0xaaa9, 0xaeac, 0xb2b1, 0xb6b4, 0xbab8, 0xbebc},
11026 {0xc2c0, 0xc6c4, 0xcac9, 0xcecc, 0xd2d1, 0xd6d4, 0xdad8, 0xdedc},
11027 {0xe2e0, 0xe6e4, 0xeae9, 0xeeec, 0xf2f1, 0xf6f4, 0xfaf8, 0xfefc}},
11028 {{0x0604'0200, 0x0e0c'0a09, 0x1614'1211, 0x1e1c'1a18},
11029 {0x2624'2220, 0x2e2c'2a29, 0x3634'3231, 0x3e3c'3a38},
11030 {0x4644'4240, 0x4e4c'4a49, 0x5654'5251, 0x5e5c'5a58},
11031 {0x6664'6260, 0x6e6c'6a69, 0x7674'7271, 0x7e7c'7a78},
11032 {0x8684'8280, 0x8e8c'8a89, 0x9694'9291, 0x9e9c'9a98},
11033 {0xa6a4'a2a0, 0xaeac'aaa9, 0xb6b4'b2b1, 0xbebc'bab8},
11034 {0xc6c4'c2c0, 0xcecc'cac9, 0xd6d4'd2d1, 0xdedc'dad8},
11035 {0xe6e4'e2e0, 0xeeec'eae9, 0xf6f4'f2f1, 0xfefc'faf8}},
11036 {{0x0e0c'0a09'0604'0200, 0x1e1c'1a18'1614'1211},
11037 {0x2e2c'2a29'2624'2220, 0x3e3c'3a38'3634'3231},
11038 {0x4e4c'4a49'4644'4240, 0x5e5c'5a58'5654'5251},
11039 {0x6e6c'6a69'6664'6260, 0x7e7c'7a78'7674'7271},
11040 {0x8e8c'8a89'8684'8280, 0x9e9c'9a98'9694'9291},
11041 {0xaeac'aaa9'a6a4'a2a0, 0xbebc'bab8'b6b4'b2b1},
11042 {0xcecc'cac9'c6c4'c2c0, 0xdedc'dad8'd6d4'd2d1},
11043 {0xeeec'eae9'e6e4'e2e0, 0xfefc'faf8'f6f4'f2f1}},
11044 kVectorCalculationsSourceLegacy);
11045
11046 // VLMUL = 0.
11047 TestVectorPermutationInstruction(
11048 ExecVslidedownvx,
11049 ExecMaskedVslidedownvx,
11050 {{2, 4, 6, 9, 10, 12, 14, 17, 18, 20, 22, 24, 26, 28, 30, 0},
11051 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11052 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11053 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11054 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11055 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11056 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11057 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
11058 {{0x0604, 0x0a09, 0x0e0c, 0x1211, 0x1614, 0x1a18, 0x1e1c, 0x0000},
11059 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11060 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11061 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11062 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11063 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11064 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11065 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}},
11066 {{0x0e0c'0a09, 0x1614'1211, 0x1e1c'1a18, 0x0000'0000},
11067 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11068 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11069 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11070 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11071 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11072 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11073 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000}},
11074 {{0x1e1c'1a18'1614'1211, 0x0000'0000'0000'0000},
11075 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11076 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11077 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11078 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11079 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11080 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11081 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000}},
11082 kVectorCalculationsSourceLegacy,
11083 /*vlmul=*/0,
11084 /*regx1=*/1,
11085 /*skip=*/0);
11086
11087 TestVectorPermutationInstruction(
11088 ExecVslidedownvx,
11089 ExecMaskedVslidedownvx,
11090 {{17, 18, 20, 22, 24, 26, 28, 30, 0, 0, 0, 0, 0, 0, 0, 0},
11091 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11092 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11093 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11094 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11095 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11096 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11097 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
11098 {{0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11099 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11100 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11101 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11102 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11103 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11104 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11105 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}},
11106 {{0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11107 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11108 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11109 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11110 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11111 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11112 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11113 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000}},
11114 {{0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11115 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11116 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11117 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11118 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11119 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11120 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11121 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000}},
11122 kVectorCalculationsSourceLegacy,
11123 /*vlmul=*/0,
11124 /*regx1=*/8,
11125 /*skip=*/0);
11126
11127 // VLMUL = 1
11128 TestVectorPermutationInstruction(
11129 ExecVslidedownvx,
11130 ExecMaskedVslidedownvx,
11131 {{2, 4, 6, 9, 10, 12, 14, 17, 18, 20, 22, 24, 26, 28, 30, 32},
11132 {34, 36, 38, 41, 42, 44, 46, 49, 50, 52, 54, 56, 58, 60, 62, 0},
11133 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11134 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11135 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11136 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11137 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11138 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
11139 {{0x0604, 0x0a09, 0x0e0c, 0x1211, 0x1614, 0x1a18, 0x1e1c, 0x2220},
11140 {0x2624, 0x2a29, 0x2e2c, 0x3231, 0x3634, 0x3a38, 0x3e3c, 0x0000},
11141 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11142 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11143 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11144 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11145 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11146 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}},
11147 {{0x0e0c'0a09, 0x1614'1211, 0x1e1c'1a18, 0x2624'2220},
11148 {0x2e2c'2a29, 0x3634'3231, 0x3e3c'3a38, 0x0000'0000},
11149 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11150 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11151 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11152 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11153 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11154 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000}},
11155 {{0x1e1c'1a18'1614'1211, 0x2e2c'2a29'2624'2220},
11156 {0x3e3c'3a38'3634'3231, 0x0000'0000'0000'0000},
11157 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11158 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11159 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11160 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11161 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11162 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000}},
11163 kVectorCalculationsSourceLegacy,
11164 /*vlmul=*/1,
11165 /*regx1=*/1,
11166 /*skip=*/0);
11167 TestVectorPermutationInstruction(
11168 ExecVslidedownvx,
11169 ExecMaskedVslidedownvx,
11170 {{17, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 41, 42, 44, 46},
11171 {49, 50, 52, 54, 56, 58, 60, 62, 0, 0, 0, 0, 0, 0, 0, 0},
11172 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11173 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11174 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11175 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11176 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11177 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
11178 {{0x2220, 0x2624, 0x2a29, 0x2e2c, 0x3231, 0x3634, 0x3a38, 0x3e3c},
11179 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11180 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11181 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11182 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11183 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11184 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11185 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}},
11186 {{0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11187 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11188 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11189 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11190 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11191 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11192 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11193 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000}},
11194 {{0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11195 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11196 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11197 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11198 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11199 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11200 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11201 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000}},
11202 kVectorCalculationsSourceLegacy,
11203 /*vlmul=*/1,
11204 /*regx1=*/8,
11205 /*skip=*/0);
11206
11207 // VLMUL = 2
11208 TestVectorPermutationInstruction(
11209 ExecVslidedownvx,
11210 ExecMaskedVslidedownvx,
11211 {{2, 4, 6, 9, 10, 12, 14, 17, 18, 20, 22, 24, 26, 28, 30, 32},
11212 {34, 36, 38, 41, 42, 44, 46, 49, 50, 52, 54, 56, 58, 60, 62, 64},
11213 {66, 68, 70, 73, 74, 76, 78, 81, 82, 84, 86, 88, 90, 92, 94, 96},
11214 {98, 100, 102, 105, 106, 108, 110, 113, 114, 116, 118, 120, 122, 124, 126, 0},
11215 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11216 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11217 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11218 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
11219 {{0x0604, 0x0a09, 0x0e0c, 0x1211, 0x1614, 0x1a18, 0x1e1c, 0x2220},
11220 {0x2624, 0x2a29, 0x2e2c, 0x3231, 0x3634, 0x3a38, 0x3e3c, 0x4240},
11221 {0x4644, 0x4a49, 0x4e4c, 0x5251, 0x5654, 0x5a58, 0x5e5c, 0x6260},
11222 {0x6664, 0x6a69, 0x6e6c, 0x7271, 0x7674, 0x7a78, 0x7e7c, 0x0000},
11223 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11224 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11225 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11226 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}},
11227 {{0x0e0c'0a09, 0x1614'1211, 0x1e1c'1a18, 0x2624'2220},
11228 {0x2e2c'2a29, 0x3634'3231, 0x3e3c'3a38, 0x4644'4240},
11229 {0x4e4c'4a49, 0x5654'5251, 0x5e5c'5a58, 0x6664'6260},
11230 {0x6e6c'6a69, 0x7674'7271, 0x7e7c'7a78, 0x0000'0000},
11231 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11232 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11233 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11234 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000}},
11235 {{0x1e1c'1a18'1614'1211, 0x2e2c'2a29'2624'2220},
11236 {0x3e3c'3a38'3634'3231, 0x4e4c'4a49'4644'4240},
11237 {0x5e5c'5a58'5654'5251, 0x6e6c'6a69'6664'6260},
11238 {0x7e7c'7a78'7674'7271, 0x0000'0000'0000'0000},
11239 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11240 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11241 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11242 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000}},
11243 kVectorCalculationsSourceLegacy,
11244 /*vlmul=*/2,
11245 /*regx1=*/1,
11246 /*skip=*/0);
11247
11248 TestVectorPermutationInstruction(
11249 ExecVslidedownvx,
11250 ExecMaskedVslidedownvx,
11251 {{17, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 41, 42, 44, 46},
11252 {49, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 73, 74, 76, 78},
11253 {81, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 105, 106, 108, 110},
11254 {113, 114, 116, 118, 120, 122, 124, 126, 0, 0, 0, 0, 0, 0, 0, 0},
11255 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11256 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11257 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11258 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
11259 {{0x2220, 0x2624, 0x2a29, 0x2e2c, 0x3231, 0x3634, 0x3a38, 0x3e3c},
11260 {0x4240, 0x4644, 0x4a49, 0x4e4c, 0x5251, 0x5654, 0x5a58, 0x5e5c},
11261 {0x6260, 0x6664, 0x6a69, 0x6e6c, 0x7271, 0x7674, 0x7a78, 0x7e7c},
11262 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11263 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11264 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11265 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11266 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}},
11267 {{0x4644'4240, 0x4e4c'4a49, 0x5654'5251, 0x5e5c'5a58},
11268 {0x6664'6260, 0x6e6c'6a69, 0x7674'7271, 0x7e7c'7a78},
11269 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11270 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11271 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11272 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11273 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11274 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000}},
11275 {{0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11276 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11277 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11278 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11279 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11280 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11281 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11282 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000}},
11283 kVectorCalculationsSourceLegacy,
11284 /*vlmul=*/2,
11285 /*regx1=*/8,
11286 /*skip=*/0);
11287
11288 // VLMUL = 3
11289 TestVectorPermutationInstruction(
11290 ExecVslidedownvx,
11291 ExecMaskedVslidedownvx,
11292 {{2, 4, 6, 9, 10, 12, 14, 17, 18, 20, 22, 24, 26, 28, 30, 32},
11293 {34, 36, 38, 41, 42, 44, 46, 49, 50, 52, 54, 56, 58, 60, 62, 64},
11294 {66, 68, 70, 73, 74, 76, 78, 81, 82, 84, 86, 88, 90, 92, 94, 96},
11295 {98, 100, 102, 105, 106, 108, 110, 113, 114, 116, 118, 120, 122, 124, 126, 128},
11296 {130, 132, 134, 137, 138, 140, 142, 145, 146, 148, 150, 152, 154, 156, 158, 160},
11297 {162, 164, 166, 169, 170, 172, 174, 177, 178, 180, 182, 184, 186, 188, 190, 192},
11298 {194, 196, 198, 201, 202, 204, 206, 209, 210, 212, 214, 216, 218, 220, 222, 224},
11299 {226, 228, 230, 233, 234, 236, 238, 241, 242, 244, 246, 248, 250, 252, 254, 0}},
11300 {{0x0604, 0x0a09, 0x0e0c, 0x1211, 0x1614, 0x1a18, 0x1e1c, 0x2220},
11301 {0x2624, 0x2a29, 0x2e2c, 0x3231, 0x3634, 0x3a38, 0x3e3c, 0x4240},
11302 {0x4644, 0x4a49, 0x4e4c, 0x5251, 0x5654, 0x5a58, 0x5e5c, 0x6260},
11303 {0x6664, 0x6a69, 0x6e6c, 0x7271, 0x7674, 0x7a78, 0x7e7c, 0x8280},
11304 {0x8684, 0x8a89, 0x8e8c, 0x9291, 0x9694, 0x9a98, 0x9e9c, 0xa2a0},
11305 {0xa6a4, 0xaaa9, 0xaeac, 0xb2b1, 0xb6b4, 0xbab8, 0xbebc, 0xc2c0},
11306 {0xc6c4, 0xcac9, 0xcecc, 0xd2d1, 0xd6d4, 0xdad8, 0xdedc, 0xe2e0},
11307 {0xe6e4, 0xeae9, 0xeeec, 0xf2f1, 0xf6f4, 0xfaf8, 0xfefc, 0x0000}},
11308 {{0x0e0c'0a09, 0x1614'1211, 0x1e1c'1a18, 0x2624'2220},
11309 {0x2e2c'2a29, 0x3634'3231, 0x3e3c'3a38, 0x4644'4240},
11310 {0x4e4c'4a49, 0x5654'5251, 0x5e5c'5a58, 0x6664'6260},
11311 {0x6e6c'6a69, 0x7674'7271, 0x7e7c'7a78, 0x8684'8280},
11312 {0x8e8c'8a89, 0x9694'9291, 0x9e9c'9a98, 0xa6a4'a2a0},
11313 {0xaeac'aaa9, 0xb6b4'b2b1, 0xbebc'bab8, 0xc6c4'c2c0},
11314 {0xcecc'cac9, 0xd6d4'd2d1, 0xdedc'dad8, 0xe6e4'e2e0},
11315 {0xeeec'eae9, 0xf6f4'f2f1, 0xfefc'faf8, 0x0000'0000}},
11316 {{0x1e1c'1a18'1614'1211, 0x2e2c'2a29'2624'2220},
11317 {0x3e3c'3a38'3634'3231, 0x4e4c'4a49'4644'4240},
11318 {0x5e5c'5a58'5654'5251, 0x6e6c'6a69'6664'6260},
11319 {0x7e7c'7a78'7674'7271, 0x8e8c'8a89'8684'8280},
11320 {0x9e9c'9a98'9694'9291, 0xaeac'aaa9'a6a4'a2a0},
11321 {0xbebc'bab8'b6b4'b2b1, 0xcecc'cac9'c6c4'c2c0},
11322 {0xdedc'dad8'd6d4'd2d1, 0xeeec'eae9'e6e4'e2e0},
11323 {0xfefc'faf8'f6f4'f2f1, 0x0000'0000'0000'0000}},
11324 kVectorCalculationsSourceLegacy,
11325 /*vlmul=*/3,
11326 /*regx1=*/1,
11327 /*skip=*/0);
11328
11329 TestVectorPermutationInstruction(
11330 ExecVslidedownvx,
11331 ExecMaskedVslidedownvx,
11332 {{17, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 41, 42, 44, 46},
11333 {49, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 73, 74, 76, 78},
11334 {81, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 105, 106, 108, 110},
11335 {113, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 137, 138, 140, 142},
11336 {145, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 166, 169, 170, 172, 174},
11337 {177, 178, 180, 182, 184, 186, 188, 190, 192, 194, 196, 198, 201, 202, 204, 206},
11338 {209, 210, 212, 214, 216, 218, 220, 222, 224, 226, 228, 230, 233, 234, 236, 238},
11339 {241, 242, 244, 246, 248, 250, 252, 254, 0, 0, 0, 0, 0, 0, 0, 0}},
11340 {{0x2220, 0x2624, 0x2a29, 0x2e2c, 0x3231, 0x3634, 0x3a38, 0x3e3c},
11341 {0x4240, 0x4644, 0x4a49, 0x4e4c, 0x5251, 0x5654, 0x5a58, 0x5e5c},
11342 {0x6260, 0x6664, 0x6a69, 0x6e6c, 0x7271, 0x7674, 0x7a78, 0x7e7c},
11343 {0x8280, 0x8684, 0x8a89, 0x8e8c, 0x9291, 0x9694, 0x9a98, 0x9e9c},
11344 {0xa2a0, 0xa6a4, 0xaaa9, 0xaeac, 0xb2b1, 0xb6b4, 0xbab8, 0xbebc},
11345 {0xc2c0, 0xc6c4, 0xcac9, 0xcecc, 0xd2d1, 0xd6d4, 0xdad8, 0xdedc},
11346 {0xe2e0, 0xe6e4, 0xeae9, 0xeeec, 0xf2f1, 0xf6f4, 0xfaf8, 0xfefc},
11347 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}},
11348 {{0x4644'4240, 0x4e4c'4a49, 0x5654'5251, 0x5e5c'5a58},
11349 {0x6664'6260, 0x6e6c'6a69, 0x7674'7271, 0x7e7c'7a78},
11350 {0x8684'8280, 0x8e8c'8a89, 0x9694'9291, 0x9e9c'9a98},
11351 {0xa6a4'a2a0, 0xaeac'aaa9, 0xb6b4'b2b1, 0xbebc'bab8},
11352 {0xc6c4'c2c0, 0xcecc'cac9, 0xd6d4'd2d1, 0xdedc'dad8},
11353 {0xe6e4'e2e0, 0xeeec'eae9, 0xf6f4'f2f1, 0xfefc'faf8},
11354 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11355 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000}},
11356 {{0x8e8c'8a89'8684'8280, 0x9e9c'9a98'9694'9291},
11357 {0xaeac'aaa9'a6a4'a2a0, 0xbebc'bab8'b6b4'b2b1},
11358 {0xcecc'cac9'c6c4'c2c0, 0xdedc'dad8'd6d4'd2d1},
11359 {0xeeec'eae9'e6e4'e2e0, 0xfefc'faf8'f6f4'f2f1},
11360 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11361 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11362 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11363 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000}},
11364 kVectorCalculationsSourceLegacy,
11365 /*vlmul=*/3,
11366 /*regx1=*/8,
11367 /*skip=*/0);
11368
11369 // VLMUL = 4
11370 TestVectorPermutationInstruction(
11371 ExecVslidedownvx,
11372 ExecMaskedVslidedownvx,
11373 {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11374 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11375 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11376 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11377 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11378 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11379 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11380 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
11381 {{0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11382 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11383 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11384 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11385 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11386 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11387 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11388 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}},
11389 {{0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11390 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11391 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11392 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11393 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11394 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11395 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11396 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000}},
11397 {{0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11398 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11399 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11400 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11401 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11402 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11403 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11404 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000}},
11405 kVectorCalculationsSourceLegacy,
11406 /*vlmul=*/4,
11407 /*regx1=*/1,
11408 /*skip=*/0);
11409
11410 TestVectorPermutationInstruction(
11411 ExecVslidedownvx,
11412 ExecMaskedVslidedownvx,
11413 {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11414 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11415 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11416 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11417 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11418 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11419 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11420 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
11421 {{0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11422 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11423 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11424 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11425 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11426 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11427 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11428 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}},
11429 {{0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11430 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11431 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11432 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11433 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11434 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11435 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11436 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000}},
11437 {{0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11438 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11439 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11440 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11441 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11442 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11443 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11444 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000}},
11445 kVectorCalculationsSourceLegacy,
11446 /*vlmul=*/4,
11447 /*regx1=*/8,
11448 /*skip=*/0);
11449
11450 // VLMUL = 5
11451 TestVectorPermutationInstruction(
11452 ExecVslidedownvx,
11453 ExecMaskedVslidedownvx,
11454 {{2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11455 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11456 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11457 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11458 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11459 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11460 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11461 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
11462 {{0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11463 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11464 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11465 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11466 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11467 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11468 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11469 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}},
11470 {{0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11471 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11472 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11473 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11474 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11475 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11476 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11477 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000}},
11478 {{0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11479 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11480 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11481 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11482 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11483 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11484 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11485 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000}},
11486 kVectorCalculationsSourceLegacy,
11487 /*vlmul=*/5,
11488 /*regx1=*/1,
11489 /*skip=*/0);
11490
11491 TestVectorPermutationInstruction(
11492 ExecVslidedownvx,
11493 ExecMaskedVslidedownvx,
11494 {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11495 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11496 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11497 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11498 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11499 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11500 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11501 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
11502 {{0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11503 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11504 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11505 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11506 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11507 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11508 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11509 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}},
11510 {{0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11511 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11512 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11513 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11514 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11515 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11516 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11517 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000}},
11518 {{0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11519 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11520 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11521 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11522 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11523 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11524 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11525 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000}},
11526 kVectorCalculationsSourceLegacy,
11527 /*vlmul=*/5,
11528 /*regx1=*/8,
11529 /*skip=*/0);
11530
11531 // VLMUL = 6
11532 TestVectorPermutationInstruction(
11533 ExecVslidedownvx,
11534 ExecMaskedVslidedownvx,
11535 {{2, 4, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11536 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11537 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11538 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11539 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11540 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11541 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11542 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
11543 {{0x0604, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11544 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11545 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11546 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11547 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11548 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11549 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11550 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}},
11551 {{0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11552 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11553 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11554 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11555 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11556 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11557 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11558 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000}},
11559 {{0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11560 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11561 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11562 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11563 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11564 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11565 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11566 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000}},
11567 kVectorCalculationsSourceLegacy,
11568 /*vlmul=*/6,
11569 /*regx1=*/1,
11570 /*skip=*/0);
11571
11572 TestVectorPermutationInstruction(
11573 ExecVslidedownvx,
11574 ExecMaskedVslidedownvx,
11575 {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11576 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11577 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11578 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11579 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11580 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11581 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11582 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
11583 {{0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11584 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11585 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11586 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11587 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11588 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11589 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11590 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}},
11591 {{0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11592 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11593 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11594 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11595 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11596 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11597 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11598 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000}},
11599 {{0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11600 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11601 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11602 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11603 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11604 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11605 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11606 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000}},
11607 kVectorCalculationsSourceLegacy,
11608 /*vlmul=*/6,
11609 /*regx1=*/8,
11610 /*skip=*/0);
11611
11612 // VLMUL = 7
11613 TestVectorPermutationInstruction(
11614 ExecVslidedownvx,
11615 ExecMaskedVslidedownvx,
11616 {{2, 4, 6, 9, 10, 12, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11617 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11618 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11619 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11620 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11621 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11622 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11623 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
11624 {{0x0604, 0x0a09, 0x0e0c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11625 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11626 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11627 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11628 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11629 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11630 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11631 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}},
11632 {{0x0e0c'0a09, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11633 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11634 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11635 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11636 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11637 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11638 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11639 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000}},
11640 {{0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11641 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11642 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11643 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11644 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11645 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11646 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11647 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000}},
11648 kVectorCalculationsSourceLegacy,
11649 /*vlmul=*/7,
11650 /*regx1=*/1,
11651 /*skip=*/0);
11652
11653 TestVectorPermutationInstruction(
11654 ExecVslidedownvx,
11655 ExecMaskedVslidedownvx,
11656 {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11657 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11658 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11659 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11660 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11661 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11662 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11663 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
11664 {{0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11665 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11666 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11667 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11668 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11669 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11670 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11671 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}},
11672 {{0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11673 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11674 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11675 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11676 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11677 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11678 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11679 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000}},
11680 {{0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11681 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11682 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11683 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11684 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11685 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11686 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11687 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000}},
11688 kVectorCalculationsSourceLegacy,
11689 /*vlmul=*/7,
11690 /*regx1=*/8,
11691 /*skip=*/0);
11692 }
11693
ExecVslideupvi()11694 [[gnu::naked]] void ExecVslideupvi() {
11695 asm("vslideup.vi v8, v24, 0\n\t"
11696 "ret\n\t");
11697 }
11698
ExecMaskedVslideupvi()11699 [[gnu::naked]] void ExecMaskedVslideupvi() {
11700 asm("vslideup.vi v8, v24, 0, v0.t\n\t"
11701 "ret\n\t");
11702 }
11703
ExecVslideupvx()11704 [[gnu::naked]] void ExecVslideupvx() {
11705 asm("vslideup.vx v8, v24, t0\n\t"
11706 "ret\n\t");
11707 }
11708
ExecMaskedVslideupvx()11709 [[gnu::naked]] void ExecMaskedVslideupvx() {
11710 asm("vslideup.vx v8, v24, t0, v0.t\n\t"
11711 "ret\n\t");
11712 }
11713
TEST(InlineAsmTestRiscv64,TestVslideup)11714 TEST(InlineAsmTestRiscv64, TestVslideup) {
11715 // With slide offset equal zero, this is equivalent to Vmv.
11716 TestVectorInstruction(
11717 ExecVslideupvi,
11718 ExecMaskedVslideupvi,
11719 {{0, 2, 4, 6, 9, 10, 12, 14, 17, 18, 20, 22, 24, 26, 28, 30},
11720 {32, 34, 36, 38, 41, 42, 44, 46, 49, 50, 52, 54, 56, 58, 60, 62},
11721 {64, 66, 68, 70, 73, 74, 76, 78, 81, 82, 84, 86, 88, 90, 92, 94},
11722 {96, 98, 100, 102, 105, 106, 108, 110, 113, 114, 116, 118, 120, 122, 124, 126},
11723 {128, 130, 132, 134, 137, 138, 140, 142, 145, 146, 148, 150, 152, 154, 156, 158},
11724 {160, 162, 164, 166, 169, 170, 172, 174, 177, 178, 180, 182, 184, 186, 188, 190},
11725 {192, 194, 196, 198, 201, 202, 204, 206, 209, 210, 212, 214, 216, 218, 220, 222},
11726 {224, 226, 228, 230, 233, 234, 236, 238, 241, 242, 244, 246, 248, 250, 252, 254}},
11727 {{0x0200, 0x0604, 0x0a09, 0x0e0c, 0x1211, 0x1614, 0x1a18, 0x1e1c},
11728 {0x2220, 0x2624, 0x2a29, 0x2e2c, 0x3231, 0x3634, 0x3a38, 0x3e3c},
11729 {0x4240, 0x4644, 0x4a49, 0x4e4c, 0x5251, 0x5654, 0x5a58, 0x5e5c},
11730 {0x6260, 0x6664, 0x6a69, 0x6e6c, 0x7271, 0x7674, 0x7a78, 0x7e7c},
11731 {0x8280, 0x8684, 0x8a89, 0x8e8c, 0x9291, 0x9694, 0x9a98, 0x9e9c},
11732 {0xa2a0, 0xa6a4, 0xaaa9, 0xaeac, 0xb2b1, 0xb6b4, 0xbab8, 0xbebc},
11733 {0xc2c0, 0xc6c4, 0xcac9, 0xcecc, 0xd2d1, 0xd6d4, 0xdad8, 0xdedc},
11734 {0xe2e0, 0xe6e4, 0xeae9, 0xeeec, 0xf2f1, 0xf6f4, 0xfaf8, 0xfefc}},
11735 {{0x0604'0200, 0x0e0c'0a09, 0x1614'1211, 0x1e1c'1a18},
11736 {0x2624'2220, 0x2e2c'2a29, 0x3634'3231, 0x3e3c'3a38},
11737 {0x4644'4240, 0x4e4c'4a49, 0x5654'5251, 0x5e5c'5a58},
11738 {0x6664'6260, 0x6e6c'6a69, 0x7674'7271, 0x7e7c'7a78},
11739 {0x8684'8280, 0x8e8c'8a89, 0x9694'9291, 0x9e9c'9a98},
11740 {0xa6a4'a2a0, 0xaeac'aaa9, 0xb6b4'b2b1, 0xbebc'bab8},
11741 {0xc6c4'c2c0, 0xcecc'cac9, 0xd6d4'd2d1, 0xdedc'dad8},
11742 {0xe6e4'e2e0, 0xeeec'eae9, 0xf6f4'f2f1, 0xfefc'faf8}},
11743 {{0x0e0c'0a09'0604'0200, 0x1e1c'1a18'1614'1211},
11744 {0x2e2c'2a29'2624'2220, 0x3e3c'3a38'3634'3231},
11745 {0x4e4c'4a49'4644'4240, 0x5e5c'5a58'5654'5251},
11746 {0x6e6c'6a69'6664'6260, 0x7e7c'7a78'7674'7271},
11747 {0x8e8c'8a89'8684'8280, 0x9e9c'9a98'9694'9291},
11748 {0xaeac'aaa9'a6a4'a2a0, 0xbebc'bab8'b6b4'b2b1},
11749 {0xcecc'cac9'c6c4'c2c0, 0xdedc'dad8'd6d4'd2d1},
11750 {0xeeec'eae9'e6e4'e2e0, 0xfefc'faf8'f6f4'f2f1}},
11751 kVectorCalculationsSourceLegacy);
11752
11753 // VLMUL = 0.
11754 TestVectorPermutationInstruction(
11755 ExecVslideupvx,
11756 ExecMaskedVslideupvx,
11757 {{85, 0, 2, 4, 6, 9, 10, 12, 14, 17, 18, 20, 22, 24, 26, 28},
11758 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11759 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11760 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11761 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11762 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11763 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11764 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
11765 {{0x5555, 0x0200, 0x0604, 0x0a09, 0x0e0c, 0x1211, 0x1614, 0x1a18},
11766 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11767 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11768 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11769 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11770 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11771 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11772 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}},
11773 {{0x5555'5555, 0x0604'0200, 0x0e0c'0a09, 0x1614'1211},
11774 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11775 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11776 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11777 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11778 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11779 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11780 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000}},
11781 {{0x5555'5555'5555'5555, 0x0e0c'0a09'0604'0200},
11782 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11783 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11784 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11785 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11786 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11787 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11788 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000}},
11789 kVectorCalculationsSourceLegacy,
11790 /*vlmul=*/0,
11791 /*regx1=*/1,
11792 /*skip=*/1);
11793 TestVectorPermutationInstruction(
11794 ExecVslideupvx,
11795 ExecMaskedVslideupvx,
11796 {{85, 85, 85, 85, 85, 85, 85, 85, 0, 2, 4, 6, 9, 10, 12, 14},
11797 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11798 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11799 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11800 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11801 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11802 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11803 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
11804 {{0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555},
11805 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11806 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11807 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11808 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11809 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11810 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11811 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}},
11812 {{0x5555'5555, 0x5555'5555, 0x5555'5555, 0x5555'5555},
11813 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11814 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11815 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11816 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11817 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11818 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11819 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000}},
11820 {{0x5555'5555'5555'5555, 0x5555'5555'5555'5555},
11821 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11822 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11823 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11824 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11825 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11826 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11827 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000}},
11828 kVectorCalculationsSourceLegacy,
11829 /*vlmul=*/0,
11830 /*regx1=*/8,
11831 /*skip=*/8);
11832
11833 // VLMUL = 1
11834 TestVectorPermutationInstruction(
11835 ExecVslideupvx,
11836 ExecMaskedVslideupvx,
11837 {{85, 0, 2, 4, 6, 9, 10, 12, 14, 17, 18, 20, 22, 24, 26, 28},
11838 {30, 32, 34, 36, 38, 41, 42, 44, 46, 49, 50, 52, 54, 56, 58, 60},
11839 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11840 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11841 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11842 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11843 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11844 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
11845 {{0x5555, 0x0200, 0x0604, 0x0a09, 0x0e0c, 0x1211, 0x1614, 0x1a18},
11846 {0x1e1c, 0x2220, 0x2624, 0x2a29, 0x2e2c, 0x3231, 0x3634, 0x3a38},
11847 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11848 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11849 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11850 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11851 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11852 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}},
11853 {{0x5555'5555, 0x0604'0200, 0x0e0c'0a09, 0x1614'1211},
11854 {0x1e1c'1a18, 0x2624'2220, 0x2e2c'2a29, 0x3634'3231},
11855 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11856 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11857 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11858 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11859 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11860 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000}},
11861 {{0x5555'5555'5555'5555, 0x0e0c'0a09'0604'0200},
11862 {0x1e1c'1a18'1614'1211, 0x2e2c'2a29'2624'2220},
11863 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11864 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11865 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11866 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11867 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11868 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000}},
11869 kVectorCalculationsSourceLegacy,
11870 /*vlmul=*/1,
11871 /*regx1=*/1,
11872 /*skip=*/1);
11873 TestVectorPermutationInstruction(
11874 ExecVslideupvx,
11875 ExecMaskedVslideupvx,
11876 {{85, 85, 85, 85, 85, 85, 85, 85, 0, 2, 4, 6, 9, 10, 12, 14},
11877 {17, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 41, 42, 44, 46},
11878 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11879 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11880 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11881 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11882 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11883 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
11884 {{0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555},
11885 {0x0200, 0x0604, 0x0a09, 0x0e0c, 0x1211, 0x1614, 0x1a18, 0x1e1c},
11886 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11887 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11888 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11889 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11890 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11891 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}},
11892 {{0x5555'5555, 0x5555'5555, 0x5555'5555, 0x5555'5555},
11893 {0x5555'5555, 0x5555'5555, 0x5555'5555, 0x5555'5555},
11894 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11895 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11896 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11897 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11898 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11899 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000}},
11900 {{0x5555'5555'5555'5555, 0x5555'5555'5555'5555},
11901 {0x5555'5555'5555'5555, 0x5555'5555'5555'5555},
11902 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11903 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11904 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11905 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11906 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11907 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000}},
11908 kVectorCalculationsSourceLegacy,
11909 /*vlmul=*/1,
11910 /*regx1=*/8,
11911 /*skip=*/8);
11912
11913 // VLMUL = 2
11914 TestVectorPermutationInstruction(
11915 ExecVslideupvx,
11916 ExecMaskedVslideupvx,
11917 {{85, 0, 2, 4, 6, 9, 10, 12, 14, 17, 18, 20, 22, 24, 26, 28},
11918 {30, 32, 34, 36, 38, 41, 42, 44, 46, 49, 50, 52, 54, 56, 58, 60},
11919 {62, 64, 66, 68, 70, 73, 74, 76, 78, 81, 82, 84, 86, 88, 90, 92},
11920 {94, 96, 98, 100, 102, 105, 106, 108, 110, 113, 114, 116, 118, 120, 122, 124},
11921 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11922 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11923 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11924 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
11925 {{0x5555, 0x0200, 0x0604, 0x0a09, 0x0e0c, 0x1211, 0x1614, 0x1a18},
11926 {0x1e1c, 0x2220, 0x2624, 0x2a29, 0x2e2c, 0x3231, 0x3634, 0x3a38},
11927 {0x3e3c, 0x4240, 0x4644, 0x4a49, 0x4e4c, 0x5251, 0x5654, 0x5a58},
11928 {0x5e5c, 0x6260, 0x6664, 0x6a69, 0x6e6c, 0x7271, 0x7674, 0x7a78},
11929 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11930 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11931 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11932 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}},
11933 {{0x5555'5555, 0x0604'0200, 0x0e0c'0a09, 0x1614'1211},
11934 {0x1e1c'1a18, 0x2624'2220, 0x2e2c'2a29, 0x3634'3231},
11935 {0x3e3c'3a38, 0x4644'4240, 0x4e4c'4a49, 0x5654'5251},
11936 {0x5e5c'5a58, 0x6664'6260, 0x6e6c'6a69, 0x7674'7271},
11937 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11938 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11939 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11940 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000}},
11941 {{0x5555'5555'5555'5555, 0x0e0c'0a09'0604'0200},
11942 {0x1e1c'1a18'1614'1211, 0x2e2c'2a29'2624'2220},
11943 {0x3e3c'3a38'3634'3231, 0x4e4c'4a49'4644'4240},
11944 {0x5e5c'5a58'5654'5251, 0x6e6c'6a69'6664'6260},
11945 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11946 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11947 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11948 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000}},
11949 kVectorCalculationsSourceLegacy,
11950 /*vlmul=*/2,
11951 /*regx1=*/1,
11952 /*skip=*/1);
11953
11954 TestVectorPermutationInstruction(
11955 ExecVslideupvx,
11956 ExecMaskedVslideupvx,
11957 {{85, 85, 85, 85, 85, 85, 85, 85, 0, 2, 4, 6, 9, 10, 12, 14},
11958 {17, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 41, 42, 44, 46},
11959 {49, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 73, 74, 76, 78},
11960 {81, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 105, 106, 108, 110},
11961 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11962 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11963 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
11964 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
11965 {{0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555},
11966 {0x0200, 0x0604, 0x0a09, 0x0e0c, 0x1211, 0x1614, 0x1a18, 0x1e1c},
11967 {0x2220, 0x2624, 0x2a29, 0x2e2c, 0x3231, 0x3634, 0x3a38, 0x3e3c},
11968 {0x4240, 0x4644, 0x4a49, 0x4e4c, 0x5251, 0x5654, 0x5a58, 0x5e5c},
11969 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11970 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11971 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
11972 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}},
11973 {{0x5555'5555, 0x5555'5555, 0x5555'5555, 0x5555'5555},
11974 {0x5555'5555, 0x5555'5555, 0x5555'5555, 0x5555'5555},
11975 {0x0604'0200, 0x0e0c'0a09, 0x1614'1211, 0x1e1c'1a18},
11976 {0x2624'2220, 0x2e2c'2a29, 0x3634'3231, 0x3e3c'3a38},
11977 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11978 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11979 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
11980 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000}},
11981 {{0x5555'5555'5555'5555, 0x5555'5555'5555'5555},
11982 {0x5555'5555'5555'5555, 0x5555'5555'5555'5555},
11983 {0x5555'5555'5555'5555, 0x5555'5555'5555'5555},
11984 {0x5555'5555'5555'5555, 0x5555'5555'5555'5555},
11985 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11986 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11987 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
11988 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000}},
11989 kVectorCalculationsSourceLegacy,
11990 /*vlmul=*/2,
11991 /*regx1=*/8,
11992 /*skip=*/8);
11993
11994 // VLMUL = 3
11995 TestVectorPermutationInstruction(
11996 ExecVslideupvx,
11997 ExecMaskedVslideupvx,
11998 {{85, 0, 2, 4, 6, 9, 10, 12, 14, 17, 18, 20, 22, 24, 26, 28},
11999 {30, 32, 34, 36, 38, 41, 42, 44, 46, 49, 50, 52, 54, 56, 58, 60},
12000 {62, 64, 66, 68, 70, 73, 74, 76, 78, 81, 82, 84, 86, 88, 90, 92},
12001 {94, 96, 98, 100, 102, 105, 106, 108, 110, 113, 114, 116, 118, 120, 122, 124},
12002 {126, 128, 130, 132, 134, 137, 138, 140, 142, 145, 146, 148, 150, 152, 154, 156},
12003 {158, 160, 162, 164, 166, 169, 170, 172, 174, 177, 178, 180, 182, 184, 186, 188},
12004 {190, 192, 194, 196, 198, 201, 202, 204, 206, 209, 210, 212, 214, 216, 218, 220},
12005 {222, 224, 226, 228, 230, 233, 234, 236, 238, 241, 242, 244, 246, 248, 250, 252}},
12006 {{0x5555, 0x0200, 0x0604, 0x0a09, 0x0e0c, 0x1211, 0x1614, 0x1a18},
12007 {0x1e1c, 0x2220, 0x2624, 0x2a29, 0x2e2c, 0x3231, 0x3634, 0x3a38},
12008 {0x3e3c, 0x4240, 0x4644, 0x4a49, 0x4e4c, 0x5251, 0x5654, 0x5a58},
12009 {0x5e5c, 0x6260, 0x6664, 0x6a69, 0x6e6c, 0x7271, 0x7674, 0x7a78},
12010 {0x7e7c, 0x8280, 0x8684, 0x8a89, 0x8e8c, 0x9291, 0x9694, 0x9a98},
12011 {0x9e9c, 0xa2a0, 0xa6a4, 0xaaa9, 0xaeac, 0xb2b1, 0xb6b4, 0xbab8},
12012 {0xbebc, 0xc2c0, 0xc6c4, 0xcac9, 0xcecc, 0xd2d1, 0xd6d4, 0xdad8},
12013 {0xdedc, 0xe2e0, 0xe6e4, 0xeae9, 0xeeec, 0xf2f1, 0xf6f4, 0xfaf8}},
12014 {{0x5555'5555, 0x0604'0200, 0x0e0c'0a09, 0x1614'1211},
12015 {0x1e1c'1a18, 0x2624'2220, 0x2e2c'2a29, 0x3634'3231},
12016 {0x3e3c'3a38, 0x4644'4240, 0x4e4c'4a49, 0x5654'5251},
12017 {0x5e5c'5a58, 0x6664'6260, 0x6e6c'6a69, 0x7674'7271},
12018 {0x7e7c'7a78, 0x8684'8280, 0x8e8c'8a89, 0x9694'9291},
12019 {0x9e9c'9a98, 0xa6a4'a2a0, 0xaeac'aaa9, 0xb6b4'b2b1},
12020 {0xbebc'bab8, 0xc6c4'c2c0, 0xcecc'cac9, 0xd6d4'd2d1},
12021 {0xdedc'dad8, 0xe6e4'e2e0, 0xeeec'eae9, 0xf6f4'f2f1}},
12022 {{0x5555'5555'5555'5555, 0x0e0c'0a09'0604'0200},
12023 {0x1e1c'1a18'1614'1211, 0x2e2c'2a29'2624'2220},
12024 {0x3e3c'3a38'3634'3231, 0x4e4c'4a49'4644'4240},
12025 {0x5e5c'5a58'5654'5251, 0x6e6c'6a69'6664'6260},
12026 {0x7e7c'7a78'7674'7271, 0x8e8c'8a89'8684'8280},
12027 {0x9e9c'9a98'9694'9291, 0xaeac'aaa9'a6a4'a2a0},
12028 {0xbebc'bab8'b6b4'b2b1, 0xcecc'cac9'c6c4'c2c0},
12029 {0xdedc'dad8'd6d4'd2d1, 0xeeec'eae9'e6e4'e2e0}},
12030 kVectorCalculationsSourceLegacy,
12031 /*vlmul=*/3,
12032 /*regx1=*/1,
12033 /*skip=*/1);
12034
12035 TestVectorPermutationInstruction(
12036 ExecVslideupvx,
12037 ExecMaskedVslideupvx,
12038 {{85, 85, 85, 85, 85, 85, 85, 85, 0, 2, 4, 6, 9, 10, 12, 14},
12039 {17, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 41, 42, 44, 46},
12040 {49, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 73, 74, 76, 78},
12041 {81, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 105, 106, 108, 110},
12042 {113, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 137, 138, 140, 142},
12043 {145, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 166, 169, 170, 172, 174},
12044 {177, 178, 180, 182, 184, 186, 188, 190, 192, 194, 196, 198, 201, 202, 204, 206},
12045 {209, 210, 212, 214, 216, 218, 220, 222, 224, 226, 228, 230, 233, 234, 236, 238}},
12046 {{0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555},
12047 {0x0200, 0x0604, 0x0a09, 0x0e0c, 0x1211, 0x1614, 0x1a18, 0x1e1c},
12048 {0x2220, 0x2624, 0x2a29, 0x2e2c, 0x3231, 0x3634, 0x3a38, 0x3e3c},
12049 {0x4240, 0x4644, 0x4a49, 0x4e4c, 0x5251, 0x5654, 0x5a58, 0x5e5c},
12050 {0x6260, 0x6664, 0x6a69, 0x6e6c, 0x7271, 0x7674, 0x7a78, 0x7e7c},
12051 {0x8280, 0x8684, 0x8a89, 0x8e8c, 0x9291, 0x9694, 0x9a98, 0x9e9c},
12052 {0xa2a0, 0xa6a4, 0xaaa9, 0xaeac, 0xb2b1, 0xb6b4, 0xbab8, 0xbebc},
12053 {0xc2c0, 0xc6c4, 0xcac9, 0xcecc, 0xd2d1, 0xd6d4, 0xdad8, 0xdedc}},
12054 {{0x5555'5555, 0x5555'5555, 0x5555'5555, 0x5555'5555},
12055 {0x5555'5555, 0x5555'5555, 0x5555'5555, 0x5555'5555},
12056 {0x0604'0200, 0x0e0c'0a09, 0x1614'1211, 0x1e1c'1a18},
12057 {0x2624'2220, 0x2e2c'2a29, 0x3634'3231, 0x3e3c'3a38},
12058 {0x4644'4240, 0x4e4c'4a49, 0x5654'5251, 0x5e5c'5a58},
12059 {0x6664'6260, 0x6e6c'6a69, 0x7674'7271, 0x7e7c'7a78},
12060 {0x8684'8280, 0x8e8c'8a89, 0x9694'9291, 0x9e9c'9a98},
12061 {0xa6a4'a2a0, 0xaeac'aaa9, 0xb6b4'b2b1, 0xbebc'bab8}},
12062 {{0x5555'5555'5555'5555, 0x5555'5555'5555'5555},
12063 {0x5555'5555'5555'5555, 0x5555'5555'5555'5555},
12064 {0x5555'5555'5555'5555, 0x5555'5555'5555'5555},
12065 {0x5555'5555'5555'5555, 0x5555'5555'5555'5555},
12066 {0x0e0c'0a09'0604'0200, 0x1e1c'1a18'1614'1211},
12067 {0x2e2c'2a29'2624'2220, 0x3e3c'3a38'3634'3231},
12068 {0x4e4c'4a49'4644'4240, 0x5e5c'5a58'5654'5251},
12069 {0x6e6c'6a69'6664'6260, 0x7e7c'7a78'7674'7271}},
12070 kVectorCalculationsSourceLegacy,
12071 /*vlmul=*/3,
12072 /*regx1=*/8,
12073 /*skip=*/8);
12074
12075 // VLMUL = 4
12076 TestVectorPermutationInstruction(
12077 ExecVslideupvx,
12078 ExecMaskedVslideupvx,
12079 {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12080 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12081 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12082 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12083 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12084 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12085 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12086 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
12087 {{0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12088 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12089 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12090 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12091 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12092 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12093 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12094 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}},
12095 {{0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12096 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12097 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12098 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12099 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12100 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12101 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12102 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000}},
12103 {{0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12104 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12105 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12106 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12107 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12108 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12109 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12110 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000}},
12111 kVectorCalculationsSourceLegacy,
12112 /*vlmul=*/4,
12113 /*regx1=*/1,
12114 /*skip=*/1);
12115
12116 TestVectorPermutationInstruction(
12117 ExecVslideupvx,
12118 ExecMaskedVslideupvx,
12119 {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12120 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12121 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12122 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12123 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12124 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12125 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12126 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
12127 {{0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12128 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12129 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12130 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12131 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12132 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12133 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12134 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}},
12135 {{0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12136 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12137 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12138 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12139 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12140 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12141 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12142 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000}},
12143 {{0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12144 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12145 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12146 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12147 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12148 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12149 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12150 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000}},
12151 kVectorCalculationsSourceLegacy,
12152 /*vlmul=*/4,
12153 /*regx1=*/8,
12154 /*skip=*/8);
12155
12156 // VLMUL = 5
12157 TestVectorPermutationInstruction(
12158 ExecVslideupvx,
12159 ExecMaskedVslideupvx,
12160 {{85, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12161 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12162 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12163 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12164 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12165 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12166 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12167 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
12168 {{0x5555, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12169 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12170 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12171 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12172 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12173 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12174 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12175 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}},
12176 {{0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12177 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12178 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12179 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12180 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12181 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12182 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12183 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000}},
12184 {{0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12185 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12186 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12187 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12188 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12189 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12190 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12191 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000}},
12192 kVectorCalculationsSourceLegacy,
12193 /*vlmul=*/5,
12194 /*regx1=*/1,
12195 /*skip=*/1);
12196
12197 TestVectorPermutationInstruction(
12198 ExecVslideupvx,
12199 ExecMaskedVslideupvx,
12200 {{85, 85, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12201 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12202 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12203 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12204 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12205 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12206 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12207 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
12208 {{0x5555, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12209 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12210 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12211 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12212 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12213 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12214 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12215 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}},
12216 {{0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12217 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12218 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12219 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12220 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12221 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12222 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12223 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000}},
12224 {{0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12225 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12226 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12227 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12228 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12229 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12230 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12231 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000}},
12232 kVectorCalculationsSourceLegacy,
12233 /*vlmul=*/5,
12234 /*regx1=*/8,
12235 /*skip=*/8);
12236
12237 // VLMUL = 6
12238 TestVectorPermutationInstruction(
12239 ExecVslideupvx,
12240 ExecMaskedVslideupvx,
12241 {{85, 0, 2, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12242 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12243 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12244 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12245 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12246 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12247 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12248 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
12249 {{0x5555, 0x0200, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12250 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12251 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12252 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12253 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12254 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12255 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12256 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}},
12257 {{0x5555'5555, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12258 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12259 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12260 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12261 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12262 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12263 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12264 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000}},
12265 {{0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12266 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12267 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12268 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12269 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12270 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12271 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12272 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000}},
12273 kVectorCalculationsSourceLegacy,
12274 /*vlmul=*/6,
12275 /*regx1=*/1,
12276 /*skip=*/1);
12277
12278 TestVectorPermutationInstruction(
12279 ExecVslideupvx,
12280 ExecMaskedVslideupvx,
12281 {{85, 85, 85, 85, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12282 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12283 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12284 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12285 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12286 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12287 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12288 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
12289 {{0x5555, 0x5555, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12290 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12291 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12292 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12293 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12294 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12295 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12296 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}},
12297 {{0x5555'5555, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12298 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12299 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12300 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12301 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12302 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12303 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12304 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000}},
12305 {{0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12306 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12307 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12308 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12309 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12310 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12311 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12312 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000}},
12313 kVectorCalculationsSourceLegacy,
12314 /*vlmul=*/6,
12315 /*regx1=*/8,
12316 /*skip=*/8);
12317
12318 // VLMUL = 7
12319 TestVectorPermutationInstruction(
12320 ExecVslideupvx,
12321 ExecMaskedVslideupvx,
12322 {{85, 0, 2, 4, 6, 9, 10, 12, 0, 0, 0, 0, 0, 0, 0, 0},
12323 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12324 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12325 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12326 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12327 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12328 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12329 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
12330 {{0x5555, 0x0200, 0x0604, 0x0a09, 0x0000, 0x0000, 0x0000, 0x0000},
12331 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12332 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12333 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12334 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12335 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12336 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12337 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}},
12338 {{0x5555'5555, 0x0604'0200, 0x0000'0000, 0x0000'0000},
12339 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12340 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12341 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12342 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12343 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12344 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12345 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000}},
12346 {{0x5555'5555'5555'5555, 0x0000'0000'0000'0000},
12347 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12348 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12349 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12350 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12351 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12352 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12353 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000}},
12354 kVectorCalculationsSourceLegacy,
12355 /*vlmul=*/7,
12356 /*regx1=*/1,
12357 /*skip=*/1);
12358
12359 TestVectorPermutationInstruction(
12360 ExecVslideupvx,
12361 ExecMaskedVslideupvx,
12362 {{85, 85, 85, 85, 85, 85, 85, 85, 0, 0, 0, 0, 0, 0, 0, 0},
12363 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12364 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12365 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12366 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12367 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12368 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
12369 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
12370 {{0x5555, 0x5555, 0x5555, 0x5555, 0x0000, 0x0000, 0x0000, 0x0000},
12371 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12372 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12373 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12374 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12375 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12376 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
12377 {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}},
12378 {{0x5555'5555, 0x5555'5555, 0x0000'0000, 0x0000'0000},
12379 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12380 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12381 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12382 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12383 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12384 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000},
12385 {0x0000'0000, 0x0000'0000, 0x0000'0000, 0x0000'0000}},
12386 {{0x5555'5555'5555'5555, 0x0000'0000'0000'0000},
12387 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12388 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12389 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12390 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12391 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12392 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000},
12393 {0x0000'0000'0000'0000, 0x0000'0000'0000'0000}},
12394 kVectorCalculationsSourceLegacy,
12395 /*vlmul=*/7,
12396 /*regx1=*/8,
12397 /*skip=*/8);
12398 }
12399
ExecVfirstm()12400 [[gnu::naked]] void ExecVfirstm() {
12401 asm("vfirst.m t0, v16\n\t"
12402 "ret\n\t");
12403 }
12404
TEST(InlineAsmTestRiscv64,TestVfirstm)12405 TEST(InlineAsmTestRiscv64, TestVfirstm) {
12406 SIMD128Register source[16]{};
12407 SIMD128Register unused_result[8]{};
12408 // Setup 8-bit elements in 8 registers to involve all 128 bits in vl. Masks and tail processing
12409 // aren't used in this test.
12410 uint64_t vtype = 3;
12411 for (uint64_t bit = 0; bit < 128; bit++) {
12412 uint64_t result{~uint64_t{0}};
12413 source[0] = __uint128_t{1} << bit;
12414 RunCommonVectorFunc(
12415 &ExecVfirstm, &source[0], nullptr, &result, nullptr, 0, 0, vtype, /*vl*/ 128);
12416 EXPECT_EQ(result, bit);
12417 }
12418
12419 // Also test the zero special case.
12420 uint64_t result{0};
12421 source[0] = __uint128_t{0};
12422 RunCommonVectorFunc(&ExecVfirstm, &source[0], nullptr, &result, nullptr, 0, 0, vtype, /*vl*/ 128);
12423 EXPECT_EQ(result, ~uint64_t{0});
12424 }
12425
12426 } // namespace
12427
12428 } // namespace berberis
12429