Bug Summary

File:build/source/build-llvm/tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc
Warning:line 69, column 3
Value stored to 'DefaultPolicy' is never read

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name CGBuiltin.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -relaxed-aliasing -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/source/build-llvm -resource-dir /usr/lib/llvm-16/lib/clang/16 -I tools/clang/lib/CodeGen -I /build/source/clang/lib/CodeGen -I /build/source/clang/include -I tools/clang/include -I include -I /build/source/llvm/include -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -D _FORTIFY_SOURCE=2 -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-16/lib/clang/16/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/build/source/build-llvm=build-llvm -fmacro-prefix-map=/build/source/= -fcoverage-prefix-map=/build/source/build-llvm=build-llvm -fcoverage-prefix-map=/build/source/= -source-date-epoch 1671833309 -O3 -Wno-unused-command-line-argument -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -Wno-misleading-indentation -std=c++17 -fdeprecated-macro -fdebug-compilation-dir=/build/source/build-llvm -fdebug-prefix-map=/build/source/build-llvm=build-llvm -fdebug-prefix-map=/build/source/= -fdebug-prefix-map=/build/source/build-llvm=build-llvm -fdebug-prefix-map=/build/source/= -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-12-24-002659-1137794-1 -x c++ /build/source/clang/lib/CodeGen/CGBuiltin.cpp
1case RISCVVector::BI__builtin_rvv_vget_v:
2 DefaultPolicy = 1;
3IsMasked = false;
4
5 {
6 ID = Intrinsic::vector_extract;
7 auto *VecTy = cast<ScalableVectorType>(ResultType);
8 auto *OpVecTy = cast<ScalableVectorType>(Ops[0]->getType());
9 // Mask to only valid indices.
10 unsigned MaxIndex = OpVecTy->getMinNumElements() / VecTy->getMinNumElements();
11 assert(isPowerOf2_32(MaxIndex))(static_cast <bool> (isPowerOf2_32(MaxIndex)) ? void (0
) : __assert_fail ("isPowerOf2_32(MaxIndex)", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 11, __extension__ __PRETTY_FUNCTION__));
12 Ops[1] = Builder.CreateZExt(Ops[1], Builder.getInt64Ty());
13 Ops[1] = Builder.CreateAnd(Ops[1], MaxIndex - 1);
14 Ops[1] = Builder.CreateMul(Ops[1],
15 ConstantInt::get(Ops[1]->getType(),
16 VecTy->getMinNumElements()));
17 IntrinsicTypes = {ResultType, Ops[0]->getType()};
18 return Builder.CreateCall(CGM.getIntrinsic(ID, IntrinsicTypes), Ops, "");
19 }
20 break;
21case RISCVVector::BI__builtin_rvv_vset_v:
22 DefaultPolicy = 1;
23IsMasked = false;
24
25 {
26 ID = Intrinsic::vector_insert;
27 IntrinsicTypes = {ResultType, Ops[2]->getType()};
28 auto *ResVecTy = cast<ScalableVectorType>(ResultType);
29 auto *VecTy = cast<ScalableVectorType>(Ops[2]->getType());
30 // Mask to only valid indices.
31 unsigned MaxIndex = ResVecTy->getMinNumElements() / VecTy->getMinNumElements();
32 assert(isPowerOf2_32(MaxIndex))(static_cast <bool> (isPowerOf2_32(MaxIndex)) ? void (0
) : __assert_fail ("isPowerOf2_32(MaxIndex)", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 32, __extension__ __PRETTY_FUNCTION__));
33 Ops[1] = Builder.CreateZExt(Ops[1], Builder.getInt64Ty());
34 Ops[1] = Builder.CreateAnd(Ops[1], MaxIndex - 1);
35 Ops[1] = Builder.CreateMul(Ops[1],
36 ConstantInt::get(Ops[1]->getType(),
37 VecTy->getMinNumElements()));
38 std::swap(Ops[1], Ops[2]);
39 return Builder.CreateCall(CGM.getIntrinsic(ID, IntrinsicTypes), Ops, "");
40 }
41 break;
42case RISCVVector::BI__builtin_rvv_vlmul_ext_v:
43 DefaultPolicy = 1;
44IsMasked = false;
45
46 ID = Intrinsic::vector_insert;
47 IntrinsicTypes = {ResultType, Ops[0]->getType()};
48 Ops.push_back(llvm::PoisonValue::get(ResultType));
49 std::swap(Ops[0], Ops[1]);
50 Ops.push_back(ConstantInt::get(Int64Ty, 0));
51 return Builder.CreateCall(CGM.getIntrinsic(ID, IntrinsicTypes), Ops, "");
52 break;
53case RISCVVector::BI__builtin_rvv_vlmul_trunc_v:
54 DefaultPolicy = 1;
55IsMasked = false;
56 {
57 ID = Intrinsic::vector_extract;
58 IntrinsicTypes = {ResultType, Ops[0]->getType()};
59 Ops.push_back(ConstantInt::get(Int64Ty, 0));
60 return Builder.CreateCall(CGM.getIntrinsic(ID, IntrinsicTypes), Ops, "");
61 } break;
62case RISCVVector::BI__builtin_rvv_vreinterpret_v:
63 DefaultPolicy = 1;
64IsMasked = false;
65
66 return Builder.CreateBitCast(Ops[0], ResultType);
67 break;
68case RISCVVector::BI__builtin_rvv_vundefined:
69 DefaultPolicy = 1;
Value stored to 'DefaultPolicy' is never read
70IsMasked = false;
71
72 return llvm::PoisonValue::get(ResultType);
73 break;
74case RISCVVector::BI__builtin_rvv_vaadd_vv_tu:
75case RISCVVector::BI__builtin_rvv_vaadd_vx_tu:
76 ID = Intrinsic::riscv_vaadd;
77 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
78 break;
79case RISCVVector::BI__builtin_rvv_vaadd_vv_ta:
80case RISCVVector::BI__builtin_rvv_vaadd_vx_ta:
81 ID = Intrinsic::riscv_vaadd;
82 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
83 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
84 break;
85case RISCVVector::BI__builtin_rvv_vaadd_vv_tuma:
86case RISCVVector::BI__builtin_rvv_vaadd_vx_tuma:
87 ID = Intrinsic::riscv_vaadd_mask;
88 DefaultPolicy = 2;
89 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
90 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
91 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
92 break;
93case RISCVVector::BI__builtin_rvv_vaadd_vv_tama:
94case RISCVVector::BI__builtin_rvv_vaadd_vx_tama:
95 ID = Intrinsic::riscv_vaadd_mask;
96 DefaultPolicy = 3;
97 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
98 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
99 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
100 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
101 break;
102case RISCVVector::BI__builtin_rvv_vaadd_vv_tumu:
103case RISCVVector::BI__builtin_rvv_vaadd_vx_tumu:
104 ID = Intrinsic::riscv_vaadd_mask;
105 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
106 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
107 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
108 break;
109case RISCVVector::BI__builtin_rvv_vaadd_vv_tamu:
110case RISCVVector::BI__builtin_rvv_vaadd_vx_tamu:
111 ID = Intrinsic::riscv_vaadd_mask;
112 DefaultPolicy = 1;
113 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
114 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
115 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
116 break;
117case RISCVVector::BI__builtin_rvv_vaaddu_vv_tu:
118case RISCVVector::BI__builtin_rvv_vaaddu_vx_tu:
119 ID = Intrinsic::riscv_vaaddu;
120 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
121 break;
122case RISCVVector::BI__builtin_rvv_vaaddu_vv_ta:
123case RISCVVector::BI__builtin_rvv_vaaddu_vx_ta:
124 ID = Intrinsic::riscv_vaaddu;
125 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
126 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
127 break;
128case RISCVVector::BI__builtin_rvv_vaaddu_vv_tuma:
129case RISCVVector::BI__builtin_rvv_vaaddu_vx_tuma:
130 ID = Intrinsic::riscv_vaaddu_mask;
131 DefaultPolicy = 2;
132 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
133 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
134 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
135 break;
136case RISCVVector::BI__builtin_rvv_vaaddu_vv_tama:
137case RISCVVector::BI__builtin_rvv_vaaddu_vx_tama:
138 ID = Intrinsic::riscv_vaaddu_mask;
139 DefaultPolicy = 3;
140 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
141 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
142 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
143 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
144 break;
145case RISCVVector::BI__builtin_rvv_vaaddu_vv_tumu:
146case RISCVVector::BI__builtin_rvv_vaaddu_vx_tumu:
147 ID = Intrinsic::riscv_vaaddu_mask;
148 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
149 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
150 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
151 break;
152case RISCVVector::BI__builtin_rvv_vaaddu_vv_tamu:
153case RISCVVector::BI__builtin_rvv_vaaddu_vx_tamu:
154 ID = Intrinsic::riscv_vaaddu_mask;
155 DefaultPolicy = 1;
156 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
157 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
158 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
159 break;
160case RISCVVector::BI__builtin_rvv_vadc_vvm_tu:
161case RISCVVector::BI__builtin_rvv_vadc_vxm_tu:
162 ID = Intrinsic::riscv_vadc;
163 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
164 break;
165case RISCVVector::BI__builtin_rvv_vadc_vvm_ta:
166case RISCVVector::BI__builtin_rvv_vadc_vxm_ta:
167 ID = Intrinsic::riscv_vadc;
168 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
169 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
170 break;
171case RISCVVector::BI__builtin_rvv_vadd_vv_tu:
172case RISCVVector::BI__builtin_rvv_vadd_vx_tu:
173 ID = Intrinsic::riscv_vadd;
174 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
175 break;
176case RISCVVector::BI__builtin_rvv_vadd_vv_ta:
177case RISCVVector::BI__builtin_rvv_vadd_vx_ta:
178 ID = Intrinsic::riscv_vadd;
179 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
180 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
181 break;
182case RISCVVector::BI__builtin_rvv_vadd_vv_tuma:
183case RISCVVector::BI__builtin_rvv_vadd_vx_tuma:
184 ID = Intrinsic::riscv_vadd_mask;
185 DefaultPolicy = 2;
186 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
187 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
188 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
189 break;
190case RISCVVector::BI__builtin_rvv_vadd_vv_tama:
191case RISCVVector::BI__builtin_rvv_vadd_vx_tama:
192 ID = Intrinsic::riscv_vadd_mask;
193 DefaultPolicy = 3;
194 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
195 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
196 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
197 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
198 break;
199case RISCVVector::BI__builtin_rvv_vadd_vv_tumu:
200case RISCVVector::BI__builtin_rvv_vadd_vx_tumu:
201 ID = Intrinsic::riscv_vadd_mask;
202 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
203 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
204 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
205 break;
206case RISCVVector::BI__builtin_rvv_vadd_vv_tamu:
207case RISCVVector::BI__builtin_rvv_vadd_vx_tamu:
208 ID = Intrinsic::riscv_vadd_mask;
209 DefaultPolicy = 1;
210 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
211 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
212 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
213 break;
214case RISCVVector::BI__builtin_rvv_vand_vv_tu:
215case RISCVVector::BI__builtin_rvv_vand_vx_tu:
216 ID = Intrinsic::riscv_vand;
217 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
218 break;
219case RISCVVector::BI__builtin_rvv_vand_vv_ta:
220case RISCVVector::BI__builtin_rvv_vand_vx_ta:
221 ID = Intrinsic::riscv_vand;
222 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
223 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
224 break;
225case RISCVVector::BI__builtin_rvv_vand_vv_tuma:
226case RISCVVector::BI__builtin_rvv_vand_vx_tuma:
227 ID = Intrinsic::riscv_vand_mask;
228 DefaultPolicy = 2;
229 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
230 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
231 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
232 break;
233case RISCVVector::BI__builtin_rvv_vand_vv_tama:
234case RISCVVector::BI__builtin_rvv_vand_vx_tama:
235 ID = Intrinsic::riscv_vand_mask;
236 DefaultPolicy = 3;
237 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
238 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
239 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
240 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
241 break;
242case RISCVVector::BI__builtin_rvv_vand_vv_tumu:
243case RISCVVector::BI__builtin_rvv_vand_vx_tumu:
244 ID = Intrinsic::riscv_vand_mask;
245 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
246 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
247 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
248 break;
249case RISCVVector::BI__builtin_rvv_vand_vv_tamu:
250case RISCVVector::BI__builtin_rvv_vand_vx_tamu:
251 ID = Intrinsic::riscv_vand_mask;
252 DefaultPolicy = 1;
253 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
254 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
255 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
256 break;
257case RISCVVector::BI__builtin_rvv_vasub_vv_tu:
258case RISCVVector::BI__builtin_rvv_vasub_vx_tu:
259 ID = Intrinsic::riscv_vasub;
260 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
261 break;
262case RISCVVector::BI__builtin_rvv_vasub_vv_ta:
263case RISCVVector::BI__builtin_rvv_vasub_vx_ta:
264 ID = Intrinsic::riscv_vasub;
265 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
266 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
267 break;
268case RISCVVector::BI__builtin_rvv_vasub_vv_tuma:
269case RISCVVector::BI__builtin_rvv_vasub_vx_tuma:
270 ID = Intrinsic::riscv_vasub_mask;
271 DefaultPolicy = 2;
272 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
273 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
274 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
275 break;
276case RISCVVector::BI__builtin_rvv_vasub_vv_tama:
277case RISCVVector::BI__builtin_rvv_vasub_vx_tama:
278 ID = Intrinsic::riscv_vasub_mask;
279 DefaultPolicy = 3;
280 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
281 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
282 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
283 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
284 break;
285case RISCVVector::BI__builtin_rvv_vasub_vv_tumu:
286case RISCVVector::BI__builtin_rvv_vasub_vx_tumu:
287 ID = Intrinsic::riscv_vasub_mask;
288 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
289 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
290 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
291 break;
292case RISCVVector::BI__builtin_rvv_vasub_vv_tamu:
293case RISCVVector::BI__builtin_rvv_vasub_vx_tamu:
294 ID = Intrinsic::riscv_vasub_mask;
295 DefaultPolicy = 1;
296 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
297 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
298 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
299 break;
300case RISCVVector::BI__builtin_rvv_vasubu_vv_tu:
301case RISCVVector::BI__builtin_rvv_vasubu_vx_tu:
302 ID = Intrinsic::riscv_vasubu;
303 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
304 break;
305case RISCVVector::BI__builtin_rvv_vasubu_vv_ta:
306case RISCVVector::BI__builtin_rvv_vasubu_vx_ta:
307 ID = Intrinsic::riscv_vasubu;
308 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
309 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
310 break;
311case RISCVVector::BI__builtin_rvv_vasubu_vv_tuma:
312case RISCVVector::BI__builtin_rvv_vasubu_vx_tuma:
313 ID = Intrinsic::riscv_vasubu_mask;
314 DefaultPolicy = 2;
315 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
316 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
317 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
318 break;
319case RISCVVector::BI__builtin_rvv_vasubu_vv_tama:
320case RISCVVector::BI__builtin_rvv_vasubu_vx_tama:
321 ID = Intrinsic::riscv_vasubu_mask;
322 DefaultPolicy = 3;
323 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
324 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
325 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
326 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
327 break;
328case RISCVVector::BI__builtin_rvv_vasubu_vv_tumu:
329case RISCVVector::BI__builtin_rvv_vasubu_vx_tumu:
330 ID = Intrinsic::riscv_vasubu_mask;
331 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
332 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
333 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
334 break;
335case RISCVVector::BI__builtin_rvv_vasubu_vv_tamu:
336case RISCVVector::BI__builtin_rvv_vasubu_vx_tamu:
337 ID = Intrinsic::riscv_vasubu_mask;
338 DefaultPolicy = 1;
339 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
340 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
341 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
342 break;
343case RISCVVector::BI__builtin_rvv_vcompress_vm_tu:
344 ID = Intrinsic::riscv_vcompress;
345 DefaultPolicy = 0;
346IsMasked = false;
347
348 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
349 // insert poison passthru
350 if (DefaultPolicy == TAIL_AGNOSTIC)
351 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
352 IntrinsicTypes = {ResultType, Ops.back()->getType()};
353 break;
354case RISCVVector::BI__builtin_rvv_vcompress_vm_ta:
355 ID = Intrinsic::riscv_vcompress;
356 DefaultPolicy = 1;
357IsMasked = false;
358
359 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
360 // insert poison passthru
361 if (DefaultPolicy == TAIL_AGNOSTIC)
362 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
363 IntrinsicTypes = {ResultType, Ops.back()->getType()};
364 break;
365case RISCVVector::BI__builtin_rvv_vcpop_m:
366 ID = Intrinsic::riscv_vcpop;
367 DefaultPolicy = 1;
368 IntrinsicTypes = {Ops[0]->getType(), Ops.back()->getType()};
369 break;
370case RISCVVector::BI__builtin_rvv_vcpop_m_m:
371 ID = Intrinsic::riscv_vcpop_mask;
372 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
373 IntrinsicTypes = {Ops[0]->getType(), Ops.back()->getType()};
374 break;
375case RISCVVector::BI__builtin_rvv_vdiv_vv_tu:
376case RISCVVector::BI__builtin_rvv_vdiv_vx_tu:
377 ID = Intrinsic::riscv_vdiv;
378 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
379 break;
380case RISCVVector::BI__builtin_rvv_vdiv_vv_ta:
381case RISCVVector::BI__builtin_rvv_vdiv_vx_ta:
382 ID = Intrinsic::riscv_vdiv;
383 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
384 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
385 break;
386case RISCVVector::BI__builtin_rvv_vdiv_vv_tuma:
387case RISCVVector::BI__builtin_rvv_vdiv_vx_tuma:
388 ID = Intrinsic::riscv_vdiv_mask;
389 DefaultPolicy = 2;
390 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
391 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
392 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
393 break;
394case RISCVVector::BI__builtin_rvv_vdiv_vv_tama:
395case RISCVVector::BI__builtin_rvv_vdiv_vx_tama:
396 ID = Intrinsic::riscv_vdiv_mask;
397 DefaultPolicy = 3;
398 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
399 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
400 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
401 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
402 break;
403case RISCVVector::BI__builtin_rvv_vdiv_vv_tumu:
404case RISCVVector::BI__builtin_rvv_vdiv_vx_tumu:
405 ID = Intrinsic::riscv_vdiv_mask;
406 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
407 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
408 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
409 break;
410case RISCVVector::BI__builtin_rvv_vdiv_vv_tamu:
411case RISCVVector::BI__builtin_rvv_vdiv_vx_tamu:
412 ID = Intrinsic::riscv_vdiv_mask;
413 DefaultPolicy = 1;
414 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
415 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
416 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
417 break;
418case RISCVVector::BI__builtin_rvv_vdivu_vv_tu:
419case RISCVVector::BI__builtin_rvv_vdivu_vx_tu:
420 ID = Intrinsic::riscv_vdivu;
421 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
422 break;
423case RISCVVector::BI__builtin_rvv_vdivu_vv_ta:
424case RISCVVector::BI__builtin_rvv_vdivu_vx_ta:
425 ID = Intrinsic::riscv_vdivu;
426 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
427 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
428 break;
429case RISCVVector::BI__builtin_rvv_vdivu_vv_tuma:
430case RISCVVector::BI__builtin_rvv_vdivu_vx_tuma:
431 ID = Intrinsic::riscv_vdivu_mask;
432 DefaultPolicy = 2;
433 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
434 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
435 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
436 break;
437case RISCVVector::BI__builtin_rvv_vdivu_vv_tama:
438case RISCVVector::BI__builtin_rvv_vdivu_vx_tama:
439 ID = Intrinsic::riscv_vdivu_mask;
440 DefaultPolicy = 3;
441 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
442 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
443 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
444 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
445 break;
446case RISCVVector::BI__builtin_rvv_vdivu_vv_tumu:
447case RISCVVector::BI__builtin_rvv_vdivu_vx_tumu:
448 ID = Intrinsic::riscv_vdivu_mask;
449 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
450 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
451 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
452 break;
453case RISCVVector::BI__builtin_rvv_vdivu_vv_tamu:
454case RISCVVector::BI__builtin_rvv_vdivu_vx_tamu:
455 ID = Intrinsic::riscv_vdivu_mask;
456 DefaultPolicy = 1;
457 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
458 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
459 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
460 break;
461case RISCVVector::BI__builtin_rvv_vfadd_vv_tu:
462case RISCVVector::BI__builtin_rvv_vfadd_vf_tu:
463 ID = Intrinsic::riscv_vfadd;
464 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
465 break;
466case RISCVVector::BI__builtin_rvv_vfadd_vv_ta:
467case RISCVVector::BI__builtin_rvv_vfadd_vf_ta:
468 ID = Intrinsic::riscv_vfadd;
469 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
470 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
471 break;
472case RISCVVector::BI__builtin_rvv_vfadd_vv_tuma:
473case RISCVVector::BI__builtin_rvv_vfadd_vf_tuma:
474 ID = Intrinsic::riscv_vfadd_mask;
475 DefaultPolicy = 2;
476 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
477 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
478 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
479 break;
480case RISCVVector::BI__builtin_rvv_vfadd_vv_tama:
481case RISCVVector::BI__builtin_rvv_vfadd_vf_tama:
482 ID = Intrinsic::riscv_vfadd_mask;
483 DefaultPolicy = 3;
484 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
485 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
486 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
487 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
488 break;
489case RISCVVector::BI__builtin_rvv_vfadd_vv_tumu:
490case RISCVVector::BI__builtin_rvv_vfadd_vf_tumu:
491 ID = Intrinsic::riscv_vfadd_mask;
492 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
493 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
494 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
495 break;
496case RISCVVector::BI__builtin_rvv_vfadd_vv_tamu:
497case RISCVVector::BI__builtin_rvv_vfadd_vf_tamu:
498 ID = Intrinsic::riscv_vfadd_mask;
499 DefaultPolicy = 1;
500 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
501 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
502 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
503 break;
504case RISCVVector::BI__builtin_rvv_vfclass_v_tu:
505 ID = Intrinsic::riscv_vfclass;
506 IntrinsicTypes = {Ops[1]->getType(), Ops.back()->getType()};
507 break;
508case RISCVVector::BI__builtin_rvv_vfclass_v_ta:
509 ID = Intrinsic::riscv_vfclass;
510 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
511 IntrinsicTypes = {Ops[1]->getType(), Ops.back()->getType()};
512 break;
513case RISCVVector::BI__builtin_rvv_vfclass_v_tuma:
514 ID = Intrinsic::riscv_vfclass_mask;
515 DefaultPolicy = 2;
516 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
517 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
518 IntrinsicTypes = {Ops[1]->getType(), Ops.back()->getType()};
519 break;
520case RISCVVector::BI__builtin_rvv_vfclass_v_tama:
521 ID = Intrinsic::riscv_vfclass_mask;
522 DefaultPolicy = 3;
523 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
524 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
525 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
526 IntrinsicTypes = {Ops[1]->getType(), Ops.back()->getType()};
527 break;
528case RISCVVector::BI__builtin_rvv_vfclass_v_tumu:
529 ID = Intrinsic::riscv_vfclass_mask;
530 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
531 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
532 IntrinsicTypes = {Ops[1]->getType(), Ops.back()->getType()};
533 break;
534case RISCVVector::BI__builtin_rvv_vfclass_v_tamu:
535 ID = Intrinsic::riscv_vfclass_mask;
536 DefaultPolicy = 1;
537 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
538 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
539 IntrinsicTypes = {Ops[1]->getType(), Ops.back()->getType()};
540 break;
541case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_tu:
542 ID = Intrinsic::riscv_vfcvt_f_x_v;
543 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
544 break;
545case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_ta:
546 ID = Intrinsic::riscv_vfcvt_f_x_v;
547 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
548 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
549 break;
550case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_tuma:
551 ID = Intrinsic::riscv_vfcvt_f_x_v_mask;
552 DefaultPolicy = 2;
553 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
554 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
555 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
556 break;
557case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_tama:
558 ID = Intrinsic::riscv_vfcvt_f_x_v_mask;
559 DefaultPolicy = 3;
560 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
561 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
562 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
563 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
564 break;
565case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_tumu:
566 ID = Intrinsic::riscv_vfcvt_f_x_v_mask;
567 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
568 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
569 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
570 break;
571case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_tamu:
572 ID = Intrinsic::riscv_vfcvt_f_x_v_mask;
573 DefaultPolicy = 1;
574 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
575 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
576 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
577 break;
578case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_tu:
579 ID = Intrinsic::riscv_vfcvt_f_xu_v;
580 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
581 break;
582case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_ta:
583 ID = Intrinsic::riscv_vfcvt_f_xu_v;
584 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
585 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
586 break;
587case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_tuma:
588 ID = Intrinsic::riscv_vfcvt_f_xu_v_mask;
589 DefaultPolicy = 2;
590 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
591 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
592 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
593 break;
594case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_tama:
595 ID = Intrinsic::riscv_vfcvt_f_xu_v_mask;
596 DefaultPolicy = 3;
597 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
598 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
599 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
600 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
601 break;
602case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_tumu:
603 ID = Intrinsic::riscv_vfcvt_f_xu_v_mask;
604 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
605 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
606 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
607 break;
608case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_tamu:
609 ID = Intrinsic::riscv_vfcvt_f_xu_v_mask;
610 DefaultPolicy = 1;
611 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
612 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
613 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
614 break;
615case RISCVVector::BI__builtin_rvv_vfcvt_rtz_x_f_v_tu:
616 ID = Intrinsic::riscv_vfcvt_rtz_x_f_v;
617 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
618 break;
619case RISCVVector::BI__builtin_rvv_vfcvt_rtz_x_f_v_ta:
620 ID = Intrinsic::riscv_vfcvt_rtz_x_f_v;
621 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
622 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
623 break;
624case RISCVVector::BI__builtin_rvv_vfcvt_rtz_x_f_v_tuma:
625 ID = Intrinsic::riscv_vfcvt_rtz_x_f_v_mask;
626 DefaultPolicy = 2;
627 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
628 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
629 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
630 break;
631case RISCVVector::BI__builtin_rvv_vfcvt_rtz_x_f_v_tama:
632 ID = Intrinsic::riscv_vfcvt_rtz_x_f_v_mask;
633 DefaultPolicy = 3;
634 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
635 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
636 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
637 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
638 break;
639case RISCVVector::BI__builtin_rvv_vfcvt_rtz_x_f_v_tumu:
640 ID = Intrinsic::riscv_vfcvt_rtz_x_f_v_mask;
641 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
642 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
643 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
644 break;
645case RISCVVector::BI__builtin_rvv_vfcvt_rtz_x_f_v_tamu:
646 ID = Intrinsic::riscv_vfcvt_rtz_x_f_v_mask;
647 DefaultPolicy = 1;
648 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
649 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
650 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
651 break;
652case RISCVVector::BI__builtin_rvv_vfcvt_rtz_xu_f_v_tu:
653 ID = Intrinsic::riscv_vfcvt_rtz_xu_f_v;
654 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
655 break;
656case RISCVVector::BI__builtin_rvv_vfcvt_rtz_xu_f_v_ta:
657 ID = Intrinsic::riscv_vfcvt_rtz_xu_f_v;
658 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
659 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
660 break;
661case RISCVVector::BI__builtin_rvv_vfcvt_rtz_xu_f_v_tuma:
662 ID = Intrinsic::riscv_vfcvt_rtz_xu_f_v_mask;
663 DefaultPolicy = 2;
664 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
665 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
666 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
667 break;
668case RISCVVector::BI__builtin_rvv_vfcvt_rtz_xu_f_v_tama:
669 ID = Intrinsic::riscv_vfcvt_rtz_xu_f_v_mask;
670 DefaultPolicy = 3;
671 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
672 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
673 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
674 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
675 break;
676case RISCVVector::BI__builtin_rvv_vfcvt_rtz_xu_f_v_tumu:
677 ID = Intrinsic::riscv_vfcvt_rtz_xu_f_v_mask;
678 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
679 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
680 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
681 break;
682case RISCVVector::BI__builtin_rvv_vfcvt_rtz_xu_f_v_tamu:
683 ID = Intrinsic::riscv_vfcvt_rtz_xu_f_v_mask;
684 DefaultPolicy = 1;
685 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
686 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
687 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
688 break;
689case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_tu:
690 ID = Intrinsic::riscv_vfcvt_x_f_v;
691 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
692 break;
693case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_ta:
694 ID = Intrinsic::riscv_vfcvt_x_f_v;
695 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
696 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
697 break;
698case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_tuma:
699 ID = Intrinsic::riscv_vfcvt_x_f_v_mask;
700 DefaultPolicy = 2;
701 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
702 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
703 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
704 break;
705case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_tama:
706 ID = Intrinsic::riscv_vfcvt_x_f_v_mask;
707 DefaultPolicy = 3;
708 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
709 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
710 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
711 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
712 break;
713case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_tumu:
714 ID = Intrinsic::riscv_vfcvt_x_f_v_mask;
715 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
716 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
717 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
718 break;
719case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_tamu:
720 ID = Intrinsic::riscv_vfcvt_x_f_v_mask;
721 DefaultPolicy = 1;
722 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
723 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
724 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
725 break;
726case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_tu:
727 ID = Intrinsic::riscv_vfcvt_xu_f_v;
728 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
729 break;
730case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_ta:
731 ID = Intrinsic::riscv_vfcvt_xu_f_v;
732 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
733 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
734 break;
735case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_tuma:
736 ID = Intrinsic::riscv_vfcvt_xu_f_v_mask;
737 DefaultPolicy = 2;
738 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
739 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
740 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
741 break;
742case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_tama:
743 ID = Intrinsic::riscv_vfcvt_xu_f_v_mask;
744 DefaultPolicy = 3;
745 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
746 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
747 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
748 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
749 break;
750case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_tumu:
751 ID = Intrinsic::riscv_vfcvt_xu_f_v_mask;
752 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
753 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
754 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
755 break;
756case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_tamu:
757 ID = Intrinsic::riscv_vfcvt_xu_f_v_mask;
758 DefaultPolicy = 1;
759 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
760 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
761 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
762 break;
763case RISCVVector::BI__builtin_rvv_vfdiv_vv_tu:
764case RISCVVector::BI__builtin_rvv_vfdiv_vf_tu:
765 ID = Intrinsic::riscv_vfdiv;
766 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
767 break;
768case RISCVVector::BI__builtin_rvv_vfdiv_vv_ta:
769case RISCVVector::BI__builtin_rvv_vfdiv_vf_ta:
770 ID = Intrinsic::riscv_vfdiv;
771 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
772 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
773 break;
774case RISCVVector::BI__builtin_rvv_vfdiv_vv_tuma:
775case RISCVVector::BI__builtin_rvv_vfdiv_vf_tuma:
776 ID = Intrinsic::riscv_vfdiv_mask;
777 DefaultPolicy = 2;
778 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
779 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
780 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
781 break;
782case RISCVVector::BI__builtin_rvv_vfdiv_vv_tama:
783case RISCVVector::BI__builtin_rvv_vfdiv_vf_tama:
784 ID = Intrinsic::riscv_vfdiv_mask;
785 DefaultPolicy = 3;
786 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
787 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
788 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
789 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
790 break;
791case RISCVVector::BI__builtin_rvv_vfdiv_vv_tumu:
792case RISCVVector::BI__builtin_rvv_vfdiv_vf_tumu:
793 ID = Intrinsic::riscv_vfdiv_mask;
794 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
795 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
796 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
797 break;
798case RISCVVector::BI__builtin_rvv_vfdiv_vv_tamu:
799case RISCVVector::BI__builtin_rvv_vfdiv_vf_tamu:
800 ID = Intrinsic::riscv_vfdiv_mask;
801 DefaultPolicy = 1;
802 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
803 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
804 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
805 break;
806case RISCVVector::BI__builtin_rvv_vfirst_m:
807 ID = Intrinsic::riscv_vfirst;
808 DefaultPolicy = 1;
809 IntrinsicTypes = {Ops[0]->getType(), Ops.back()->getType()};
810 break;
811case RISCVVector::BI__builtin_rvv_vfirst_m_m:
812 ID = Intrinsic::riscv_vfirst_mask;
813 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
814 IntrinsicTypes = {Ops[0]->getType(), Ops.back()->getType()};
815 break;
816case RISCVVector::BI__builtin_rvv_vfmacc_vv_tu:
817case RISCVVector::BI__builtin_rvv_vfmacc_vf_tu:
818 ID = Intrinsic::riscv_vfmacc;
819 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
820 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
821 break;
822case RISCVVector::BI__builtin_rvv_vfmacc_vv_ta:
823case RISCVVector::BI__builtin_rvv_vfmacc_vf_ta:
824 ID = Intrinsic::riscv_vfmacc;
825 DefaultPolicy = 1;
826 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
827 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
828 break;
829case RISCVVector::BI__builtin_rvv_vfmacc_vv_tuma:
830case RISCVVector::BI__builtin_rvv_vfmacc_vf_tuma:
831 ID = Intrinsic::riscv_vfmacc_mask;
832 DefaultPolicy = 2;
833 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
834 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
835 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
836 break;
837case RISCVVector::BI__builtin_rvv_vfmacc_vv_tama:
838case RISCVVector::BI__builtin_rvv_vfmacc_vf_tama:
839 ID = Intrinsic::riscv_vfmacc_mask;
840 DefaultPolicy = 3;
841 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
842 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
843 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
844 break;
845case RISCVVector::BI__builtin_rvv_vfmacc_vv_tumu:
846case RISCVVector::BI__builtin_rvv_vfmacc_vf_tumu:
847 ID = Intrinsic::riscv_vfmacc_mask;
848 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
849 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
850 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
851 break;
852case RISCVVector::BI__builtin_rvv_vfmacc_vv_tamu:
853case RISCVVector::BI__builtin_rvv_vfmacc_vf_tamu:
854 ID = Intrinsic::riscv_vfmacc_mask;
855 DefaultPolicy = 1;
856 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
857 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
858 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
859 break;
860case RISCVVector::BI__builtin_rvv_vfmadd_vv_tu:
861case RISCVVector::BI__builtin_rvv_vfmadd_vf_tu:
862 ID = Intrinsic::riscv_vfmadd;
863 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
864 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
865 break;
866case RISCVVector::BI__builtin_rvv_vfmadd_vv_ta:
867case RISCVVector::BI__builtin_rvv_vfmadd_vf_ta:
868 ID = Intrinsic::riscv_vfmadd;
869 DefaultPolicy = 1;
870 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
871 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
872 break;
873case RISCVVector::BI__builtin_rvv_vfmadd_vv_tuma:
874case RISCVVector::BI__builtin_rvv_vfmadd_vf_tuma:
875 ID = Intrinsic::riscv_vfmadd_mask;
876 DefaultPolicy = 2;
877 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
878 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
879 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
880 break;
881case RISCVVector::BI__builtin_rvv_vfmadd_vv_tama:
882case RISCVVector::BI__builtin_rvv_vfmadd_vf_tama:
883 ID = Intrinsic::riscv_vfmadd_mask;
884 DefaultPolicy = 3;
885 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
886 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
887 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
888 break;
889case RISCVVector::BI__builtin_rvv_vfmadd_vv_tumu:
890case RISCVVector::BI__builtin_rvv_vfmadd_vf_tumu:
891 ID = Intrinsic::riscv_vfmadd_mask;
892 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
893 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
894 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
895 break;
896case RISCVVector::BI__builtin_rvv_vfmadd_vv_tamu:
897case RISCVVector::BI__builtin_rvv_vfmadd_vf_tamu:
898 ID = Intrinsic::riscv_vfmadd_mask;
899 DefaultPolicy = 1;
900 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
901 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
902 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
903 break;
904case RISCVVector::BI__builtin_rvv_vfmax_vv_tu:
905case RISCVVector::BI__builtin_rvv_vfmax_vf_tu:
906 ID = Intrinsic::riscv_vfmax;
907 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
908 break;
909case RISCVVector::BI__builtin_rvv_vfmax_vv_ta:
910case RISCVVector::BI__builtin_rvv_vfmax_vf_ta:
911 ID = Intrinsic::riscv_vfmax;
912 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
913 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
914 break;
915case RISCVVector::BI__builtin_rvv_vfmax_vv_tuma:
916case RISCVVector::BI__builtin_rvv_vfmax_vf_tuma:
917 ID = Intrinsic::riscv_vfmax_mask;
918 DefaultPolicy = 2;
919 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
920 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
921 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
922 break;
923case RISCVVector::BI__builtin_rvv_vfmax_vv_tama:
924case RISCVVector::BI__builtin_rvv_vfmax_vf_tama:
925 ID = Intrinsic::riscv_vfmax_mask;
926 DefaultPolicy = 3;
927 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
928 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
929 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
930 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
931 break;
932case RISCVVector::BI__builtin_rvv_vfmax_vv_tumu:
933case RISCVVector::BI__builtin_rvv_vfmax_vf_tumu:
934 ID = Intrinsic::riscv_vfmax_mask;
935 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
936 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
937 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
938 break;
939case RISCVVector::BI__builtin_rvv_vfmax_vv_tamu:
940case RISCVVector::BI__builtin_rvv_vfmax_vf_tamu:
941 ID = Intrinsic::riscv_vfmax_mask;
942 DefaultPolicy = 1;
943 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
944 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
945 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
946 break;
947case RISCVVector::BI__builtin_rvv_vfmerge_vfm_tu:
948 ID = Intrinsic::riscv_vfmerge;
949 DefaultPolicy = 0;
950IsMasked = false;
951
952 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
953 // insert poison passthru
954 if (DefaultPolicy == TAIL_AGNOSTIC)
955 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
956 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
957 break;
958case RISCVVector::BI__builtin_rvv_vfmerge_vfm_ta:
959 ID = Intrinsic::riscv_vfmerge;
960 DefaultPolicy = 1;
961IsMasked = false;
962
963 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
964 // insert poison passthru
965 if (DefaultPolicy == TAIL_AGNOSTIC)
966 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
967 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
968 break;
969case RISCVVector::BI__builtin_rvv_vfmin_vv_tu:
970case RISCVVector::BI__builtin_rvv_vfmin_vf_tu:
971 ID = Intrinsic::riscv_vfmin;
972 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
973 break;
974case RISCVVector::BI__builtin_rvv_vfmin_vv_ta:
975case RISCVVector::BI__builtin_rvv_vfmin_vf_ta:
976 ID = Intrinsic::riscv_vfmin;
977 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
978 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
979 break;
980case RISCVVector::BI__builtin_rvv_vfmin_vv_tuma:
981case RISCVVector::BI__builtin_rvv_vfmin_vf_tuma:
982 ID = Intrinsic::riscv_vfmin_mask;
983 DefaultPolicy = 2;
984 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
985 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
986 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
987 break;
988case RISCVVector::BI__builtin_rvv_vfmin_vv_tama:
989case RISCVVector::BI__builtin_rvv_vfmin_vf_tama:
990 ID = Intrinsic::riscv_vfmin_mask;
991 DefaultPolicy = 3;
992 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
993 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
994 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
995 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
996 break;
997case RISCVVector::BI__builtin_rvv_vfmin_vv_tumu:
998case RISCVVector::BI__builtin_rvv_vfmin_vf_tumu:
999 ID = Intrinsic::riscv_vfmin_mask;
1000 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1001 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1002 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
1003 break;
1004case RISCVVector::BI__builtin_rvv_vfmin_vv_tamu:
1005case RISCVVector::BI__builtin_rvv_vfmin_vf_tamu:
1006 ID = Intrinsic::riscv_vfmin_mask;
1007 DefaultPolicy = 1;
1008 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1009 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1010 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
1011 break;
1012case RISCVVector::BI__builtin_rvv_vfmsac_vv_tu:
1013case RISCVVector::BI__builtin_rvv_vfmsac_vf_tu:
1014 ID = Intrinsic::riscv_vfmsac;
1015 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1016 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1017 break;
1018case RISCVVector::BI__builtin_rvv_vfmsac_vv_ta:
1019case RISCVVector::BI__builtin_rvv_vfmsac_vf_ta:
1020 ID = Intrinsic::riscv_vfmsac;
1021 DefaultPolicy = 1;
1022 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1023 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1024 break;
1025case RISCVVector::BI__builtin_rvv_vfmsac_vv_tuma:
1026case RISCVVector::BI__builtin_rvv_vfmsac_vf_tuma:
1027 ID = Intrinsic::riscv_vfmsac_mask;
1028 DefaultPolicy = 2;
1029 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1030 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1031 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1032 break;
1033case RISCVVector::BI__builtin_rvv_vfmsac_vv_tama:
1034case RISCVVector::BI__builtin_rvv_vfmsac_vf_tama:
1035 ID = Intrinsic::riscv_vfmsac_mask;
1036 DefaultPolicy = 3;
1037 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1038 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1039 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1040 break;
1041case RISCVVector::BI__builtin_rvv_vfmsac_vv_tumu:
1042case RISCVVector::BI__builtin_rvv_vfmsac_vf_tumu:
1043 ID = Intrinsic::riscv_vfmsac_mask;
1044 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1045 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1046 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1047 break;
1048case RISCVVector::BI__builtin_rvv_vfmsac_vv_tamu:
1049case RISCVVector::BI__builtin_rvv_vfmsac_vf_tamu:
1050 ID = Intrinsic::riscv_vfmsac_mask;
1051 DefaultPolicy = 1;
1052 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1053 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1054 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1055 break;
1056case RISCVVector::BI__builtin_rvv_vfmsub_vv_tu:
1057case RISCVVector::BI__builtin_rvv_vfmsub_vf_tu:
1058 ID = Intrinsic::riscv_vfmsub;
1059 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1060 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1061 break;
1062case RISCVVector::BI__builtin_rvv_vfmsub_vv_ta:
1063case RISCVVector::BI__builtin_rvv_vfmsub_vf_ta:
1064 ID = Intrinsic::riscv_vfmsub;
1065 DefaultPolicy = 1;
1066 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1067 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1068 break;
1069case RISCVVector::BI__builtin_rvv_vfmsub_vv_tuma:
1070case RISCVVector::BI__builtin_rvv_vfmsub_vf_tuma:
1071 ID = Intrinsic::riscv_vfmsub_mask;
1072 DefaultPolicy = 2;
1073 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1074 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1075 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1076 break;
1077case RISCVVector::BI__builtin_rvv_vfmsub_vv_tama:
1078case RISCVVector::BI__builtin_rvv_vfmsub_vf_tama:
1079 ID = Intrinsic::riscv_vfmsub_mask;
1080 DefaultPolicy = 3;
1081 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1082 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1083 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1084 break;
1085case RISCVVector::BI__builtin_rvv_vfmsub_vv_tumu:
1086case RISCVVector::BI__builtin_rvv_vfmsub_vf_tumu:
1087 ID = Intrinsic::riscv_vfmsub_mask;
1088 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1089 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1090 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1091 break;
1092case RISCVVector::BI__builtin_rvv_vfmsub_vv_tamu:
1093case RISCVVector::BI__builtin_rvv_vfmsub_vf_tamu:
1094 ID = Intrinsic::riscv_vfmsub_mask;
1095 DefaultPolicy = 1;
1096 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1097 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1098 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1099 break;
1100case RISCVVector::BI__builtin_rvv_vfmul_vv_tu:
1101case RISCVVector::BI__builtin_rvv_vfmul_vf_tu:
1102 ID = Intrinsic::riscv_vfmul;
1103 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
1104 break;
1105case RISCVVector::BI__builtin_rvv_vfmul_vv_ta:
1106case RISCVVector::BI__builtin_rvv_vfmul_vf_ta:
1107 ID = Intrinsic::riscv_vfmul;
1108 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
1109 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
1110 break;
1111case RISCVVector::BI__builtin_rvv_vfmul_vv_tuma:
1112case RISCVVector::BI__builtin_rvv_vfmul_vf_tuma:
1113 ID = Intrinsic::riscv_vfmul_mask;
1114 DefaultPolicy = 2;
1115 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1116 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1117 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
1118 break;
1119case RISCVVector::BI__builtin_rvv_vfmul_vv_tama:
1120case RISCVVector::BI__builtin_rvv_vfmul_vf_tama:
1121 ID = Intrinsic::riscv_vfmul_mask;
1122 DefaultPolicy = 3;
1123 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1124 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1125 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
1126 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
1127 break;
1128case RISCVVector::BI__builtin_rvv_vfmul_vv_tumu:
1129case RISCVVector::BI__builtin_rvv_vfmul_vf_tumu:
1130 ID = Intrinsic::riscv_vfmul_mask;
1131 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1132 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1133 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
1134 break;
1135case RISCVVector::BI__builtin_rvv_vfmul_vv_tamu:
1136case RISCVVector::BI__builtin_rvv_vfmul_vf_tamu:
1137 ID = Intrinsic::riscv_vfmul_mask;
1138 DefaultPolicy = 1;
1139 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1140 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1141 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
1142 break;
1143case RISCVVector::BI__builtin_rvv_vfmv_f_s:
1144 ID = Intrinsic::riscv_vfmv_f_s;
1145 IntrinsicTypes = {Ops[0]->getType()};
1146 break;
1147case RISCVVector::BI__builtin_rvv_vfmv_s_f_tu:
1148case RISCVVector::BI__builtin_rvv_vfmv_s_x_tu:
1149 ID = Intrinsic::riscv_vfmv_s_f;
1150 IntrinsicTypes = {ResultType, Ops.back()->getType()};
1151 break;
1152case RISCVVector::BI__builtin_rvv_vfmv_s_f_ta:
1153case RISCVVector::BI__builtin_rvv_vfmv_s_x_ta:
1154 ID = Intrinsic::riscv_vfmv_s_f;
1155 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
1156 IntrinsicTypes = {ResultType, Ops.back()->getType()};
1157 break;
1158case RISCVVector::BI__builtin_rvv_vfmv_v_f_tu:
1159 ID = Intrinsic::riscv_vfmv_v_f;
1160 IntrinsicTypes = {ResultType, Ops.back()->getType()};
1161 break;
1162case RISCVVector::BI__builtin_rvv_vfmv_v_f_ta:
1163 ID = Intrinsic::riscv_vfmv_v_f;
1164 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
1165 IntrinsicTypes = {ResultType, Ops.back()->getType()};
1166 break;
1167case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_tu:
1168 ID = Intrinsic::riscv_vfncvt_f_f_w;
1169 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1170 break;
1171case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_ta:
1172 ID = Intrinsic::riscv_vfncvt_f_f_w;
1173 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
1174 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1175 break;
1176case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_tuma:
1177 ID = Intrinsic::riscv_vfncvt_f_f_w_mask;
1178 DefaultPolicy = 2;
1179 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1180 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1181 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1182 break;
1183case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_tama:
1184 ID = Intrinsic::riscv_vfncvt_f_f_w_mask;
1185 DefaultPolicy = 3;
1186 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1187 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1188 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
1189 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1190 break;
1191case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_tumu:
1192 ID = Intrinsic::riscv_vfncvt_f_f_w_mask;
1193 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1194 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1195 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1196 break;
1197case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_tamu:
1198 ID = Intrinsic::riscv_vfncvt_f_f_w_mask;
1199 DefaultPolicy = 1;
1200 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1201 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1202 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1203 break;
1204case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_tu:
1205 ID = Intrinsic::riscv_vfncvt_f_x_w;
1206 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1207 break;
1208case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_ta:
1209 ID = Intrinsic::riscv_vfncvt_f_x_w;
1210 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
1211 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1212 break;
1213case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_tuma:
1214 ID = Intrinsic::riscv_vfncvt_f_x_w_mask;
1215 DefaultPolicy = 2;
1216 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1217 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1218 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1219 break;
1220case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_tama:
1221 ID = Intrinsic::riscv_vfncvt_f_x_w_mask;
1222 DefaultPolicy = 3;
1223 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1224 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1225 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
1226 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1227 break;
1228case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_tumu:
1229 ID = Intrinsic::riscv_vfncvt_f_x_w_mask;
1230 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1231 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1232 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1233 break;
1234case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_tamu:
1235 ID = Intrinsic::riscv_vfncvt_f_x_w_mask;
1236 DefaultPolicy = 1;
1237 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1238 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1239 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1240 break;
1241case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_tu:
1242 ID = Intrinsic::riscv_vfncvt_f_xu_w;
1243 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1244 break;
1245case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_ta:
1246 ID = Intrinsic::riscv_vfncvt_f_xu_w;
1247 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
1248 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1249 break;
1250case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_tuma:
1251 ID = Intrinsic::riscv_vfncvt_f_xu_w_mask;
1252 DefaultPolicy = 2;
1253 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1254 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1255 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1256 break;
1257case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_tama:
1258 ID = Intrinsic::riscv_vfncvt_f_xu_w_mask;
1259 DefaultPolicy = 3;
1260 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1261 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1262 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
1263 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1264 break;
1265case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_tumu:
1266 ID = Intrinsic::riscv_vfncvt_f_xu_w_mask;
1267 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1268 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1269 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1270 break;
1271case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_tamu:
1272 ID = Intrinsic::riscv_vfncvt_f_xu_w_mask;
1273 DefaultPolicy = 1;
1274 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1275 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1276 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1277 break;
1278case RISCVVector::BI__builtin_rvv_vfncvt_rod_f_f_w_tu:
1279 ID = Intrinsic::riscv_vfncvt_rod_f_f_w;
1280 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1281 break;
1282case RISCVVector::BI__builtin_rvv_vfncvt_rod_f_f_w_ta:
1283 ID = Intrinsic::riscv_vfncvt_rod_f_f_w;
1284 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
1285 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1286 break;
1287case RISCVVector::BI__builtin_rvv_vfncvt_rod_f_f_w_tuma:
1288 ID = Intrinsic::riscv_vfncvt_rod_f_f_w_mask;
1289 DefaultPolicy = 2;
1290 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1291 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1292 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1293 break;
1294case RISCVVector::BI__builtin_rvv_vfncvt_rod_f_f_w_tama:
1295 ID = Intrinsic::riscv_vfncvt_rod_f_f_w_mask;
1296 DefaultPolicy = 3;
1297 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1298 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1299 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
1300 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1301 break;
1302case RISCVVector::BI__builtin_rvv_vfncvt_rod_f_f_w_tumu:
1303 ID = Intrinsic::riscv_vfncvt_rod_f_f_w_mask;
1304 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1305 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1306 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1307 break;
1308case RISCVVector::BI__builtin_rvv_vfncvt_rod_f_f_w_tamu:
1309 ID = Intrinsic::riscv_vfncvt_rod_f_f_w_mask;
1310 DefaultPolicy = 1;
1311 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1312 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1313 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1314 break;
1315case RISCVVector::BI__builtin_rvv_vfncvt_rtz_x_f_w_tu:
1316 ID = Intrinsic::riscv_vfncvt_rtz_x_f_w;
1317 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1318 break;
1319case RISCVVector::BI__builtin_rvv_vfncvt_rtz_x_f_w_ta:
1320 ID = Intrinsic::riscv_vfncvt_rtz_x_f_w;
1321 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
1322 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1323 break;
1324case RISCVVector::BI__builtin_rvv_vfncvt_rtz_x_f_w_tuma:
1325 ID = Intrinsic::riscv_vfncvt_rtz_x_f_w_mask;
1326 DefaultPolicy = 2;
1327 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1328 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1329 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1330 break;
1331case RISCVVector::BI__builtin_rvv_vfncvt_rtz_x_f_w_tama:
1332 ID = Intrinsic::riscv_vfncvt_rtz_x_f_w_mask;
1333 DefaultPolicy = 3;
1334 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1335 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1336 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
1337 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1338 break;
1339case RISCVVector::BI__builtin_rvv_vfncvt_rtz_x_f_w_tumu:
1340 ID = Intrinsic::riscv_vfncvt_rtz_x_f_w_mask;
1341 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1342 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1343 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1344 break;
1345case RISCVVector::BI__builtin_rvv_vfncvt_rtz_x_f_w_tamu:
1346 ID = Intrinsic::riscv_vfncvt_rtz_x_f_w_mask;
1347 DefaultPolicy = 1;
1348 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1349 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1350 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1351 break;
1352case RISCVVector::BI__builtin_rvv_vfncvt_rtz_xu_f_w_tu:
1353 ID = Intrinsic::riscv_vfncvt_rtz_xu_f_w;
1354 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1355 break;
1356case RISCVVector::BI__builtin_rvv_vfncvt_rtz_xu_f_w_ta:
1357 ID = Intrinsic::riscv_vfncvt_rtz_xu_f_w;
1358 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
1359 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1360 break;
1361case RISCVVector::BI__builtin_rvv_vfncvt_rtz_xu_f_w_tuma:
1362 ID = Intrinsic::riscv_vfncvt_rtz_xu_f_w_mask;
1363 DefaultPolicy = 2;
1364 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1365 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1366 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1367 break;
1368case RISCVVector::BI__builtin_rvv_vfncvt_rtz_xu_f_w_tama:
1369 ID = Intrinsic::riscv_vfncvt_rtz_xu_f_w_mask;
1370 DefaultPolicy = 3;
1371 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1372 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1373 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
1374 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1375 break;
1376case RISCVVector::BI__builtin_rvv_vfncvt_rtz_xu_f_w_tumu:
1377 ID = Intrinsic::riscv_vfncvt_rtz_xu_f_w_mask;
1378 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1379 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1380 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1381 break;
1382case RISCVVector::BI__builtin_rvv_vfncvt_rtz_xu_f_w_tamu:
1383 ID = Intrinsic::riscv_vfncvt_rtz_xu_f_w_mask;
1384 DefaultPolicy = 1;
1385 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1386 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1387 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1388 break;
1389case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_tu:
1390 ID = Intrinsic::riscv_vfncvt_x_f_w;
1391 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1392 break;
1393case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_ta:
1394 ID = Intrinsic::riscv_vfncvt_x_f_w;
1395 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
1396 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1397 break;
1398case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_tuma:
1399 ID = Intrinsic::riscv_vfncvt_x_f_w_mask;
1400 DefaultPolicy = 2;
1401 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1402 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1403 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1404 break;
1405case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_tama:
1406 ID = Intrinsic::riscv_vfncvt_x_f_w_mask;
1407 DefaultPolicy = 3;
1408 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1409 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1410 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
1411 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1412 break;
1413case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_tumu:
1414 ID = Intrinsic::riscv_vfncvt_x_f_w_mask;
1415 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1416 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1417 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1418 break;
1419case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_tamu:
1420 ID = Intrinsic::riscv_vfncvt_x_f_w_mask;
1421 DefaultPolicy = 1;
1422 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1423 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1424 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1425 break;
1426case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_tu:
1427 ID = Intrinsic::riscv_vfncvt_xu_f_w;
1428 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1429 break;
1430case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_ta:
1431 ID = Intrinsic::riscv_vfncvt_xu_f_w;
1432 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
1433 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1434 break;
1435case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_tuma:
1436 ID = Intrinsic::riscv_vfncvt_xu_f_w_mask;
1437 DefaultPolicy = 2;
1438 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1439 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1440 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1441 break;
1442case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_tama:
1443 ID = Intrinsic::riscv_vfncvt_xu_f_w_mask;
1444 DefaultPolicy = 3;
1445 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1446 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1447 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
1448 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1449 break;
1450case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_tumu:
1451 ID = Intrinsic::riscv_vfncvt_xu_f_w_mask;
1452 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1453 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1454 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1455 break;
1456case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_tamu:
1457 ID = Intrinsic::riscv_vfncvt_xu_f_w_mask;
1458 DefaultPolicy = 1;
1459 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1460 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1461 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1462 break;
1463case RISCVVector::BI__builtin_rvv_vfnmacc_vv_tu:
1464case RISCVVector::BI__builtin_rvv_vfnmacc_vf_tu:
1465 ID = Intrinsic::riscv_vfnmacc;
1466 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1467 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1468 break;
1469case RISCVVector::BI__builtin_rvv_vfnmacc_vv_ta:
1470case RISCVVector::BI__builtin_rvv_vfnmacc_vf_ta:
1471 ID = Intrinsic::riscv_vfnmacc;
1472 DefaultPolicy = 1;
1473 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1474 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1475 break;
1476case RISCVVector::BI__builtin_rvv_vfnmacc_vv_tuma:
1477case RISCVVector::BI__builtin_rvv_vfnmacc_vf_tuma:
1478 ID = Intrinsic::riscv_vfnmacc_mask;
1479 DefaultPolicy = 2;
1480 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1481 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1482 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1483 break;
1484case RISCVVector::BI__builtin_rvv_vfnmacc_vv_tama:
1485case RISCVVector::BI__builtin_rvv_vfnmacc_vf_tama:
1486 ID = Intrinsic::riscv_vfnmacc_mask;
1487 DefaultPolicy = 3;
1488 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1489 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1490 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1491 break;
1492case RISCVVector::BI__builtin_rvv_vfnmacc_vv_tumu:
1493case RISCVVector::BI__builtin_rvv_vfnmacc_vf_tumu:
1494 ID = Intrinsic::riscv_vfnmacc_mask;
1495 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1496 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1497 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1498 break;
1499case RISCVVector::BI__builtin_rvv_vfnmacc_vv_tamu:
1500case RISCVVector::BI__builtin_rvv_vfnmacc_vf_tamu:
1501 ID = Intrinsic::riscv_vfnmacc_mask;
1502 DefaultPolicy = 1;
1503 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1504 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1505 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1506 break;
1507case RISCVVector::BI__builtin_rvv_vfnmadd_vv_tu:
1508case RISCVVector::BI__builtin_rvv_vfnmadd_vf_tu:
1509 ID = Intrinsic::riscv_vfnmadd;
1510 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1511 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1512 break;
1513case RISCVVector::BI__builtin_rvv_vfnmadd_vv_ta:
1514case RISCVVector::BI__builtin_rvv_vfnmadd_vf_ta:
1515 ID = Intrinsic::riscv_vfnmadd;
1516 DefaultPolicy = 1;
1517 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1518 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1519 break;
1520case RISCVVector::BI__builtin_rvv_vfnmadd_vv_tuma:
1521case RISCVVector::BI__builtin_rvv_vfnmadd_vf_tuma:
1522 ID = Intrinsic::riscv_vfnmadd_mask;
1523 DefaultPolicy = 2;
1524 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1525 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1526 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1527 break;
1528case RISCVVector::BI__builtin_rvv_vfnmadd_vv_tama:
1529case RISCVVector::BI__builtin_rvv_vfnmadd_vf_tama:
1530 ID = Intrinsic::riscv_vfnmadd_mask;
1531 DefaultPolicy = 3;
1532 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1533 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1534 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1535 break;
1536case RISCVVector::BI__builtin_rvv_vfnmadd_vv_tumu:
1537case RISCVVector::BI__builtin_rvv_vfnmadd_vf_tumu:
1538 ID = Intrinsic::riscv_vfnmadd_mask;
1539 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1540 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1541 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1542 break;
1543case RISCVVector::BI__builtin_rvv_vfnmadd_vv_tamu:
1544case RISCVVector::BI__builtin_rvv_vfnmadd_vf_tamu:
1545 ID = Intrinsic::riscv_vfnmadd_mask;
1546 DefaultPolicy = 1;
1547 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1548 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1549 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1550 break;
1551case RISCVVector::BI__builtin_rvv_vfnmsac_vv_tu:
1552case RISCVVector::BI__builtin_rvv_vfnmsac_vf_tu:
1553 ID = Intrinsic::riscv_vfnmsac;
1554 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1555 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1556 break;
1557case RISCVVector::BI__builtin_rvv_vfnmsac_vv_ta:
1558case RISCVVector::BI__builtin_rvv_vfnmsac_vf_ta:
1559 ID = Intrinsic::riscv_vfnmsac;
1560 DefaultPolicy = 1;
1561 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1562 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1563 break;
1564case RISCVVector::BI__builtin_rvv_vfnmsac_vv_tuma:
1565case RISCVVector::BI__builtin_rvv_vfnmsac_vf_tuma:
1566 ID = Intrinsic::riscv_vfnmsac_mask;
1567 DefaultPolicy = 2;
1568 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1569 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1570 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1571 break;
1572case RISCVVector::BI__builtin_rvv_vfnmsac_vv_tama:
1573case RISCVVector::BI__builtin_rvv_vfnmsac_vf_tama:
1574 ID = Intrinsic::riscv_vfnmsac_mask;
1575 DefaultPolicy = 3;
1576 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1577 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1578 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1579 break;
1580case RISCVVector::BI__builtin_rvv_vfnmsac_vv_tumu:
1581case RISCVVector::BI__builtin_rvv_vfnmsac_vf_tumu:
1582 ID = Intrinsic::riscv_vfnmsac_mask;
1583 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1584 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1585 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1586 break;
1587case RISCVVector::BI__builtin_rvv_vfnmsac_vv_tamu:
1588case RISCVVector::BI__builtin_rvv_vfnmsac_vf_tamu:
1589 ID = Intrinsic::riscv_vfnmsac_mask;
1590 DefaultPolicy = 1;
1591 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1592 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1593 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1594 break;
1595case RISCVVector::BI__builtin_rvv_vfnmsub_vv_tu:
1596case RISCVVector::BI__builtin_rvv_vfnmsub_vf_tu:
1597 ID = Intrinsic::riscv_vfnmsub;
1598 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1599 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1600 break;
1601case RISCVVector::BI__builtin_rvv_vfnmsub_vv_ta:
1602case RISCVVector::BI__builtin_rvv_vfnmsub_vf_ta:
1603 ID = Intrinsic::riscv_vfnmsub;
1604 DefaultPolicy = 1;
1605 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1606 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1607 break;
1608case RISCVVector::BI__builtin_rvv_vfnmsub_vv_tuma:
1609case RISCVVector::BI__builtin_rvv_vfnmsub_vf_tuma:
1610 ID = Intrinsic::riscv_vfnmsub_mask;
1611 DefaultPolicy = 2;
1612 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1613 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1614 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1615 break;
1616case RISCVVector::BI__builtin_rvv_vfnmsub_vv_tama:
1617case RISCVVector::BI__builtin_rvv_vfnmsub_vf_tama:
1618 ID = Intrinsic::riscv_vfnmsub_mask;
1619 DefaultPolicy = 3;
1620 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1621 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1622 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1623 break;
1624case RISCVVector::BI__builtin_rvv_vfnmsub_vv_tumu:
1625case RISCVVector::BI__builtin_rvv_vfnmsub_vf_tumu:
1626 ID = Intrinsic::riscv_vfnmsub_mask;
1627 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1628 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1629 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1630 break;
1631case RISCVVector::BI__builtin_rvv_vfnmsub_vv_tamu:
1632case RISCVVector::BI__builtin_rvv_vfnmsub_vf_tamu:
1633 ID = Intrinsic::riscv_vfnmsub_mask;
1634 DefaultPolicy = 1;
1635 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1636 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1637 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1638 break;
1639case RISCVVector::BI__builtin_rvv_vfrdiv_vf_tu:
1640 ID = Intrinsic::riscv_vfrdiv;
1641 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
1642 break;
1643case RISCVVector::BI__builtin_rvv_vfrdiv_vf_ta:
1644 ID = Intrinsic::riscv_vfrdiv;
1645 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
1646 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
1647 break;
1648case RISCVVector::BI__builtin_rvv_vfrdiv_vf_tuma:
1649 ID = Intrinsic::riscv_vfrdiv_mask;
1650 DefaultPolicy = 2;
1651 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1652 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1653 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
1654 break;
1655case RISCVVector::BI__builtin_rvv_vfrdiv_vf_tama:
1656 ID = Intrinsic::riscv_vfrdiv_mask;
1657 DefaultPolicy = 3;
1658 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1659 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1660 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
1661 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
1662 break;
1663case RISCVVector::BI__builtin_rvv_vfrdiv_vf_tumu:
1664 ID = Intrinsic::riscv_vfrdiv_mask;
1665 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1666 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1667 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
1668 break;
1669case RISCVVector::BI__builtin_rvv_vfrdiv_vf_tamu:
1670 ID = Intrinsic::riscv_vfrdiv_mask;
1671 DefaultPolicy = 1;
1672 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1673 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1674 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
1675 break;
1676case RISCVVector::BI__builtin_rvv_vfrec7_v_tu:
1677 ID = Intrinsic::riscv_vfrec7;
1678 IntrinsicTypes = {ResultType, Ops.back()->getType()};
1679 break;
1680case RISCVVector::BI__builtin_rvv_vfrec7_v_ta:
1681 ID = Intrinsic::riscv_vfrec7;
1682 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
1683 IntrinsicTypes = {ResultType, Ops.back()->getType()};
1684 break;
1685case RISCVVector::BI__builtin_rvv_vfrec7_v_tuma:
1686 ID = Intrinsic::riscv_vfrec7_mask;
1687 DefaultPolicy = 2;
1688 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1689 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1690 IntrinsicTypes = {ResultType, Ops.back()->getType()};
1691 break;
1692case RISCVVector::BI__builtin_rvv_vfrec7_v_tama:
1693 ID = Intrinsic::riscv_vfrec7_mask;
1694 DefaultPolicy = 3;
1695 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1696 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1697 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
1698 IntrinsicTypes = {ResultType, Ops.back()->getType()};
1699 break;
1700case RISCVVector::BI__builtin_rvv_vfrec7_v_tumu:
1701 ID = Intrinsic::riscv_vfrec7_mask;
1702 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1703 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1704 IntrinsicTypes = {ResultType, Ops.back()->getType()};
1705 break;
1706case RISCVVector::BI__builtin_rvv_vfrec7_v_tamu:
1707 ID = Intrinsic::riscv_vfrec7_mask;
1708 DefaultPolicy = 1;
1709 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1710 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1711 IntrinsicTypes = {ResultType, Ops.back()->getType()};
1712 break;
1713case RISCVVector::BI__builtin_rvv_vfredmax_vs_tu:
1714 ID = Intrinsic::riscv_vfredmax;
1715 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1716 break;
1717case RISCVVector::BI__builtin_rvv_vfredmax_vs_ta:
1718 ID = Intrinsic::riscv_vfredmax;
1719 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
1720 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1721 break;
1722case RISCVVector::BI__builtin_rvv_vfredmax_vs_tum:
1723 ID = Intrinsic::riscv_vfredmax_mask;
1724 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1725 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1726 break;
1727case RISCVVector::BI__builtin_rvv_vfredmax_vs_tam:
1728 ID = Intrinsic::riscv_vfredmax_mask;
1729 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1730 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
1731 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1732 break;
1733case RISCVVector::BI__builtin_rvv_vfredmax_vs_tumu:
1734 ID = Intrinsic::riscv_vfredmax_mask;
1735 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1736 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1737 break;
1738case RISCVVector::BI__builtin_rvv_vfredmin_vs_tu:
1739 ID = Intrinsic::riscv_vfredmin;
1740 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1741 break;
1742case RISCVVector::BI__builtin_rvv_vfredmin_vs_ta:
1743 ID = Intrinsic::riscv_vfredmin;
1744 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
1745 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1746 break;
1747case RISCVVector::BI__builtin_rvv_vfredmin_vs_tum:
1748 ID = Intrinsic::riscv_vfredmin_mask;
1749 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1750 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1751 break;
1752case RISCVVector::BI__builtin_rvv_vfredmin_vs_tam:
1753 ID = Intrinsic::riscv_vfredmin_mask;
1754 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1755 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
1756 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1757 break;
1758case RISCVVector::BI__builtin_rvv_vfredmin_vs_tumu:
1759 ID = Intrinsic::riscv_vfredmin_mask;
1760 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1761 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1762 break;
1763case RISCVVector::BI__builtin_rvv_vfredosum_vs_tu:
1764 ID = Intrinsic::riscv_vfredosum;
1765 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1766 break;
1767case RISCVVector::BI__builtin_rvv_vfredosum_vs_ta:
1768 ID = Intrinsic::riscv_vfredosum;
1769 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
1770 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1771 break;
1772case RISCVVector::BI__builtin_rvv_vfredosum_vs_tum:
1773 ID = Intrinsic::riscv_vfredosum_mask;
1774 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1775 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1776 break;
1777case RISCVVector::BI__builtin_rvv_vfredosum_vs_tam:
1778 ID = Intrinsic::riscv_vfredosum_mask;
1779 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1780 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
1781 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1782 break;
1783case RISCVVector::BI__builtin_rvv_vfredosum_vs_tumu:
1784 ID = Intrinsic::riscv_vfredosum_mask;
1785 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1786 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1787 break;
1788case RISCVVector::BI__builtin_rvv_vfredusum_vs_tu:
1789 ID = Intrinsic::riscv_vfredusum;
1790 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1791 break;
1792case RISCVVector::BI__builtin_rvv_vfredusum_vs_ta:
1793 ID = Intrinsic::riscv_vfredusum;
1794 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
1795 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1796 break;
1797case RISCVVector::BI__builtin_rvv_vfredusum_vs_tum:
1798 ID = Intrinsic::riscv_vfredusum_mask;
1799 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1800 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1801 break;
1802case RISCVVector::BI__builtin_rvv_vfredusum_vs_tam:
1803 ID = Intrinsic::riscv_vfredusum_mask;
1804 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1805 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
1806 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1807 break;
1808case RISCVVector::BI__builtin_rvv_vfredusum_vs_tumu:
1809 ID = Intrinsic::riscv_vfredusum_mask;
1810 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1811 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
1812 break;
1813case RISCVVector::BI__builtin_rvv_vfrsqrt7_v_tu:
1814 ID = Intrinsic::riscv_vfrsqrt7;
1815 IntrinsicTypes = {ResultType, Ops.back()->getType()};
1816 break;
1817case RISCVVector::BI__builtin_rvv_vfrsqrt7_v_ta:
1818 ID = Intrinsic::riscv_vfrsqrt7;
1819 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
1820 IntrinsicTypes = {ResultType, Ops.back()->getType()};
1821 break;
1822case RISCVVector::BI__builtin_rvv_vfrsqrt7_v_tuma:
1823 ID = Intrinsic::riscv_vfrsqrt7_mask;
1824 DefaultPolicy = 2;
1825 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1826 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1827 IntrinsicTypes = {ResultType, Ops.back()->getType()};
1828 break;
1829case RISCVVector::BI__builtin_rvv_vfrsqrt7_v_tama:
1830 ID = Intrinsic::riscv_vfrsqrt7_mask;
1831 DefaultPolicy = 3;
1832 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1833 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1834 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
1835 IntrinsicTypes = {ResultType, Ops.back()->getType()};
1836 break;
1837case RISCVVector::BI__builtin_rvv_vfrsqrt7_v_tumu:
1838 ID = Intrinsic::riscv_vfrsqrt7_mask;
1839 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1840 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1841 IntrinsicTypes = {ResultType, Ops.back()->getType()};
1842 break;
1843case RISCVVector::BI__builtin_rvv_vfrsqrt7_v_tamu:
1844 ID = Intrinsic::riscv_vfrsqrt7_mask;
1845 DefaultPolicy = 1;
1846 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1847 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1848 IntrinsicTypes = {ResultType, Ops.back()->getType()};
1849 break;
1850case RISCVVector::BI__builtin_rvv_vfrsub_vf_tu:
1851 ID = Intrinsic::riscv_vfrsub;
1852 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
1853 break;
1854case RISCVVector::BI__builtin_rvv_vfrsub_vf_ta:
1855 ID = Intrinsic::riscv_vfrsub;
1856 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
1857 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
1858 break;
1859case RISCVVector::BI__builtin_rvv_vfrsub_vf_tuma:
1860 ID = Intrinsic::riscv_vfrsub_mask;
1861 DefaultPolicy = 2;
1862 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1863 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1864 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
1865 break;
1866case RISCVVector::BI__builtin_rvv_vfrsub_vf_tama:
1867 ID = Intrinsic::riscv_vfrsub_mask;
1868 DefaultPolicy = 3;
1869 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1870 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1871 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
1872 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
1873 break;
1874case RISCVVector::BI__builtin_rvv_vfrsub_vf_tumu:
1875 ID = Intrinsic::riscv_vfrsub_mask;
1876 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1877 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1878 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
1879 break;
1880case RISCVVector::BI__builtin_rvv_vfrsub_vf_tamu:
1881 ID = Intrinsic::riscv_vfrsub_mask;
1882 DefaultPolicy = 1;
1883 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1884 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1885 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
1886 break;
1887case RISCVVector::BI__builtin_rvv_vfsgnj_vv_tu:
1888case RISCVVector::BI__builtin_rvv_vfsgnj_vf_tu:
1889 ID = Intrinsic::riscv_vfsgnj;
1890 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
1891 break;
1892case RISCVVector::BI__builtin_rvv_vfsgnj_vv_ta:
1893case RISCVVector::BI__builtin_rvv_vfsgnj_vf_ta:
1894 ID = Intrinsic::riscv_vfsgnj;
1895 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
1896 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
1897 break;
1898case RISCVVector::BI__builtin_rvv_vfsgnj_vv_tuma:
1899case RISCVVector::BI__builtin_rvv_vfsgnj_vf_tuma:
1900 ID = Intrinsic::riscv_vfsgnj_mask;
1901 DefaultPolicy = 2;
1902 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1903 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1904 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
1905 break;
1906case RISCVVector::BI__builtin_rvv_vfsgnj_vv_tama:
1907case RISCVVector::BI__builtin_rvv_vfsgnj_vf_tama:
1908 ID = Intrinsic::riscv_vfsgnj_mask;
1909 DefaultPolicy = 3;
1910 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1911 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1912 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
1913 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
1914 break;
1915case RISCVVector::BI__builtin_rvv_vfsgnj_vv_tumu:
1916case RISCVVector::BI__builtin_rvv_vfsgnj_vf_tumu:
1917 ID = Intrinsic::riscv_vfsgnj_mask;
1918 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1919 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1920 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
1921 break;
1922case RISCVVector::BI__builtin_rvv_vfsgnj_vv_tamu:
1923case RISCVVector::BI__builtin_rvv_vfsgnj_vf_tamu:
1924 ID = Intrinsic::riscv_vfsgnj_mask;
1925 DefaultPolicy = 1;
1926 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1927 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1928 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
1929 break;
1930case RISCVVector::BI__builtin_rvv_vfsgnjn_vv_tu:
1931case RISCVVector::BI__builtin_rvv_vfsgnjn_vf_tu:
1932 ID = Intrinsic::riscv_vfsgnjn;
1933 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
1934 break;
1935case RISCVVector::BI__builtin_rvv_vfneg_v_tu:
1936 ID = Intrinsic::riscv_vfsgnjn;
1937 DefaultPolicy = 0;
1938IsMasked = false;
1939
1940 {
1941 if (IsMasked) {
1942 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1943 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
1944 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
1945 Ops.insert(Ops.begin() + 2, Ops[1]);
1946 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1947 // maskedoff, op1, op2, mask, vl
1948 IntrinsicTypes = {ResultType,
1949 Ops[2]->getType(),
1950 Ops.back()->getType()};
1951 } else {
1952 if (DefaultPolicy == TAIL_AGNOSTIC)
1953 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
1954 // op1, po2, vl
1955 IntrinsicTypes = {ResultType,
1956 Ops[1]->getType(), Ops[2]->getType()};
1957 Ops.insert(Ops.begin() + 2, Ops[1]);
1958 break;
1959 }
1960 break;
1961 }
1962 break;
1963case RISCVVector::BI__builtin_rvv_vfsgnjn_vv_ta:
1964case RISCVVector::BI__builtin_rvv_vfsgnjn_vf_ta:
1965 ID = Intrinsic::riscv_vfsgnjn;
1966 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
1967 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
1968 break;
1969case RISCVVector::BI__builtin_rvv_vfneg_v_ta:
1970 ID = Intrinsic::riscv_vfsgnjn;
1971 DefaultPolicy = 1;
1972IsMasked = false;
1973
1974 {
1975 if (IsMasked) {
1976 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
1977 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
1978 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
1979 Ops.insert(Ops.begin() + 2, Ops[1]);
1980 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
1981 // maskedoff, op1, op2, mask, vl
1982 IntrinsicTypes = {ResultType,
1983 Ops[2]->getType(),
1984 Ops.back()->getType()};
1985 } else {
1986 if (DefaultPolicy == TAIL_AGNOSTIC)
1987 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
1988 // op1, po2, vl
1989 IntrinsicTypes = {ResultType,
1990 Ops[1]->getType(), Ops[2]->getType()};
1991 Ops.insert(Ops.begin() + 2, Ops[1]);
1992 break;
1993 }
1994 break;
1995 }
1996 break;
1997case RISCVVector::BI__builtin_rvv_vfsgnjn_vv_tuma:
1998case RISCVVector::BI__builtin_rvv_vfsgnjn_vf_tuma:
1999 ID = Intrinsic::riscv_vfsgnjn_mask;
2000 DefaultPolicy = 2;
2001 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2002 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2003 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
2004 break;
2005case RISCVVector::BI__builtin_rvv_vfneg_v_tuma:
2006 ID = Intrinsic::riscv_vfsgnjn_mask;
2007 DefaultPolicy = 2;
2008IsMasked = true;
2009
2010 {
2011 if (IsMasked) {
2012 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2013 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
2014 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
2015 Ops.insert(Ops.begin() + 2, Ops[1]);
2016 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2017 // maskedoff, op1, op2, mask, vl
2018 IntrinsicTypes = {ResultType,
2019 Ops[2]->getType(),
2020 Ops.back()->getType()};
2021 } else {
2022 if (DefaultPolicy == TAIL_AGNOSTIC)
2023 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
2024 // op1, po2, vl
2025 IntrinsicTypes = {ResultType,
2026 Ops[1]->getType(), Ops[2]->getType()};
2027 Ops.insert(Ops.begin() + 2, Ops[1]);
2028 break;
2029 }
2030 break;
2031 }
2032 break;
2033case RISCVVector::BI__builtin_rvv_vfsgnjn_vv_tama:
2034case RISCVVector::BI__builtin_rvv_vfsgnjn_vf_tama:
2035 ID = Intrinsic::riscv_vfsgnjn_mask;
2036 DefaultPolicy = 3;
2037 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2038 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2039 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
2040 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
2041 break;
2042case RISCVVector::BI__builtin_rvv_vfneg_v_tama:
2043 ID = Intrinsic::riscv_vfsgnjn_mask;
2044 DefaultPolicy = 3;
2045IsMasked = true;
2046
2047 {
2048 if (IsMasked) {
2049 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2050 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
2051 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
2052 Ops.insert(Ops.begin() + 2, Ops[1]);
2053 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2054 // maskedoff, op1, op2, mask, vl
2055 IntrinsicTypes = {ResultType,
2056 Ops[2]->getType(),
2057 Ops.back()->getType()};
2058 } else {
2059 if (DefaultPolicy == TAIL_AGNOSTIC)
2060 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
2061 // op1, po2, vl
2062 IntrinsicTypes = {ResultType,
2063 Ops[1]->getType(), Ops[2]->getType()};
2064 Ops.insert(Ops.begin() + 2, Ops[1]);
2065 break;
2066 }
2067 break;
2068 }
2069 break;
2070case RISCVVector::BI__builtin_rvv_vfsgnjn_vv_tumu:
2071case RISCVVector::BI__builtin_rvv_vfsgnjn_vf_tumu:
2072 ID = Intrinsic::riscv_vfsgnjn_mask;
2073 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2074 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2075 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
2076 break;
2077case RISCVVector::BI__builtin_rvv_vfneg_v_tumu:
2078 ID = Intrinsic::riscv_vfsgnjn_mask;
2079 DefaultPolicy = 0;
2080IsMasked = true;
2081
2082 {
2083 if (IsMasked) {
2084 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2085 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
2086 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
2087 Ops.insert(Ops.begin() + 2, Ops[1]);
2088 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2089 // maskedoff, op1, op2, mask, vl
2090 IntrinsicTypes = {ResultType,
2091 Ops[2]->getType(),
2092 Ops.back()->getType()};
2093 } else {
2094 if (DefaultPolicy == TAIL_AGNOSTIC)
2095 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
2096 // op1, po2, vl
2097 IntrinsicTypes = {ResultType,
2098 Ops[1]->getType(), Ops[2]->getType()};
2099 Ops.insert(Ops.begin() + 2, Ops[1]);
2100 break;
2101 }
2102 break;
2103 }
2104 break;
2105case RISCVVector::BI__builtin_rvv_vfsgnjn_vv_tamu:
2106case RISCVVector::BI__builtin_rvv_vfsgnjn_vf_tamu:
2107 ID = Intrinsic::riscv_vfsgnjn_mask;
2108 DefaultPolicy = 1;
2109 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2110 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2111 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
2112 break;
2113case RISCVVector::BI__builtin_rvv_vfneg_v_tamu:
2114 ID = Intrinsic::riscv_vfsgnjn_mask;
2115 DefaultPolicy = 1;
2116IsMasked = true;
2117
2118 {
2119 if (IsMasked) {
2120 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2121 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
2122 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
2123 Ops.insert(Ops.begin() + 2, Ops[1]);
2124 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2125 // maskedoff, op1, op2, mask, vl
2126 IntrinsicTypes = {ResultType,
2127 Ops[2]->getType(),
2128 Ops.back()->getType()};
2129 } else {
2130 if (DefaultPolicy == TAIL_AGNOSTIC)
2131 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
2132 // op1, po2, vl
2133 IntrinsicTypes = {ResultType,
2134 Ops[1]->getType(), Ops[2]->getType()};
2135 Ops.insert(Ops.begin() + 2, Ops[1]);
2136 break;
2137 }
2138 break;
2139 }
2140 break;
2141case RISCVVector::BI__builtin_rvv_vfsgnjx_vv_tu:
2142case RISCVVector::BI__builtin_rvv_vfsgnjx_vf_tu:
2143 ID = Intrinsic::riscv_vfsgnjx;
2144 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
2145 break;
2146case RISCVVector::BI__builtin_rvv_vfabs_v_tu:
2147 ID = Intrinsic::riscv_vfsgnjx;
2148 DefaultPolicy = 0;
2149IsMasked = false;
2150
2151 {
2152 if (IsMasked) {
2153 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2154 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
2155 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
2156 Ops.insert(Ops.begin() + 2, Ops[1]);
2157 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2158 // maskedoff, op1, op2, mask, vl
2159 IntrinsicTypes = {ResultType,
2160 Ops[2]->getType(),
2161 Ops.back()->getType()};
2162 } else {
2163 if (DefaultPolicy == TAIL_AGNOSTIC)
2164 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
2165 // op1, po2, vl
2166 IntrinsicTypes = {ResultType,
2167 Ops[1]->getType(), Ops[2]->getType()};
2168 Ops.insert(Ops.begin() + 2, Ops[1]);
2169 break;
2170 }
2171 break;
2172 }
2173 break;
2174case RISCVVector::BI__builtin_rvv_vfsgnjx_vv_ta:
2175case RISCVVector::BI__builtin_rvv_vfsgnjx_vf_ta:
2176 ID = Intrinsic::riscv_vfsgnjx;
2177 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
2178 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
2179 break;
2180case RISCVVector::BI__builtin_rvv_vfabs_v_ta:
2181 ID = Intrinsic::riscv_vfsgnjx;
2182 DefaultPolicy = 1;
2183IsMasked = false;
2184
2185 {
2186 if (IsMasked) {
2187 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2188 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
2189 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
2190 Ops.insert(Ops.begin() + 2, Ops[1]);
2191 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2192 // maskedoff, op1, op2, mask, vl
2193 IntrinsicTypes = {ResultType,
2194 Ops[2]->getType(),
2195 Ops.back()->getType()};
2196 } else {
2197 if (DefaultPolicy == TAIL_AGNOSTIC)
2198 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
2199 // op1, po2, vl
2200 IntrinsicTypes = {ResultType,
2201 Ops[1]->getType(), Ops[2]->getType()};
2202 Ops.insert(Ops.begin() + 2, Ops[1]);
2203 break;
2204 }
2205 break;
2206 }
2207 break;
2208case RISCVVector::BI__builtin_rvv_vfsgnjx_vv_tuma:
2209case RISCVVector::BI__builtin_rvv_vfsgnjx_vf_tuma:
2210 ID = Intrinsic::riscv_vfsgnjx_mask;
2211 DefaultPolicy = 2;
2212 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2213 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2214 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
2215 break;
2216case RISCVVector::BI__builtin_rvv_vfabs_v_tuma:
2217 ID = Intrinsic::riscv_vfsgnjx_mask;
2218 DefaultPolicy = 2;
2219IsMasked = true;
2220
2221 {
2222 if (IsMasked) {
2223 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2224 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
2225 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
2226 Ops.insert(Ops.begin() + 2, Ops[1]);
2227 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2228 // maskedoff, op1, op2, mask, vl
2229 IntrinsicTypes = {ResultType,
2230 Ops[2]->getType(),
2231 Ops.back()->getType()};
2232 } else {
2233 if (DefaultPolicy == TAIL_AGNOSTIC)
2234 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
2235 // op1, po2, vl
2236 IntrinsicTypes = {ResultType,
2237 Ops[1]->getType(), Ops[2]->getType()};
2238 Ops.insert(Ops.begin() + 2, Ops[1]);
2239 break;
2240 }
2241 break;
2242 }
2243 break;
2244case RISCVVector::BI__builtin_rvv_vfsgnjx_vv_tama:
2245case RISCVVector::BI__builtin_rvv_vfsgnjx_vf_tama:
2246 ID = Intrinsic::riscv_vfsgnjx_mask;
2247 DefaultPolicy = 3;
2248 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2249 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2250 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
2251 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
2252 break;
2253case RISCVVector::BI__builtin_rvv_vfabs_v_tama:
2254 ID = Intrinsic::riscv_vfsgnjx_mask;
2255 DefaultPolicy = 3;
2256IsMasked = true;
2257
2258 {
2259 if (IsMasked) {
2260 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2261 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
2262 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
2263 Ops.insert(Ops.begin() + 2, Ops[1]);
2264 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2265 // maskedoff, op1, op2, mask, vl
2266 IntrinsicTypes = {ResultType,
2267 Ops[2]->getType(),
2268 Ops.back()->getType()};
2269 } else {
2270 if (DefaultPolicy == TAIL_AGNOSTIC)
2271 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
2272 // op1, po2, vl
2273 IntrinsicTypes = {ResultType,
2274 Ops[1]->getType(), Ops[2]->getType()};
2275 Ops.insert(Ops.begin() + 2, Ops[1]);
2276 break;
2277 }
2278 break;
2279 }
2280 break;
2281case RISCVVector::BI__builtin_rvv_vfsgnjx_vv_tumu:
2282case RISCVVector::BI__builtin_rvv_vfsgnjx_vf_tumu:
2283 ID = Intrinsic::riscv_vfsgnjx_mask;
2284 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2285 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2286 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
2287 break;
2288case RISCVVector::BI__builtin_rvv_vfabs_v_tumu:
2289 ID = Intrinsic::riscv_vfsgnjx_mask;
2290 DefaultPolicy = 0;
2291IsMasked = true;
2292
2293 {
2294 if (IsMasked) {
2295 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2296 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
2297 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
2298 Ops.insert(Ops.begin() + 2, Ops[1]);
2299 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2300 // maskedoff, op1, op2, mask, vl
2301 IntrinsicTypes = {ResultType,
2302 Ops[2]->getType(),
2303 Ops.back()->getType()};
2304 } else {
2305 if (DefaultPolicy == TAIL_AGNOSTIC)
2306 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
2307 // op1, po2, vl
2308 IntrinsicTypes = {ResultType,
2309 Ops[1]->getType(), Ops[2]->getType()};
2310 Ops.insert(Ops.begin() + 2, Ops[1]);
2311 break;
2312 }
2313 break;
2314 }
2315 break;
2316case RISCVVector::BI__builtin_rvv_vfsgnjx_vv_tamu:
2317case RISCVVector::BI__builtin_rvv_vfsgnjx_vf_tamu:
2318 ID = Intrinsic::riscv_vfsgnjx_mask;
2319 DefaultPolicy = 1;
2320 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2321 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2322 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
2323 break;
2324case RISCVVector::BI__builtin_rvv_vfabs_v_tamu:
2325 ID = Intrinsic::riscv_vfsgnjx_mask;
2326 DefaultPolicy = 1;
2327IsMasked = true;
2328
2329 {
2330 if (IsMasked) {
2331 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2332 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
2333 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
2334 Ops.insert(Ops.begin() + 2, Ops[1]);
2335 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2336 // maskedoff, op1, op2, mask, vl
2337 IntrinsicTypes = {ResultType,
2338 Ops[2]->getType(),
2339 Ops.back()->getType()};
2340 } else {
2341 if (DefaultPolicy == TAIL_AGNOSTIC)
2342 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
2343 // op1, po2, vl
2344 IntrinsicTypes = {ResultType,
2345 Ops[1]->getType(), Ops[2]->getType()};
2346 Ops.insert(Ops.begin() + 2, Ops[1]);
2347 break;
2348 }
2349 break;
2350 }
2351 break;
2352case RISCVVector::BI__builtin_rvv_vfslide1down_vf_tu:
2353 ID = Intrinsic::riscv_vfslide1down;
2354 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
2355 break;
2356case RISCVVector::BI__builtin_rvv_vfslide1down_vf_ta:
2357 ID = Intrinsic::riscv_vfslide1down;
2358 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
2359 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
2360 break;
2361case RISCVVector::BI__builtin_rvv_vfslide1down_vf_tuma:
2362 ID = Intrinsic::riscv_vfslide1down_mask;
2363 DefaultPolicy = 2;
2364 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2365 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2366 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
2367 break;
2368case RISCVVector::BI__builtin_rvv_vfslide1down_vf_tama:
2369 ID = Intrinsic::riscv_vfslide1down_mask;
2370 DefaultPolicy = 3;
2371 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2372 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2373 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
2374 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
2375 break;
2376case RISCVVector::BI__builtin_rvv_vfslide1down_vf_tumu:
2377 ID = Intrinsic::riscv_vfslide1down_mask;
2378 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2379 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2380 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
2381 break;
2382case RISCVVector::BI__builtin_rvv_vfslide1down_vf_tamu:
2383 ID = Intrinsic::riscv_vfslide1down_mask;
2384 DefaultPolicy = 1;
2385 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2386 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2387 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
2388 break;
2389case RISCVVector::BI__builtin_rvv_vfslide1up_vf_tu:
2390 ID = Intrinsic::riscv_vfslide1up;
2391 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
2392 break;
2393case RISCVVector::BI__builtin_rvv_vfslide1up_vf_ta:
2394 ID = Intrinsic::riscv_vfslide1up;
2395 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
2396 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
2397 break;
2398case RISCVVector::BI__builtin_rvv_vfslide1up_vf_tuma:
2399 ID = Intrinsic::riscv_vfslide1up_mask;
2400 DefaultPolicy = 2;
2401 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2402 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2403 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
2404 break;
2405case RISCVVector::BI__builtin_rvv_vfslide1up_vf_tama:
2406 ID = Intrinsic::riscv_vfslide1up_mask;
2407 DefaultPolicy = 3;
2408 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2409 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2410 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
2411 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
2412 break;
2413case RISCVVector::BI__builtin_rvv_vfslide1up_vf_tumu:
2414 ID = Intrinsic::riscv_vfslide1up_mask;
2415 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2416 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2417 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
2418 break;
2419case RISCVVector::BI__builtin_rvv_vfslide1up_vf_tamu:
2420 ID = Intrinsic::riscv_vfslide1up_mask;
2421 DefaultPolicy = 1;
2422 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2423 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2424 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
2425 break;
2426case RISCVVector::BI__builtin_rvv_vfsqrt_v_tu:
2427 ID = Intrinsic::riscv_vfsqrt;
2428 IntrinsicTypes = {ResultType, Ops.back()->getType()};
2429 break;
2430case RISCVVector::BI__builtin_rvv_vfsqrt_v_ta:
2431 ID = Intrinsic::riscv_vfsqrt;
2432 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
2433 IntrinsicTypes = {ResultType, Ops.back()->getType()};
2434 break;
2435case RISCVVector::BI__builtin_rvv_vfsqrt_v_tuma:
2436 ID = Intrinsic::riscv_vfsqrt_mask;
2437 DefaultPolicy = 2;
2438 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2439 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2440 IntrinsicTypes = {ResultType, Ops.back()->getType()};
2441 break;
2442case RISCVVector::BI__builtin_rvv_vfsqrt_v_tama:
2443 ID = Intrinsic::riscv_vfsqrt_mask;
2444 DefaultPolicy = 3;
2445 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2446 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2447 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
2448 IntrinsicTypes = {ResultType, Ops.back()->getType()};
2449 break;
2450case RISCVVector::BI__builtin_rvv_vfsqrt_v_tumu:
2451 ID = Intrinsic::riscv_vfsqrt_mask;
2452 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2453 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2454 IntrinsicTypes = {ResultType, Ops.back()->getType()};
2455 break;
2456case RISCVVector::BI__builtin_rvv_vfsqrt_v_tamu:
2457 ID = Intrinsic::riscv_vfsqrt_mask;
2458 DefaultPolicy = 1;
2459 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2460 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2461 IntrinsicTypes = {ResultType, Ops.back()->getType()};
2462 break;
2463case RISCVVector::BI__builtin_rvv_vfsub_vv_tu:
2464case RISCVVector::BI__builtin_rvv_vfsub_vf_tu:
2465 ID = Intrinsic::riscv_vfsub;
2466 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
2467 break;
2468case RISCVVector::BI__builtin_rvv_vfsub_vv_ta:
2469case RISCVVector::BI__builtin_rvv_vfsub_vf_ta:
2470 ID = Intrinsic::riscv_vfsub;
2471 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
2472 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
2473 break;
2474case RISCVVector::BI__builtin_rvv_vfsub_vv_tuma:
2475case RISCVVector::BI__builtin_rvv_vfsub_vf_tuma:
2476 ID = Intrinsic::riscv_vfsub_mask;
2477 DefaultPolicy = 2;
2478 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2479 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2480 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
2481 break;
2482case RISCVVector::BI__builtin_rvv_vfsub_vv_tama:
2483case RISCVVector::BI__builtin_rvv_vfsub_vf_tama:
2484 ID = Intrinsic::riscv_vfsub_mask;
2485 DefaultPolicy = 3;
2486 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2487 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2488 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
2489 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
2490 break;
2491case RISCVVector::BI__builtin_rvv_vfsub_vv_tumu:
2492case RISCVVector::BI__builtin_rvv_vfsub_vf_tumu:
2493 ID = Intrinsic::riscv_vfsub_mask;
2494 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2495 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2496 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
2497 break;
2498case RISCVVector::BI__builtin_rvv_vfsub_vv_tamu:
2499case RISCVVector::BI__builtin_rvv_vfsub_vf_tamu:
2500 ID = Intrinsic::riscv_vfsub_mask;
2501 DefaultPolicy = 1;
2502 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2503 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2504 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
2505 break;
2506case RISCVVector::BI__builtin_rvv_vfwadd_vv_tu:
2507case RISCVVector::BI__builtin_rvv_vfwadd_vf_tu:
2508 ID = Intrinsic::riscv_vfwadd;
2509 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
2510 break;
2511case RISCVVector::BI__builtin_rvv_vfwadd_vv_ta:
2512case RISCVVector::BI__builtin_rvv_vfwadd_vf_ta:
2513 ID = Intrinsic::riscv_vfwadd;
2514 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
2515 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
2516 break;
2517case RISCVVector::BI__builtin_rvv_vfwadd_vv_tuma:
2518case RISCVVector::BI__builtin_rvv_vfwadd_vf_tuma:
2519 ID = Intrinsic::riscv_vfwadd_mask;
2520 DefaultPolicy = 2;
2521 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2522 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2523 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
2524 break;
2525case RISCVVector::BI__builtin_rvv_vfwadd_vv_tama:
2526case RISCVVector::BI__builtin_rvv_vfwadd_vf_tama:
2527 ID = Intrinsic::riscv_vfwadd_mask;
2528 DefaultPolicy = 3;
2529 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2530 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2531 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
2532 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
2533 break;
2534case RISCVVector::BI__builtin_rvv_vfwadd_vv_tumu:
2535case RISCVVector::BI__builtin_rvv_vfwadd_vf_tumu:
2536 ID = Intrinsic::riscv_vfwadd_mask;
2537 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2538 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2539 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
2540 break;
2541case RISCVVector::BI__builtin_rvv_vfwadd_vv_tamu:
2542case RISCVVector::BI__builtin_rvv_vfwadd_vf_tamu:
2543 ID = Intrinsic::riscv_vfwadd_mask;
2544 DefaultPolicy = 1;
2545 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2546 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2547 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
2548 break;
2549case RISCVVector::BI__builtin_rvv_vfwadd_wv_tu:
2550case RISCVVector::BI__builtin_rvv_vfwadd_wf_tu:
2551 ID = Intrinsic::riscv_vfwadd_w;
2552 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
2553 break;
2554case RISCVVector::BI__builtin_rvv_vfwadd_wv_ta:
2555case RISCVVector::BI__builtin_rvv_vfwadd_wf_ta:
2556 ID = Intrinsic::riscv_vfwadd_w;
2557 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
2558 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
2559 break;
2560case RISCVVector::BI__builtin_rvv_vfwadd_wv_tuma:
2561case RISCVVector::BI__builtin_rvv_vfwadd_wf_tuma:
2562 ID = Intrinsic::riscv_vfwadd_w_mask;
2563 DefaultPolicy = 2;
2564 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2565 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2566 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
2567 break;
2568case RISCVVector::BI__builtin_rvv_vfwadd_wv_tama:
2569case RISCVVector::BI__builtin_rvv_vfwadd_wf_tama:
2570 ID = Intrinsic::riscv_vfwadd_w_mask;
2571 DefaultPolicy = 3;
2572 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2573 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2574 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
2575 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
2576 break;
2577case RISCVVector::BI__builtin_rvv_vfwadd_wv_tumu:
2578case RISCVVector::BI__builtin_rvv_vfwadd_wf_tumu:
2579 ID = Intrinsic::riscv_vfwadd_w_mask;
2580 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2581 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2582 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
2583 break;
2584case RISCVVector::BI__builtin_rvv_vfwadd_wv_tamu:
2585case RISCVVector::BI__builtin_rvv_vfwadd_wf_tamu:
2586 ID = Intrinsic::riscv_vfwadd_w_mask;
2587 DefaultPolicy = 1;
2588 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2589 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2590 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
2591 break;
2592case RISCVVector::BI__builtin_rvv_vfwcvt_f_f_v_tu:
2593 ID = Intrinsic::riscv_vfwcvt_f_f_v;
2594 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
2595 break;
2596case RISCVVector::BI__builtin_rvv_vfwcvt_f_f_v_ta:
2597 ID = Intrinsic::riscv_vfwcvt_f_f_v;
2598 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
2599 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
2600 break;
2601case RISCVVector::BI__builtin_rvv_vfwcvt_f_f_v_tuma:
2602 ID = Intrinsic::riscv_vfwcvt_f_f_v_mask;
2603 DefaultPolicy = 2;
2604 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2605 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2606 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
2607 break;
2608case RISCVVector::BI__builtin_rvv_vfwcvt_f_f_v_tama:
2609 ID = Intrinsic::riscv_vfwcvt_f_f_v_mask;
2610 DefaultPolicy = 3;
2611 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2612 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2613 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
2614 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
2615 break;
2616case RISCVVector::BI__builtin_rvv_vfwcvt_f_f_v_tumu:
2617 ID = Intrinsic::riscv_vfwcvt_f_f_v_mask;
2618 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2619 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2620 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
2621 break;
2622case RISCVVector::BI__builtin_rvv_vfwcvt_f_f_v_tamu:
2623 ID = Intrinsic::riscv_vfwcvt_f_f_v_mask;
2624 DefaultPolicy = 1;
2625 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2626 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2627 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
2628 break;
2629case RISCVVector::BI__builtin_rvv_vfwcvt_f_x_v_tu:
2630 ID = Intrinsic::riscv_vfwcvt_f_x_v;
2631 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
2632 break;
2633case RISCVVector::BI__builtin_rvv_vfwcvt_f_x_v_ta:
2634 ID = Intrinsic::riscv_vfwcvt_f_x_v;
2635 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
2636 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
2637 break;
2638case RISCVVector::BI__builtin_rvv_vfwcvt_f_x_v_tuma:
2639 ID = Intrinsic::riscv_vfwcvt_f_x_v_mask;
2640 DefaultPolicy = 2;
2641 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2642 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2643 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
2644 break;
2645case RISCVVector::BI__builtin_rvv_vfwcvt_f_x_v_tama:
2646 ID = Intrinsic::riscv_vfwcvt_f_x_v_mask;
2647 DefaultPolicy = 3;
2648 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2649 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2650 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
2651 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
2652 break;
2653case RISCVVector::BI__builtin_rvv_vfwcvt_f_x_v_tumu:
2654 ID = Intrinsic::riscv_vfwcvt_f_x_v_mask;
2655 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2656 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2657 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
2658 break;
2659case RISCVVector::BI__builtin_rvv_vfwcvt_f_x_v_tamu:
2660 ID = Intrinsic::riscv_vfwcvt_f_x_v_mask;
2661 DefaultPolicy = 1;
2662 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2663 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2664 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
2665 break;
2666case RISCVVector::BI__builtin_rvv_vfwcvt_f_xu_v_tu:
2667 ID = Intrinsic::riscv_vfwcvt_f_xu_v;
2668 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
2669 break;
2670case RISCVVector::BI__builtin_rvv_vfwcvt_f_xu_v_ta:
2671 ID = Intrinsic::riscv_vfwcvt_f_xu_v;
2672 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
2673 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
2674 break;
2675case RISCVVector::BI__builtin_rvv_vfwcvt_f_xu_v_tuma:
2676 ID = Intrinsic::riscv_vfwcvt_f_xu_v_mask;
2677 DefaultPolicy = 2;
2678 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2679 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2680 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
2681 break;
2682case RISCVVector::BI__builtin_rvv_vfwcvt_f_xu_v_tama:
2683 ID = Intrinsic::riscv_vfwcvt_f_xu_v_mask;
2684 DefaultPolicy = 3;
2685 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2686 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2687 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
2688 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
2689 break;
2690case RISCVVector::BI__builtin_rvv_vfwcvt_f_xu_v_tumu:
2691 ID = Intrinsic::riscv_vfwcvt_f_xu_v_mask;
2692 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2693 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2694 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
2695 break;
2696case RISCVVector::BI__builtin_rvv_vfwcvt_f_xu_v_tamu:
2697 ID = Intrinsic::riscv_vfwcvt_f_xu_v_mask;
2698 DefaultPolicy = 1;
2699 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2700 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2701 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
2702 break;
2703case RISCVVector::BI__builtin_rvv_vfwcvt_rtz_x_f_v_tu:
2704 ID = Intrinsic::riscv_vfwcvt_rtz_x_f_v;
2705 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
2706 break;
2707case RISCVVector::BI__builtin_rvv_vfwcvt_rtz_x_f_v_ta:
2708 ID = Intrinsic::riscv_vfwcvt_rtz_x_f_v;
2709 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
2710 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
2711 break;
2712case RISCVVector::BI__builtin_rvv_vfwcvt_rtz_x_f_v_tuma:
2713 ID = Intrinsic::riscv_vfwcvt_rtz_x_f_v_mask;
2714 DefaultPolicy = 2;
2715 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2716 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2717 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
2718 break;
2719case RISCVVector::BI__builtin_rvv_vfwcvt_rtz_x_f_v_tama:
2720 ID = Intrinsic::riscv_vfwcvt_rtz_x_f_v_mask;
2721 DefaultPolicy = 3;
2722 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2723 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2724 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
2725 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
2726 break;
2727case RISCVVector::BI__builtin_rvv_vfwcvt_rtz_x_f_v_tumu:
2728 ID = Intrinsic::riscv_vfwcvt_rtz_x_f_v_mask;
2729 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2730 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2731 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
2732 break;
2733case RISCVVector::BI__builtin_rvv_vfwcvt_rtz_x_f_v_tamu:
2734 ID = Intrinsic::riscv_vfwcvt_rtz_x_f_v_mask;
2735 DefaultPolicy = 1;
2736 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2737 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2738 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
2739 break;
2740case RISCVVector::BI__builtin_rvv_vfwcvt_rtz_xu_f_v_tu:
2741 ID = Intrinsic::riscv_vfwcvt_rtz_xu_f_v;
2742 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
2743 break;
2744case RISCVVector::BI__builtin_rvv_vfwcvt_rtz_xu_f_v_ta:
2745 ID = Intrinsic::riscv_vfwcvt_rtz_xu_f_v;
2746 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
2747 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
2748 break;
2749case RISCVVector::BI__builtin_rvv_vfwcvt_rtz_xu_f_v_tuma:
2750 ID = Intrinsic::riscv_vfwcvt_rtz_xu_f_v_mask;
2751 DefaultPolicy = 2;
2752 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2753 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2754 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
2755 break;
2756case RISCVVector::BI__builtin_rvv_vfwcvt_rtz_xu_f_v_tama:
2757 ID = Intrinsic::riscv_vfwcvt_rtz_xu_f_v_mask;
2758 DefaultPolicy = 3;
2759 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2760 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2761 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
2762 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
2763 break;
2764case RISCVVector::BI__builtin_rvv_vfwcvt_rtz_xu_f_v_tumu:
2765 ID = Intrinsic::riscv_vfwcvt_rtz_xu_f_v_mask;
2766 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2767 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2768 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
2769 break;
2770case RISCVVector::BI__builtin_rvv_vfwcvt_rtz_xu_f_v_tamu:
2771 ID = Intrinsic::riscv_vfwcvt_rtz_xu_f_v_mask;
2772 DefaultPolicy = 1;
2773 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2774 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2775 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
2776 break;
2777case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_tu:
2778 ID = Intrinsic::riscv_vfwcvt_x_f_v;
2779 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
2780 break;
2781case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_ta:
2782 ID = Intrinsic::riscv_vfwcvt_x_f_v;
2783 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
2784 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
2785 break;
2786case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_tuma:
2787 ID = Intrinsic::riscv_vfwcvt_x_f_v_mask;
2788 DefaultPolicy = 2;
2789 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2790 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2791 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
2792 break;
2793case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_tama:
2794 ID = Intrinsic::riscv_vfwcvt_x_f_v_mask;
2795 DefaultPolicy = 3;
2796 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2797 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2798 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
2799 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
2800 break;
2801case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_tumu:
2802 ID = Intrinsic::riscv_vfwcvt_x_f_v_mask;
2803 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2804 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2805 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
2806 break;
2807case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_tamu:
2808 ID = Intrinsic::riscv_vfwcvt_x_f_v_mask;
2809 DefaultPolicy = 1;
2810 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2811 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2812 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
2813 break;
2814case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_tu:
2815 ID = Intrinsic::riscv_vfwcvt_xu_f_v;
2816 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
2817 break;
2818case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_ta:
2819 ID = Intrinsic::riscv_vfwcvt_xu_f_v;
2820 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
2821 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
2822 break;
2823case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_tuma:
2824 ID = Intrinsic::riscv_vfwcvt_xu_f_v_mask;
2825 DefaultPolicy = 2;
2826 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2827 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2828 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
2829 break;
2830case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_tama:
2831 ID = Intrinsic::riscv_vfwcvt_xu_f_v_mask;
2832 DefaultPolicy = 3;
2833 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2834 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2835 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
2836 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
2837 break;
2838case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_tumu:
2839 ID = Intrinsic::riscv_vfwcvt_xu_f_v_mask;
2840 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2841 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2842 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
2843 break;
2844case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_tamu:
2845 ID = Intrinsic::riscv_vfwcvt_xu_f_v_mask;
2846 DefaultPolicy = 1;
2847 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2848 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2849 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
2850 break;
2851case RISCVVector::BI__builtin_rvv_vfwmacc_vv_tu:
2852case RISCVVector::BI__builtin_rvv_vfwmacc_vf_tu:
2853 ID = Intrinsic::riscv_vfwmacc;
2854 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2855 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
2856 break;
2857case RISCVVector::BI__builtin_rvv_vfwmacc_vv_ta:
2858case RISCVVector::BI__builtin_rvv_vfwmacc_vf_ta:
2859 ID = Intrinsic::riscv_vfwmacc;
2860 DefaultPolicy = 1;
2861 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2862 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
2863 break;
2864case RISCVVector::BI__builtin_rvv_vfwmacc_vv_tuma:
2865case RISCVVector::BI__builtin_rvv_vfwmacc_vf_tuma:
2866 ID = Intrinsic::riscv_vfwmacc_mask;
2867 DefaultPolicy = 2;
2868 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2869 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2870 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
2871 break;
2872case RISCVVector::BI__builtin_rvv_vfwmacc_vv_tama:
2873case RISCVVector::BI__builtin_rvv_vfwmacc_vf_tama:
2874 ID = Intrinsic::riscv_vfwmacc_mask;
2875 DefaultPolicy = 3;
2876 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2877 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2878 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
2879 break;
2880case RISCVVector::BI__builtin_rvv_vfwmacc_vv_tumu:
2881case RISCVVector::BI__builtin_rvv_vfwmacc_vf_tumu:
2882 ID = Intrinsic::riscv_vfwmacc_mask;
2883 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2884 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2885 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
2886 break;
2887case RISCVVector::BI__builtin_rvv_vfwmacc_vv_tamu:
2888case RISCVVector::BI__builtin_rvv_vfwmacc_vf_tamu:
2889 ID = Intrinsic::riscv_vfwmacc_mask;
2890 DefaultPolicy = 1;
2891 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2892 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2893 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
2894 break;
2895case RISCVVector::BI__builtin_rvv_vfwmsac_vv_tu:
2896case RISCVVector::BI__builtin_rvv_vfwmsac_vf_tu:
2897 ID = Intrinsic::riscv_vfwmsac;
2898 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2899 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
2900 break;
2901case RISCVVector::BI__builtin_rvv_vfwmsac_vv_ta:
2902case RISCVVector::BI__builtin_rvv_vfwmsac_vf_ta:
2903 ID = Intrinsic::riscv_vfwmsac;
2904 DefaultPolicy = 1;
2905 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2906 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
2907 break;
2908case RISCVVector::BI__builtin_rvv_vfwmsac_vv_tuma:
2909case RISCVVector::BI__builtin_rvv_vfwmsac_vf_tuma:
2910 ID = Intrinsic::riscv_vfwmsac_mask;
2911 DefaultPolicy = 2;
2912 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2913 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2914 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
2915 break;
2916case RISCVVector::BI__builtin_rvv_vfwmsac_vv_tama:
2917case RISCVVector::BI__builtin_rvv_vfwmsac_vf_tama:
2918 ID = Intrinsic::riscv_vfwmsac_mask;
2919 DefaultPolicy = 3;
2920 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2921 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2922 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
2923 break;
2924case RISCVVector::BI__builtin_rvv_vfwmsac_vv_tumu:
2925case RISCVVector::BI__builtin_rvv_vfwmsac_vf_tumu:
2926 ID = Intrinsic::riscv_vfwmsac_mask;
2927 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2928 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2929 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
2930 break;
2931case RISCVVector::BI__builtin_rvv_vfwmsac_vv_tamu:
2932case RISCVVector::BI__builtin_rvv_vfwmsac_vf_tamu:
2933 ID = Intrinsic::riscv_vfwmsac_mask;
2934 DefaultPolicy = 1;
2935 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2936 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2937 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
2938 break;
2939case RISCVVector::BI__builtin_rvv_vfwmul_vv_tu:
2940case RISCVVector::BI__builtin_rvv_vfwmul_vf_tu:
2941 ID = Intrinsic::riscv_vfwmul;
2942 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
2943 break;
2944case RISCVVector::BI__builtin_rvv_vfwmul_vv_ta:
2945case RISCVVector::BI__builtin_rvv_vfwmul_vf_ta:
2946 ID = Intrinsic::riscv_vfwmul;
2947 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
2948 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
2949 break;
2950case RISCVVector::BI__builtin_rvv_vfwmul_vv_tuma:
2951case RISCVVector::BI__builtin_rvv_vfwmul_vf_tuma:
2952 ID = Intrinsic::riscv_vfwmul_mask;
2953 DefaultPolicy = 2;
2954 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2955 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2956 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
2957 break;
2958case RISCVVector::BI__builtin_rvv_vfwmul_vv_tama:
2959case RISCVVector::BI__builtin_rvv_vfwmul_vf_tama:
2960 ID = Intrinsic::riscv_vfwmul_mask;
2961 DefaultPolicy = 3;
2962 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2963 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2964 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
2965 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
2966 break;
2967case RISCVVector::BI__builtin_rvv_vfwmul_vv_tumu:
2968case RISCVVector::BI__builtin_rvv_vfwmul_vf_tumu:
2969 ID = Intrinsic::riscv_vfwmul_mask;
2970 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2971 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2972 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
2973 break;
2974case RISCVVector::BI__builtin_rvv_vfwmul_vv_tamu:
2975case RISCVVector::BI__builtin_rvv_vfwmul_vf_tamu:
2976 ID = Intrinsic::riscv_vfwmul_mask;
2977 DefaultPolicy = 1;
2978 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
2979 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2980 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
2981 break;
2982case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_tu:
2983case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_tu:
2984 ID = Intrinsic::riscv_vfwnmacc;
2985 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2986 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
2987 break;
2988case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_ta:
2989case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_ta:
2990 ID = Intrinsic::riscv_vfwnmacc;
2991 DefaultPolicy = 1;
2992 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
2993 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
2994 break;
2995case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_tuma:
2996case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_tuma:
2997 ID = Intrinsic::riscv_vfwnmacc_mask;
2998 DefaultPolicy = 2;
2999 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3000 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3001 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
3002 break;
3003case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_tama:
3004case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_tama:
3005 ID = Intrinsic::riscv_vfwnmacc_mask;
3006 DefaultPolicy = 3;
3007 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3008 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3009 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
3010 break;
3011case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_tumu:
3012case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_tumu:
3013 ID = Intrinsic::riscv_vfwnmacc_mask;
3014 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3015 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3016 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
3017 break;
3018case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_tamu:
3019case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_tamu:
3020 ID = Intrinsic::riscv_vfwnmacc_mask;
3021 DefaultPolicy = 1;
3022 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3023 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3024 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
3025 break;
3026case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_tu:
3027case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_tu:
3028 ID = Intrinsic::riscv_vfwnmsac;
3029 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3030 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
3031 break;
3032case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_ta:
3033case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_ta:
3034 ID = Intrinsic::riscv_vfwnmsac;
3035 DefaultPolicy = 1;
3036 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3037 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
3038 break;
3039case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_tuma:
3040case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_tuma:
3041 ID = Intrinsic::riscv_vfwnmsac_mask;
3042 DefaultPolicy = 2;
3043 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3044 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3045 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
3046 break;
3047case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_tama:
3048case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_tama:
3049 ID = Intrinsic::riscv_vfwnmsac_mask;
3050 DefaultPolicy = 3;
3051 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3052 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3053 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
3054 break;
3055case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_tumu:
3056case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_tumu:
3057 ID = Intrinsic::riscv_vfwnmsac_mask;
3058 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3059 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3060 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
3061 break;
3062case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_tamu:
3063case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_tamu:
3064 ID = Intrinsic::riscv_vfwnmsac_mask;
3065 DefaultPolicy = 1;
3066 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3067 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3068 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
3069 break;
3070case RISCVVector::BI__builtin_rvv_vfwredosum_vs_tu:
3071 ID = Intrinsic::riscv_vfwredosum;
3072 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
3073 break;
3074case RISCVVector::BI__builtin_rvv_vfwredosum_vs_ta:
3075 ID = Intrinsic::riscv_vfwredosum;
3076 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
3077 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
3078 break;
3079case RISCVVector::BI__builtin_rvv_vfwredosum_vs_tum:
3080 ID = Intrinsic::riscv_vfwredosum_mask;
3081 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3082 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
3083 break;
3084case RISCVVector::BI__builtin_rvv_vfwredosum_vs_tam:
3085 ID = Intrinsic::riscv_vfwredosum_mask;
3086 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3087 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
3088 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
3089 break;
3090case RISCVVector::BI__builtin_rvv_vfwredosum_vs_tumu:
3091 ID = Intrinsic::riscv_vfwredosum_mask;
3092 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3093 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
3094 break;
3095case RISCVVector::BI__builtin_rvv_vfwredusum_vs_tu:
3096 ID = Intrinsic::riscv_vfwredusum;
3097 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
3098 break;
3099case RISCVVector::BI__builtin_rvv_vfwredusum_vs_ta:
3100 ID = Intrinsic::riscv_vfwredusum;
3101 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
3102 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
3103 break;
3104case RISCVVector::BI__builtin_rvv_vfwredusum_vs_tum:
3105 ID = Intrinsic::riscv_vfwredusum_mask;
3106 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3107 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
3108 break;
3109case RISCVVector::BI__builtin_rvv_vfwredusum_vs_tam:
3110 ID = Intrinsic::riscv_vfwredusum_mask;
3111 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3112 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
3113 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
3114 break;
3115case RISCVVector::BI__builtin_rvv_vfwredusum_vs_tumu:
3116 ID = Intrinsic::riscv_vfwredusum_mask;
3117 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3118 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
3119 break;
3120case RISCVVector::BI__builtin_rvv_vfwsub_vv_tu:
3121case RISCVVector::BI__builtin_rvv_vfwsub_vf_tu:
3122 ID = Intrinsic::riscv_vfwsub;
3123 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
3124 break;
3125case RISCVVector::BI__builtin_rvv_vfwsub_vv_ta:
3126case RISCVVector::BI__builtin_rvv_vfwsub_vf_ta:
3127 ID = Intrinsic::riscv_vfwsub;
3128 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
3129 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
3130 break;
3131case RISCVVector::BI__builtin_rvv_vfwsub_vv_tuma:
3132case RISCVVector::BI__builtin_rvv_vfwsub_vf_tuma:
3133 ID = Intrinsic::riscv_vfwsub_mask;
3134 DefaultPolicy = 2;
3135 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3136 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3137 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
3138 break;
3139case RISCVVector::BI__builtin_rvv_vfwsub_vv_tama:
3140case RISCVVector::BI__builtin_rvv_vfwsub_vf_tama:
3141 ID = Intrinsic::riscv_vfwsub_mask;
3142 DefaultPolicy = 3;
3143 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3144 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3145 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
3146 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
3147 break;
3148case RISCVVector::BI__builtin_rvv_vfwsub_vv_tumu:
3149case RISCVVector::BI__builtin_rvv_vfwsub_vf_tumu:
3150 ID = Intrinsic::riscv_vfwsub_mask;
3151 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3152 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3153 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
3154 break;
3155case RISCVVector::BI__builtin_rvv_vfwsub_vv_tamu:
3156case RISCVVector::BI__builtin_rvv_vfwsub_vf_tamu:
3157 ID = Intrinsic::riscv_vfwsub_mask;
3158 DefaultPolicy = 1;
3159 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3160 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3161 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
3162 break;
3163case RISCVVector::BI__builtin_rvv_vfwsub_wv_tu:
3164case RISCVVector::BI__builtin_rvv_vfwsub_wf_tu:
3165 ID = Intrinsic::riscv_vfwsub_w;
3166 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
3167 break;
3168case RISCVVector::BI__builtin_rvv_vfwsub_wv_ta:
3169case RISCVVector::BI__builtin_rvv_vfwsub_wf_ta:
3170 ID = Intrinsic::riscv_vfwsub_w;
3171 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
3172 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
3173 break;
3174case RISCVVector::BI__builtin_rvv_vfwsub_wv_tuma:
3175case RISCVVector::BI__builtin_rvv_vfwsub_wf_tuma:
3176 ID = Intrinsic::riscv_vfwsub_w_mask;
3177 DefaultPolicy = 2;
3178 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3179 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3180 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
3181 break;
3182case RISCVVector::BI__builtin_rvv_vfwsub_wv_tama:
3183case RISCVVector::BI__builtin_rvv_vfwsub_wf_tama:
3184 ID = Intrinsic::riscv_vfwsub_w_mask;
3185 DefaultPolicy = 3;
3186 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3187 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3188 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
3189 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
3190 break;
3191case RISCVVector::BI__builtin_rvv_vfwsub_wv_tumu:
3192case RISCVVector::BI__builtin_rvv_vfwsub_wf_tumu:
3193 ID = Intrinsic::riscv_vfwsub_w_mask;
3194 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3195 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3196 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
3197 break;
3198case RISCVVector::BI__builtin_rvv_vfwsub_wv_tamu:
3199case RISCVVector::BI__builtin_rvv_vfwsub_wf_tamu:
3200 ID = Intrinsic::riscv_vfwsub_w_mask;
3201 DefaultPolicy = 1;
3202 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3203 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3204 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
3205 break;
3206case RISCVVector::BI__builtin_rvv_vid_v_tu:
3207 ID = Intrinsic::riscv_vid;
3208 IntrinsicTypes = {ResultType, Ops.back()->getType()};
3209 break;
3210case RISCVVector::BI__builtin_rvv_vid_v_ta:
3211 ID = Intrinsic::riscv_vid;
3212 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
3213 IntrinsicTypes = {ResultType, Ops.back()->getType()};
3214 break;
3215case RISCVVector::BI__builtin_rvv_vid_v_tuma:
3216 ID = Intrinsic::riscv_vid_mask;
3217 DefaultPolicy = 2;
3218 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3219 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3220 IntrinsicTypes = {ResultType, Ops.back()->getType()};
3221 break;
3222case RISCVVector::BI__builtin_rvv_vid_v_tama:
3223 ID = Intrinsic::riscv_vid_mask;
3224 DefaultPolicy = 3;
3225 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3226 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3227 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
3228 IntrinsicTypes = {ResultType, Ops.back()->getType()};
3229 break;
3230case RISCVVector::BI__builtin_rvv_vid_v_tumu:
3231 ID = Intrinsic::riscv_vid_mask;
3232 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3233 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3234 IntrinsicTypes = {ResultType, Ops.back()->getType()};
3235 break;
3236case RISCVVector::BI__builtin_rvv_vid_v_tamu:
3237 ID = Intrinsic::riscv_vid_mask;
3238 DefaultPolicy = 1;
3239 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3240 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3241 IntrinsicTypes = {ResultType, Ops.back()->getType()};
3242 break;
3243case RISCVVector::BI__builtin_rvv_viota_m_tu:
3244 ID = Intrinsic::riscv_viota;
3245 IntrinsicTypes = {ResultType, Ops.back()->getType()};
3246 break;
3247case RISCVVector::BI__builtin_rvv_viota_m_ta:
3248 ID = Intrinsic::riscv_viota;
3249 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
3250 IntrinsicTypes = {ResultType, Ops.back()->getType()};
3251 break;
3252case RISCVVector::BI__builtin_rvv_viota_m_tuma:
3253 ID = Intrinsic::riscv_viota_mask;
3254 DefaultPolicy = 2;
3255 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3256 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3257 IntrinsicTypes = {ResultType, Ops.back()->getType()};
3258 break;
3259case RISCVVector::BI__builtin_rvv_viota_m_tama:
3260 ID = Intrinsic::riscv_viota_mask;
3261 DefaultPolicy = 3;
3262 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3263 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3264 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
3265 IntrinsicTypes = {ResultType, Ops.back()->getType()};
3266 break;
3267case RISCVVector::BI__builtin_rvv_viota_m_tumu:
3268 ID = Intrinsic::riscv_viota_mask;
3269 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3270 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3271 IntrinsicTypes = {ResultType, Ops.back()->getType()};
3272 break;
3273case RISCVVector::BI__builtin_rvv_viota_m_tamu:
3274 ID = Intrinsic::riscv_viota_mask;
3275 DefaultPolicy = 1;
3276 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3277 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3278 IntrinsicTypes = {ResultType, Ops.back()->getType()};
3279 break;
3280case RISCVVector::BI__builtin_rvv_vle8_v_tu:
3281case RISCVVector::BI__builtin_rvv_vle16_v_tu:
3282case RISCVVector::BI__builtin_rvv_vle32_v_tu:
3283case RISCVVector::BI__builtin_rvv_vle64_v_tu:
3284 ID = Intrinsic::riscv_vle;
3285 Ops[1] = Builder.CreateBitCast(Ops[1], ResultType->getPointerTo());
3286 IntrinsicTypes = {ResultType, Ops.back()->getType()};
3287 break;
3288case RISCVVector::BI__builtin_rvv_vle8_v_ta:
3289case RISCVVector::BI__builtin_rvv_vle16_v_ta:
3290case RISCVVector::BI__builtin_rvv_vle32_v_ta:
3291case RISCVVector::BI__builtin_rvv_vle64_v_ta:
3292 ID = Intrinsic::riscv_vle;
3293 Ops[0] = Builder.CreateBitCast(Ops[0], ResultType->getPointerTo());
3294 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
3295 IntrinsicTypes = {ResultType, Ops.back()->getType()};
3296 break;
3297case RISCVVector::BI__builtin_rvv_vle8_v_tuma:
3298case RISCVVector::BI__builtin_rvv_vle16_v_tuma:
3299case RISCVVector::BI__builtin_rvv_vle32_v_tuma:
3300case RISCVVector::BI__builtin_rvv_vle64_v_tuma:
3301 ID = Intrinsic::riscv_vle_mask;
3302 DefaultPolicy = 2;
3303 Ops[2] = Builder.CreateBitCast(Ops[2], ResultType->getPointerTo());
3304 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3305 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3306 IntrinsicTypes = {ResultType, Ops.back()->getType()};
3307 break;
3308case RISCVVector::BI__builtin_rvv_vle8_v_tama:
3309case RISCVVector::BI__builtin_rvv_vle16_v_tama:
3310case RISCVVector::BI__builtin_rvv_vle32_v_tama:
3311case RISCVVector::BI__builtin_rvv_vle64_v_tama:
3312 ID = Intrinsic::riscv_vle_mask;
3313 DefaultPolicy = 3;
3314 Ops[1] = Builder.CreateBitCast(Ops[1], ResultType->getPointerTo());
3315 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3316 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3317 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
3318 IntrinsicTypes = {ResultType, Ops.back()->getType()};
3319 break;
3320case RISCVVector::BI__builtin_rvv_vle8_v_tumu:
3321case RISCVVector::BI__builtin_rvv_vle16_v_tumu:
3322case RISCVVector::BI__builtin_rvv_vle32_v_tumu:
3323case RISCVVector::BI__builtin_rvv_vle64_v_tumu:
3324 ID = Intrinsic::riscv_vle_mask;
3325 Ops[2] = Builder.CreateBitCast(Ops[2], ResultType->getPointerTo());
3326 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3327 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3328 IntrinsicTypes = {ResultType, Ops.back()->getType()};
3329 break;
3330case RISCVVector::BI__builtin_rvv_vle8_v_tamu:
3331case RISCVVector::BI__builtin_rvv_vle16_v_tamu:
3332case RISCVVector::BI__builtin_rvv_vle32_v_tamu:
3333case RISCVVector::BI__builtin_rvv_vle64_v_tamu:
3334 ID = Intrinsic::riscv_vle_mask;
3335 DefaultPolicy = 1;
3336 Ops[2] = Builder.CreateBitCast(Ops[2], ResultType->getPointerTo());
3337 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3338 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3339 IntrinsicTypes = {ResultType, Ops.back()->getType()};
3340 break;
3341case RISCVVector::BI__builtin_rvv_vle16ff_v_tu:
3342case RISCVVector::BI__builtin_rvv_vle32ff_v_tu:
3343case RISCVVector::BI__builtin_rvv_vle64ff_v_tu:
3344case RISCVVector::BI__builtin_rvv_vle8ff_v_tu:
3345 ID = Intrinsic::riscv_vleff;
3346 DefaultPolicy = 0;
3347IsMasked = false;
3348
3349 {
3350 if (IsMasked) {
3351 // Move mask to right before vl.
3352 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3353 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
3354 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
3355 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3356 IntrinsicTypes = {ResultType, Ops[4]->getType()};
3357 } else {
3358 if (DefaultPolicy == TAIL_AGNOSTIC)
3359 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
3360 IntrinsicTypes = {ResultType, Ops[3]->getType()};
3361 }
3362 Ops[1] = Builder.CreateBitCast(Ops[1], ResultType->getPointerTo());
3363 Value *NewVL = Ops[2];
3364 Ops.erase(Ops.begin() + 2);
3365 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
3366 llvm::Value *LoadValue = Builder.CreateCall(F, Ops, "");
3367 llvm::Value *V = Builder.CreateExtractValue(LoadValue, {0});
3368 // Store new_vl.
3369 clang::CharUnits Align;
3370 if (IsMasked)
3371 Align = CGM.getNaturalPointeeTypeAlignment(E->getArg(E->getNumArgs()-2)->getType());
3372 else
3373 Align = CGM.getNaturalPointeeTypeAlignment(E->getArg(1)->getType());
3374 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {1});
3375 Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
3376 return V;
3377 }
3378 break;
3379case RISCVVector::BI__builtin_rvv_vle16ff_v_ta:
3380case RISCVVector::BI__builtin_rvv_vle32ff_v_ta:
3381case RISCVVector::BI__builtin_rvv_vle64ff_v_ta:
3382case RISCVVector::BI__builtin_rvv_vle8ff_v_ta:
3383 ID = Intrinsic::riscv_vleff;
3384 DefaultPolicy = 1;
3385IsMasked = false;
3386
3387 {
3388 if (IsMasked) {
3389 // Move mask to right before vl.
3390 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3391 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
3392 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
3393 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3394 IntrinsicTypes = {ResultType, Ops[4]->getType()};
3395 } else {
3396 if (DefaultPolicy == TAIL_AGNOSTIC)
3397 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
3398 IntrinsicTypes = {ResultType, Ops[3]->getType()};
3399 }
3400 Ops[1] = Builder.CreateBitCast(Ops[1], ResultType->getPointerTo());
3401 Value *NewVL = Ops[2];
3402 Ops.erase(Ops.begin() + 2);
3403 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
3404 llvm::Value *LoadValue = Builder.CreateCall(F, Ops, "");
3405 llvm::Value *V = Builder.CreateExtractValue(LoadValue, {0});
3406 // Store new_vl.
3407 clang::CharUnits Align;
3408 if (IsMasked)
3409 Align = CGM.getNaturalPointeeTypeAlignment(E->getArg(E->getNumArgs()-2)->getType());
3410 else
3411 Align = CGM.getNaturalPointeeTypeAlignment(E->getArg(1)->getType());
3412 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {1});
3413 Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
3414 return V;
3415 }
3416 break;
3417case RISCVVector::BI__builtin_rvv_vle16ff_v_tuma:
3418case RISCVVector::BI__builtin_rvv_vle32ff_v_tuma:
3419case RISCVVector::BI__builtin_rvv_vle64ff_v_tuma:
3420case RISCVVector::BI__builtin_rvv_vle8ff_v_tuma:
3421 ID = Intrinsic::riscv_vleff_mask;
3422 DefaultPolicy = 2;
3423IsMasked = true;
3424
3425 {
3426 if (IsMasked) {
3427 // Move mask to right before vl.
3428 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3429 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
3430 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
3431 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3432 IntrinsicTypes = {ResultType, Ops[4]->getType()};
3433 } else {
3434 if (DefaultPolicy == TAIL_AGNOSTIC)
3435 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
3436 IntrinsicTypes = {ResultType, Ops[3]->getType()};
3437 }
3438 Ops[1] = Builder.CreateBitCast(Ops[1], ResultType->getPointerTo());
3439 Value *NewVL = Ops[2];
3440 Ops.erase(Ops.begin() + 2);
3441 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
3442 llvm::Value *LoadValue = Builder.CreateCall(F, Ops, "");
3443 llvm::Value *V = Builder.CreateExtractValue(LoadValue, {0});
3444 // Store new_vl.
3445 clang::CharUnits Align;
3446 if (IsMasked)
3447 Align = CGM.getNaturalPointeeTypeAlignment(E->getArg(E->getNumArgs()-2)->getType());
3448 else
3449 Align = CGM.getNaturalPointeeTypeAlignment(E->getArg(1)->getType());
3450 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {1});
3451 Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
3452 return V;
3453 }
3454 break;
3455case RISCVVector::BI__builtin_rvv_vle16ff_v_tama:
3456case RISCVVector::BI__builtin_rvv_vle32ff_v_tama:
3457case RISCVVector::BI__builtin_rvv_vle64ff_v_tama:
3458case RISCVVector::BI__builtin_rvv_vle8ff_v_tama:
3459 ID = Intrinsic::riscv_vleff_mask;
3460 DefaultPolicy = 3;
3461IsMasked = true;
3462
3463 {
3464 if (IsMasked) {
3465 // Move mask to right before vl.
3466 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3467 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
3468 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
3469 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3470 IntrinsicTypes = {ResultType, Ops[4]->getType()};
3471 } else {
3472 if (DefaultPolicy == TAIL_AGNOSTIC)
3473 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
3474 IntrinsicTypes = {ResultType, Ops[3]->getType()};
3475 }
3476 Ops[1] = Builder.CreateBitCast(Ops[1], ResultType->getPointerTo());
3477 Value *NewVL = Ops[2];
3478 Ops.erase(Ops.begin() + 2);
3479 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
3480 llvm::Value *LoadValue = Builder.CreateCall(F, Ops, "");
3481 llvm::Value *V = Builder.CreateExtractValue(LoadValue, {0});
3482 // Store new_vl.
3483 clang::CharUnits Align;
3484 if (IsMasked)
3485 Align = CGM.getNaturalPointeeTypeAlignment(E->getArg(E->getNumArgs()-2)->getType());
3486 else
3487 Align = CGM.getNaturalPointeeTypeAlignment(E->getArg(1)->getType());
3488 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {1});
3489 Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
3490 return V;
3491 }
3492 break;
3493case RISCVVector::BI__builtin_rvv_vle16ff_v_tumu:
3494case RISCVVector::BI__builtin_rvv_vle32ff_v_tumu:
3495case RISCVVector::BI__builtin_rvv_vle64ff_v_tumu:
3496case RISCVVector::BI__builtin_rvv_vle8ff_v_tumu:
3497 ID = Intrinsic::riscv_vleff_mask;
3498 DefaultPolicy = 0;
3499IsMasked = true;
3500
3501 {
3502 if (IsMasked) {
3503 // Move mask to right before vl.
3504 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3505 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
3506 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
3507 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3508 IntrinsicTypes = {ResultType, Ops[4]->getType()};
3509 } else {
3510 if (DefaultPolicy == TAIL_AGNOSTIC)
3511 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
3512 IntrinsicTypes = {ResultType, Ops[3]->getType()};
3513 }
3514 Ops[1] = Builder.CreateBitCast(Ops[1], ResultType->getPointerTo());
3515 Value *NewVL = Ops[2];
3516 Ops.erase(Ops.begin() + 2);
3517 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
3518 llvm::Value *LoadValue = Builder.CreateCall(F, Ops, "");
3519 llvm::Value *V = Builder.CreateExtractValue(LoadValue, {0});
3520 // Store new_vl.
3521 clang::CharUnits Align;
3522 if (IsMasked)
3523 Align = CGM.getNaturalPointeeTypeAlignment(E->getArg(E->getNumArgs()-2)->getType());
3524 else
3525 Align = CGM.getNaturalPointeeTypeAlignment(E->getArg(1)->getType());
3526 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {1});
3527 Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
3528 return V;
3529 }
3530 break;
3531case RISCVVector::BI__builtin_rvv_vle16ff_v_tamu:
3532case RISCVVector::BI__builtin_rvv_vle32ff_v_tamu:
3533case RISCVVector::BI__builtin_rvv_vle64ff_v_tamu:
3534case RISCVVector::BI__builtin_rvv_vle8ff_v_tamu:
3535 ID = Intrinsic::riscv_vleff_mask;
3536 DefaultPolicy = 1;
3537IsMasked = true;
3538
3539 {
3540 if (IsMasked) {
3541 // Move mask to right before vl.
3542 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3543 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
3544 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
3545 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3546 IntrinsicTypes = {ResultType, Ops[4]->getType()};
3547 } else {
3548 if (DefaultPolicy == TAIL_AGNOSTIC)
3549 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
3550 IntrinsicTypes = {ResultType, Ops[3]->getType()};
3551 }
3552 Ops[1] = Builder.CreateBitCast(Ops[1], ResultType->getPointerTo());
3553 Value *NewVL = Ops[2];
3554 Ops.erase(Ops.begin() + 2);
3555 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
3556 llvm::Value *LoadValue = Builder.CreateCall(F, Ops, "");
3557 llvm::Value *V = Builder.CreateExtractValue(LoadValue, {0});
3558 // Store new_vl.
3559 clang::CharUnits Align;
3560 if (IsMasked)
3561 Align = CGM.getNaturalPointeeTypeAlignment(E->getArg(E->getNumArgs()-2)->getType());
3562 else
3563 Align = CGM.getNaturalPointeeTypeAlignment(E->getArg(1)->getType());
3564 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {1});
3565 Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
3566 return V;
3567 }
3568 break;
3569case RISCVVector::BI__builtin_rvv_vlm_v:
3570 ID = Intrinsic::riscv_vlm;
3571 DefaultPolicy = 1;
3572 Ops[0] = Builder.CreateBitCast(Ops[0], ResultType->getPointerTo());
3573 IntrinsicTypes = {ResultType, Ops.back()->getType()};
3574 break;
3575case RISCVVector::BI__builtin_rvv_vloxei8_v_tu:
3576case RISCVVector::BI__builtin_rvv_vloxei16_v_tu:
3577case RISCVVector::BI__builtin_rvv_vloxei32_v_tu:
3578case RISCVVector::BI__builtin_rvv_vloxei64_v_tu:
3579 ID = Intrinsic::riscv_vloxei;
3580 Ops[1] = Builder.CreateBitCast(Ops[1], ResultType->getPointerTo());
3581 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
3582 break;
3583case RISCVVector::BI__builtin_rvv_vloxei8_v_ta:
3584case RISCVVector::BI__builtin_rvv_vloxei16_v_ta:
3585case RISCVVector::BI__builtin_rvv_vloxei32_v_ta:
3586case RISCVVector::BI__builtin_rvv_vloxei64_v_ta:
3587 ID = Intrinsic::riscv_vloxei;
3588 Ops[0] = Builder.CreateBitCast(Ops[0], ResultType->getPointerTo());
3589 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
3590 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
3591 break;
3592case RISCVVector::BI__builtin_rvv_vloxei8_v_tuma:
3593case RISCVVector::BI__builtin_rvv_vloxei16_v_tuma:
3594case RISCVVector::BI__builtin_rvv_vloxei32_v_tuma:
3595case RISCVVector::BI__builtin_rvv_vloxei64_v_tuma:
3596 ID = Intrinsic::riscv_vloxei_mask;
3597 DefaultPolicy = 2;
3598 Ops[2] = Builder.CreateBitCast(Ops[2], ResultType->getPointerTo());
3599 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3600 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3601 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
3602 break;
3603case RISCVVector::BI__builtin_rvv_vloxei8_v_tama:
3604case RISCVVector::BI__builtin_rvv_vloxei16_v_tama:
3605case RISCVVector::BI__builtin_rvv_vloxei32_v_tama:
3606case RISCVVector::BI__builtin_rvv_vloxei64_v_tama:
3607 ID = Intrinsic::riscv_vloxei_mask;
3608 DefaultPolicy = 3;
3609 Ops[1] = Builder.CreateBitCast(Ops[1], ResultType->getPointerTo());
3610 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3611 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3612 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
3613 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
3614 break;
3615case RISCVVector::BI__builtin_rvv_vloxei8_v_tumu:
3616case RISCVVector::BI__builtin_rvv_vloxei16_v_tumu:
3617case RISCVVector::BI__builtin_rvv_vloxei32_v_tumu:
3618case RISCVVector::BI__builtin_rvv_vloxei64_v_tumu:
3619 ID = Intrinsic::riscv_vloxei_mask;
3620 Ops[2] = Builder.CreateBitCast(Ops[2], ResultType->getPointerTo());
3621 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3622 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3623 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
3624 break;
3625case RISCVVector::BI__builtin_rvv_vloxei8_v_tamu:
3626case RISCVVector::BI__builtin_rvv_vloxei16_v_tamu:
3627case RISCVVector::BI__builtin_rvv_vloxei32_v_tamu:
3628case RISCVVector::BI__builtin_rvv_vloxei64_v_tamu:
3629 ID = Intrinsic::riscv_vloxei_mask;
3630 DefaultPolicy = 1;
3631 Ops[2] = Builder.CreateBitCast(Ops[2], ResultType->getPointerTo());
3632 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
3633 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3634 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
3635 break;
3636case RISCVVector::BI__builtin_rvv_vloxseg2ei16_v_tu:
3637case RISCVVector::BI__builtin_rvv_vloxseg2ei32_v_tu:
3638case RISCVVector::BI__builtin_rvv_vloxseg2ei64_v_tu:
3639case RISCVVector::BI__builtin_rvv_vloxseg2ei8_v_tu:
3640 ID = Intrinsic::riscv_vloxseg2;
3641 NF = 2;
3642 DefaultPolicy = 0;
3643IsMasked = false;
3644
3645 {
3646 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
3647 SmallVector<llvm::Value*, 12> Operands;
3648 if (IsMasked) {
3649 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
3650 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
3651 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
3652 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
3653 for (unsigned I = 0; I < NF; ++I)
3654 Operands.push_back(llvm::PoisonValue::get(ResultType));
3655 Operands.push_back(Ops[NF + 1]);
3656 Operands.push_back(Ops[NF + 2]);
3657 Operands.push_back(Ops[NF]);
3658 Operands.push_back(Ops[NF + 3]);
3659 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
3660 } else {
3661 for (unsigned I = 0; I < NF; ++I)
3662 Operands.push_back(Ops[NF + I + 1]);
3663 Operands.push_back(Ops[2 * NF + 1]);
3664 Operands.push_back(Ops[2 * NF + 2]);
3665 Operands.push_back(Ops[NF]);
3666 Operands.push_back(Ops[2 * NF + 3]);
3667 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
3668 }
3669 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3670 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 3670, __extension__ __PRETTY_FUNCTION__));
3671 } else {
3672 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
3673 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
3674 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
3675 if (DefaultPolicy == TAIL_AGNOSTIC) {
3676 for (unsigned I = 0; I < NF; ++I)
3677 Operands.push_back(llvm::PoisonValue::get(ResultType));
3678 Operands.push_back(Ops[NF]);
3679 Operands.push_back(Ops[NF + 1]);
3680 Operands.push_back(Ops[NF + 2]);
3681 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
3682 } else {
3683 for (unsigned I = 0; I < NF; ++I)
3684 Operands.push_back(Ops[NF + I]);
3685 Operands.push_back(Ops[2 * NF]);
3686 Operands.push_back(Ops[2 * NF + 1]);
3687 Operands.push_back(Ops[2 * NF + 2]);
3688 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
3689 }
3690 }
3691 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
3692 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
3693 clang::CharUnits Align =
3694 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
3695 llvm::Value *V;
3696 for (unsigned I = 0; I < NF; ++I) {
3697 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
3698 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
3699 }
3700 return V;
3701 }
3702 break;
3703case RISCVVector::BI__builtin_rvv_vloxseg2ei16_v_ta:
3704case RISCVVector::BI__builtin_rvv_vloxseg2ei32_v_ta:
3705case RISCVVector::BI__builtin_rvv_vloxseg2ei64_v_ta:
3706case RISCVVector::BI__builtin_rvv_vloxseg2ei8_v_ta:
3707 ID = Intrinsic::riscv_vloxseg2;
3708 NF = 2;
3709 DefaultPolicy = 1;
3710IsMasked = false;
3711
3712 {
3713 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
3714 SmallVector<llvm::Value*, 12> Operands;
3715 if (IsMasked) {
3716 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
3717 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
3718 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
3719 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
3720 for (unsigned I = 0; I < NF; ++I)
3721 Operands.push_back(llvm::PoisonValue::get(ResultType));
3722 Operands.push_back(Ops[NF + 1]);
3723 Operands.push_back(Ops[NF + 2]);
3724 Operands.push_back(Ops[NF]);
3725 Operands.push_back(Ops[NF + 3]);
3726 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
3727 } else {
3728 for (unsigned I = 0; I < NF; ++I)
3729 Operands.push_back(Ops[NF + I + 1]);
3730 Operands.push_back(Ops[2 * NF + 1]);
3731 Operands.push_back(Ops[2 * NF + 2]);
3732 Operands.push_back(Ops[NF]);
3733 Operands.push_back(Ops[2 * NF + 3]);
3734 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
3735 }
3736 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3737 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 3737, __extension__ __PRETTY_FUNCTION__));
3738 } else {
3739 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
3740 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
3741 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
3742 if (DefaultPolicy == TAIL_AGNOSTIC) {
3743 for (unsigned I = 0; I < NF; ++I)
3744 Operands.push_back(llvm::PoisonValue::get(ResultType));
3745 Operands.push_back(Ops[NF]);
3746 Operands.push_back(Ops[NF + 1]);
3747 Operands.push_back(Ops[NF + 2]);
3748 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
3749 } else {
3750 for (unsigned I = 0; I < NF; ++I)
3751 Operands.push_back(Ops[NF + I]);
3752 Operands.push_back(Ops[2 * NF]);
3753 Operands.push_back(Ops[2 * NF + 1]);
3754 Operands.push_back(Ops[2 * NF + 2]);
3755 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
3756 }
3757 }
3758 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
3759 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
3760 clang::CharUnits Align =
3761 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
3762 llvm::Value *V;
3763 for (unsigned I = 0; I < NF; ++I) {
3764 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
3765 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
3766 }
3767 return V;
3768 }
3769 break;
3770case RISCVVector::BI__builtin_rvv_vloxseg2ei16_v_tuma:
3771case RISCVVector::BI__builtin_rvv_vloxseg2ei32_v_tuma:
3772case RISCVVector::BI__builtin_rvv_vloxseg2ei64_v_tuma:
3773case RISCVVector::BI__builtin_rvv_vloxseg2ei8_v_tuma:
3774 ID = Intrinsic::riscv_vloxseg2_mask;
3775 NF = 2;
3776 DefaultPolicy = 2;
3777IsMasked = true;
3778
3779 {
3780 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
3781 SmallVector<llvm::Value*, 12> Operands;
3782 if (IsMasked) {
3783 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
3784 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
3785 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
3786 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
3787 for (unsigned I = 0; I < NF; ++I)
3788 Operands.push_back(llvm::PoisonValue::get(ResultType));
3789 Operands.push_back(Ops[NF + 1]);
3790 Operands.push_back(Ops[NF + 2]);
3791 Operands.push_back(Ops[NF]);
3792 Operands.push_back(Ops[NF + 3]);
3793 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
3794 } else {
3795 for (unsigned I = 0; I < NF; ++I)
3796 Operands.push_back(Ops[NF + I + 1]);
3797 Operands.push_back(Ops[2 * NF + 1]);
3798 Operands.push_back(Ops[2 * NF + 2]);
3799 Operands.push_back(Ops[NF]);
3800 Operands.push_back(Ops[2 * NF + 3]);
3801 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
3802 }
3803 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3804 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 3804, __extension__ __PRETTY_FUNCTION__));
3805 } else {
3806 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
3807 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
3808 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
3809 if (DefaultPolicy == TAIL_AGNOSTIC) {
3810 for (unsigned I = 0; I < NF; ++I)
3811 Operands.push_back(llvm::PoisonValue::get(ResultType));
3812 Operands.push_back(Ops[NF]);
3813 Operands.push_back(Ops[NF + 1]);
3814 Operands.push_back(Ops[NF + 2]);
3815 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
3816 } else {
3817 for (unsigned I = 0; I < NF; ++I)
3818 Operands.push_back(Ops[NF + I]);
3819 Operands.push_back(Ops[2 * NF]);
3820 Operands.push_back(Ops[2 * NF + 1]);
3821 Operands.push_back(Ops[2 * NF + 2]);
3822 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
3823 }
3824 }
3825 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
3826 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
3827 clang::CharUnits Align =
3828 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
3829 llvm::Value *V;
3830 for (unsigned I = 0; I < NF; ++I) {
3831 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
3832 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
3833 }
3834 return V;
3835 }
3836 break;
3837case RISCVVector::BI__builtin_rvv_vloxseg2ei16_v_tama:
3838case RISCVVector::BI__builtin_rvv_vloxseg2ei32_v_tama:
3839case RISCVVector::BI__builtin_rvv_vloxseg2ei64_v_tama:
3840case RISCVVector::BI__builtin_rvv_vloxseg2ei8_v_tama:
3841 ID = Intrinsic::riscv_vloxseg2_mask;
3842 NF = 2;
3843 DefaultPolicy = 3;
3844IsMasked = true;
3845
3846 {
3847 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
3848 SmallVector<llvm::Value*, 12> Operands;
3849 if (IsMasked) {
3850 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
3851 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
3852 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
3853 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
3854 for (unsigned I = 0; I < NF; ++I)
3855 Operands.push_back(llvm::PoisonValue::get(ResultType));
3856 Operands.push_back(Ops[NF + 1]);
3857 Operands.push_back(Ops[NF + 2]);
3858 Operands.push_back(Ops[NF]);
3859 Operands.push_back(Ops[NF + 3]);
3860 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
3861 } else {
3862 for (unsigned I = 0; I < NF; ++I)
3863 Operands.push_back(Ops[NF + I + 1]);
3864 Operands.push_back(Ops[2 * NF + 1]);
3865 Operands.push_back(Ops[2 * NF + 2]);
3866 Operands.push_back(Ops[NF]);
3867 Operands.push_back(Ops[2 * NF + 3]);
3868 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
3869 }
3870 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3871 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 3871, __extension__ __PRETTY_FUNCTION__));
3872 } else {
3873 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
3874 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
3875 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
3876 if (DefaultPolicy == TAIL_AGNOSTIC) {
3877 for (unsigned I = 0; I < NF; ++I)
3878 Operands.push_back(llvm::PoisonValue::get(ResultType));
3879 Operands.push_back(Ops[NF]);
3880 Operands.push_back(Ops[NF + 1]);
3881 Operands.push_back(Ops[NF + 2]);
3882 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
3883 } else {
3884 for (unsigned I = 0; I < NF; ++I)
3885 Operands.push_back(Ops[NF + I]);
3886 Operands.push_back(Ops[2 * NF]);
3887 Operands.push_back(Ops[2 * NF + 1]);
3888 Operands.push_back(Ops[2 * NF + 2]);
3889 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
3890 }
3891 }
3892 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
3893 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
3894 clang::CharUnits Align =
3895 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
3896 llvm::Value *V;
3897 for (unsigned I = 0; I < NF; ++I) {
3898 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
3899 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
3900 }
3901 return V;
3902 }
3903 break;
3904case RISCVVector::BI__builtin_rvv_vloxseg2ei16_v_tumu:
3905case RISCVVector::BI__builtin_rvv_vloxseg2ei32_v_tumu:
3906case RISCVVector::BI__builtin_rvv_vloxseg2ei64_v_tumu:
3907case RISCVVector::BI__builtin_rvv_vloxseg2ei8_v_tumu:
3908 ID = Intrinsic::riscv_vloxseg2_mask;
3909 NF = 2;
3910 DefaultPolicy = 0;
3911IsMasked = true;
3912
3913 {
3914 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
3915 SmallVector<llvm::Value*, 12> Operands;
3916 if (IsMasked) {
3917 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
3918 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
3919 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
3920 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
3921 for (unsigned I = 0; I < NF; ++I)
3922 Operands.push_back(llvm::PoisonValue::get(ResultType));
3923 Operands.push_back(Ops[NF + 1]);
3924 Operands.push_back(Ops[NF + 2]);
3925 Operands.push_back(Ops[NF]);
3926 Operands.push_back(Ops[NF + 3]);
3927 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
3928 } else {
3929 for (unsigned I = 0; I < NF; ++I)
3930 Operands.push_back(Ops[NF + I + 1]);
3931 Operands.push_back(Ops[2 * NF + 1]);
3932 Operands.push_back(Ops[2 * NF + 2]);
3933 Operands.push_back(Ops[NF]);
3934 Operands.push_back(Ops[2 * NF + 3]);
3935 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
3936 }
3937 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
3938 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 3938, __extension__ __PRETTY_FUNCTION__));
3939 } else {
3940 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
3941 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
3942 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
3943 if (DefaultPolicy == TAIL_AGNOSTIC) {
3944 for (unsigned I = 0; I < NF; ++I)
3945 Operands.push_back(llvm::PoisonValue::get(ResultType));
3946 Operands.push_back(Ops[NF]);
3947 Operands.push_back(Ops[NF + 1]);
3948 Operands.push_back(Ops[NF + 2]);
3949 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
3950 } else {
3951 for (unsigned I = 0; I < NF; ++I)
3952 Operands.push_back(Ops[NF + I]);
3953 Operands.push_back(Ops[2 * NF]);
3954 Operands.push_back(Ops[2 * NF + 1]);
3955 Operands.push_back(Ops[2 * NF + 2]);
3956 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
3957 }
3958 }
3959 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
3960 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
3961 clang::CharUnits Align =
3962 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
3963 llvm::Value *V;
3964 for (unsigned I = 0; I < NF; ++I) {
3965 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
3966 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
3967 }
3968 return V;
3969 }
3970 break;
3971case RISCVVector::BI__builtin_rvv_vloxseg2ei16_v_tamu:
3972case RISCVVector::BI__builtin_rvv_vloxseg2ei32_v_tamu:
3973case RISCVVector::BI__builtin_rvv_vloxseg2ei64_v_tamu:
3974case RISCVVector::BI__builtin_rvv_vloxseg2ei8_v_tamu:
3975 ID = Intrinsic::riscv_vloxseg2_mask;
3976 NF = 2;
3977 DefaultPolicy = 1;
3978IsMasked = true;
3979
3980 {
3981 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
3982 SmallVector<llvm::Value*, 12> Operands;
3983 if (IsMasked) {
3984 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
3985 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
3986 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
3987 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
3988 for (unsigned I = 0; I < NF; ++I)
3989 Operands.push_back(llvm::PoisonValue::get(ResultType));
3990 Operands.push_back(Ops[NF + 1]);
3991 Operands.push_back(Ops[NF + 2]);
3992 Operands.push_back(Ops[NF]);
3993 Operands.push_back(Ops[NF + 3]);
3994 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
3995 } else {
3996 for (unsigned I = 0; I < NF; ++I)
3997 Operands.push_back(Ops[NF + I + 1]);
3998 Operands.push_back(Ops[2 * NF + 1]);
3999 Operands.push_back(Ops[2 * NF + 2]);
4000 Operands.push_back(Ops[NF]);
4001 Operands.push_back(Ops[2 * NF + 3]);
4002 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
4003 }
4004 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
4005 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 4005, __extension__ __PRETTY_FUNCTION__));
4006 } else {
4007 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
4008 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
4009 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
4010 if (DefaultPolicy == TAIL_AGNOSTIC) {
4011 for (unsigned I = 0; I < NF; ++I)
4012 Operands.push_back(llvm::PoisonValue::get(ResultType));
4013 Operands.push_back(Ops[NF]);
4014 Operands.push_back(Ops[NF + 1]);
4015 Operands.push_back(Ops[NF + 2]);
4016 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
4017 } else {
4018 for (unsigned I = 0; I < NF; ++I)
4019 Operands.push_back(Ops[NF + I]);
4020 Operands.push_back(Ops[2 * NF]);
4021 Operands.push_back(Ops[2 * NF + 1]);
4022 Operands.push_back(Ops[2 * NF + 2]);
4023 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
4024 }
4025 }
4026 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
4027 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
4028 clang::CharUnits Align =
4029 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
4030 llvm::Value *V;
4031 for (unsigned I = 0; I < NF; ++I) {
4032 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
4033 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
4034 }
4035 return V;
4036 }
4037 break;
4038case RISCVVector::BI__builtin_rvv_vloxseg3ei8_v_tu:
4039case RISCVVector::BI__builtin_rvv_vloxseg3ei16_v_tu:
4040case RISCVVector::BI__builtin_rvv_vloxseg3ei32_v_tu:
4041case RISCVVector::BI__builtin_rvv_vloxseg3ei64_v_tu:
4042 ID = Intrinsic::riscv_vloxseg3;
4043 NF = 3;
4044 DefaultPolicy = 0;
4045IsMasked = false;
4046
4047 {
4048 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
4049 SmallVector<llvm::Value*, 12> Operands;
4050 if (IsMasked) {
4051 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
4052 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
4053 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
4054 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
4055 for (unsigned I = 0; I < NF; ++I)
4056 Operands.push_back(llvm::PoisonValue::get(ResultType));
4057 Operands.push_back(Ops[NF + 1]);
4058 Operands.push_back(Ops[NF + 2]);
4059 Operands.push_back(Ops[NF]);
4060 Operands.push_back(Ops[NF + 3]);
4061 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
4062 } else {
4063 for (unsigned I = 0; I < NF; ++I)
4064 Operands.push_back(Ops[NF + I + 1]);
4065 Operands.push_back(Ops[2 * NF + 1]);
4066 Operands.push_back(Ops[2 * NF + 2]);
4067 Operands.push_back(Ops[NF]);
4068 Operands.push_back(Ops[2 * NF + 3]);
4069 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
4070 }
4071 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
4072 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 4072, __extension__ __PRETTY_FUNCTION__));
4073 } else {
4074 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
4075 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
4076 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
4077 if (DefaultPolicy == TAIL_AGNOSTIC) {
4078 for (unsigned I = 0; I < NF; ++I)
4079 Operands.push_back(llvm::PoisonValue::get(ResultType));
4080 Operands.push_back(Ops[NF]);
4081 Operands.push_back(Ops[NF + 1]);
4082 Operands.push_back(Ops[NF + 2]);
4083 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
4084 } else {
4085 for (unsigned I = 0; I < NF; ++I)
4086 Operands.push_back(Ops[NF + I]);
4087 Operands.push_back(Ops[2 * NF]);
4088 Operands.push_back(Ops[2 * NF + 1]);
4089 Operands.push_back(Ops[2 * NF + 2]);
4090 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
4091 }
4092 }
4093 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
4094 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
4095 clang::CharUnits Align =
4096 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
4097 llvm::Value *V;
4098 for (unsigned I = 0; I < NF; ++I) {
4099 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
4100 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
4101 }
4102 return V;
4103 }
4104 break;
4105case RISCVVector::BI__builtin_rvv_vloxseg3ei8_v_ta:
4106case RISCVVector::BI__builtin_rvv_vloxseg3ei16_v_ta:
4107case RISCVVector::BI__builtin_rvv_vloxseg3ei32_v_ta:
4108case RISCVVector::BI__builtin_rvv_vloxseg3ei64_v_ta:
4109 ID = Intrinsic::riscv_vloxseg3;
4110 NF = 3;
4111 DefaultPolicy = 1;
4112IsMasked = false;
4113
4114 {
4115 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
4116 SmallVector<llvm::Value*, 12> Operands;
4117 if (IsMasked) {
4118 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
4119 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
4120 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
4121 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
4122 for (unsigned I = 0; I < NF; ++I)
4123 Operands.push_back(llvm::PoisonValue::get(ResultType));
4124 Operands.push_back(Ops[NF + 1]);
4125 Operands.push_back(Ops[NF + 2]);
4126 Operands.push_back(Ops[NF]);
4127 Operands.push_back(Ops[NF + 3]);
4128 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
4129 } else {
4130 for (unsigned I = 0; I < NF; ++I)
4131 Operands.push_back(Ops[NF + I + 1]);
4132 Operands.push_back(Ops[2 * NF + 1]);
4133 Operands.push_back(Ops[2 * NF + 2]);
4134 Operands.push_back(Ops[NF]);
4135 Operands.push_back(Ops[2 * NF + 3]);
4136 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
4137 }
4138 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
4139 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 4139, __extension__ __PRETTY_FUNCTION__));
4140 } else {
4141 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
4142 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
4143 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
4144 if (DefaultPolicy == TAIL_AGNOSTIC) {
4145 for (unsigned I = 0; I < NF; ++I)
4146 Operands.push_back(llvm::PoisonValue::get(ResultType));
4147 Operands.push_back(Ops[NF]);
4148 Operands.push_back(Ops[NF + 1]);
4149 Operands.push_back(Ops[NF + 2]);
4150 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
4151 } else {
4152 for (unsigned I = 0; I < NF; ++I)
4153 Operands.push_back(Ops[NF + I]);
4154 Operands.push_back(Ops[2 * NF]);
4155 Operands.push_back(Ops[2 * NF + 1]);
4156 Operands.push_back(Ops[2 * NF + 2]);
4157 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
4158 }
4159 }
4160 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
4161 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
4162 clang::CharUnits Align =
4163 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
4164 llvm::Value *V;
4165 for (unsigned I = 0; I < NF; ++I) {
4166 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
4167 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
4168 }
4169 return V;
4170 }
4171 break;
4172case RISCVVector::BI__builtin_rvv_vloxseg3ei8_v_tuma:
4173case RISCVVector::BI__builtin_rvv_vloxseg3ei16_v_tuma:
4174case RISCVVector::BI__builtin_rvv_vloxseg3ei32_v_tuma:
4175case RISCVVector::BI__builtin_rvv_vloxseg3ei64_v_tuma:
4176 ID = Intrinsic::riscv_vloxseg3_mask;
4177 NF = 3;
4178 DefaultPolicy = 2;
4179IsMasked = true;
4180
4181 {
4182 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
4183 SmallVector<llvm::Value*, 12> Operands;
4184 if (IsMasked) {
4185 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
4186 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
4187 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
4188 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
4189 for (unsigned I = 0; I < NF; ++I)
4190 Operands.push_back(llvm::PoisonValue::get(ResultType));
4191 Operands.push_back(Ops[NF + 1]);
4192 Operands.push_back(Ops[NF + 2]);
4193 Operands.push_back(Ops[NF]);
4194 Operands.push_back(Ops[NF + 3]);
4195 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
4196 } else {
4197 for (unsigned I = 0; I < NF; ++I)
4198 Operands.push_back(Ops[NF + I + 1]);
4199 Operands.push_back(Ops[2 * NF + 1]);
4200 Operands.push_back(Ops[2 * NF + 2]);
4201 Operands.push_back(Ops[NF]);
4202 Operands.push_back(Ops[2 * NF + 3]);
4203 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
4204 }
4205 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
4206 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 4206, __extension__ __PRETTY_FUNCTION__));
4207 } else {
4208 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
4209 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
4210 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
4211 if (DefaultPolicy == TAIL_AGNOSTIC) {
4212 for (unsigned I = 0; I < NF; ++I)
4213 Operands.push_back(llvm::PoisonValue::get(ResultType));
4214 Operands.push_back(Ops[NF]);
4215 Operands.push_back(Ops[NF + 1]);
4216 Operands.push_back(Ops[NF + 2]);
4217 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
4218 } else {
4219 for (unsigned I = 0; I < NF; ++I)
4220 Operands.push_back(Ops[NF + I]);
4221 Operands.push_back(Ops[2 * NF]);
4222 Operands.push_back(Ops[2 * NF + 1]);
4223 Operands.push_back(Ops[2 * NF + 2]);
4224 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
4225 }
4226 }
4227 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
4228 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
4229 clang::CharUnits Align =
4230 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
4231 llvm::Value *V;
4232 for (unsigned I = 0; I < NF; ++I) {
4233 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
4234 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
4235 }
4236 return V;
4237 }
4238 break;
4239case RISCVVector::BI__builtin_rvv_vloxseg3ei8_v_tama:
4240case RISCVVector::BI__builtin_rvv_vloxseg3ei16_v_tama:
4241case RISCVVector::BI__builtin_rvv_vloxseg3ei32_v_tama:
4242case RISCVVector::BI__builtin_rvv_vloxseg3ei64_v_tama:
4243 ID = Intrinsic::riscv_vloxseg3_mask;
4244 NF = 3;
4245 DefaultPolicy = 3;
4246IsMasked = true;
4247
4248 {
4249 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
4250 SmallVector<llvm::Value*, 12> Operands;
4251 if (IsMasked) {
4252 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
4253 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
4254 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
4255 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
4256 for (unsigned I = 0; I < NF; ++I)
4257 Operands.push_back(llvm::PoisonValue::get(ResultType));
4258 Operands.push_back(Ops[NF + 1]);
4259 Operands.push_back(Ops[NF + 2]);
4260 Operands.push_back(Ops[NF]);
4261 Operands.push_back(Ops[NF + 3]);
4262 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
4263 } else {
4264 for (unsigned I = 0; I < NF; ++I)
4265 Operands.push_back(Ops[NF + I + 1]);
4266 Operands.push_back(Ops[2 * NF + 1]);
4267 Operands.push_back(Ops[2 * NF + 2]);
4268 Operands.push_back(Ops[NF]);
4269 Operands.push_back(Ops[2 * NF + 3]);
4270 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
4271 }
4272 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
4273 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 4273, __extension__ __PRETTY_FUNCTION__));
4274 } else {
4275 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
4276 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
4277 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
4278 if (DefaultPolicy == TAIL_AGNOSTIC) {
4279 for (unsigned I = 0; I < NF; ++I)
4280 Operands.push_back(llvm::PoisonValue::get(ResultType));
4281 Operands.push_back(Ops[NF]);
4282 Operands.push_back(Ops[NF + 1]);
4283 Operands.push_back(Ops[NF + 2]);
4284 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
4285 } else {
4286 for (unsigned I = 0; I < NF; ++I)
4287 Operands.push_back(Ops[NF + I]);
4288 Operands.push_back(Ops[2 * NF]);
4289 Operands.push_back(Ops[2 * NF + 1]);
4290 Operands.push_back(Ops[2 * NF + 2]);
4291 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
4292 }
4293 }
4294 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
4295 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
4296 clang::CharUnits Align =
4297 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
4298 llvm::Value *V;
4299 for (unsigned I = 0; I < NF; ++I) {
4300 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
4301 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
4302 }
4303 return V;
4304 }
4305 break;
4306case RISCVVector::BI__builtin_rvv_vloxseg3ei8_v_tumu:
4307case RISCVVector::BI__builtin_rvv_vloxseg3ei16_v_tumu:
4308case RISCVVector::BI__builtin_rvv_vloxseg3ei32_v_tumu:
4309case RISCVVector::BI__builtin_rvv_vloxseg3ei64_v_tumu:
4310 ID = Intrinsic::riscv_vloxseg3_mask;
4311 NF = 3;
4312 DefaultPolicy = 0;
4313IsMasked = true;
4314
4315 {
4316 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
4317 SmallVector<llvm::Value*, 12> Operands;
4318 if (IsMasked) {
4319 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
4320 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
4321 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
4322 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
4323 for (unsigned I = 0; I < NF; ++I)
4324 Operands.push_back(llvm::PoisonValue::get(ResultType));
4325 Operands.push_back(Ops[NF + 1]);
4326 Operands.push_back(Ops[NF + 2]);
4327 Operands.push_back(Ops[NF]);
4328 Operands.push_back(Ops[NF + 3]);
4329 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
4330 } else {
4331 for (unsigned I = 0; I < NF; ++I)
4332 Operands.push_back(Ops[NF + I + 1]);
4333 Operands.push_back(Ops[2 * NF + 1]);
4334 Operands.push_back(Ops[2 * NF + 2]);
4335 Operands.push_back(Ops[NF]);
4336 Operands.push_back(Ops[2 * NF + 3]);
4337 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
4338 }
4339 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
4340 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 4340, __extension__ __PRETTY_FUNCTION__));
4341 } else {
4342 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
4343 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
4344 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
4345 if (DefaultPolicy == TAIL_AGNOSTIC) {
4346 for (unsigned I = 0; I < NF; ++I)
4347 Operands.push_back(llvm::PoisonValue::get(ResultType));
4348 Operands.push_back(Ops[NF]);
4349 Operands.push_back(Ops[NF + 1]);
4350 Operands.push_back(Ops[NF + 2]);
4351 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
4352 } else {
4353 for (unsigned I = 0; I < NF; ++I)
4354 Operands.push_back(Ops[NF + I]);
4355 Operands.push_back(Ops[2 * NF]);
4356 Operands.push_back(Ops[2 * NF + 1]);
4357 Operands.push_back(Ops[2 * NF + 2]);
4358 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
4359 }
4360 }
4361 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
4362 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
4363 clang::CharUnits Align =
4364 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
4365 llvm::Value *V;
4366 for (unsigned I = 0; I < NF; ++I) {
4367 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
4368 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
4369 }
4370 return V;
4371 }
4372 break;
4373case RISCVVector::BI__builtin_rvv_vloxseg3ei8_v_tamu:
4374case RISCVVector::BI__builtin_rvv_vloxseg3ei16_v_tamu:
4375case RISCVVector::BI__builtin_rvv_vloxseg3ei32_v_tamu:
4376case RISCVVector::BI__builtin_rvv_vloxseg3ei64_v_tamu:
4377 ID = Intrinsic::riscv_vloxseg3_mask;
4378 NF = 3;
4379 DefaultPolicy = 1;
4380IsMasked = true;
4381
4382 {
4383 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
4384 SmallVector<llvm::Value*, 12> Operands;
4385 if (IsMasked) {
4386 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
4387 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
4388 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
4389 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
4390 for (unsigned I = 0; I < NF; ++I)
4391 Operands.push_back(llvm::PoisonValue::get(ResultType));
4392 Operands.push_back(Ops[NF + 1]);
4393 Operands.push_back(Ops[NF + 2]);
4394 Operands.push_back(Ops[NF]);
4395 Operands.push_back(Ops[NF + 3]);
4396 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
4397 } else {
4398 for (unsigned I = 0; I < NF; ++I)
4399 Operands.push_back(Ops[NF + I + 1]);
4400 Operands.push_back(Ops[2 * NF + 1]);
4401 Operands.push_back(Ops[2 * NF + 2]);
4402 Operands.push_back(Ops[NF]);
4403 Operands.push_back(Ops[2 * NF + 3]);
4404 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
4405 }
4406 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
4407 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 4407, __extension__ __PRETTY_FUNCTION__));
4408 } else {
4409 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
4410 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
4411 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
4412 if (DefaultPolicy == TAIL_AGNOSTIC) {
4413 for (unsigned I = 0; I < NF; ++I)
4414 Operands.push_back(llvm::PoisonValue::get(ResultType));
4415 Operands.push_back(Ops[NF]);
4416 Operands.push_back(Ops[NF + 1]);
4417 Operands.push_back(Ops[NF + 2]);
4418 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
4419 } else {
4420 for (unsigned I = 0; I < NF; ++I)
4421 Operands.push_back(Ops[NF + I]);
4422 Operands.push_back(Ops[2 * NF]);
4423 Operands.push_back(Ops[2 * NF + 1]);
4424 Operands.push_back(Ops[2 * NF + 2]);
4425 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
4426 }
4427 }
4428 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
4429 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
4430 clang::CharUnits Align =
4431 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
4432 llvm::Value *V;
4433 for (unsigned I = 0; I < NF; ++I) {
4434 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
4435 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
4436 }
4437 return V;
4438 }
4439 break;
4440case RISCVVector::BI__builtin_rvv_vloxseg4ei8_v_tu:
4441case RISCVVector::BI__builtin_rvv_vloxseg4ei16_v_tu:
4442case RISCVVector::BI__builtin_rvv_vloxseg4ei32_v_tu:
4443case RISCVVector::BI__builtin_rvv_vloxseg4ei64_v_tu:
4444 ID = Intrinsic::riscv_vloxseg4;
4445 NF = 4;
4446 DefaultPolicy = 0;
4447IsMasked = false;
4448
4449 {
4450 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
4451 SmallVector<llvm::Value*, 12> Operands;
4452 if (IsMasked) {
4453 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
4454 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
4455 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
4456 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
4457 for (unsigned I = 0; I < NF; ++I)
4458 Operands.push_back(llvm::PoisonValue::get(ResultType));
4459 Operands.push_back(Ops[NF + 1]);
4460 Operands.push_back(Ops[NF + 2]);
4461 Operands.push_back(Ops[NF]);
4462 Operands.push_back(Ops[NF + 3]);
4463 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
4464 } else {
4465 for (unsigned I = 0; I < NF; ++I)
4466 Operands.push_back(Ops[NF + I + 1]);
4467 Operands.push_back(Ops[2 * NF + 1]);
4468 Operands.push_back(Ops[2 * NF + 2]);
4469 Operands.push_back(Ops[NF]);
4470 Operands.push_back(Ops[2 * NF + 3]);
4471 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
4472 }
4473 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
4474 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 4474, __extension__ __PRETTY_FUNCTION__));
4475 } else {
4476 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
4477 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
4478 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
4479 if (DefaultPolicy == TAIL_AGNOSTIC) {
4480 for (unsigned I = 0; I < NF; ++I)
4481 Operands.push_back(llvm::PoisonValue::get(ResultType));
4482 Operands.push_back(Ops[NF]);
4483 Operands.push_back(Ops[NF + 1]);
4484 Operands.push_back(Ops[NF + 2]);
4485 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
4486 } else {
4487 for (unsigned I = 0; I < NF; ++I)
4488 Operands.push_back(Ops[NF + I]);
4489 Operands.push_back(Ops[2 * NF]);
4490 Operands.push_back(Ops[2 * NF + 1]);
4491 Operands.push_back(Ops[2 * NF + 2]);
4492 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
4493 }
4494 }
4495 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
4496 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
4497 clang::CharUnits Align =
4498 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
4499 llvm::Value *V;
4500 for (unsigned I = 0; I < NF; ++I) {
4501 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
4502 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
4503 }
4504 return V;
4505 }
4506 break;
4507case RISCVVector::BI__builtin_rvv_vloxseg4ei8_v_ta:
4508case RISCVVector::BI__builtin_rvv_vloxseg4ei16_v_ta:
4509case RISCVVector::BI__builtin_rvv_vloxseg4ei32_v_ta:
4510case RISCVVector::BI__builtin_rvv_vloxseg4ei64_v_ta:
4511 ID = Intrinsic::riscv_vloxseg4;
4512 NF = 4;
4513 DefaultPolicy = 1;
4514IsMasked = false;
4515
4516 {
4517 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
4518 SmallVector<llvm::Value*, 12> Operands;
4519 if (IsMasked) {
4520 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
4521 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
4522 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
4523 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
4524 for (unsigned I = 0; I < NF; ++I)
4525 Operands.push_back(llvm::PoisonValue::get(ResultType));
4526 Operands.push_back(Ops[NF + 1]);
4527 Operands.push_back(Ops[NF + 2]);
4528 Operands.push_back(Ops[NF]);
4529 Operands.push_back(Ops[NF + 3]);
4530 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
4531 } else {
4532 for (unsigned I = 0; I < NF; ++I)
4533 Operands.push_back(Ops[NF + I + 1]);
4534 Operands.push_back(Ops[2 * NF + 1]);
4535 Operands.push_back(Ops[2 * NF + 2]);
4536 Operands.push_back(Ops[NF]);
4537 Operands.push_back(Ops[2 * NF + 3]);
4538 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
4539 }
4540 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
4541 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 4541, __extension__ __PRETTY_FUNCTION__));
4542 } else {
4543 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
4544 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
4545 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
4546 if (DefaultPolicy == TAIL_AGNOSTIC) {
4547 for (unsigned I = 0; I < NF; ++I)
4548 Operands.push_back(llvm::PoisonValue::get(ResultType));
4549 Operands.push_back(Ops[NF]);
4550 Operands.push_back(Ops[NF + 1]);
4551 Operands.push_back(Ops[NF + 2]);
4552 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
4553 } else {
4554 for (unsigned I = 0; I < NF; ++I)
4555 Operands.push_back(Ops[NF + I]);
4556 Operands.push_back(Ops[2 * NF]);
4557 Operands.push_back(Ops[2 * NF + 1]);
4558 Operands.push_back(Ops[2 * NF + 2]);
4559 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
4560 }
4561 }
4562 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
4563 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
4564 clang::CharUnits Align =
4565 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
4566 llvm::Value *V;
4567 for (unsigned I = 0; I < NF; ++I) {
4568 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
4569 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
4570 }
4571 return V;
4572 }
4573 break;
4574case RISCVVector::BI__builtin_rvv_vloxseg4ei8_v_tuma:
4575case RISCVVector::BI__builtin_rvv_vloxseg4ei16_v_tuma:
4576case RISCVVector::BI__builtin_rvv_vloxseg4ei32_v_tuma:
4577case RISCVVector::BI__builtin_rvv_vloxseg4ei64_v_tuma:
4578 ID = Intrinsic::riscv_vloxseg4_mask;
4579 NF = 4;
4580 DefaultPolicy = 2;
4581IsMasked = true;
4582
4583 {
4584 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
4585 SmallVector<llvm::Value*, 12> Operands;
4586 if (IsMasked) {
4587 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
4588 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
4589 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
4590 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
4591 for (unsigned I = 0; I < NF; ++I)
4592 Operands.push_back(llvm::PoisonValue::get(ResultType));
4593 Operands.push_back(Ops[NF + 1]);
4594 Operands.push_back(Ops[NF + 2]);
4595 Operands.push_back(Ops[NF]);
4596 Operands.push_back(Ops[NF + 3]);
4597 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
4598 } else {
4599 for (unsigned I = 0; I < NF; ++I)
4600 Operands.push_back(Ops[NF + I + 1]);
4601 Operands.push_back(Ops[2 * NF + 1]);
4602 Operands.push_back(Ops[2 * NF + 2]);
4603 Operands.push_back(Ops[NF]);
4604 Operands.push_back(Ops[2 * NF + 3]);
4605 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
4606 }
4607 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
4608 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 4608, __extension__ __PRETTY_FUNCTION__));
4609 } else {
4610 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
4611 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
4612 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
4613 if (DefaultPolicy == TAIL_AGNOSTIC) {
4614 for (unsigned I = 0; I < NF; ++I)
4615 Operands.push_back(llvm::PoisonValue::get(ResultType));
4616 Operands.push_back(Ops[NF]);
4617 Operands.push_back(Ops[NF + 1]);
4618 Operands.push_back(Ops[NF + 2]);
4619 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
4620 } else {
4621 for (unsigned I = 0; I < NF; ++I)
4622 Operands.push_back(Ops[NF + I]);
4623 Operands.push_back(Ops[2 * NF]);
4624 Operands.push_back(Ops[2 * NF + 1]);
4625 Operands.push_back(Ops[2 * NF + 2]);
4626 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
4627 }
4628 }
4629 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
4630 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
4631 clang::CharUnits Align =
4632 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
4633 llvm::Value *V;
4634 for (unsigned I = 0; I < NF; ++I) {
4635 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
4636 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
4637 }
4638 return V;
4639 }
4640 break;
4641case RISCVVector::BI__builtin_rvv_vloxseg4ei8_v_tama:
4642case RISCVVector::BI__builtin_rvv_vloxseg4ei16_v_tama:
4643case RISCVVector::BI__builtin_rvv_vloxseg4ei32_v_tama:
4644case RISCVVector::BI__builtin_rvv_vloxseg4ei64_v_tama:
4645 ID = Intrinsic::riscv_vloxseg4_mask;
4646 NF = 4;
4647 DefaultPolicy = 3;
4648IsMasked = true;
4649
4650 {
4651 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
4652 SmallVector<llvm::Value*, 12> Operands;
4653 if (IsMasked) {
4654 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
4655 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
4656 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
4657 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
4658 for (unsigned I = 0; I < NF; ++I)
4659 Operands.push_back(llvm::PoisonValue::get(ResultType));
4660 Operands.push_back(Ops[NF + 1]);
4661 Operands.push_back(Ops[NF + 2]);
4662 Operands.push_back(Ops[NF]);
4663 Operands.push_back(Ops[NF + 3]);
4664 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
4665 } else {
4666 for (unsigned I = 0; I < NF; ++I)
4667 Operands.push_back(Ops[NF + I + 1]);
4668 Operands.push_back(Ops[2 * NF + 1]);
4669 Operands.push_back(Ops[2 * NF + 2]);
4670 Operands.push_back(Ops[NF]);
4671 Operands.push_back(Ops[2 * NF + 3]);
4672 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
4673 }
4674 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
4675 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 4675, __extension__ __PRETTY_FUNCTION__));
4676 } else {
4677 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
4678 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
4679 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
4680 if (DefaultPolicy == TAIL_AGNOSTIC) {
4681 for (unsigned I = 0; I < NF; ++I)
4682 Operands.push_back(llvm::PoisonValue::get(ResultType));
4683 Operands.push_back(Ops[NF]);
4684 Operands.push_back(Ops[NF + 1]);
4685 Operands.push_back(Ops[NF + 2]);
4686 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
4687 } else {
4688 for (unsigned I = 0; I < NF; ++I)
4689 Operands.push_back(Ops[NF + I]);
4690 Operands.push_back(Ops[2 * NF]);
4691 Operands.push_back(Ops[2 * NF + 1]);
4692 Operands.push_back(Ops[2 * NF + 2]);
4693 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
4694 }
4695 }
4696 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
4697 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
4698 clang::CharUnits Align =
4699 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
4700 llvm::Value *V;
4701 for (unsigned I = 0; I < NF; ++I) {
4702 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
4703 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
4704 }
4705 return V;
4706 }
4707 break;
4708case RISCVVector::BI__builtin_rvv_vloxseg4ei8_v_tumu:
4709case RISCVVector::BI__builtin_rvv_vloxseg4ei16_v_tumu:
4710case RISCVVector::BI__builtin_rvv_vloxseg4ei32_v_tumu:
4711case RISCVVector::BI__builtin_rvv_vloxseg4ei64_v_tumu:
4712 ID = Intrinsic::riscv_vloxseg4_mask;
4713 NF = 4;
4714 DefaultPolicy = 0;
4715IsMasked = true;
4716
4717 {
4718 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
4719 SmallVector<llvm::Value*, 12> Operands;
4720 if (IsMasked) {
4721 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
4722 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
4723 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
4724 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
4725 for (unsigned I = 0; I < NF; ++I)
4726 Operands.push_back(llvm::PoisonValue::get(ResultType));
4727 Operands.push_back(Ops[NF + 1]);
4728 Operands.push_back(Ops[NF + 2]);
4729 Operands.push_back(Ops[NF]);
4730 Operands.push_back(Ops[NF + 3]);
4731 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
4732 } else {
4733 for (unsigned I = 0; I < NF; ++I)
4734 Operands.push_back(Ops[NF + I + 1]);
4735 Operands.push_back(Ops[2 * NF + 1]);
4736 Operands.push_back(Ops[2 * NF + 2]);
4737 Operands.push_back(Ops[NF]);
4738 Operands.push_back(Ops[2 * NF + 3]);
4739 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
4740 }
4741 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
4742 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 4742, __extension__ __PRETTY_FUNCTION__));
4743 } else {
4744 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
4745 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
4746 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
4747 if (DefaultPolicy == TAIL_AGNOSTIC) {
4748 for (unsigned I = 0; I < NF; ++I)
4749 Operands.push_back(llvm::PoisonValue::get(ResultType));
4750 Operands.push_back(Ops[NF]);
4751 Operands.push_back(Ops[NF + 1]);
4752 Operands.push_back(Ops[NF + 2]);
4753 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
4754 } else {
4755 for (unsigned I = 0; I < NF; ++I)
4756 Operands.push_back(Ops[NF + I]);
4757 Operands.push_back(Ops[2 * NF]);
4758 Operands.push_back(Ops[2 * NF + 1]);
4759 Operands.push_back(Ops[2 * NF + 2]);
4760 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
4761 }
4762 }
4763 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
4764 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
4765 clang::CharUnits Align =
4766 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
4767 llvm::Value *V;
4768 for (unsigned I = 0; I < NF; ++I) {
4769 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
4770 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
4771 }
4772 return V;
4773 }
4774 break;
4775case RISCVVector::BI__builtin_rvv_vloxseg4ei8_v_tamu:
4776case RISCVVector::BI__builtin_rvv_vloxseg4ei16_v_tamu:
4777case RISCVVector::BI__builtin_rvv_vloxseg4ei32_v_tamu:
4778case RISCVVector::BI__builtin_rvv_vloxseg4ei64_v_tamu:
4779 ID = Intrinsic::riscv_vloxseg4_mask;
4780 NF = 4;
4781 DefaultPolicy = 1;
4782IsMasked = true;
4783
4784 {
4785 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
4786 SmallVector<llvm::Value*, 12> Operands;
4787 if (IsMasked) {
4788 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
4789 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
4790 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
4791 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
4792 for (unsigned I = 0; I < NF; ++I)
4793 Operands.push_back(llvm::PoisonValue::get(ResultType));
4794 Operands.push_back(Ops[NF + 1]);
4795 Operands.push_back(Ops[NF + 2]);
4796 Operands.push_back(Ops[NF]);
4797 Operands.push_back(Ops[NF + 3]);
4798 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
4799 } else {
4800 for (unsigned I = 0; I < NF; ++I)
4801 Operands.push_back(Ops[NF + I + 1]);
4802 Operands.push_back(Ops[2 * NF + 1]);
4803 Operands.push_back(Ops[2 * NF + 2]);
4804 Operands.push_back(Ops[NF]);
4805 Operands.push_back(Ops[2 * NF + 3]);
4806 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
4807 }
4808 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
4809 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 4809, __extension__ __PRETTY_FUNCTION__));
4810 } else {
4811 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
4812 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
4813 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
4814 if (DefaultPolicy == TAIL_AGNOSTIC) {
4815 for (unsigned I = 0; I < NF; ++I)
4816 Operands.push_back(llvm::PoisonValue::get(ResultType));
4817 Operands.push_back(Ops[NF]);
4818 Operands.push_back(Ops[NF + 1]);
4819 Operands.push_back(Ops[NF + 2]);
4820 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
4821 } else {
4822 for (unsigned I = 0; I < NF; ++I)
4823 Operands.push_back(Ops[NF + I]);
4824 Operands.push_back(Ops[2 * NF]);
4825 Operands.push_back(Ops[2 * NF + 1]);
4826 Operands.push_back(Ops[2 * NF + 2]);
4827 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
4828 }
4829 }
4830 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
4831 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
4832 clang::CharUnits Align =
4833 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
4834 llvm::Value *V;
4835 for (unsigned I = 0; I < NF; ++I) {
4836 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
4837 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
4838 }
4839 return V;
4840 }
4841 break;
4842case RISCVVector::BI__builtin_rvv_vloxseg5ei8_v_tu:
4843case RISCVVector::BI__builtin_rvv_vloxseg5ei16_v_tu:
4844case RISCVVector::BI__builtin_rvv_vloxseg5ei32_v_tu:
4845case RISCVVector::BI__builtin_rvv_vloxseg5ei64_v_tu:
4846 ID = Intrinsic::riscv_vloxseg5;
4847 NF = 5;
4848 DefaultPolicy = 0;
4849IsMasked = false;
4850
4851 {
4852 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
4853 SmallVector<llvm::Value*, 12> Operands;
4854 if (IsMasked) {
4855 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
4856 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
4857 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
4858 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
4859 for (unsigned I = 0; I < NF; ++I)
4860 Operands.push_back(llvm::PoisonValue::get(ResultType));
4861 Operands.push_back(Ops[NF + 1]);
4862 Operands.push_back(Ops[NF + 2]);
4863 Operands.push_back(Ops[NF]);
4864 Operands.push_back(Ops[NF + 3]);
4865 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
4866 } else {
4867 for (unsigned I = 0; I < NF; ++I)
4868 Operands.push_back(Ops[NF + I + 1]);
4869 Operands.push_back(Ops[2 * NF + 1]);
4870 Operands.push_back(Ops[2 * NF + 2]);
4871 Operands.push_back(Ops[NF]);
4872 Operands.push_back(Ops[2 * NF + 3]);
4873 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
4874 }
4875 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
4876 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 4876, __extension__ __PRETTY_FUNCTION__));
4877 } else {
4878 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
4879 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
4880 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
4881 if (DefaultPolicy == TAIL_AGNOSTIC) {
4882 for (unsigned I = 0; I < NF; ++I)
4883 Operands.push_back(llvm::PoisonValue::get(ResultType));
4884 Operands.push_back(Ops[NF]);
4885 Operands.push_back(Ops[NF + 1]);
4886 Operands.push_back(Ops[NF + 2]);
4887 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
4888 } else {
4889 for (unsigned I = 0; I < NF; ++I)
4890 Operands.push_back(Ops[NF + I]);
4891 Operands.push_back(Ops[2 * NF]);
4892 Operands.push_back(Ops[2 * NF + 1]);
4893 Operands.push_back(Ops[2 * NF + 2]);
4894 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
4895 }
4896 }
4897 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
4898 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
4899 clang::CharUnits Align =
4900 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
4901 llvm::Value *V;
4902 for (unsigned I = 0; I < NF; ++I) {
4903 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
4904 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
4905 }
4906 return V;
4907 }
4908 break;
4909case RISCVVector::BI__builtin_rvv_vloxseg5ei8_v_ta:
4910case RISCVVector::BI__builtin_rvv_vloxseg5ei16_v_ta:
4911case RISCVVector::BI__builtin_rvv_vloxseg5ei32_v_ta:
4912case RISCVVector::BI__builtin_rvv_vloxseg5ei64_v_ta:
4913 ID = Intrinsic::riscv_vloxseg5;
4914 NF = 5;
4915 DefaultPolicy = 1;
4916IsMasked = false;
4917
4918 {
4919 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
4920 SmallVector<llvm::Value*, 12> Operands;
4921 if (IsMasked) {
4922 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
4923 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
4924 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
4925 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
4926 for (unsigned I = 0; I < NF; ++I)
4927 Operands.push_back(llvm::PoisonValue::get(ResultType));
4928 Operands.push_back(Ops[NF + 1]);
4929 Operands.push_back(Ops[NF + 2]);
4930 Operands.push_back(Ops[NF]);
4931 Operands.push_back(Ops[NF + 3]);
4932 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
4933 } else {
4934 for (unsigned I = 0; I < NF; ++I)
4935 Operands.push_back(Ops[NF + I + 1]);
4936 Operands.push_back(Ops[2 * NF + 1]);
4937 Operands.push_back(Ops[2 * NF + 2]);
4938 Operands.push_back(Ops[NF]);
4939 Operands.push_back(Ops[2 * NF + 3]);
4940 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
4941 }
4942 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
4943 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 4943, __extension__ __PRETTY_FUNCTION__));
4944 } else {
4945 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
4946 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
4947 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
4948 if (DefaultPolicy == TAIL_AGNOSTIC) {
4949 for (unsigned I = 0; I < NF; ++I)
4950 Operands.push_back(llvm::PoisonValue::get(ResultType));
4951 Operands.push_back(Ops[NF]);
4952 Operands.push_back(Ops[NF + 1]);
4953 Operands.push_back(Ops[NF + 2]);
4954 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
4955 } else {
4956 for (unsigned I = 0; I < NF; ++I)
4957 Operands.push_back(Ops[NF + I]);
4958 Operands.push_back(Ops[2 * NF]);
4959 Operands.push_back(Ops[2 * NF + 1]);
4960 Operands.push_back(Ops[2 * NF + 2]);
4961 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
4962 }
4963 }
4964 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
4965 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
4966 clang::CharUnits Align =
4967 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
4968 llvm::Value *V;
4969 for (unsigned I = 0; I < NF; ++I) {
4970 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
4971 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
4972 }
4973 return V;
4974 }
4975 break;
4976case RISCVVector::BI__builtin_rvv_vloxseg5ei8_v_tuma:
4977case RISCVVector::BI__builtin_rvv_vloxseg5ei16_v_tuma:
4978case RISCVVector::BI__builtin_rvv_vloxseg5ei32_v_tuma:
4979case RISCVVector::BI__builtin_rvv_vloxseg5ei64_v_tuma:
4980 ID = Intrinsic::riscv_vloxseg5_mask;
4981 NF = 5;
4982 DefaultPolicy = 2;
4983IsMasked = true;
4984
4985 {
4986 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
4987 SmallVector<llvm::Value*, 12> Operands;
4988 if (IsMasked) {
4989 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
4990 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
4991 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
4992 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
4993 for (unsigned I = 0; I < NF; ++I)
4994 Operands.push_back(llvm::PoisonValue::get(ResultType));
4995 Operands.push_back(Ops[NF + 1]);
4996 Operands.push_back(Ops[NF + 2]);
4997 Operands.push_back(Ops[NF]);
4998 Operands.push_back(Ops[NF + 3]);
4999 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
5000 } else {
5001 for (unsigned I = 0; I < NF; ++I)
5002 Operands.push_back(Ops[NF + I + 1]);
5003 Operands.push_back(Ops[2 * NF + 1]);
5004 Operands.push_back(Ops[2 * NF + 2]);
5005 Operands.push_back(Ops[NF]);
5006 Operands.push_back(Ops[2 * NF + 3]);
5007 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
5008 }
5009 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
5010 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 5010, __extension__ __PRETTY_FUNCTION__));
5011 } else {
5012 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
5013 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
5014 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
5015 if (DefaultPolicy == TAIL_AGNOSTIC) {
5016 for (unsigned I = 0; I < NF; ++I)
5017 Operands.push_back(llvm::PoisonValue::get(ResultType));
5018 Operands.push_back(Ops[NF]);
5019 Operands.push_back(Ops[NF + 1]);
5020 Operands.push_back(Ops[NF + 2]);
5021 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
5022 } else {
5023 for (unsigned I = 0; I < NF; ++I)
5024 Operands.push_back(Ops[NF + I]);
5025 Operands.push_back(Ops[2 * NF]);
5026 Operands.push_back(Ops[2 * NF + 1]);
5027 Operands.push_back(Ops[2 * NF + 2]);
5028 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
5029 }
5030 }
5031 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
5032 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
5033 clang::CharUnits Align =
5034 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
5035 llvm::Value *V;
5036 for (unsigned I = 0; I < NF; ++I) {
5037 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
5038 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
5039 }
5040 return V;
5041 }
5042 break;
5043case RISCVVector::BI__builtin_rvv_vloxseg5ei8_v_tama:
5044case RISCVVector::BI__builtin_rvv_vloxseg5ei16_v_tama:
5045case RISCVVector::BI__builtin_rvv_vloxseg5ei32_v_tama:
5046case RISCVVector::BI__builtin_rvv_vloxseg5ei64_v_tama:
5047 ID = Intrinsic::riscv_vloxseg5_mask;
5048 NF = 5;
5049 DefaultPolicy = 3;
5050IsMasked = true;
5051
5052 {
5053 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
5054 SmallVector<llvm::Value*, 12> Operands;
5055 if (IsMasked) {
5056 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
5057 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
5058 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
5059 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
5060 for (unsigned I = 0; I < NF; ++I)
5061 Operands.push_back(llvm::PoisonValue::get(ResultType));
5062 Operands.push_back(Ops[NF + 1]);
5063 Operands.push_back(Ops[NF + 2]);
5064 Operands.push_back(Ops[NF]);
5065 Operands.push_back(Ops[NF + 3]);
5066 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
5067 } else {
5068 for (unsigned I = 0; I < NF; ++I)
5069 Operands.push_back(Ops[NF + I + 1]);
5070 Operands.push_back(Ops[2 * NF + 1]);
5071 Operands.push_back(Ops[2 * NF + 2]);
5072 Operands.push_back(Ops[NF]);
5073 Operands.push_back(Ops[2 * NF + 3]);
5074 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
5075 }
5076 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
5077 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 5077, __extension__ __PRETTY_FUNCTION__));
5078 } else {
5079 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
5080 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
5081 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
5082 if (DefaultPolicy == TAIL_AGNOSTIC) {
5083 for (unsigned I = 0; I < NF; ++I)
5084 Operands.push_back(llvm::PoisonValue::get(ResultType));
5085 Operands.push_back(Ops[NF]);
5086 Operands.push_back(Ops[NF + 1]);
5087 Operands.push_back(Ops[NF + 2]);
5088 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
5089 } else {
5090 for (unsigned I = 0; I < NF; ++I)
5091 Operands.push_back(Ops[NF + I]);
5092 Operands.push_back(Ops[2 * NF]);
5093 Operands.push_back(Ops[2 * NF + 1]);
5094 Operands.push_back(Ops[2 * NF + 2]);
5095 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
5096 }
5097 }
5098 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
5099 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
5100 clang::CharUnits Align =
5101 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
5102 llvm::Value *V;
5103 for (unsigned I = 0; I < NF; ++I) {
5104 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
5105 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
5106 }
5107 return V;
5108 }
5109 break;
5110case RISCVVector::BI__builtin_rvv_vloxseg5ei8_v_tumu:
5111case RISCVVector::BI__builtin_rvv_vloxseg5ei16_v_tumu:
5112case RISCVVector::BI__builtin_rvv_vloxseg5ei32_v_tumu:
5113case RISCVVector::BI__builtin_rvv_vloxseg5ei64_v_tumu:
5114 ID = Intrinsic::riscv_vloxseg5_mask;
5115 NF = 5;
5116 DefaultPolicy = 0;
5117IsMasked = true;
5118
5119 {
5120 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
5121 SmallVector<llvm::Value*, 12> Operands;
5122 if (IsMasked) {
5123 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
5124 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
5125 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
5126 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
5127 for (unsigned I = 0; I < NF; ++I)
5128 Operands.push_back(llvm::PoisonValue::get(ResultType));
5129 Operands.push_back(Ops[NF + 1]);
5130 Operands.push_back(Ops[NF + 2]);
5131 Operands.push_back(Ops[NF]);
5132 Operands.push_back(Ops[NF + 3]);
5133 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
5134 } else {
5135 for (unsigned I = 0; I < NF; ++I)
5136 Operands.push_back(Ops[NF + I + 1]);
5137 Operands.push_back(Ops[2 * NF + 1]);
5138 Operands.push_back(Ops[2 * NF + 2]);
5139 Operands.push_back(Ops[NF]);
5140 Operands.push_back(Ops[2 * NF + 3]);
5141 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
5142 }
5143 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
5144 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 5144, __extension__ __PRETTY_FUNCTION__));
5145 } else {
5146 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
5147 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
5148 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
5149 if (DefaultPolicy == TAIL_AGNOSTIC) {
5150 for (unsigned I = 0; I < NF; ++I)
5151 Operands.push_back(llvm::PoisonValue::get(ResultType));
5152 Operands.push_back(Ops[NF]);
5153 Operands.push_back(Ops[NF + 1]);
5154 Operands.push_back(Ops[NF + 2]);
5155 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
5156 } else {
5157 for (unsigned I = 0; I < NF; ++I)
5158 Operands.push_back(Ops[NF + I]);
5159 Operands.push_back(Ops[2 * NF]);
5160 Operands.push_back(Ops[2 * NF + 1]);
5161 Operands.push_back(Ops[2 * NF + 2]);
5162 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
5163 }
5164 }
5165 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
5166 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
5167 clang::CharUnits Align =
5168 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
5169 llvm::Value *V;
5170 for (unsigned I = 0; I < NF; ++I) {
5171 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
5172 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
5173 }
5174 return V;
5175 }
5176 break;
5177case RISCVVector::BI__builtin_rvv_vloxseg5ei8_v_tamu:
5178case RISCVVector::BI__builtin_rvv_vloxseg5ei16_v_tamu:
5179case RISCVVector::BI__builtin_rvv_vloxseg5ei32_v_tamu:
5180case RISCVVector::BI__builtin_rvv_vloxseg5ei64_v_tamu:
5181 ID = Intrinsic::riscv_vloxseg5_mask;
5182 NF = 5;
5183 DefaultPolicy = 1;
5184IsMasked = true;
5185
5186 {
5187 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
5188 SmallVector<llvm::Value*, 12> Operands;
5189 if (IsMasked) {
5190 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
5191 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
5192 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
5193 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
5194 for (unsigned I = 0; I < NF; ++I)
5195 Operands.push_back(llvm::PoisonValue::get(ResultType));
5196 Operands.push_back(Ops[NF + 1]);
5197 Operands.push_back(Ops[NF + 2]);
5198 Operands.push_back(Ops[NF]);
5199 Operands.push_back(Ops[NF + 3]);
5200 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
5201 } else {
5202 for (unsigned I = 0; I < NF; ++I)
5203 Operands.push_back(Ops[NF + I + 1]);
5204 Operands.push_back(Ops[2 * NF + 1]);
5205 Operands.push_back(Ops[2 * NF + 2]);
5206 Operands.push_back(Ops[NF]);
5207 Operands.push_back(Ops[2 * NF + 3]);
5208 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
5209 }
5210 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
5211 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 5211, __extension__ __PRETTY_FUNCTION__));
5212 } else {
5213 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
5214 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
5215 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
5216 if (DefaultPolicy == TAIL_AGNOSTIC) {
5217 for (unsigned I = 0; I < NF; ++I)
5218 Operands.push_back(llvm::PoisonValue::get(ResultType));
5219 Operands.push_back(Ops[NF]);
5220 Operands.push_back(Ops[NF + 1]);
5221 Operands.push_back(Ops[NF + 2]);
5222 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
5223 } else {
5224 for (unsigned I = 0; I < NF; ++I)
5225 Operands.push_back(Ops[NF + I]);
5226 Operands.push_back(Ops[2 * NF]);
5227 Operands.push_back(Ops[2 * NF + 1]);
5228 Operands.push_back(Ops[2 * NF + 2]);
5229 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
5230 }
5231 }
5232 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
5233 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
5234 clang::CharUnits Align =
5235 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
5236 llvm::Value *V;
5237 for (unsigned I = 0; I < NF; ++I) {
5238 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
5239 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
5240 }
5241 return V;
5242 }
5243 break;
5244case RISCVVector::BI__builtin_rvv_vloxseg6ei8_v_tu:
5245case RISCVVector::BI__builtin_rvv_vloxseg6ei16_v_tu:
5246case RISCVVector::BI__builtin_rvv_vloxseg6ei32_v_tu:
5247case RISCVVector::BI__builtin_rvv_vloxseg6ei64_v_tu:
5248 ID = Intrinsic::riscv_vloxseg6;
5249 NF = 6;
5250 DefaultPolicy = 0;
5251IsMasked = false;
5252
5253 {
5254 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
5255 SmallVector<llvm::Value*, 12> Operands;
5256 if (IsMasked) {
5257 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
5258 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
5259 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
5260 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
5261 for (unsigned I = 0; I < NF; ++I)
5262 Operands.push_back(llvm::PoisonValue::get(ResultType));
5263 Operands.push_back(Ops[NF + 1]);
5264 Operands.push_back(Ops[NF + 2]);
5265 Operands.push_back(Ops[NF]);
5266 Operands.push_back(Ops[NF + 3]);
5267 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
5268 } else {
5269 for (unsigned I = 0; I < NF; ++I)
5270 Operands.push_back(Ops[NF + I + 1]);
5271 Operands.push_back(Ops[2 * NF + 1]);
5272 Operands.push_back(Ops[2 * NF + 2]);
5273 Operands.push_back(Ops[NF]);
5274 Operands.push_back(Ops[2 * NF + 3]);
5275 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
5276 }
5277 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
5278 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 5278, __extension__ __PRETTY_FUNCTION__));
5279 } else {
5280 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
5281 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
5282 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
5283 if (DefaultPolicy == TAIL_AGNOSTIC) {
5284 for (unsigned I = 0; I < NF; ++I)
5285 Operands.push_back(llvm::PoisonValue::get(ResultType));
5286 Operands.push_back(Ops[NF]);
5287 Operands.push_back(Ops[NF + 1]);
5288 Operands.push_back(Ops[NF + 2]);
5289 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
5290 } else {
5291 for (unsigned I = 0; I < NF; ++I)
5292 Operands.push_back(Ops[NF + I]);
5293 Operands.push_back(Ops[2 * NF]);
5294 Operands.push_back(Ops[2 * NF + 1]);
5295 Operands.push_back(Ops[2 * NF + 2]);
5296 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
5297 }
5298 }
5299 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
5300 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
5301 clang::CharUnits Align =
5302 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
5303 llvm::Value *V;
5304 for (unsigned I = 0; I < NF; ++I) {
5305 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
5306 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
5307 }
5308 return V;
5309 }
5310 break;
5311case RISCVVector::BI__builtin_rvv_vloxseg6ei8_v_ta:
5312case RISCVVector::BI__builtin_rvv_vloxseg6ei16_v_ta:
5313case RISCVVector::BI__builtin_rvv_vloxseg6ei32_v_ta:
5314case RISCVVector::BI__builtin_rvv_vloxseg6ei64_v_ta:
5315 ID = Intrinsic::riscv_vloxseg6;
5316 NF = 6;
5317 DefaultPolicy = 1;
5318IsMasked = false;
5319
5320 {
5321 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
5322 SmallVector<llvm::Value*, 12> Operands;
5323 if (IsMasked) {
5324 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
5325 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
5326 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
5327 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
5328 for (unsigned I = 0; I < NF; ++I)
5329 Operands.push_back(llvm::PoisonValue::get(ResultType));
5330 Operands.push_back(Ops[NF + 1]);
5331 Operands.push_back(Ops[NF + 2]);
5332 Operands.push_back(Ops[NF]);
5333 Operands.push_back(Ops[NF + 3]);
5334 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
5335 } else {
5336 for (unsigned I = 0; I < NF; ++I)
5337 Operands.push_back(Ops[NF + I + 1]);
5338 Operands.push_back(Ops[2 * NF + 1]);
5339 Operands.push_back(Ops[2 * NF + 2]);
5340 Operands.push_back(Ops[NF]);
5341 Operands.push_back(Ops[2 * NF + 3]);
5342 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
5343 }
5344 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
5345 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 5345, __extension__ __PRETTY_FUNCTION__));
5346 } else {
5347 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
5348 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
5349 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
5350 if (DefaultPolicy == TAIL_AGNOSTIC) {
5351 for (unsigned I = 0; I < NF; ++I)
5352 Operands.push_back(llvm::PoisonValue::get(ResultType));
5353 Operands.push_back(Ops[NF]);
5354 Operands.push_back(Ops[NF + 1]);
5355 Operands.push_back(Ops[NF + 2]);
5356 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
5357 } else {
5358 for (unsigned I = 0; I < NF; ++I)
5359 Operands.push_back(Ops[NF + I]);
5360 Operands.push_back(Ops[2 * NF]);
5361 Operands.push_back(Ops[2 * NF + 1]);
5362 Operands.push_back(Ops[2 * NF + 2]);
5363 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
5364 }
5365 }
5366 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
5367 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
5368 clang::CharUnits Align =
5369 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
5370 llvm::Value *V;
5371 for (unsigned I = 0; I < NF; ++I) {
5372 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
5373 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
5374 }
5375 return V;
5376 }
5377 break;
5378case RISCVVector::BI__builtin_rvv_vloxseg6ei8_v_tuma:
5379case RISCVVector::BI__builtin_rvv_vloxseg6ei16_v_tuma:
5380case RISCVVector::BI__builtin_rvv_vloxseg6ei32_v_tuma:
5381case RISCVVector::BI__builtin_rvv_vloxseg6ei64_v_tuma:
5382 ID = Intrinsic::riscv_vloxseg6_mask;
5383 NF = 6;
5384 DefaultPolicy = 2;
5385IsMasked = true;
5386
5387 {
5388 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
5389 SmallVector<llvm::Value*, 12> Operands;
5390 if (IsMasked) {
5391 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
5392 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
5393 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
5394 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
5395 for (unsigned I = 0; I < NF; ++I)
5396 Operands.push_back(llvm::PoisonValue::get(ResultType));
5397 Operands.push_back(Ops[NF + 1]);
5398 Operands.push_back(Ops[NF + 2]);
5399 Operands.push_back(Ops[NF]);
5400 Operands.push_back(Ops[NF + 3]);
5401 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
5402 } else {
5403 for (unsigned I = 0; I < NF; ++I)
5404 Operands.push_back(Ops[NF + I + 1]);
5405 Operands.push_back(Ops[2 * NF + 1]);
5406 Operands.push_back(Ops[2 * NF + 2]);
5407 Operands.push_back(Ops[NF]);
5408 Operands.push_back(Ops[2 * NF + 3]);
5409 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
5410 }
5411 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
5412 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 5412, __extension__ __PRETTY_FUNCTION__));
5413 } else {
5414 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
5415 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
5416 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
5417 if (DefaultPolicy == TAIL_AGNOSTIC) {
5418 for (unsigned I = 0; I < NF; ++I)
5419 Operands.push_back(llvm::PoisonValue::get(ResultType));
5420 Operands.push_back(Ops[NF]);
5421 Operands.push_back(Ops[NF + 1]);
5422 Operands.push_back(Ops[NF + 2]);
5423 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
5424 } else {
5425 for (unsigned I = 0; I < NF; ++I)
5426 Operands.push_back(Ops[NF + I]);
5427 Operands.push_back(Ops[2 * NF]);
5428 Operands.push_back(Ops[2 * NF + 1]);
5429 Operands.push_back(Ops[2 * NF + 2]);
5430 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
5431 }
5432 }
5433 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
5434 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
5435 clang::CharUnits Align =
5436 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
5437 llvm::Value *V;
5438 for (unsigned I = 0; I < NF; ++I) {
5439 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
5440 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
5441 }
5442 return V;
5443 }
5444 break;
5445case RISCVVector::BI__builtin_rvv_vloxseg6ei8_v_tama:
5446case RISCVVector::BI__builtin_rvv_vloxseg6ei16_v_tama:
5447case RISCVVector::BI__builtin_rvv_vloxseg6ei32_v_tama:
5448case RISCVVector::BI__builtin_rvv_vloxseg6ei64_v_tama:
5449 ID = Intrinsic::riscv_vloxseg6_mask;
5450 NF = 6;
5451 DefaultPolicy = 3;
5452IsMasked = true;
5453
5454 {
5455 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
5456 SmallVector<llvm::Value*, 12> Operands;
5457 if (IsMasked) {
5458 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
5459 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
5460 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
5461 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
5462 for (unsigned I = 0; I < NF; ++I)
5463 Operands.push_back(llvm::PoisonValue::get(ResultType));
5464 Operands.push_back(Ops[NF + 1]);
5465 Operands.push_back(Ops[NF + 2]);
5466 Operands.push_back(Ops[NF]);
5467 Operands.push_back(Ops[NF + 3]);
5468 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
5469 } else {
5470 for (unsigned I = 0; I < NF; ++I)
5471 Operands.push_back(Ops[NF + I + 1]);
5472 Operands.push_back(Ops[2 * NF + 1]);
5473 Operands.push_back(Ops[2 * NF + 2]);
5474 Operands.push_back(Ops[NF]);
5475 Operands.push_back(Ops[2 * NF + 3]);
5476 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
5477 }
5478 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
5479 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 5479, __extension__ __PRETTY_FUNCTION__));
5480 } else {
5481 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
5482 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
5483 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
5484 if (DefaultPolicy == TAIL_AGNOSTIC) {
5485 for (unsigned I = 0; I < NF; ++I)
5486 Operands.push_back(llvm::PoisonValue::get(ResultType));
5487 Operands.push_back(Ops[NF]);
5488 Operands.push_back(Ops[NF + 1]);
5489 Operands.push_back(Ops[NF + 2]);
5490 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
5491 } else {
5492 for (unsigned I = 0; I < NF; ++I)
5493 Operands.push_back(Ops[NF + I]);
5494 Operands.push_back(Ops[2 * NF]);
5495 Operands.push_back(Ops[2 * NF + 1]);
5496 Operands.push_back(Ops[2 * NF + 2]);
5497 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
5498 }
5499 }
5500 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
5501 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
5502 clang::CharUnits Align =
5503 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
5504 llvm::Value *V;
5505 for (unsigned I = 0; I < NF; ++I) {
5506 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
5507 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
5508 }
5509 return V;
5510 }
5511 break;
5512case RISCVVector::BI__builtin_rvv_vloxseg6ei8_v_tumu:
5513case RISCVVector::BI__builtin_rvv_vloxseg6ei16_v_tumu:
5514case RISCVVector::BI__builtin_rvv_vloxseg6ei32_v_tumu:
5515case RISCVVector::BI__builtin_rvv_vloxseg6ei64_v_tumu:
5516 ID = Intrinsic::riscv_vloxseg6_mask;
5517 NF = 6;
5518 DefaultPolicy = 0;
5519IsMasked = true;
5520
5521 {
5522 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
5523 SmallVector<llvm::Value*, 12> Operands;
5524 if (IsMasked) {
5525 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
5526 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
5527 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
5528 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
5529 for (unsigned I = 0; I < NF; ++I)
5530 Operands.push_back(llvm::PoisonValue::get(ResultType));
5531 Operands.push_back(Ops[NF + 1]);
5532 Operands.push_back(Ops[NF + 2]);
5533 Operands.push_back(Ops[NF]);
5534 Operands.push_back(Ops[NF + 3]);
5535 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
5536 } else {
5537 for (unsigned I = 0; I < NF; ++I)
5538 Operands.push_back(Ops[NF + I + 1]);
5539 Operands.push_back(Ops[2 * NF + 1]);
5540 Operands.push_back(Ops[2 * NF + 2]);
5541 Operands.push_back(Ops[NF]);
5542 Operands.push_back(Ops[2 * NF + 3]);
5543 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
5544 }
5545 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
5546 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 5546, __extension__ __PRETTY_FUNCTION__));
5547 } else {
5548 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
5549 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
5550 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
5551 if (DefaultPolicy == TAIL_AGNOSTIC) {
5552 for (unsigned I = 0; I < NF; ++I)
5553 Operands.push_back(llvm::PoisonValue::get(ResultType));
5554 Operands.push_back(Ops[NF]);
5555 Operands.push_back(Ops[NF + 1]);
5556 Operands.push_back(Ops[NF + 2]);
5557 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
5558 } else {
5559 for (unsigned I = 0; I < NF; ++I)
5560 Operands.push_back(Ops[NF + I]);
5561 Operands.push_back(Ops[2 * NF]);
5562 Operands.push_back(Ops[2 * NF + 1]);
5563 Operands.push_back(Ops[2 * NF + 2]);
5564 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
5565 }
5566 }
5567 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
5568 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
5569 clang::CharUnits Align =
5570 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
5571 llvm::Value *V;
5572 for (unsigned I = 0; I < NF; ++I) {
5573 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
5574 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
5575 }
5576 return V;
5577 }
5578 break;
5579case RISCVVector::BI__builtin_rvv_vloxseg6ei8_v_tamu:
5580case RISCVVector::BI__builtin_rvv_vloxseg6ei16_v_tamu:
5581case RISCVVector::BI__builtin_rvv_vloxseg6ei32_v_tamu:
5582case RISCVVector::BI__builtin_rvv_vloxseg6ei64_v_tamu:
5583 ID = Intrinsic::riscv_vloxseg6_mask;
5584 NF = 6;
5585 DefaultPolicy = 1;
5586IsMasked = true;
5587
5588 {
5589 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
5590 SmallVector<llvm::Value*, 12> Operands;
5591 if (IsMasked) {
5592 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
5593 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
5594 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
5595 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
5596 for (unsigned I = 0; I < NF; ++I)
5597 Operands.push_back(llvm::PoisonValue::get(ResultType));
5598 Operands.push_back(Ops[NF + 1]);
5599 Operands.push_back(Ops[NF + 2]);
5600 Operands.push_back(Ops[NF]);
5601 Operands.push_back(Ops[NF + 3]);
5602 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
5603 } else {
5604 for (unsigned I = 0; I < NF; ++I)
5605 Operands.push_back(Ops[NF + I + 1]);
5606 Operands.push_back(Ops[2 * NF + 1]);
5607 Operands.push_back(Ops[2 * NF + 2]);
5608 Operands.push_back(Ops[NF]);
5609 Operands.push_back(Ops[2 * NF + 3]);
5610 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
5611 }
5612 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
5613 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 5613, __extension__ __PRETTY_FUNCTION__));
5614 } else {
5615 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
5616 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
5617 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
5618 if (DefaultPolicy == TAIL_AGNOSTIC) {
5619 for (unsigned I = 0; I < NF; ++I)
5620 Operands.push_back(llvm::PoisonValue::get(ResultType));
5621 Operands.push_back(Ops[NF]);
5622 Operands.push_back(Ops[NF + 1]);
5623 Operands.push_back(Ops[NF + 2]);
5624 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
5625 } else {
5626 for (unsigned I = 0; I < NF; ++I)
5627 Operands.push_back(Ops[NF + I]);
5628 Operands.push_back(Ops[2 * NF]);
5629 Operands.push_back(Ops[2 * NF + 1]);
5630 Operands.push_back(Ops[2 * NF + 2]);
5631 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
5632 }
5633 }
5634 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
5635 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
5636 clang::CharUnits Align =
5637 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
5638 llvm::Value *V;
5639 for (unsigned I = 0; I < NF; ++I) {
5640 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
5641 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
5642 }
5643 return V;
5644 }
5645 break;
5646case RISCVVector::BI__builtin_rvv_vloxseg7ei8_v_tu:
5647case RISCVVector::BI__builtin_rvv_vloxseg7ei16_v_tu:
5648case RISCVVector::BI__builtin_rvv_vloxseg7ei32_v_tu:
5649case RISCVVector::BI__builtin_rvv_vloxseg7ei64_v_tu:
5650 ID = Intrinsic::riscv_vloxseg7;
5651 NF = 7;
5652 DefaultPolicy = 0;
5653IsMasked = false;
5654
5655 {
5656 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
5657 SmallVector<llvm::Value*, 12> Operands;
5658 if (IsMasked) {
5659 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
5660 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
5661 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
5662 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
5663 for (unsigned I = 0; I < NF; ++I)
5664 Operands.push_back(llvm::PoisonValue::get(ResultType));
5665 Operands.push_back(Ops[NF + 1]);
5666 Operands.push_back(Ops[NF + 2]);
5667 Operands.push_back(Ops[NF]);
5668 Operands.push_back(Ops[NF + 3]);
5669 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
5670 } else {
5671 for (unsigned I = 0; I < NF; ++I)
5672 Operands.push_back(Ops[NF + I + 1]);
5673 Operands.push_back(Ops[2 * NF + 1]);
5674 Operands.push_back(Ops[2 * NF + 2]);
5675 Operands.push_back(Ops[NF]);
5676 Operands.push_back(Ops[2 * NF + 3]);
5677 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
5678 }
5679 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
5680 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 5680, __extension__ __PRETTY_FUNCTION__));
5681 } else {
5682 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
5683 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
5684 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
5685 if (DefaultPolicy == TAIL_AGNOSTIC) {
5686 for (unsigned I = 0; I < NF; ++I)
5687 Operands.push_back(llvm::PoisonValue::get(ResultType));
5688 Operands.push_back(Ops[NF]);
5689 Operands.push_back(Ops[NF + 1]);
5690 Operands.push_back(Ops[NF + 2]);
5691 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
5692 } else {
5693 for (unsigned I = 0; I < NF; ++I)
5694 Operands.push_back(Ops[NF + I]);
5695 Operands.push_back(Ops[2 * NF]);
5696 Operands.push_back(Ops[2 * NF + 1]);
5697 Operands.push_back(Ops[2 * NF + 2]);
5698 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
5699 }
5700 }
5701 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
5702 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
5703 clang::CharUnits Align =
5704 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
5705 llvm::Value *V;
5706 for (unsigned I = 0; I < NF; ++I) {
5707 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
5708 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
5709 }
5710 return V;
5711 }
5712 break;
5713case RISCVVector::BI__builtin_rvv_vloxseg7ei8_v_ta:
5714case RISCVVector::BI__builtin_rvv_vloxseg7ei16_v_ta:
5715case RISCVVector::BI__builtin_rvv_vloxseg7ei32_v_ta:
5716case RISCVVector::BI__builtin_rvv_vloxseg7ei64_v_ta:
5717 ID = Intrinsic::riscv_vloxseg7;
5718 NF = 7;
5719 DefaultPolicy = 1;
5720IsMasked = false;
5721
5722 {
5723 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
5724 SmallVector<llvm::Value*, 12> Operands;
5725 if (IsMasked) {
5726 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
5727 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
5728 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
5729 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
5730 for (unsigned I = 0; I < NF; ++I)
5731 Operands.push_back(llvm::PoisonValue::get(ResultType));
5732 Operands.push_back(Ops[NF + 1]);
5733 Operands.push_back(Ops[NF + 2]);
5734 Operands.push_back(Ops[NF]);
5735 Operands.push_back(Ops[NF + 3]);
5736 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
5737 } else {
5738 for (unsigned I = 0; I < NF; ++I)
5739 Operands.push_back(Ops[NF + I + 1]);
5740 Operands.push_back(Ops[2 * NF + 1]);
5741 Operands.push_back(Ops[2 * NF + 2]);
5742 Operands.push_back(Ops[NF]);
5743 Operands.push_back(Ops[2 * NF + 3]);
5744 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
5745 }
5746 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
5747 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 5747, __extension__ __PRETTY_FUNCTION__));
5748 } else {
5749 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
5750 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
5751 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
5752 if (DefaultPolicy == TAIL_AGNOSTIC) {
5753 for (unsigned I = 0; I < NF; ++I)
5754 Operands.push_back(llvm::PoisonValue::get(ResultType));
5755 Operands.push_back(Ops[NF]);
5756 Operands.push_back(Ops[NF + 1]);
5757 Operands.push_back(Ops[NF + 2]);
5758 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
5759 } else {
5760 for (unsigned I = 0; I < NF; ++I)
5761 Operands.push_back(Ops[NF + I]);
5762 Operands.push_back(Ops[2 * NF]);
5763 Operands.push_back(Ops[2 * NF + 1]);
5764 Operands.push_back(Ops[2 * NF + 2]);
5765 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
5766 }
5767 }
5768 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
5769 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
5770 clang::CharUnits Align =
5771 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
5772 llvm::Value *V;
5773 for (unsigned I = 0; I < NF; ++I) {
5774 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
5775 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
5776 }
5777 return V;
5778 }
5779 break;
5780case RISCVVector::BI__builtin_rvv_vloxseg7ei8_v_tuma:
5781case RISCVVector::BI__builtin_rvv_vloxseg7ei16_v_tuma:
5782case RISCVVector::BI__builtin_rvv_vloxseg7ei32_v_tuma:
5783case RISCVVector::BI__builtin_rvv_vloxseg7ei64_v_tuma:
5784 ID = Intrinsic::riscv_vloxseg7_mask;
5785 NF = 7;
5786 DefaultPolicy = 2;
5787IsMasked = true;
5788
5789 {
5790 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
5791 SmallVector<llvm::Value*, 12> Operands;
5792 if (IsMasked) {
5793 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
5794 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
5795 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
5796 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
5797 for (unsigned I = 0; I < NF; ++I)
5798 Operands.push_back(llvm::PoisonValue::get(ResultType));
5799 Operands.push_back(Ops[NF + 1]);
5800 Operands.push_back(Ops[NF + 2]);
5801 Operands.push_back(Ops[NF]);
5802 Operands.push_back(Ops[NF + 3]);
5803 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
5804 } else {
5805 for (unsigned I = 0; I < NF; ++I)
5806 Operands.push_back(Ops[NF + I + 1]);
5807 Operands.push_back(Ops[2 * NF + 1]);
5808 Operands.push_back(Ops[2 * NF + 2]);
5809 Operands.push_back(Ops[NF]);
5810 Operands.push_back(Ops[2 * NF + 3]);
5811 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
5812 }
5813 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
5814 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 5814, __extension__ __PRETTY_FUNCTION__));
5815 } else {
5816 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
5817 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
5818 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
5819 if (DefaultPolicy == TAIL_AGNOSTIC) {
5820 for (unsigned I = 0; I < NF; ++I)
5821 Operands.push_back(llvm::PoisonValue::get(ResultType));
5822 Operands.push_back(Ops[NF]);
5823 Operands.push_back(Ops[NF + 1]);
5824 Operands.push_back(Ops[NF + 2]);
5825 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
5826 } else {
5827 for (unsigned I = 0; I < NF; ++I)
5828 Operands.push_back(Ops[NF + I]);
5829 Operands.push_back(Ops[2 * NF]);
5830 Operands.push_back(Ops[2 * NF + 1]);
5831 Operands.push_back(Ops[2 * NF + 2]);
5832 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
5833 }
5834 }
5835 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
5836 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
5837 clang::CharUnits Align =
5838 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
5839 llvm::Value *V;
5840 for (unsigned I = 0; I < NF; ++I) {
5841 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
5842 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
5843 }
5844 return V;
5845 }
5846 break;
5847case RISCVVector::BI__builtin_rvv_vloxseg7ei8_v_tama:
5848case RISCVVector::BI__builtin_rvv_vloxseg7ei16_v_tama:
5849case RISCVVector::BI__builtin_rvv_vloxseg7ei32_v_tama:
5850case RISCVVector::BI__builtin_rvv_vloxseg7ei64_v_tama:
5851 ID = Intrinsic::riscv_vloxseg7_mask;
5852 NF = 7;
5853 DefaultPolicy = 3;
5854IsMasked = true;
5855
5856 {
5857 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
5858 SmallVector<llvm::Value*, 12> Operands;
5859 if (IsMasked) {
5860 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
5861 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
5862 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
5863 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
5864 for (unsigned I = 0; I < NF; ++I)
5865 Operands.push_back(llvm::PoisonValue::get(ResultType));
5866 Operands.push_back(Ops[NF + 1]);
5867 Operands.push_back(Ops[NF + 2]);
5868 Operands.push_back(Ops[NF]);
5869 Operands.push_back(Ops[NF + 3]);
5870 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
5871 } else {
5872 for (unsigned I = 0; I < NF; ++I)
5873 Operands.push_back(Ops[NF + I + 1]);
5874 Operands.push_back(Ops[2 * NF + 1]);
5875 Operands.push_back(Ops[2 * NF + 2]);
5876 Operands.push_back(Ops[NF]);
5877 Operands.push_back(Ops[2 * NF + 3]);
5878 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
5879 }
5880 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
5881 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 5881, __extension__ __PRETTY_FUNCTION__));
5882 } else {
5883 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
5884 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
5885 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
5886 if (DefaultPolicy == TAIL_AGNOSTIC) {
5887 for (unsigned I = 0; I < NF; ++I)
5888 Operands.push_back(llvm::PoisonValue::get(ResultType));
5889 Operands.push_back(Ops[NF]);
5890 Operands.push_back(Ops[NF + 1]);
5891 Operands.push_back(Ops[NF + 2]);
5892 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
5893 } else {
5894 for (unsigned I = 0; I < NF; ++I)
5895 Operands.push_back(Ops[NF + I]);
5896 Operands.push_back(Ops[2 * NF]);
5897 Operands.push_back(Ops[2 * NF + 1]);
5898 Operands.push_back(Ops[2 * NF + 2]);
5899 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
5900 }
5901 }
5902 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
5903 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
5904 clang::CharUnits Align =
5905 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
5906 llvm::Value *V;
5907 for (unsigned I = 0; I < NF; ++I) {
5908 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
5909 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
5910 }
5911 return V;
5912 }
5913 break;
5914case RISCVVector::BI__builtin_rvv_vloxseg7ei8_v_tumu:
5915case RISCVVector::BI__builtin_rvv_vloxseg7ei16_v_tumu:
5916case RISCVVector::BI__builtin_rvv_vloxseg7ei32_v_tumu:
5917case RISCVVector::BI__builtin_rvv_vloxseg7ei64_v_tumu:
5918 ID = Intrinsic::riscv_vloxseg7_mask;
5919 NF = 7;
5920 DefaultPolicy = 0;
5921IsMasked = true;
5922
5923 {
5924 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
5925 SmallVector<llvm::Value*, 12> Operands;
5926 if (IsMasked) {
5927 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
5928 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
5929 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
5930 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
5931 for (unsigned I = 0; I < NF; ++I)
5932 Operands.push_back(llvm::PoisonValue::get(ResultType));
5933 Operands.push_back(Ops[NF + 1]);
5934 Operands.push_back(Ops[NF + 2]);
5935 Operands.push_back(Ops[NF]);
5936 Operands.push_back(Ops[NF + 3]);
5937 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
5938 } else {
5939 for (unsigned I = 0; I < NF; ++I)
5940 Operands.push_back(Ops[NF + I + 1]);
5941 Operands.push_back(Ops[2 * NF + 1]);
5942 Operands.push_back(Ops[2 * NF + 2]);
5943 Operands.push_back(Ops[NF]);
5944 Operands.push_back(Ops[2 * NF + 3]);
5945 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
5946 }
5947 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
5948 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 5948, __extension__ __PRETTY_FUNCTION__));
5949 } else {
5950 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
5951 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
5952 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
5953 if (DefaultPolicy == TAIL_AGNOSTIC) {
5954 for (unsigned I = 0; I < NF; ++I)
5955 Operands.push_back(llvm::PoisonValue::get(ResultType));
5956 Operands.push_back(Ops[NF]);
5957 Operands.push_back(Ops[NF + 1]);
5958 Operands.push_back(Ops[NF + 2]);
5959 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
5960 } else {
5961 for (unsigned I = 0; I < NF; ++I)
5962 Operands.push_back(Ops[NF + I]);
5963 Operands.push_back(Ops[2 * NF]);
5964 Operands.push_back(Ops[2 * NF + 1]);
5965 Operands.push_back(Ops[2 * NF + 2]);
5966 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
5967 }
5968 }
5969 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
5970 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
5971 clang::CharUnits Align =
5972 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
5973 llvm::Value *V;
5974 for (unsigned I = 0; I < NF; ++I) {
5975 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
5976 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
5977 }
5978 return V;
5979 }
5980 break;
5981case RISCVVector::BI__builtin_rvv_vloxseg7ei8_v_tamu:
5982case RISCVVector::BI__builtin_rvv_vloxseg7ei16_v_tamu:
5983case RISCVVector::BI__builtin_rvv_vloxseg7ei32_v_tamu:
5984case RISCVVector::BI__builtin_rvv_vloxseg7ei64_v_tamu:
5985 ID = Intrinsic::riscv_vloxseg7_mask;
5986 NF = 7;
5987 DefaultPolicy = 1;
5988IsMasked = true;
5989
5990 {
5991 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
5992 SmallVector<llvm::Value*, 12> Operands;
5993 if (IsMasked) {
5994 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
5995 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
5996 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
5997 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
5998 for (unsigned I = 0; I < NF; ++I)
5999 Operands.push_back(llvm::PoisonValue::get(ResultType));
6000 Operands.push_back(Ops[NF + 1]);
6001 Operands.push_back(Ops[NF + 2]);
6002 Operands.push_back(Ops[NF]);
6003 Operands.push_back(Ops[NF + 3]);
6004 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
6005 } else {
6006 for (unsigned I = 0; I < NF; ++I)
6007 Operands.push_back(Ops[NF + I + 1]);
6008 Operands.push_back(Ops[2 * NF + 1]);
6009 Operands.push_back(Ops[2 * NF + 2]);
6010 Operands.push_back(Ops[NF]);
6011 Operands.push_back(Ops[2 * NF + 3]);
6012 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
6013 }
6014 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
6015 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 6015, __extension__ __PRETTY_FUNCTION__));
6016 } else {
6017 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
6018 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
6019 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
6020 if (DefaultPolicy == TAIL_AGNOSTIC) {
6021 for (unsigned I = 0; I < NF; ++I)
6022 Operands.push_back(llvm::PoisonValue::get(ResultType));
6023 Operands.push_back(Ops[NF]);
6024 Operands.push_back(Ops[NF + 1]);
6025 Operands.push_back(Ops[NF + 2]);
6026 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
6027 } else {
6028 for (unsigned I = 0; I < NF; ++I)
6029 Operands.push_back(Ops[NF + I]);
6030 Operands.push_back(Ops[2 * NF]);
6031 Operands.push_back(Ops[2 * NF + 1]);
6032 Operands.push_back(Ops[2 * NF + 2]);
6033 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
6034 }
6035 }
6036 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
6037 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
6038 clang::CharUnits Align =
6039 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
6040 llvm::Value *V;
6041 for (unsigned I = 0; I < NF; ++I) {
6042 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
6043 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
6044 }
6045 return V;
6046 }
6047 break;
6048case RISCVVector::BI__builtin_rvv_vloxseg8ei8_v_tu:
6049case RISCVVector::BI__builtin_rvv_vloxseg8ei16_v_tu:
6050case RISCVVector::BI__builtin_rvv_vloxseg8ei32_v_tu:
6051case RISCVVector::BI__builtin_rvv_vloxseg8ei64_v_tu:
6052 ID = Intrinsic::riscv_vloxseg8;
6053 NF = 8;
6054 DefaultPolicy = 0;
6055IsMasked = false;
6056
6057 {
6058 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
6059 SmallVector<llvm::Value*, 12> Operands;
6060 if (IsMasked) {
6061 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
6062 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
6063 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
6064 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
6065 for (unsigned I = 0; I < NF; ++I)
6066 Operands.push_back(llvm::PoisonValue::get(ResultType));
6067 Operands.push_back(Ops[NF + 1]);
6068 Operands.push_back(Ops[NF + 2]);
6069 Operands.push_back(Ops[NF]);
6070 Operands.push_back(Ops[NF + 3]);
6071 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
6072 } else {
6073 for (unsigned I = 0; I < NF; ++I)
6074 Operands.push_back(Ops[NF + I + 1]);
6075 Operands.push_back(Ops[2 * NF + 1]);
6076 Operands.push_back(Ops[2 * NF + 2]);
6077 Operands.push_back(Ops[NF]);
6078 Operands.push_back(Ops[2 * NF + 3]);
6079 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
6080 }
6081 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
6082 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 6082, __extension__ __PRETTY_FUNCTION__));
6083 } else {
6084 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
6085 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
6086 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
6087 if (DefaultPolicy == TAIL_AGNOSTIC) {
6088 for (unsigned I = 0; I < NF; ++I)
6089 Operands.push_back(llvm::PoisonValue::get(ResultType));
6090 Operands.push_back(Ops[NF]);
6091 Operands.push_back(Ops[NF + 1]);
6092 Operands.push_back(Ops[NF + 2]);
6093 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
6094 } else {
6095 for (unsigned I = 0; I < NF; ++I)
6096 Operands.push_back(Ops[NF + I]);
6097 Operands.push_back(Ops[2 * NF]);
6098 Operands.push_back(Ops[2 * NF + 1]);
6099 Operands.push_back(Ops[2 * NF + 2]);
6100 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
6101 }
6102 }
6103 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
6104 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
6105 clang::CharUnits Align =
6106 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
6107 llvm::Value *V;
6108 for (unsigned I = 0; I < NF; ++I) {
6109 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
6110 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
6111 }
6112 return V;
6113 }
6114 break;
6115case RISCVVector::BI__builtin_rvv_vloxseg8ei8_v_ta:
6116case RISCVVector::BI__builtin_rvv_vloxseg8ei16_v_ta:
6117case RISCVVector::BI__builtin_rvv_vloxseg8ei32_v_ta:
6118case RISCVVector::BI__builtin_rvv_vloxseg8ei64_v_ta:
6119 ID = Intrinsic::riscv_vloxseg8;
6120 NF = 8;
6121 DefaultPolicy = 1;
6122IsMasked = false;
6123
6124 {
6125 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
6126 SmallVector<llvm::Value*, 12> Operands;
6127 if (IsMasked) {
6128 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
6129 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
6130 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
6131 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
6132 for (unsigned I = 0; I < NF; ++I)
6133 Operands.push_back(llvm::PoisonValue::get(ResultType));
6134 Operands.push_back(Ops[NF + 1]);
6135 Operands.push_back(Ops[NF + 2]);
6136 Operands.push_back(Ops[NF]);
6137 Operands.push_back(Ops[NF + 3]);
6138 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
6139 } else {
6140 for (unsigned I = 0; I < NF; ++I)
6141 Operands.push_back(Ops[NF + I + 1]);
6142 Operands.push_back(Ops[2 * NF + 1]);
6143 Operands.push_back(Ops[2 * NF + 2]);
6144 Operands.push_back(Ops[NF]);
6145 Operands.push_back(Ops[2 * NF + 3]);
6146 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
6147 }
6148 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
6149 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 6149, __extension__ __PRETTY_FUNCTION__));
6150 } else {
6151 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
6152 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
6153 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
6154 if (DefaultPolicy == TAIL_AGNOSTIC) {
6155 for (unsigned I = 0; I < NF; ++I)
6156 Operands.push_back(llvm::PoisonValue::get(ResultType));
6157 Operands.push_back(Ops[NF]);
6158 Operands.push_back(Ops[NF + 1]);
6159 Operands.push_back(Ops[NF + 2]);
6160 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
6161 } else {
6162 for (unsigned I = 0; I < NF; ++I)
6163 Operands.push_back(Ops[NF + I]);
6164 Operands.push_back(Ops[2 * NF]);
6165 Operands.push_back(Ops[2 * NF + 1]);
6166 Operands.push_back(Ops[2 * NF + 2]);
6167 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
6168 }
6169 }
6170 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
6171 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
6172 clang::CharUnits Align =
6173 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
6174 llvm::Value *V;
6175 for (unsigned I = 0; I < NF; ++I) {
6176 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
6177 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
6178 }
6179 return V;
6180 }
6181 break;
6182case RISCVVector::BI__builtin_rvv_vloxseg8ei8_v_tuma:
6183case RISCVVector::BI__builtin_rvv_vloxseg8ei16_v_tuma:
6184case RISCVVector::BI__builtin_rvv_vloxseg8ei32_v_tuma:
6185case RISCVVector::BI__builtin_rvv_vloxseg8ei64_v_tuma:
6186 ID = Intrinsic::riscv_vloxseg8_mask;
6187 NF = 8;
6188 DefaultPolicy = 2;
6189IsMasked = true;
6190
6191 {
6192 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
6193 SmallVector<llvm::Value*, 12> Operands;
6194 if (IsMasked) {
6195 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
6196 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
6197 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
6198 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
6199 for (unsigned I = 0; I < NF; ++I)
6200 Operands.push_back(llvm::PoisonValue::get(ResultType));
6201 Operands.push_back(Ops[NF + 1]);
6202 Operands.push_back(Ops[NF + 2]);
6203 Operands.push_back(Ops[NF]);
6204 Operands.push_back(Ops[NF + 3]);
6205 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
6206 } else {
6207 for (unsigned I = 0; I < NF; ++I)
6208 Operands.push_back(Ops[NF + I + 1]);
6209 Operands.push_back(Ops[2 * NF + 1]);
6210 Operands.push_back(Ops[2 * NF + 2]);
6211 Operands.push_back(Ops[NF]);
6212 Operands.push_back(Ops[2 * NF + 3]);
6213 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
6214 }
6215 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
6216 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 6216, __extension__ __PRETTY_FUNCTION__));
6217 } else {
6218 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
6219 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
6220 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
6221 if (DefaultPolicy == TAIL_AGNOSTIC) {
6222 for (unsigned I = 0; I < NF; ++I)
6223 Operands.push_back(llvm::PoisonValue::get(ResultType));
6224 Operands.push_back(Ops[NF]);
6225 Operands.push_back(Ops[NF + 1]);
6226 Operands.push_back(Ops[NF + 2]);
6227 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
6228 } else {
6229 for (unsigned I = 0; I < NF; ++I)
6230 Operands.push_back(Ops[NF + I]);
6231 Operands.push_back(Ops[2 * NF]);
6232 Operands.push_back(Ops[2 * NF + 1]);
6233 Operands.push_back(Ops[2 * NF + 2]);
6234 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
6235 }
6236 }
6237 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
6238 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
6239 clang::CharUnits Align =
6240 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
6241 llvm::Value *V;
6242 for (unsigned I = 0; I < NF; ++I) {
6243 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
6244 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
6245 }
6246 return V;
6247 }
6248 break;
6249case RISCVVector::BI__builtin_rvv_vloxseg8ei8_v_tama:
6250case RISCVVector::BI__builtin_rvv_vloxseg8ei16_v_tama:
6251case RISCVVector::BI__builtin_rvv_vloxseg8ei32_v_tama:
6252case RISCVVector::BI__builtin_rvv_vloxseg8ei64_v_tama:
6253 ID = Intrinsic::riscv_vloxseg8_mask;
6254 NF = 8;
6255 DefaultPolicy = 3;
6256IsMasked = true;
6257
6258 {
6259 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
6260 SmallVector<llvm::Value*, 12> Operands;
6261 if (IsMasked) {
6262 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
6263 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
6264 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
6265 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
6266 for (unsigned I = 0; I < NF; ++I)
6267 Operands.push_back(llvm::PoisonValue::get(ResultType));
6268 Operands.push_back(Ops[NF + 1]);
6269 Operands.push_back(Ops[NF + 2]);
6270 Operands.push_back(Ops[NF]);
6271 Operands.push_back(Ops[NF + 3]);
6272 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
6273 } else {
6274 for (unsigned I = 0; I < NF; ++I)
6275 Operands.push_back(Ops[NF + I + 1]);
6276 Operands.push_back(Ops[2 * NF + 1]);
6277 Operands.push_back(Ops[2 * NF + 2]);
6278 Operands.push_back(Ops[NF]);
6279 Operands.push_back(Ops[2 * NF + 3]);
6280 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
6281 }
6282 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
6283 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 6283, __extension__ __PRETTY_FUNCTION__));
6284 } else {
6285 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
6286 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
6287 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
6288 if (DefaultPolicy == TAIL_AGNOSTIC) {
6289 for (unsigned I = 0; I < NF; ++I)
6290 Operands.push_back(llvm::PoisonValue::get(ResultType));
6291 Operands.push_back(Ops[NF]);
6292 Operands.push_back(Ops[NF + 1]);
6293 Operands.push_back(Ops[NF + 2]);
6294 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
6295 } else {
6296 for (unsigned I = 0; I < NF; ++I)
6297 Operands.push_back(Ops[NF + I]);
6298 Operands.push_back(Ops[2 * NF]);
6299 Operands.push_back(Ops[2 * NF + 1]);
6300 Operands.push_back(Ops[2 * NF + 2]);
6301 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
6302 }
6303 }
6304 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
6305 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
6306 clang::CharUnits Align =
6307 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
6308 llvm::Value *V;
6309 for (unsigned I = 0; I < NF; ++I) {
6310 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
6311 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
6312 }
6313 return V;
6314 }
6315 break;
6316case RISCVVector::BI__builtin_rvv_vloxseg8ei8_v_tumu:
6317case RISCVVector::BI__builtin_rvv_vloxseg8ei16_v_tumu:
6318case RISCVVector::BI__builtin_rvv_vloxseg8ei32_v_tumu:
6319case RISCVVector::BI__builtin_rvv_vloxseg8ei64_v_tumu:
6320 ID = Intrinsic::riscv_vloxseg8_mask;
6321 NF = 8;
6322 DefaultPolicy = 0;
6323IsMasked = true;
6324
6325 {
6326 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
6327 SmallVector<llvm::Value*, 12> Operands;
6328 if (IsMasked) {
6329 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
6330 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
6331 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
6332 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
6333 for (unsigned I = 0; I < NF; ++I)
6334 Operands.push_back(llvm::PoisonValue::get(ResultType));
6335 Operands.push_back(Ops[NF + 1]);
6336 Operands.push_back(Ops[NF + 2]);
6337 Operands.push_back(Ops[NF]);
6338 Operands.push_back(Ops[NF + 3]);
6339 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
6340 } else {
6341 for (unsigned I = 0; I < NF; ++I)
6342 Operands.push_back(Ops[NF + I + 1]);
6343 Operands.push_back(Ops[2 * NF + 1]);
6344 Operands.push_back(Ops[2 * NF + 2]);
6345 Operands.push_back(Ops[NF]);
6346 Operands.push_back(Ops[2 * NF + 3]);
6347 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
6348 }
6349 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
6350 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 6350, __extension__ __PRETTY_FUNCTION__));
6351 } else {
6352 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
6353 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
6354 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
6355 if (DefaultPolicy == TAIL_AGNOSTIC) {
6356 for (unsigned I = 0; I < NF; ++I)
6357 Operands.push_back(llvm::PoisonValue::get(ResultType));
6358 Operands.push_back(Ops[NF]);
6359 Operands.push_back(Ops[NF + 1]);
6360 Operands.push_back(Ops[NF + 2]);
6361 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
6362 } else {
6363 for (unsigned I = 0; I < NF; ++I)
6364 Operands.push_back(Ops[NF + I]);
6365 Operands.push_back(Ops[2 * NF]);
6366 Operands.push_back(Ops[2 * NF + 1]);
6367 Operands.push_back(Ops[2 * NF + 2]);
6368 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
6369 }
6370 }
6371 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
6372 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
6373 clang::CharUnits Align =
6374 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
6375 llvm::Value *V;
6376 for (unsigned I = 0; I < NF; ++I) {
6377 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
6378 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
6379 }
6380 return V;
6381 }
6382 break;
6383case RISCVVector::BI__builtin_rvv_vloxseg8ei8_v_tamu:
6384case RISCVVector::BI__builtin_rvv_vloxseg8ei16_v_tamu:
6385case RISCVVector::BI__builtin_rvv_vloxseg8ei32_v_tamu:
6386case RISCVVector::BI__builtin_rvv_vloxseg8ei64_v_tamu:
6387 ID = Intrinsic::riscv_vloxseg8_mask;
6388 NF = 8;
6389 DefaultPolicy = 1;
6390IsMasked = true;
6391
6392 {
6393 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
6394 SmallVector<llvm::Value*, 12> Operands;
6395 if (IsMasked) {
6396 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
6397 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
6398 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
6399 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
6400 for (unsigned I = 0; I < NF; ++I)
6401 Operands.push_back(llvm::PoisonValue::get(ResultType));
6402 Operands.push_back(Ops[NF + 1]);
6403 Operands.push_back(Ops[NF + 2]);
6404 Operands.push_back(Ops[NF]);
6405 Operands.push_back(Ops[NF + 3]);
6406 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
6407 } else {
6408 for (unsigned I = 0; I < NF; ++I)
6409 Operands.push_back(Ops[NF + I + 1]);
6410 Operands.push_back(Ops[2 * NF + 1]);
6411 Operands.push_back(Ops[2 * NF + 2]);
6412 Operands.push_back(Ops[NF]);
6413 Operands.push_back(Ops[2 * NF + 3]);
6414 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
6415 }
6416 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
6417 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 6417, __extension__ __PRETTY_FUNCTION__));
6418 } else {
6419 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
6420 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
6421 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
6422 if (DefaultPolicy == TAIL_AGNOSTIC) {
6423 for (unsigned I = 0; I < NF; ++I)
6424 Operands.push_back(llvm::PoisonValue::get(ResultType));
6425 Operands.push_back(Ops[NF]);
6426 Operands.push_back(Ops[NF + 1]);
6427 Operands.push_back(Ops[NF + 2]);
6428 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
6429 } else {
6430 for (unsigned I = 0; I < NF; ++I)
6431 Operands.push_back(Ops[NF + I]);
6432 Operands.push_back(Ops[2 * NF]);
6433 Operands.push_back(Ops[2 * NF + 1]);
6434 Operands.push_back(Ops[2 * NF + 2]);
6435 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
6436 }
6437 }
6438 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
6439 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
6440 clang::CharUnits Align =
6441 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
6442 llvm::Value *V;
6443 for (unsigned I = 0; I < NF; ++I) {
6444 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
6445 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
6446 }
6447 return V;
6448 }
6449 break;
6450case RISCVVector::BI__builtin_rvv_vlse32_v_tu:
6451case RISCVVector::BI__builtin_rvv_vlse64_v_tu:
6452case RISCVVector::BI__builtin_rvv_vlse8_v_tu:
6453case RISCVVector::BI__builtin_rvv_vlse16_v_tu:
6454 ID = Intrinsic::riscv_vlse;
6455 Ops[1] = Builder.CreateBitCast(Ops[1], ResultType->getPointerTo());
6456 IntrinsicTypes = {ResultType, Ops.back()->getType()};
6457 break;
6458case RISCVVector::BI__builtin_rvv_vlse32_v_ta:
6459case RISCVVector::BI__builtin_rvv_vlse64_v_ta:
6460case RISCVVector::BI__builtin_rvv_vlse8_v_ta:
6461case RISCVVector::BI__builtin_rvv_vlse16_v_ta:
6462 ID = Intrinsic::riscv_vlse;
6463 Ops[0] = Builder.CreateBitCast(Ops[0], ResultType->getPointerTo());
6464 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
6465 IntrinsicTypes = {ResultType, Ops.back()->getType()};
6466 break;
6467case RISCVVector::BI__builtin_rvv_vlse32_v_tuma:
6468case RISCVVector::BI__builtin_rvv_vlse64_v_tuma:
6469case RISCVVector::BI__builtin_rvv_vlse8_v_tuma:
6470case RISCVVector::BI__builtin_rvv_vlse16_v_tuma:
6471 ID = Intrinsic::riscv_vlse_mask;
6472 DefaultPolicy = 2;
6473 Ops[2] = Builder.CreateBitCast(Ops[2], ResultType->getPointerTo());
6474 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
6475 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
6476 IntrinsicTypes = {ResultType, Ops.back()->getType()};
6477 break;
6478case RISCVVector::BI__builtin_rvv_vlse32_v_tama:
6479case RISCVVector::BI__builtin_rvv_vlse64_v_tama:
6480case RISCVVector::BI__builtin_rvv_vlse8_v_tama:
6481case RISCVVector::BI__builtin_rvv_vlse16_v_tama:
6482 ID = Intrinsic::riscv_vlse_mask;
6483 DefaultPolicy = 3;
6484 Ops[1] = Builder.CreateBitCast(Ops[1], ResultType->getPointerTo());
6485 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
6486 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
6487 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
6488 IntrinsicTypes = {ResultType, Ops.back()->getType()};
6489 break;
6490case RISCVVector::BI__builtin_rvv_vlse32_v_tumu:
6491case RISCVVector::BI__builtin_rvv_vlse64_v_tumu:
6492case RISCVVector::BI__builtin_rvv_vlse8_v_tumu:
6493case RISCVVector::BI__builtin_rvv_vlse16_v_tumu:
6494 ID = Intrinsic::riscv_vlse_mask;
6495 Ops[2] = Builder.CreateBitCast(Ops[2], ResultType->getPointerTo());
6496 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
6497 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
6498 IntrinsicTypes = {ResultType, Ops.back()->getType()};
6499 break;
6500case RISCVVector::BI__builtin_rvv_vlse32_v_tamu:
6501case RISCVVector::BI__builtin_rvv_vlse64_v_tamu:
6502case RISCVVector::BI__builtin_rvv_vlse8_v_tamu:
6503case RISCVVector::BI__builtin_rvv_vlse16_v_tamu:
6504 ID = Intrinsic::riscv_vlse_mask;
6505 DefaultPolicy = 1;
6506 Ops[2] = Builder.CreateBitCast(Ops[2], ResultType->getPointerTo());
6507 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
6508 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
6509 IntrinsicTypes = {ResultType, Ops.back()->getType()};
6510 break;
6511case RISCVVector::BI__builtin_rvv_vlseg2e8_v_tu:
6512case RISCVVector::BI__builtin_rvv_vlseg2e16_v_tu:
6513case RISCVVector::BI__builtin_rvv_vlseg2e32_v_tu:
6514case RISCVVector::BI__builtin_rvv_vlseg2e64_v_tu:
6515 ID = Intrinsic::riscv_vlseg2;
6516 NF = 2;
6517 DefaultPolicy = 0;
6518IsMasked = false;
6519
6520 {
6521 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
6522 IntrinsicTypes = {ResultType, Ops.back()->getType()};
6523 SmallVector<llvm::Value*, 10> Operands;
6524 if (IsMasked) {
6525 // TAMA builtin: (val0 address, ..., mask, ptr, vl)
6526 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
6527 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
6528 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
6529 for (unsigned I = 0; I < NF; ++I)
6530 Operands.push_back(llvm::PoisonValue::get(ResultType));
6531 Operands.push_back(Ops[NF + 1]);
6532 Operands.push_back(Ops[NF]);
6533 Operands.push_back(Ops[NF + 2]);
6534 } else {
6535 for (unsigned I = 0; I < NF; ++I)
6536 Operands.push_back(Ops[NF + I + 1]);
6537 Operands.push_back(Ops[2 * NF + 1]);
6538 Operands.push_back(Ops[NF]);
6539 Operands.push_back(Ops[2 * NF + 2]);
6540 }
6541 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
6542 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 6542, __extension__ __PRETTY_FUNCTION__));
6543 } else {
6544 // TA builtin: (val0 address, val1 address, ..., ptr, vl)
6545 // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
6546 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
6547 if (DefaultPolicy == TAIL_AGNOSTIC) {
6548 for (unsigned I = 0; I < NF; ++I)
6549 Operands.push_back(llvm::PoisonValue::get(ResultType));
6550 Operands.push_back(Ops[NF]);
6551 Operands.push_back(Ops[NF + 1]);
6552 } else {
6553 for (unsigned I = 0; I < NF; ++I)
6554 Operands.push_back(Ops[NF + I]);
6555 Operands.push_back(Ops[2 * NF]);
6556 Operands.push_back(Ops[2 * NF + 1]);
6557 }
6558 }
6559 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
6560 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
6561 clang::CharUnits Align =
6562 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
6563 llvm::Value *V;
6564 for (unsigned I = 0; I < NF; ++I) {
6565 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
6566 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
6567 }
6568 return V;
6569 }
6570 break;
6571case RISCVVector::BI__builtin_rvv_vlseg2e8_v_ta:
6572case RISCVVector::BI__builtin_rvv_vlseg2e16_v_ta:
6573case RISCVVector::BI__builtin_rvv_vlseg2e32_v_ta:
6574case RISCVVector::BI__builtin_rvv_vlseg2e64_v_ta:
6575 ID = Intrinsic::riscv_vlseg2;
6576 NF = 2;
6577 DefaultPolicy = 1;
6578IsMasked = false;
6579
6580 {
6581 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
6582 IntrinsicTypes = {ResultType, Ops.back()->getType()};
6583 SmallVector<llvm::Value*, 10> Operands;
6584 if (IsMasked) {
6585 // TAMA builtin: (val0 address, ..., mask, ptr, vl)
6586 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
6587 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
6588 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
6589 for (unsigned I = 0; I < NF; ++I)
6590 Operands.push_back(llvm::PoisonValue::get(ResultType));
6591 Operands.push_back(Ops[NF + 1]);
6592 Operands.push_back(Ops[NF]);
6593 Operands.push_back(Ops[NF + 2]);
6594 } else {
6595 for (unsigned I = 0; I < NF; ++I)
6596 Operands.push_back(Ops[NF + I + 1]);
6597 Operands.push_back(Ops[2 * NF + 1]);
6598 Operands.push_back(Ops[NF]);
6599 Operands.push_back(Ops[2 * NF + 2]);
6600 }
6601 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
6602 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 6602, __extension__ __PRETTY_FUNCTION__));
6603 } else {
6604 // TA builtin: (val0 address, val1 address, ..., ptr, vl)
6605 // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
6606 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
6607 if (DefaultPolicy == TAIL_AGNOSTIC) {
6608 for (unsigned I = 0; I < NF; ++I)
6609 Operands.push_back(llvm::PoisonValue::get(ResultType));
6610 Operands.push_back(Ops[NF]);
6611 Operands.push_back(Ops[NF + 1]);
6612 } else {
6613 for (unsigned I = 0; I < NF; ++I)
6614 Operands.push_back(Ops[NF + I]);
6615 Operands.push_back(Ops[2 * NF]);
6616 Operands.push_back(Ops[2 * NF + 1]);
6617 }
6618 }
6619 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
6620 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
6621 clang::CharUnits Align =
6622 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
6623 llvm::Value *V;
6624 for (unsigned I = 0; I < NF; ++I) {
6625 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
6626 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
6627 }
6628 return V;
6629 }
6630 break;
6631case RISCVVector::BI__builtin_rvv_vlseg2e8_v_tuma:
6632case RISCVVector::BI__builtin_rvv_vlseg2e16_v_tuma:
6633case RISCVVector::BI__builtin_rvv_vlseg2e32_v_tuma:
6634case RISCVVector::BI__builtin_rvv_vlseg2e64_v_tuma:
6635 ID = Intrinsic::riscv_vlseg2_mask;
6636 NF = 2;
6637 DefaultPolicy = 2;
6638IsMasked = true;
6639
6640 {
6641 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
6642 IntrinsicTypes = {ResultType, Ops.back()->getType()};
6643 SmallVector<llvm::Value*, 10> Operands;
6644 if (IsMasked) {
6645 // TAMA builtin: (val0 address, ..., mask, ptr, vl)
6646 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
6647 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
6648 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
6649 for (unsigned I = 0; I < NF; ++I)
6650 Operands.push_back(llvm::PoisonValue::get(ResultType));
6651 Operands.push_back(Ops[NF + 1]);
6652 Operands.push_back(Ops[NF]);
6653 Operands.push_back(Ops[NF + 2]);
6654 } else {
6655 for (unsigned I = 0; I < NF; ++I)
6656 Operands.push_back(Ops[NF + I + 1]);
6657 Operands.push_back(Ops[2 * NF + 1]);
6658 Operands.push_back(Ops[NF]);
6659 Operands.push_back(Ops[2 * NF + 2]);
6660 }
6661 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
6662 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 6662, __extension__ __PRETTY_FUNCTION__));
6663 } else {
6664 // TA builtin: (val0 address, val1 address, ..., ptr, vl)
6665 // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
6666 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
6667 if (DefaultPolicy == TAIL_AGNOSTIC) {
6668 for (unsigned I = 0; I < NF; ++I)
6669 Operands.push_back(llvm::PoisonValue::get(ResultType));
6670 Operands.push_back(Ops[NF]);
6671 Operands.push_back(Ops[NF + 1]);
6672 } else {
6673 for (unsigned I = 0; I < NF; ++I)
6674 Operands.push_back(Ops[NF + I]);
6675 Operands.push_back(Ops[2 * NF]);
6676 Operands.push_back(Ops[2 * NF + 1]);
6677 }
6678 }
6679 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
6680 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
6681 clang::CharUnits Align =
6682 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
6683 llvm::Value *V;
6684 for (unsigned I = 0; I < NF; ++I) {
6685 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
6686 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
6687 }
6688 return V;
6689 }
6690 break;
6691case RISCVVector::BI__builtin_rvv_vlseg2e8_v_tama:
6692case RISCVVector::BI__builtin_rvv_vlseg2e16_v_tama:
6693case RISCVVector::BI__builtin_rvv_vlseg2e32_v_tama:
6694case RISCVVector::BI__builtin_rvv_vlseg2e64_v_tama:
6695 ID = Intrinsic::riscv_vlseg2_mask;
6696 NF = 2;
6697 DefaultPolicy = 3;
6698IsMasked = true;
6699
6700 {
6701 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
6702 IntrinsicTypes = {ResultType, Ops.back()->getType()};
6703 SmallVector<llvm::Value*, 10> Operands;
6704 if (IsMasked) {
6705 // TAMA builtin: (val0 address, ..., mask, ptr, vl)
6706 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
6707 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
6708 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
6709 for (unsigned I = 0; I < NF; ++I)
6710 Operands.push_back(llvm::PoisonValue::get(ResultType));
6711 Operands.push_back(Ops[NF + 1]);
6712 Operands.push_back(Ops[NF]);
6713 Operands.push_back(Ops[NF + 2]);
6714 } else {
6715 for (unsigned I = 0; I < NF; ++I)
6716 Operands.push_back(Ops[NF + I + 1]);
6717 Operands.push_back(Ops[2 * NF + 1]);
6718 Operands.push_back(Ops[NF]);
6719 Operands.push_back(Ops[2 * NF + 2]);
6720 }
6721 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
6722 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 6722, __extension__ __PRETTY_FUNCTION__));
6723 } else {
6724 // TA builtin: (val0 address, val1 address, ..., ptr, vl)
6725 // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
6726 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
6727 if (DefaultPolicy == TAIL_AGNOSTIC) {
6728 for (unsigned I = 0; I < NF; ++I)
6729 Operands.push_back(llvm::PoisonValue::get(ResultType));
6730 Operands.push_back(Ops[NF]);
6731 Operands.push_back(Ops[NF + 1]);
6732 } else {
6733 for (unsigned I = 0; I < NF; ++I)
6734 Operands.push_back(Ops[NF + I]);
6735 Operands.push_back(Ops[2 * NF]);
6736 Operands.push_back(Ops[2 * NF + 1]);
6737 }
6738 }
6739 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
6740 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
6741 clang::CharUnits Align =
6742 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
6743 llvm::Value *V;
6744 for (unsigned I = 0; I < NF; ++I) {
6745 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
6746 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
6747 }
6748 return V;
6749 }
6750 break;
6751case RISCVVector::BI__builtin_rvv_vlseg2e8_v_tumu:
6752case RISCVVector::BI__builtin_rvv_vlseg2e16_v_tumu:
6753case RISCVVector::BI__builtin_rvv_vlseg2e32_v_tumu:
6754case RISCVVector::BI__builtin_rvv_vlseg2e64_v_tumu:
6755 ID = Intrinsic::riscv_vlseg2_mask;
6756 NF = 2;
6757 DefaultPolicy = 0;
6758IsMasked = true;
6759
6760 {
6761 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
6762 IntrinsicTypes = {ResultType, Ops.back()->getType()};
6763 SmallVector<llvm::Value*, 10> Operands;
6764 if (IsMasked) {
6765 // TAMA builtin: (val0 address, ..., mask, ptr, vl)
6766 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
6767 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
6768 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
6769 for (unsigned I = 0; I < NF; ++I)
6770 Operands.push_back(llvm::PoisonValue::get(ResultType));
6771 Operands.push_back(Ops[NF + 1]);
6772 Operands.push_back(Ops[NF]);
6773 Operands.push_back(Ops[NF + 2]);
6774 } else {
6775 for (unsigned I = 0; I < NF; ++I)
6776 Operands.push_back(Ops[NF + I + 1]);
6777 Operands.push_back(Ops[2 * NF + 1]);
6778 Operands.push_back(Ops[NF]);
6779 Operands.push_back(Ops[2 * NF + 2]);
6780 }
6781 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
6782 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 6782, __extension__ __PRETTY_FUNCTION__));
6783 } else {
6784 // TA builtin: (val0 address, val1 address, ..., ptr, vl)
6785 // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
6786 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
6787 if (DefaultPolicy == TAIL_AGNOSTIC) {
6788 for (unsigned I = 0; I < NF; ++I)
6789 Operands.push_back(llvm::PoisonValue::get(ResultType));
6790 Operands.push_back(Ops[NF]);
6791 Operands.push_back(Ops[NF + 1]);
6792 } else {
6793 for (unsigned I = 0; I < NF; ++I)
6794 Operands.push_back(Ops[NF + I]);
6795 Operands.push_back(Ops[2 * NF]);
6796 Operands.push_back(Ops[2 * NF + 1]);
6797 }
6798 }
6799 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
6800 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
6801 clang::CharUnits Align =
6802 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
6803 llvm::Value *V;
6804 for (unsigned I = 0; I < NF; ++I) {
6805 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
6806 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
6807 }
6808 return V;
6809 }
6810 break;
6811case RISCVVector::BI__builtin_rvv_vlseg2e8_v_tamu:
6812case RISCVVector::BI__builtin_rvv_vlseg2e16_v_tamu:
6813case RISCVVector::BI__builtin_rvv_vlseg2e32_v_tamu:
6814case RISCVVector::BI__builtin_rvv_vlseg2e64_v_tamu:
6815 ID = Intrinsic::riscv_vlseg2_mask;
6816 NF = 2;
6817 DefaultPolicy = 1;
6818IsMasked = true;
6819
6820 {
6821 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
6822 IntrinsicTypes = {ResultType, Ops.back()->getType()};
6823 SmallVector<llvm::Value*, 10> Operands;
6824 if (IsMasked) {
6825 // TAMA builtin: (val0 address, ..., mask, ptr, vl)
6826 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
6827 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
6828 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
6829 for (unsigned I = 0; I < NF; ++I)
6830 Operands.push_back(llvm::PoisonValue::get(ResultType));
6831 Operands.push_back(Ops[NF + 1]);
6832 Operands.push_back(Ops[NF]);
6833 Operands.push_back(Ops[NF + 2]);
6834 } else {
6835 for (unsigned I = 0; I < NF; ++I)
6836 Operands.push_back(Ops[NF + I + 1]);
6837 Operands.push_back(Ops[2 * NF + 1]);
6838 Operands.push_back(Ops[NF]);
6839 Operands.push_back(Ops[2 * NF + 2]);
6840 }
6841 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
6842 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 6842, __extension__ __PRETTY_FUNCTION__));
6843 } else {
6844 // TA builtin: (val0 address, val1 address, ..., ptr, vl)
6845 // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
6846 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
6847 if (DefaultPolicy == TAIL_AGNOSTIC) {
6848 for (unsigned I = 0; I < NF; ++I)
6849 Operands.push_back(llvm::PoisonValue::get(ResultType));
6850 Operands.push_back(Ops[NF]);
6851 Operands.push_back(Ops[NF + 1]);
6852 } else {
6853 for (unsigned I = 0; I < NF; ++I)
6854 Operands.push_back(Ops[NF + I]);
6855 Operands.push_back(Ops[2 * NF]);
6856 Operands.push_back(Ops[2 * NF + 1]);
6857 }
6858 }
6859 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
6860 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
6861 clang::CharUnits Align =
6862 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
6863 llvm::Value *V;
6864 for (unsigned I = 0; I < NF; ++I) {
6865 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
6866 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
6867 }
6868 return V;
6869 }
6870 break;
6871case RISCVVector::BI__builtin_rvv_vlseg2e16ff_v_tu:
6872case RISCVVector::BI__builtin_rvv_vlseg2e32ff_v_tu:
6873case RISCVVector::BI__builtin_rvv_vlseg2e64ff_v_tu:
6874case RISCVVector::BI__builtin_rvv_vlseg2e8ff_v_tu:
6875 ID = Intrinsic::riscv_vlseg2ff;
6876 NF = 2;
6877 DefaultPolicy = 0;
6878IsMasked = false;
6879
6880 {
6881 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
6882 IntrinsicTypes = {ResultType, Ops.back()->getType()};
6883 SmallVector<llvm::Value*, 12> Operands;
6884 Value *NewVL;
6885
6886 if (IsMasked) {
6887 // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
6888 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
6889 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
6890 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
6891 for (unsigned I = 0; I < NF; ++I)
6892 Operands.push_back(llvm::PoisonValue::get(ResultType));
6893 Operands.push_back(Ops[NF + 1]);
6894 Operands.push_back(Ops[NF]);
6895 Operands.push_back(Ops[NF + 3]);
6896 NewVL = Ops[NF + 2];
6897 } else {
6898 for (unsigned I = 0; I < NF; ++I)
6899 Operands.push_back(Ops[NF + I + 1]);
6900 Operands.push_back(Ops[2 * NF + 1]);
6901 Operands.push_back(Ops[NF]);
6902 Operands.push_back(Ops[2 * NF + 3]);
6903 NewVL = Ops[2 * NF + 2];
6904 }
6905 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
6906 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 6906, __extension__ __PRETTY_FUNCTION__));
6907 } else {
6908 // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
6909 // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
6910 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
6911 if (DefaultPolicy == TAIL_AGNOSTIC) {
6912 for (unsigned I = 0; I < NF; ++I)
6913 Operands.push_back(llvm::PoisonValue::get(ResultType));
6914 Operands.push_back(Ops[NF]);
6915 Operands.push_back(Ops[NF + 2]);
6916 NewVL = Ops[NF + 1];
6917 } else {
6918 for (unsigned I = 0; I < NF; ++I)
6919 Operands.push_back(Ops[NF + I]);
6920 Operands.push_back(Ops[2 * NF]);
6921 Operands.push_back(Ops[2 * NF + 2]);
6922 NewVL = Ops[2 * NF + 1];
6923 }
6924 }
6925 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
6926 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
6927 clang::CharUnits Align =
6928 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
6929 for (unsigned I = 0; I < NF; ++I) {
6930 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
6931 Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
6932 }
6933 // Store new_vl.
6934 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
6935 return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
6936 }
6937 break;
6938case RISCVVector::BI__builtin_rvv_vlseg2e16ff_v_ta:
6939case RISCVVector::BI__builtin_rvv_vlseg2e32ff_v_ta:
6940case RISCVVector::BI__builtin_rvv_vlseg2e64ff_v_ta:
6941case RISCVVector::BI__builtin_rvv_vlseg2e8ff_v_ta:
6942 ID = Intrinsic::riscv_vlseg2ff;
6943 NF = 2;
6944 DefaultPolicy = 1;
6945IsMasked = false;
6946
6947 {
6948 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
6949 IntrinsicTypes = {ResultType, Ops.back()->getType()};
6950 SmallVector<llvm::Value*, 12> Operands;
6951 Value *NewVL;
6952
6953 if (IsMasked) {
6954 // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
6955 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
6956 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
6957 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
6958 for (unsigned I = 0; I < NF; ++I)
6959 Operands.push_back(llvm::PoisonValue::get(ResultType));
6960 Operands.push_back(Ops[NF + 1]);
6961 Operands.push_back(Ops[NF]);
6962 Operands.push_back(Ops[NF + 3]);
6963 NewVL = Ops[NF + 2];
6964 } else {
6965 for (unsigned I = 0; I < NF; ++I)
6966 Operands.push_back(Ops[NF + I + 1]);
6967 Operands.push_back(Ops[2 * NF + 1]);
6968 Operands.push_back(Ops[NF]);
6969 Operands.push_back(Ops[2 * NF + 3]);
6970 NewVL = Ops[2 * NF + 2];
6971 }
6972 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
6973 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 6973, __extension__ __PRETTY_FUNCTION__));
6974 } else {
6975 // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
6976 // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
6977 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
6978 if (DefaultPolicy == TAIL_AGNOSTIC) {
6979 for (unsigned I = 0; I < NF; ++I)
6980 Operands.push_back(llvm::PoisonValue::get(ResultType));
6981 Operands.push_back(Ops[NF]);
6982 Operands.push_back(Ops[NF + 2]);
6983 NewVL = Ops[NF + 1];
6984 } else {
6985 for (unsigned I = 0; I < NF; ++I)
6986 Operands.push_back(Ops[NF + I]);
6987 Operands.push_back(Ops[2 * NF]);
6988 Operands.push_back(Ops[2 * NF + 2]);
6989 NewVL = Ops[2 * NF + 1];
6990 }
6991 }
6992 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
6993 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
6994 clang::CharUnits Align =
6995 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
6996 for (unsigned I = 0; I < NF; ++I) {
6997 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
6998 Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
6999 }
7000 // Store new_vl.
7001 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
7002 return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
7003 }
7004 break;
7005case RISCVVector::BI__builtin_rvv_vlseg2e16ff_v_tuma:
7006case RISCVVector::BI__builtin_rvv_vlseg2e32ff_v_tuma:
7007case RISCVVector::BI__builtin_rvv_vlseg2e64ff_v_tuma:
7008case RISCVVector::BI__builtin_rvv_vlseg2e8ff_v_tuma:
7009 ID = Intrinsic::riscv_vlseg2ff_mask;
7010 NF = 2;
7011 DefaultPolicy = 2;
7012IsMasked = true;
7013
7014 {
7015 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
7016 IntrinsicTypes = {ResultType, Ops.back()->getType()};
7017 SmallVector<llvm::Value*, 12> Operands;
7018 Value *NewVL;
7019
7020 if (IsMasked) {
7021 // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
7022 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
7023 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
7024 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
7025 for (unsigned I = 0; I < NF; ++I)
7026 Operands.push_back(llvm::PoisonValue::get(ResultType));
7027 Operands.push_back(Ops[NF + 1]);
7028 Operands.push_back(Ops[NF]);
7029 Operands.push_back(Ops[NF + 3]);
7030 NewVL = Ops[NF + 2];
7031 } else {
7032 for (unsigned I = 0; I < NF; ++I)
7033 Operands.push_back(Ops[NF + I + 1]);
7034 Operands.push_back(Ops[2 * NF + 1]);
7035 Operands.push_back(Ops[NF]);
7036 Operands.push_back(Ops[2 * NF + 3]);
7037 NewVL = Ops[2 * NF + 2];
7038 }
7039 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
7040 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 7040, __extension__ __PRETTY_FUNCTION__));
7041 } else {
7042 // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
7043 // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
7044 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
7045 if (DefaultPolicy == TAIL_AGNOSTIC) {
7046 for (unsigned I = 0; I < NF; ++I)
7047 Operands.push_back(llvm::PoisonValue::get(ResultType));
7048 Operands.push_back(Ops[NF]);
7049 Operands.push_back(Ops[NF + 2]);
7050 NewVL = Ops[NF + 1];
7051 } else {
7052 for (unsigned I = 0; I < NF; ++I)
7053 Operands.push_back(Ops[NF + I]);
7054 Operands.push_back(Ops[2 * NF]);
7055 Operands.push_back(Ops[2 * NF + 2]);
7056 NewVL = Ops[2 * NF + 1];
7057 }
7058 }
7059 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
7060 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
7061 clang::CharUnits Align =
7062 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
7063 for (unsigned I = 0; I < NF; ++I) {
7064 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
7065 Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
7066 }
7067 // Store new_vl.
7068 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
7069 return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
7070 }
7071 break;
7072case RISCVVector::BI__builtin_rvv_vlseg2e16ff_v_tama:
7073case RISCVVector::BI__builtin_rvv_vlseg2e32ff_v_tama:
7074case RISCVVector::BI__builtin_rvv_vlseg2e64ff_v_tama:
7075case RISCVVector::BI__builtin_rvv_vlseg2e8ff_v_tama:
7076 ID = Intrinsic::riscv_vlseg2ff_mask;
7077 NF = 2;
7078 DefaultPolicy = 3;
7079IsMasked = true;
7080
7081 {
7082 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
7083 IntrinsicTypes = {ResultType, Ops.back()->getType()};
7084 SmallVector<llvm::Value*, 12> Operands;
7085 Value *NewVL;
7086
7087 if (IsMasked) {
7088 // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
7089 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
7090 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
7091 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
7092 for (unsigned I = 0; I < NF; ++I)
7093 Operands.push_back(llvm::PoisonValue::get(ResultType));
7094 Operands.push_back(Ops[NF + 1]);
7095 Operands.push_back(Ops[NF]);
7096 Operands.push_back(Ops[NF + 3]);
7097 NewVL = Ops[NF + 2];
7098 } else {
7099 for (unsigned I = 0; I < NF; ++I)
7100 Operands.push_back(Ops[NF + I + 1]);
7101 Operands.push_back(Ops[2 * NF + 1]);
7102 Operands.push_back(Ops[NF]);
7103 Operands.push_back(Ops[2 * NF + 3]);
7104 NewVL = Ops[2 * NF + 2];
7105 }
7106 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
7107 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 7107, __extension__ __PRETTY_FUNCTION__));
7108 } else {
7109 // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
7110 // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
7111 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
7112 if (DefaultPolicy == TAIL_AGNOSTIC) {
7113 for (unsigned I = 0; I < NF; ++I)
7114 Operands.push_back(llvm::PoisonValue::get(ResultType));
7115 Operands.push_back(Ops[NF]);
7116 Operands.push_back(Ops[NF + 2]);
7117 NewVL = Ops[NF + 1];
7118 } else {
7119 for (unsigned I = 0; I < NF; ++I)
7120 Operands.push_back(Ops[NF + I]);
7121 Operands.push_back(Ops[2 * NF]);
7122 Operands.push_back(Ops[2 * NF + 2]);
7123 NewVL = Ops[2 * NF + 1];
7124 }
7125 }
7126 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
7127 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
7128 clang::CharUnits Align =
7129 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
7130 for (unsigned I = 0; I < NF; ++I) {
7131 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
7132 Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
7133 }
7134 // Store new_vl.
7135 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
7136 return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
7137 }
7138 break;
7139case RISCVVector::BI__builtin_rvv_vlseg2e16ff_v_tumu:
7140case RISCVVector::BI__builtin_rvv_vlseg2e32ff_v_tumu:
7141case RISCVVector::BI__builtin_rvv_vlseg2e64ff_v_tumu:
7142case RISCVVector::BI__builtin_rvv_vlseg2e8ff_v_tumu:
7143 ID = Intrinsic::riscv_vlseg2ff_mask;
7144 NF = 2;
7145 DefaultPolicy = 0;
7146IsMasked = true;
7147
7148 {
7149 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
7150 IntrinsicTypes = {ResultType, Ops.back()->getType()};
7151 SmallVector<llvm::Value*, 12> Operands;
7152 Value *NewVL;
7153
7154 if (IsMasked) {
7155 // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
7156 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
7157 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
7158 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
7159 for (unsigned I = 0; I < NF; ++I)
7160 Operands.push_back(llvm::PoisonValue::get(ResultType));
7161 Operands.push_back(Ops[NF + 1]);
7162 Operands.push_back(Ops[NF]);
7163 Operands.push_back(Ops[NF + 3]);
7164 NewVL = Ops[NF + 2];
7165 } else {
7166 for (unsigned I = 0; I < NF; ++I)
7167 Operands.push_back(Ops[NF + I + 1]);
7168 Operands.push_back(Ops[2 * NF + 1]);
7169 Operands.push_back(Ops[NF]);
7170 Operands.push_back(Ops[2 * NF + 3]);
7171 NewVL = Ops[2 * NF + 2];
7172 }
7173 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
7174 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 7174, __extension__ __PRETTY_FUNCTION__));
7175 } else {
7176 // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
7177 // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
7178 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
7179 if (DefaultPolicy == TAIL_AGNOSTIC) {
7180 for (unsigned I = 0; I < NF; ++I)
7181 Operands.push_back(llvm::PoisonValue::get(ResultType));
7182 Operands.push_back(Ops[NF]);
7183 Operands.push_back(Ops[NF + 2]);
7184 NewVL = Ops[NF + 1];
7185 } else {
7186 for (unsigned I = 0; I < NF; ++I)
7187 Operands.push_back(Ops[NF + I]);
7188 Operands.push_back(Ops[2 * NF]);
7189 Operands.push_back(Ops[2 * NF + 2]);
7190 NewVL = Ops[2 * NF + 1];
7191 }
7192 }
7193 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
7194 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
7195 clang::CharUnits Align =
7196 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
7197 for (unsigned I = 0; I < NF; ++I) {
7198 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
7199 Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
7200 }
7201 // Store new_vl.
7202 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
7203 return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
7204 }
7205 break;
7206case RISCVVector::BI__builtin_rvv_vlseg2e16ff_v_tamu:
7207case RISCVVector::BI__builtin_rvv_vlseg2e32ff_v_tamu:
7208case RISCVVector::BI__builtin_rvv_vlseg2e64ff_v_tamu:
7209case RISCVVector::BI__builtin_rvv_vlseg2e8ff_v_tamu:
7210 ID = Intrinsic::riscv_vlseg2ff_mask;
7211 NF = 2;
7212 DefaultPolicy = 1;
7213IsMasked = true;
7214
7215 {
7216 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
7217 IntrinsicTypes = {ResultType, Ops.back()->getType()};
7218 SmallVector<llvm::Value*, 12> Operands;
7219 Value *NewVL;
7220
7221 if (IsMasked) {
7222 // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
7223 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
7224 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
7225 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
7226 for (unsigned I = 0; I < NF; ++I)
7227 Operands.push_back(llvm::PoisonValue::get(ResultType));
7228 Operands.push_back(Ops[NF + 1]);
7229 Operands.push_back(Ops[NF]);
7230 Operands.push_back(Ops[NF + 3]);
7231 NewVL = Ops[NF + 2];
7232 } else {
7233 for (unsigned I = 0; I < NF; ++I)
7234 Operands.push_back(Ops[NF + I + 1]);
7235 Operands.push_back(Ops[2 * NF + 1]);
7236 Operands.push_back(Ops[NF]);
7237 Operands.push_back(Ops[2 * NF + 3]);
7238 NewVL = Ops[2 * NF + 2];
7239 }
7240 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
7241 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 7241, __extension__ __PRETTY_FUNCTION__));
7242 } else {
7243 // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
7244 // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
7245 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
7246 if (DefaultPolicy == TAIL_AGNOSTIC) {
7247 for (unsigned I = 0; I < NF; ++I)
7248 Operands.push_back(llvm::PoisonValue::get(ResultType));
7249 Operands.push_back(Ops[NF]);
7250 Operands.push_back(Ops[NF + 2]);
7251 NewVL = Ops[NF + 1];
7252 } else {
7253 for (unsigned I = 0; I < NF; ++I)
7254 Operands.push_back(Ops[NF + I]);
7255 Operands.push_back(Ops[2 * NF]);
7256 Operands.push_back(Ops[2 * NF + 2]);
7257 NewVL = Ops[2 * NF + 1];
7258 }
7259 }
7260 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
7261 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
7262 clang::CharUnits Align =
7263 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
7264 for (unsigned I = 0; I < NF; ++I) {
7265 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
7266 Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
7267 }
7268 // Store new_vl.
7269 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
7270 return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
7271 }
7272 break;
7273case RISCVVector::BI__builtin_rvv_vlseg3e8_v_tu:
7274case RISCVVector::BI__builtin_rvv_vlseg3e16_v_tu:
7275case RISCVVector::BI__builtin_rvv_vlseg3e32_v_tu:
7276case RISCVVector::BI__builtin_rvv_vlseg3e64_v_tu:
7277 ID = Intrinsic::riscv_vlseg3;
7278 NF = 3;
7279 DefaultPolicy = 0;
7280IsMasked = false;
7281
7282 {
7283 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
7284 IntrinsicTypes = {ResultType, Ops.back()->getType()};
7285 SmallVector<llvm::Value*, 10> Operands;
7286 if (IsMasked) {
7287 // TAMA builtin: (val0 address, ..., mask, ptr, vl)
7288 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
7289 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
7290 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
7291 for (unsigned I = 0; I < NF; ++I)
7292 Operands.push_back(llvm::PoisonValue::get(ResultType));
7293 Operands.push_back(Ops[NF + 1]);
7294 Operands.push_back(Ops[NF]);
7295 Operands.push_back(Ops[NF + 2]);
7296 } else {
7297 for (unsigned I = 0; I < NF; ++I)
7298 Operands.push_back(Ops[NF + I + 1]);
7299 Operands.push_back(Ops[2 * NF + 1]);
7300 Operands.push_back(Ops[NF]);
7301 Operands.push_back(Ops[2 * NF + 2]);
7302 }
7303 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
7304 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 7304, __extension__ __PRETTY_FUNCTION__));
7305 } else {
7306 // TA builtin: (val0 address, val1 address, ..., ptr, vl)
7307 // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
7308 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
7309 if (DefaultPolicy == TAIL_AGNOSTIC) {
7310 for (unsigned I = 0; I < NF; ++I)
7311 Operands.push_back(llvm::PoisonValue::get(ResultType));
7312 Operands.push_back(Ops[NF]);
7313 Operands.push_back(Ops[NF + 1]);
7314 } else {
7315 for (unsigned I = 0; I < NF; ++I)
7316 Operands.push_back(Ops[NF + I]);
7317 Operands.push_back(Ops[2 * NF]);
7318 Operands.push_back(Ops[2 * NF + 1]);
7319 }
7320 }
7321 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
7322 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
7323 clang::CharUnits Align =
7324 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
7325 llvm::Value *V;
7326 for (unsigned I = 0; I < NF; ++I) {
7327 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
7328 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
7329 }
7330 return V;
7331 }
7332 break;
7333case RISCVVector::BI__builtin_rvv_vlseg3e8_v_ta:
7334case RISCVVector::BI__builtin_rvv_vlseg3e16_v_ta:
7335case RISCVVector::BI__builtin_rvv_vlseg3e32_v_ta:
7336case RISCVVector::BI__builtin_rvv_vlseg3e64_v_ta:
7337 ID = Intrinsic::riscv_vlseg3;
7338 NF = 3;
7339 DefaultPolicy = 1;
7340IsMasked = false;
7341
7342 {
7343 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
7344 IntrinsicTypes = {ResultType, Ops.back()->getType()};
7345 SmallVector<llvm::Value*, 10> Operands;
7346 if (IsMasked) {
7347 // TAMA builtin: (val0 address, ..., mask, ptr, vl)
7348 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
7349 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
7350 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
7351 for (unsigned I = 0; I < NF; ++I)
7352 Operands.push_back(llvm::PoisonValue::get(ResultType));
7353 Operands.push_back(Ops[NF + 1]);
7354 Operands.push_back(Ops[NF]);
7355 Operands.push_back(Ops[NF + 2]);
7356 } else {
7357 for (unsigned I = 0; I < NF; ++I)
7358 Operands.push_back(Ops[NF + I + 1]);
7359 Operands.push_back(Ops[2 * NF + 1]);
7360 Operands.push_back(Ops[NF]);
7361 Operands.push_back(Ops[2 * NF + 2]);
7362 }
7363 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
7364 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 7364, __extension__ __PRETTY_FUNCTION__));
7365 } else {
7366 // TA builtin: (val0 address, val1 address, ..., ptr, vl)
7367 // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
7368 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
7369 if (DefaultPolicy == TAIL_AGNOSTIC) {
7370 for (unsigned I = 0; I < NF; ++I)
7371 Operands.push_back(llvm::PoisonValue::get(ResultType));
7372 Operands.push_back(Ops[NF]);
7373 Operands.push_back(Ops[NF + 1]);
7374 } else {
7375 for (unsigned I = 0; I < NF; ++I)
7376 Operands.push_back(Ops[NF + I]);
7377 Operands.push_back(Ops[2 * NF]);
7378 Operands.push_back(Ops[2 * NF + 1]);
7379 }
7380 }
7381 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
7382 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
7383 clang::CharUnits Align =
7384 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
7385 llvm::Value *V;
7386 for (unsigned I = 0; I < NF; ++I) {
7387 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
7388 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
7389 }
7390 return V;
7391 }
7392 break;
7393case RISCVVector::BI__builtin_rvv_vlseg3e8_v_tuma:
7394case RISCVVector::BI__builtin_rvv_vlseg3e16_v_tuma:
7395case RISCVVector::BI__builtin_rvv_vlseg3e32_v_tuma:
7396case RISCVVector::BI__builtin_rvv_vlseg3e64_v_tuma:
7397 ID = Intrinsic::riscv_vlseg3_mask;
7398 NF = 3;
7399 DefaultPolicy = 2;
7400IsMasked = true;
7401
7402 {
7403 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
7404 IntrinsicTypes = {ResultType, Ops.back()->getType()};
7405 SmallVector<llvm::Value*, 10> Operands;
7406 if (IsMasked) {
7407 // TAMA builtin: (val0 address, ..., mask, ptr, vl)
7408 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
7409 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
7410 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
7411 for (unsigned I = 0; I < NF; ++I)
7412 Operands.push_back(llvm::PoisonValue::get(ResultType));
7413 Operands.push_back(Ops[NF + 1]);
7414 Operands.push_back(Ops[NF]);
7415 Operands.push_back(Ops[NF + 2]);
7416 } else {
7417 for (unsigned I = 0; I < NF; ++I)
7418 Operands.push_back(Ops[NF + I + 1]);
7419 Operands.push_back(Ops[2 * NF + 1]);
7420 Operands.push_back(Ops[NF]);
7421 Operands.push_back(Ops[2 * NF + 2]);
7422 }
7423 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
7424 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 7424, __extension__ __PRETTY_FUNCTION__));
7425 } else {
7426 // TA builtin: (val0 address, val1 address, ..., ptr, vl)
7427 // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
7428 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
7429 if (DefaultPolicy == TAIL_AGNOSTIC) {
7430 for (unsigned I = 0; I < NF; ++I)
7431 Operands.push_back(llvm::PoisonValue::get(ResultType));
7432 Operands.push_back(Ops[NF]);
7433 Operands.push_back(Ops[NF + 1]);
7434 } else {
7435 for (unsigned I = 0; I < NF; ++I)
7436 Operands.push_back(Ops[NF + I]);
7437 Operands.push_back(Ops[2 * NF]);
7438 Operands.push_back(Ops[2 * NF + 1]);
7439 }
7440 }
7441 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
7442 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
7443 clang::CharUnits Align =
7444 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
7445 llvm::Value *V;
7446 for (unsigned I = 0; I < NF; ++I) {
7447 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
7448 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
7449 }
7450 return V;
7451 }
7452 break;
7453case RISCVVector::BI__builtin_rvv_vlseg3e8_v_tama:
7454case RISCVVector::BI__builtin_rvv_vlseg3e16_v_tama:
7455case RISCVVector::BI__builtin_rvv_vlseg3e32_v_tama:
7456case RISCVVector::BI__builtin_rvv_vlseg3e64_v_tama:
7457 ID = Intrinsic::riscv_vlseg3_mask;
7458 NF = 3;
7459 DefaultPolicy = 3;
7460IsMasked = true;
7461
7462 {
7463 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
7464 IntrinsicTypes = {ResultType, Ops.back()->getType()};
7465 SmallVector<llvm::Value*, 10> Operands;
7466 if (IsMasked) {
7467 // TAMA builtin: (val0 address, ..., mask, ptr, vl)
7468 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
7469 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
7470 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
7471 for (unsigned I = 0; I < NF; ++I)
7472 Operands.push_back(llvm::PoisonValue::get(ResultType));
7473 Operands.push_back(Ops[NF + 1]);
7474 Operands.push_back(Ops[NF]);
7475 Operands.push_back(Ops[NF + 2]);
7476 } else {
7477 for (unsigned I = 0; I < NF; ++I)
7478 Operands.push_back(Ops[NF + I + 1]);
7479 Operands.push_back(Ops[2 * NF + 1]);
7480 Operands.push_back(Ops[NF]);
7481 Operands.push_back(Ops[2 * NF + 2]);
7482 }
7483 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
7484 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 7484, __extension__ __PRETTY_FUNCTION__));
7485 } else {
7486 // TA builtin: (val0 address, val1 address, ..., ptr, vl)
7487 // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
7488 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
7489 if (DefaultPolicy == TAIL_AGNOSTIC) {
7490 for (unsigned I = 0; I < NF; ++I)
7491 Operands.push_back(llvm::PoisonValue::get(ResultType));
7492 Operands.push_back(Ops[NF]);
7493 Operands.push_back(Ops[NF + 1]);
7494 } else {
7495 for (unsigned I = 0; I < NF; ++I)
7496 Operands.push_back(Ops[NF + I]);
7497 Operands.push_back(Ops[2 * NF]);
7498 Operands.push_back(Ops[2 * NF + 1]);
7499 }
7500 }
7501 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
7502 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
7503 clang::CharUnits Align =
7504 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
7505 llvm::Value *V;
7506 for (unsigned I = 0; I < NF; ++I) {
7507 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
7508 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
7509 }
7510 return V;
7511 }
7512 break;
7513case RISCVVector::BI__builtin_rvv_vlseg3e8_v_tumu:
7514case RISCVVector::BI__builtin_rvv_vlseg3e16_v_tumu:
7515case RISCVVector::BI__builtin_rvv_vlseg3e32_v_tumu:
7516case RISCVVector::BI__builtin_rvv_vlseg3e64_v_tumu:
7517 ID = Intrinsic::riscv_vlseg3_mask;
7518 NF = 3;
7519 DefaultPolicy = 0;
7520IsMasked = true;
7521
7522 {
7523 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
7524 IntrinsicTypes = {ResultType, Ops.back()->getType()};
7525 SmallVector<llvm::Value*, 10> Operands;
7526 if (IsMasked) {
7527 // TAMA builtin: (val0 address, ..., mask, ptr, vl)
7528 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
7529 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
7530 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
7531 for (unsigned I = 0; I < NF; ++I)
7532 Operands.push_back(llvm::PoisonValue::get(ResultType));
7533 Operands.push_back(Ops[NF + 1]);
7534 Operands.push_back(Ops[NF]);
7535 Operands.push_back(Ops[NF + 2]);
7536 } else {
7537 for (unsigned I = 0; I < NF; ++I)
7538 Operands.push_back(Ops[NF + I + 1]);
7539 Operands.push_back(Ops[2 * NF + 1]);
7540 Operands.push_back(Ops[NF]);
7541 Operands.push_back(Ops[2 * NF + 2]);
7542 }
7543 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
7544 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 7544, __extension__ __PRETTY_FUNCTION__));
7545 } else {
7546 // TA builtin: (val0 address, val1 address, ..., ptr, vl)
7547 // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
7548 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
7549 if (DefaultPolicy == TAIL_AGNOSTIC) {
7550 for (unsigned I = 0; I < NF; ++I)
7551 Operands.push_back(llvm::PoisonValue::get(ResultType));
7552 Operands.push_back(Ops[NF]);
7553 Operands.push_back(Ops[NF + 1]);
7554 } else {
7555 for (unsigned I = 0; I < NF; ++I)
7556 Operands.push_back(Ops[NF + I]);
7557 Operands.push_back(Ops[2 * NF]);
7558 Operands.push_back(Ops[2 * NF + 1]);
7559 }
7560 }
7561 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
7562 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
7563 clang::CharUnits Align =
7564 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
7565 llvm::Value *V;
7566 for (unsigned I = 0; I < NF; ++I) {
7567 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
7568 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
7569 }
7570 return V;
7571 }
7572 break;
7573case RISCVVector::BI__builtin_rvv_vlseg3e8_v_tamu:
7574case RISCVVector::BI__builtin_rvv_vlseg3e16_v_tamu:
7575case RISCVVector::BI__builtin_rvv_vlseg3e32_v_tamu:
7576case RISCVVector::BI__builtin_rvv_vlseg3e64_v_tamu:
7577 ID = Intrinsic::riscv_vlseg3_mask;
7578 NF = 3;
7579 DefaultPolicy = 1;
7580IsMasked = true;
7581
7582 {
7583 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
7584 IntrinsicTypes = {ResultType, Ops.back()->getType()};
7585 SmallVector<llvm::Value*, 10> Operands;
7586 if (IsMasked) {
7587 // TAMA builtin: (val0 address, ..., mask, ptr, vl)
7588 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
7589 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
7590 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
7591 for (unsigned I = 0; I < NF; ++I)
7592 Operands.push_back(llvm::PoisonValue::get(ResultType));
7593 Operands.push_back(Ops[NF + 1]);
7594 Operands.push_back(Ops[NF]);
7595 Operands.push_back(Ops[NF + 2]);
7596 } else {
7597 for (unsigned I = 0; I < NF; ++I)
7598 Operands.push_back(Ops[NF + I + 1]);
7599 Operands.push_back(Ops[2 * NF + 1]);
7600 Operands.push_back(Ops[NF]);
7601 Operands.push_back(Ops[2 * NF + 2]);
7602 }
7603 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
7604 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 7604, __extension__ __PRETTY_FUNCTION__));
7605 } else {
7606 // TA builtin: (val0 address, val1 address, ..., ptr, vl)
7607 // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
7608 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
7609 if (DefaultPolicy == TAIL_AGNOSTIC) {
7610 for (unsigned I = 0; I < NF; ++I)
7611 Operands.push_back(llvm::PoisonValue::get(ResultType));
7612 Operands.push_back(Ops[NF]);
7613 Operands.push_back(Ops[NF + 1]);
7614 } else {
7615 for (unsigned I = 0; I < NF; ++I)
7616 Operands.push_back(Ops[NF + I]);
7617 Operands.push_back(Ops[2 * NF]);
7618 Operands.push_back(Ops[2 * NF + 1]);
7619 }
7620 }
7621 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
7622 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
7623 clang::CharUnits Align =
7624 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
7625 llvm::Value *V;
7626 for (unsigned I = 0; I < NF; ++I) {
7627 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
7628 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
7629 }
7630 return V;
7631 }
7632 break;
7633case RISCVVector::BI__builtin_rvv_vlseg3e8ff_v_tu:
7634case RISCVVector::BI__builtin_rvv_vlseg3e16ff_v_tu:
7635case RISCVVector::BI__builtin_rvv_vlseg3e32ff_v_tu:
7636case RISCVVector::BI__builtin_rvv_vlseg3e64ff_v_tu:
7637 ID = Intrinsic::riscv_vlseg3ff;
7638 NF = 3;
7639 DefaultPolicy = 0;
7640IsMasked = false;
7641
7642 {
7643 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
7644 IntrinsicTypes = {ResultType, Ops.back()->getType()};
7645 SmallVector<llvm::Value*, 12> Operands;
7646 Value *NewVL;
7647
7648 if (IsMasked) {
7649 // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
7650 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
7651 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
7652 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
7653 for (unsigned I = 0; I < NF; ++I)
7654 Operands.push_back(llvm::PoisonValue::get(ResultType));
7655 Operands.push_back(Ops[NF + 1]);
7656 Operands.push_back(Ops[NF]);
7657 Operands.push_back(Ops[NF + 3]);
7658 NewVL = Ops[NF + 2];
7659 } else {
7660 for (unsigned I = 0; I < NF; ++I)
7661 Operands.push_back(Ops[NF + I + 1]);
7662 Operands.push_back(Ops[2 * NF + 1]);
7663 Operands.push_back(Ops[NF]);
7664 Operands.push_back(Ops[2 * NF + 3]);
7665 NewVL = Ops[2 * NF + 2];
7666 }
7667 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
7668 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 7668, __extension__ __PRETTY_FUNCTION__));
7669 } else {
7670 // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
7671 // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
7672 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
7673 if (DefaultPolicy == TAIL_AGNOSTIC) {
7674 for (unsigned I = 0; I < NF; ++I)
7675 Operands.push_back(llvm::PoisonValue::get(ResultType));
7676 Operands.push_back(Ops[NF]);
7677 Operands.push_back(Ops[NF + 2]);
7678 NewVL = Ops[NF + 1];
7679 } else {
7680 for (unsigned I = 0; I < NF; ++I)
7681 Operands.push_back(Ops[NF + I]);
7682 Operands.push_back(Ops[2 * NF]);
7683 Operands.push_back(Ops[2 * NF + 2]);
7684 NewVL = Ops[2 * NF + 1];
7685 }
7686 }
7687 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
7688 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
7689 clang::CharUnits Align =
7690 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
7691 for (unsigned I = 0; I < NF; ++I) {
7692 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
7693 Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
7694 }
7695 // Store new_vl.
7696 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
7697 return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
7698 }
7699 break;
7700case RISCVVector::BI__builtin_rvv_vlseg3e8ff_v_ta:
7701case RISCVVector::BI__builtin_rvv_vlseg3e16ff_v_ta:
7702case RISCVVector::BI__builtin_rvv_vlseg3e32ff_v_ta:
7703case RISCVVector::BI__builtin_rvv_vlseg3e64ff_v_ta:
7704 ID = Intrinsic::riscv_vlseg3ff;
7705 NF = 3;
7706 DefaultPolicy = 1;
7707IsMasked = false;
7708
7709 {
7710 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
7711 IntrinsicTypes = {ResultType, Ops.back()->getType()};
7712 SmallVector<llvm::Value*, 12> Operands;
7713 Value *NewVL;
7714
7715 if (IsMasked) {
7716 // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
7717 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
7718 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
7719 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
7720 for (unsigned I = 0; I < NF; ++I)
7721 Operands.push_back(llvm::PoisonValue::get(ResultType));
7722 Operands.push_back(Ops[NF + 1]);
7723 Operands.push_back(Ops[NF]);
7724 Operands.push_back(Ops[NF + 3]);
7725 NewVL = Ops[NF + 2];
7726 } else {
7727 for (unsigned I = 0; I < NF; ++I)
7728 Operands.push_back(Ops[NF + I + 1]);
7729 Operands.push_back(Ops[2 * NF + 1]);
7730 Operands.push_back(Ops[NF]);
7731 Operands.push_back(Ops[2 * NF + 3]);
7732 NewVL = Ops[2 * NF + 2];
7733 }
7734 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
7735 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 7735, __extension__ __PRETTY_FUNCTION__));
7736 } else {
7737 // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
7738 // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
7739 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
7740 if (DefaultPolicy == TAIL_AGNOSTIC) {
7741 for (unsigned I = 0; I < NF; ++I)
7742 Operands.push_back(llvm::PoisonValue::get(ResultType));
7743 Operands.push_back(Ops[NF]);
7744 Operands.push_back(Ops[NF + 2]);
7745 NewVL = Ops[NF + 1];
7746 } else {
7747 for (unsigned I = 0; I < NF; ++I)
7748 Operands.push_back(Ops[NF + I]);
7749 Operands.push_back(Ops[2 * NF]);
7750 Operands.push_back(Ops[2 * NF + 2]);
7751 NewVL = Ops[2 * NF + 1];
7752 }
7753 }
7754 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
7755 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
7756 clang::CharUnits Align =
7757 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
7758 for (unsigned I = 0; I < NF; ++I) {
7759 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
7760 Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
7761 }
7762 // Store new_vl.
7763 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
7764 return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
7765 }
7766 break;
7767case RISCVVector::BI__builtin_rvv_vlseg3e8ff_v_tuma:
7768case RISCVVector::BI__builtin_rvv_vlseg3e16ff_v_tuma:
7769case RISCVVector::BI__builtin_rvv_vlseg3e32ff_v_tuma:
7770case RISCVVector::BI__builtin_rvv_vlseg3e64ff_v_tuma:
7771 ID = Intrinsic::riscv_vlseg3ff_mask;
7772 NF = 3;
7773 DefaultPolicy = 2;
7774IsMasked = true;
7775
7776 {
7777 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
7778 IntrinsicTypes = {ResultType, Ops.back()->getType()};
7779 SmallVector<llvm::Value*, 12> Operands;
7780 Value *NewVL;
7781
7782 if (IsMasked) {
7783 // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
7784 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
7785 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
7786 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
7787 for (unsigned I = 0; I < NF; ++I)
7788 Operands.push_back(llvm::PoisonValue::get(ResultType));
7789 Operands.push_back(Ops[NF + 1]);
7790 Operands.push_back(Ops[NF]);
7791 Operands.push_back(Ops[NF + 3]);
7792 NewVL = Ops[NF + 2];
7793 } else {
7794 for (unsigned I = 0; I < NF; ++I)
7795 Operands.push_back(Ops[NF + I + 1]);
7796 Operands.push_back(Ops[2 * NF + 1]);
7797 Operands.push_back(Ops[NF]);
7798 Operands.push_back(Ops[2 * NF + 3]);
7799 NewVL = Ops[2 * NF + 2];
7800 }
7801 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
7802 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 7802, __extension__ __PRETTY_FUNCTION__));
7803 } else {
7804 // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
7805 // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
7806 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
7807 if (DefaultPolicy == TAIL_AGNOSTIC) {
7808 for (unsigned I = 0; I < NF; ++I)
7809 Operands.push_back(llvm::PoisonValue::get(ResultType));
7810 Operands.push_back(Ops[NF]);
7811 Operands.push_back(Ops[NF + 2]);
7812 NewVL = Ops[NF + 1];
7813 } else {
7814 for (unsigned I = 0; I < NF; ++I)
7815 Operands.push_back(Ops[NF + I]);
7816 Operands.push_back(Ops[2 * NF]);
7817 Operands.push_back(Ops[2 * NF + 2]);
7818 NewVL = Ops[2 * NF + 1];
7819 }
7820 }
7821 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
7822 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
7823 clang::CharUnits Align =
7824 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
7825 for (unsigned I = 0; I < NF; ++I) {
7826 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
7827 Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
7828 }
7829 // Store new_vl.
7830 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
7831 return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
7832 }
7833 break;
7834case RISCVVector::BI__builtin_rvv_vlseg3e8ff_v_tama:
7835case RISCVVector::BI__builtin_rvv_vlseg3e16ff_v_tama:
7836case RISCVVector::BI__builtin_rvv_vlseg3e32ff_v_tama:
7837case RISCVVector::BI__builtin_rvv_vlseg3e64ff_v_tama:
7838 ID = Intrinsic::riscv_vlseg3ff_mask;
7839 NF = 3;
7840 DefaultPolicy = 3;
7841IsMasked = true;
7842
7843 {
7844 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
7845 IntrinsicTypes = {ResultType, Ops.back()->getType()};
7846 SmallVector<llvm::Value*, 12> Operands;
7847 Value *NewVL;
7848
7849 if (IsMasked) {
7850 // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
7851 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
7852 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
7853 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
7854 for (unsigned I = 0; I < NF; ++I)
7855 Operands.push_back(llvm::PoisonValue::get(ResultType));
7856 Operands.push_back(Ops[NF + 1]);
7857 Operands.push_back(Ops[NF]);
7858 Operands.push_back(Ops[NF + 3]);
7859 NewVL = Ops[NF + 2];
7860 } else {
7861 for (unsigned I = 0; I < NF; ++I)
7862 Operands.push_back(Ops[NF + I + 1]);
7863 Operands.push_back(Ops[2 * NF + 1]);
7864 Operands.push_back(Ops[NF]);
7865 Operands.push_back(Ops[2 * NF + 3]);
7866 NewVL = Ops[2 * NF + 2];
7867 }
7868 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
7869 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 7869, __extension__ __PRETTY_FUNCTION__));
7870 } else {
7871 // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
7872 // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
7873 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
7874 if (DefaultPolicy == TAIL_AGNOSTIC) {
7875 for (unsigned I = 0; I < NF; ++I)
7876 Operands.push_back(llvm::PoisonValue::get(ResultType));
7877 Operands.push_back(Ops[NF]);
7878 Operands.push_back(Ops[NF + 2]);
7879 NewVL = Ops[NF + 1];
7880 } else {
7881 for (unsigned I = 0; I < NF; ++I)
7882 Operands.push_back(Ops[NF + I]);
7883 Operands.push_back(Ops[2 * NF]);
7884 Operands.push_back(Ops[2 * NF + 2]);
7885 NewVL = Ops[2 * NF + 1];
7886 }
7887 }
7888 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
7889 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
7890 clang::CharUnits Align =
7891 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
7892 for (unsigned I = 0; I < NF; ++I) {
7893 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
7894 Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
7895 }
7896 // Store new_vl.
7897 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
7898 return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
7899 }
7900 break;
7901case RISCVVector::BI__builtin_rvv_vlseg3e8ff_v_tumu:
7902case RISCVVector::BI__builtin_rvv_vlseg3e16ff_v_tumu:
7903case RISCVVector::BI__builtin_rvv_vlseg3e32ff_v_tumu:
7904case RISCVVector::BI__builtin_rvv_vlseg3e64ff_v_tumu:
7905 ID = Intrinsic::riscv_vlseg3ff_mask;
7906 NF = 3;
7907 DefaultPolicy = 0;
7908IsMasked = true;
7909
7910 {
7911 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
7912 IntrinsicTypes = {ResultType, Ops.back()->getType()};
7913 SmallVector<llvm::Value*, 12> Operands;
7914 Value *NewVL;
7915
7916 if (IsMasked) {
7917 // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
7918 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
7919 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
7920 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
7921 for (unsigned I = 0; I < NF; ++I)
7922 Operands.push_back(llvm::PoisonValue::get(ResultType));
7923 Operands.push_back(Ops[NF + 1]);
7924 Operands.push_back(Ops[NF]);
7925 Operands.push_back(Ops[NF + 3]);
7926 NewVL = Ops[NF + 2];
7927 } else {
7928 for (unsigned I = 0; I < NF; ++I)
7929 Operands.push_back(Ops[NF + I + 1]);
7930 Operands.push_back(Ops[2 * NF + 1]);
7931 Operands.push_back(Ops[NF]);
7932 Operands.push_back(Ops[2 * NF + 3]);
7933 NewVL = Ops[2 * NF + 2];
7934 }
7935 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
7936 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 7936, __extension__ __PRETTY_FUNCTION__));
7937 } else {
7938 // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
7939 // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
7940 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
7941 if (DefaultPolicy == TAIL_AGNOSTIC) {
7942 for (unsigned I = 0; I < NF; ++I)
7943 Operands.push_back(llvm::PoisonValue::get(ResultType));
7944 Operands.push_back(Ops[NF]);
7945 Operands.push_back(Ops[NF + 2]);
7946 NewVL = Ops[NF + 1];
7947 } else {
7948 for (unsigned I = 0; I < NF; ++I)
7949 Operands.push_back(Ops[NF + I]);
7950 Operands.push_back(Ops[2 * NF]);
7951 Operands.push_back(Ops[2 * NF + 2]);
7952 NewVL = Ops[2 * NF + 1];
7953 }
7954 }
7955 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
7956 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
7957 clang::CharUnits Align =
7958 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
7959 for (unsigned I = 0; I < NF; ++I) {
7960 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
7961 Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
7962 }
7963 // Store new_vl.
7964 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
7965 return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
7966 }
7967 break;
7968case RISCVVector::BI__builtin_rvv_vlseg3e8ff_v_tamu:
7969case RISCVVector::BI__builtin_rvv_vlseg3e16ff_v_tamu:
7970case RISCVVector::BI__builtin_rvv_vlseg3e32ff_v_tamu:
7971case RISCVVector::BI__builtin_rvv_vlseg3e64ff_v_tamu:
7972 ID = Intrinsic::riscv_vlseg3ff_mask;
7973 NF = 3;
7974 DefaultPolicy = 1;
7975IsMasked = true;
7976
7977 {
7978 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
7979 IntrinsicTypes = {ResultType, Ops.back()->getType()};
7980 SmallVector<llvm::Value*, 12> Operands;
7981 Value *NewVL;
7982
7983 if (IsMasked) {
7984 // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
7985 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
7986 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
7987 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
7988 for (unsigned I = 0; I < NF; ++I)
7989 Operands.push_back(llvm::PoisonValue::get(ResultType));
7990 Operands.push_back(Ops[NF + 1]);
7991 Operands.push_back(Ops[NF]);
7992 Operands.push_back(Ops[NF + 3]);
7993 NewVL = Ops[NF + 2];
7994 } else {
7995 for (unsigned I = 0; I < NF; ++I)
7996 Operands.push_back(Ops[NF + I + 1]);
7997 Operands.push_back(Ops[2 * NF + 1]);
7998 Operands.push_back(Ops[NF]);
7999 Operands.push_back(Ops[2 * NF + 3]);
8000 NewVL = Ops[2 * NF + 2];
8001 }
8002 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
8003 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 8003, __extension__ __PRETTY_FUNCTION__));
8004 } else {
8005 // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
8006 // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
8007 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
8008 if (DefaultPolicy == TAIL_AGNOSTIC) {
8009 for (unsigned I = 0; I < NF; ++I)
8010 Operands.push_back(llvm::PoisonValue::get(ResultType));
8011 Operands.push_back(Ops[NF]);
8012 Operands.push_back(Ops[NF + 2]);
8013 NewVL = Ops[NF + 1];
8014 } else {
8015 for (unsigned I = 0; I < NF; ++I)
8016 Operands.push_back(Ops[NF + I]);
8017 Operands.push_back(Ops[2 * NF]);
8018 Operands.push_back(Ops[2 * NF + 2]);
8019 NewVL = Ops[2 * NF + 1];
8020 }
8021 }
8022 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
8023 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
8024 clang::CharUnits Align =
8025 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
8026 for (unsigned I = 0; I < NF; ++I) {
8027 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
8028 Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
8029 }
8030 // Store new_vl.
8031 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
8032 return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
8033 }
8034 break;
8035case RISCVVector::BI__builtin_rvv_vlseg4e8_v_tu:
8036case RISCVVector::BI__builtin_rvv_vlseg4e16_v_tu:
8037case RISCVVector::BI__builtin_rvv_vlseg4e32_v_tu:
8038case RISCVVector::BI__builtin_rvv_vlseg4e64_v_tu:
8039 ID = Intrinsic::riscv_vlseg4;
8040 NF = 4;
8041 DefaultPolicy = 0;
8042IsMasked = false;
8043
8044 {
8045 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
8046 IntrinsicTypes = {ResultType, Ops.back()->getType()};
8047 SmallVector<llvm::Value*, 10> Operands;
8048 if (IsMasked) {
8049 // TAMA builtin: (val0 address, ..., mask, ptr, vl)
8050 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
8051 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
8052 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
8053 for (unsigned I = 0; I < NF; ++I)
8054 Operands.push_back(llvm::PoisonValue::get(ResultType));
8055 Operands.push_back(Ops[NF + 1]);
8056 Operands.push_back(Ops[NF]);
8057 Operands.push_back(Ops[NF + 2]);
8058 } else {
8059 for (unsigned I = 0; I < NF; ++I)
8060 Operands.push_back(Ops[NF + I + 1]);
8061 Operands.push_back(Ops[2 * NF + 1]);
8062 Operands.push_back(Ops[NF]);
8063 Operands.push_back(Ops[2 * NF + 2]);
8064 }
8065 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
8066 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 8066, __extension__ __PRETTY_FUNCTION__));
8067 } else {
8068 // TA builtin: (val0 address, val1 address, ..., ptr, vl)
8069 // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
8070 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
8071 if (DefaultPolicy == TAIL_AGNOSTIC) {
8072 for (unsigned I = 0; I < NF; ++I)
8073 Operands.push_back(llvm::PoisonValue::get(ResultType));
8074 Operands.push_back(Ops[NF]);
8075 Operands.push_back(Ops[NF + 1]);
8076 } else {
8077 for (unsigned I = 0; I < NF; ++I)
8078 Operands.push_back(Ops[NF + I]);
8079 Operands.push_back(Ops[2 * NF]);
8080 Operands.push_back(Ops[2 * NF + 1]);
8081 }
8082 }
8083 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
8084 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
8085 clang::CharUnits Align =
8086 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
8087 llvm::Value *V;
8088 for (unsigned I = 0; I < NF; ++I) {
8089 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
8090 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
8091 }
8092 return V;
8093 }
8094 break;
8095case RISCVVector::BI__builtin_rvv_vlseg4e8_v_ta:
8096case RISCVVector::BI__builtin_rvv_vlseg4e16_v_ta:
8097case RISCVVector::BI__builtin_rvv_vlseg4e32_v_ta:
8098case RISCVVector::BI__builtin_rvv_vlseg4e64_v_ta:
8099 ID = Intrinsic::riscv_vlseg4;
8100 NF = 4;
8101 DefaultPolicy = 1;
8102IsMasked = false;
8103
8104 {
8105 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
8106 IntrinsicTypes = {ResultType, Ops.back()->getType()};
8107 SmallVector<llvm::Value*, 10> Operands;
8108 if (IsMasked) {
8109 // TAMA builtin: (val0 address, ..., mask, ptr, vl)
8110 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
8111 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
8112 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
8113 for (unsigned I = 0; I < NF; ++I)
8114 Operands.push_back(llvm::PoisonValue::get(ResultType));
8115 Operands.push_back(Ops[NF + 1]);
8116 Operands.push_back(Ops[NF]);
8117 Operands.push_back(Ops[NF + 2]);
8118 } else {
8119 for (unsigned I = 0; I < NF; ++I)
8120 Operands.push_back(Ops[NF + I + 1]);
8121 Operands.push_back(Ops[2 * NF + 1]);
8122 Operands.push_back(Ops[NF]);
8123 Operands.push_back(Ops[2 * NF + 2]);
8124 }
8125 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
8126 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 8126, __extension__ __PRETTY_FUNCTION__));
8127 } else {
8128 // TA builtin: (val0 address, val1 address, ..., ptr, vl)
8129 // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
8130 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
8131 if (DefaultPolicy == TAIL_AGNOSTIC) {
8132 for (unsigned I = 0; I < NF; ++I)
8133 Operands.push_back(llvm::PoisonValue::get(ResultType));
8134 Operands.push_back(Ops[NF]);
8135 Operands.push_back(Ops[NF + 1]);
8136 } else {
8137 for (unsigned I = 0; I < NF; ++I)
8138 Operands.push_back(Ops[NF + I]);
8139 Operands.push_back(Ops[2 * NF]);
8140 Operands.push_back(Ops[2 * NF + 1]);
8141 }
8142 }
8143 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
8144 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
8145 clang::CharUnits Align =
8146 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
8147 llvm::Value *V;
8148 for (unsigned I = 0; I < NF; ++I) {
8149 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
8150 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
8151 }
8152 return V;
8153 }
8154 break;
8155case RISCVVector::BI__builtin_rvv_vlseg4e8_v_tuma:
8156case RISCVVector::BI__builtin_rvv_vlseg4e16_v_tuma:
8157case RISCVVector::BI__builtin_rvv_vlseg4e32_v_tuma:
8158case RISCVVector::BI__builtin_rvv_vlseg4e64_v_tuma:
8159 ID = Intrinsic::riscv_vlseg4_mask;
8160 NF = 4;
8161 DefaultPolicy = 2;
8162IsMasked = true;
8163
8164 {
8165 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
8166 IntrinsicTypes = {ResultType, Ops.back()->getType()};
8167 SmallVector<llvm::Value*, 10> Operands;
8168 if (IsMasked) {
8169 // TAMA builtin: (val0 address, ..., mask, ptr, vl)
8170 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
8171 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
8172 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
8173 for (unsigned I = 0; I < NF; ++I)
8174 Operands.push_back(llvm::PoisonValue::get(ResultType));
8175 Operands.push_back(Ops[NF + 1]);
8176 Operands.push_back(Ops[NF]);
8177 Operands.push_back(Ops[NF + 2]);
8178 } else {
8179 for (unsigned I = 0; I < NF; ++I)
8180 Operands.push_back(Ops[NF + I + 1]);
8181 Operands.push_back(Ops[2 * NF + 1]);
8182 Operands.push_back(Ops[NF]);
8183 Operands.push_back(Ops[2 * NF + 2]);
8184 }
8185 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
8186 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 8186, __extension__ __PRETTY_FUNCTION__));
8187 } else {
8188 // TA builtin: (val0 address, val1 address, ..., ptr, vl)
8189 // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
8190 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
8191 if (DefaultPolicy == TAIL_AGNOSTIC) {
8192 for (unsigned I = 0; I < NF; ++I)
8193 Operands.push_back(llvm::PoisonValue::get(ResultType));
8194 Operands.push_back(Ops[NF]);
8195 Operands.push_back(Ops[NF + 1]);
8196 } else {
8197 for (unsigned I = 0; I < NF; ++I)
8198 Operands.push_back(Ops[NF + I]);
8199 Operands.push_back(Ops[2 * NF]);
8200 Operands.push_back(Ops[2 * NF + 1]);
8201 }
8202 }
8203 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
8204 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
8205 clang::CharUnits Align =
8206 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
8207 llvm::Value *V;
8208 for (unsigned I = 0; I < NF; ++I) {
8209 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
8210 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
8211 }
8212 return V;
8213 }
8214 break;
8215case RISCVVector::BI__builtin_rvv_vlseg4e8_v_tama:
8216case RISCVVector::BI__builtin_rvv_vlseg4e16_v_tama:
8217case RISCVVector::BI__builtin_rvv_vlseg4e32_v_tama:
8218case RISCVVector::BI__builtin_rvv_vlseg4e64_v_tama:
8219 ID = Intrinsic::riscv_vlseg4_mask;
8220 NF = 4;
8221 DefaultPolicy = 3;
8222IsMasked = true;
8223
8224 {
8225 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
8226 IntrinsicTypes = {ResultType, Ops.back()->getType()};
8227 SmallVector<llvm::Value*, 10> Operands;
8228 if (IsMasked) {
8229 // TAMA builtin: (val0 address, ..., mask, ptr, vl)
8230 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
8231 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
8232 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
8233 for (unsigned I = 0; I < NF; ++I)
8234 Operands.push_back(llvm::PoisonValue::get(ResultType));
8235 Operands.push_back(Ops[NF + 1]);
8236 Operands.push_back(Ops[NF]);
8237 Operands.push_back(Ops[NF + 2]);
8238 } else {
8239 for (unsigned I = 0; I < NF; ++I)
8240 Operands.push_back(Ops[NF + I + 1]);
8241 Operands.push_back(Ops[2 * NF + 1]);
8242 Operands.push_back(Ops[NF]);
8243 Operands.push_back(Ops[2 * NF + 2]);
8244 }
8245 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
8246 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 8246, __extension__ __PRETTY_FUNCTION__));
8247 } else {
8248 // TA builtin: (val0 address, val1 address, ..., ptr, vl)
8249 // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
8250 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
8251 if (DefaultPolicy == TAIL_AGNOSTIC) {
8252 for (unsigned I = 0; I < NF; ++I)
8253 Operands.push_back(llvm::PoisonValue::get(ResultType));
8254 Operands.push_back(Ops[NF]);
8255 Operands.push_back(Ops[NF + 1]);
8256 } else {
8257 for (unsigned I = 0; I < NF; ++I)
8258 Operands.push_back(Ops[NF + I]);
8259 Operands.push_back(Ops[2 * NF]);
8260 Operands.push_back(Ops[2 * NF + 1]);
8261 }
8262 }
8263 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
8264 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
8265 clang::CharUnits Align =
8266 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
8267 llvm::Value *V;
8268 for (unsigned I = 0; I < NF; ++I) {
8269 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
8270 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
8271 }
8272 return V;
8273 }
8274 break;
8275case RISCVVector::BI__builtin_rvv_vlseg4e8_v_tumu:
8276case RISCVVector::BI__builtin_rvv_vlseg4e16_v_tumu:
8277case RISCVVector::BI__builtin_rvv_vlseg4e32_v_tumu:
8278case RISCVVector::BI__builtin_rvv_vlseg4e64_v_tumu:
8279 ID = Intrinsic::riscv_vlseg4_mask;
8280 NF = 4;
8281 DefaultPolicy = 0;
8282IsMasked = true;
8283
8284 {
8285 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
8286 IntrinsicTypes = {ResultType, Ops.back()->getType()};
8287 SmallVector<llvm::Value*, 10> Operands;
8288 if (IsMasked) {
8289 // TAMA builtin: (val0 address, ..., mask, ptr, vl)
8290 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
8291 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
8292 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
8293 for (unsigned I = 0; I < NF; ++I)
8294 Operands.push_back(llvm::PoisonValue::get(ResultType));
8295 Operands.push_back(Ops[NF + 1]);
8296 Operands.push_back(Ops[NF]);
8297 Operands.push_back(Ops[NF + 2]);
8298 } else {
8299 for (unsigned I = 0; I < NF; ++I)
8300 Operands.push_back(Ops[NF + I + 1]);
8301 Operands.push_back(Ops[2 * NF + 1]);
8302 Operands.push_back(Ops[NF]);
8303 Operands.push_back(Ops[2 * NF + 2]);
8304 }
8305 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
8306 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 8306, __extension__ __PRETTY_FUNCTION__));
8307 } else {
8308 // TA builtin: (val0 address, val1 address, ..., ptr, vl)
8309 // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
8310 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
8311 if (DefaultPolicy == TAIL_AGNOSTIC) {
8312 for (unsigned I = 0; I < NF; ++I)
8313 Operands.push_back(llvm::PoisonValue::get(ResultType));
8314 Operands.push_back(Ops[NF]);
8315 Operands.push_back(Ops[NF + 1]);
8316 } else {
8317 for (unsigned I = 0; I < NF; ++I)
8318 Operands.push_back(Ops[NF + I]);
8319 Operands.push_back(Ops[2 * NF]);
8320 Operands.push_back(Ops[2 * NF + 1]);
8321 }
8322 }
8323 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
8324 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
8325 clang::CharUnits Align =
8326 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
8327 llvm::Value *V;
8328 for (unsigned I = 0; I < NF; ++I) {
8329 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
8330 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
8331 }
8332 return V;
8333 }
8334 break;
8335case RISCVVector::BI__builtin_rvv_vlseg4e8_v_tamu:
8336case RISCVVector::BI__builtin_rvv_vlseg4e16_v_tamu:
8337case RISCVVector::BI__builtin_rvv_vlseg4e32_v_tamu:
8338case RISCVVector::BI__builtin_rvv_vlseg4e64_v_tamu:
8339 ID = Intrinsic::riscv_vlseg4_mask;
8340 NF = 4;
8341 DefaultPolicy = 1;
8342IsMasked = true;
8343
8344 {
8345 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
8346 IntrinsicTypes = {ResultType, Ops.back()->getType()};
8347 SmallVector<llvm::Value*, 10> Operands;
8348 if (IsMasked) {
8349 // TAMA builtin: (val0 address, ..., mask, ptr, vl)
8350 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
8351 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
8352 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
8353 for (unsigned I = 0; I < NF; ++I)
8354 Operands.push_back(llvm::PoisonValue::get(ResultType));
8355 Operands.push_back(Ops[NF + 1]);
8356 Operands.push_back(Ops[NF]);
8357 Operands.push_back(Ops[NF + 2]);
8358 } else {
8359 for (unsigned I = 0; I < NF; ++I)
8360 Operands.push_back(Ops[NF + I + 1]);
8361 Operands.push_back(Ops[2 * NF + 1]);
8362 Operands.push_back(Ops[NF]);
8363 Operands.push_back(Ops[2 * NF + 2]);
8364 }
8365 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
8366 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 8366, __extension__ __PRETTY_FUNCTION__));
8367 } else {
8368 // TA builtin: (val0 address, val1 address, ..., ptr, vl)
8369 // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
8370 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
8371 if (DefaultPolicy == TAIL_AGNOSTIC) {
8372 for (unsigned I = 0; I < NF; ++I)
8373 Operands.push_back(llvm::PoisonValue::get(ResultType));
8374 Operands.push_back(Ops[NF]);
8375 Operands.push_back(Ops[NF + 1]);
8376 } else {
8377 for (unsigned I = 0; I < NF; ++I)
8378 Operands.push_back(Ops[NF + I]);
8379 Operands.push_back(Ops[2 * NF]);
8380 Operands.push_back(Ops[2 * NF + 1]);
8381 }
8382 }
8383 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
8384 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
8385 clang::CharUnits Align =
8386 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
8387 llvm::Value *V;
8388 for (unsigned I = 0; I < NF; ++I) {
8389 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
8390 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
8391 }
8392 return V;
8393 }
8394 break;
8395case RISCVVector::BI__builtin_rvv_vlseg4e8ff_v_tu:
8396case RISCVVector::BI__builtin_rvv_vlseg4e16ff_v_tu:
8397case RISCVVector::BI__builtin_rvv_vlseg4e32ff_v_tu:
8398case RISCVVector::BI__builtin_rvv_vlseg4e64ff_v_tu:
8399 ID = Intrinsic::riscv_vlseg4ff;
8400 NF = 4;
8401 DefaultPolicy = 0;
8402IsMasked = false;
8403
8404 {
8405 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
8406 IntrinsicTypes = {ResultType, Ops.back()->getType()};
8407 SmallVector<llvm::Value*, 12> Operands;
8408 Value *NewVL;
8409
8410 if (IsMasked) {
8411 // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
8412 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
8413 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
8414 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
8415 for (unsigned I = 0; I < NF; ++I)
8416 Operands.push_back(llvm::PoisonValue::get(ResultType));
8417 Operands.push_back(Ops[NF + 1]);
8418 Operands.push_back(Ops[NF]);
8419 Operands.push_back(Ops[NF + 3]);
8420 NewVL = Ops[NF + 2];
8421 } else {
8422 for (unsigned I = 0; I < NF; ++I)
8423 Operands.push_back(Ops[NF + I + 1]);
8424 Operands.push_back(Ops[2 * NF + 1]);
8425 Operands.push_back(Ops[NF]);
8426 Operands.push_back(Ops[2 * NF + 3]);
8427 NewVL = Ops[2 * NF + 2];
8428 }
8429 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
8430 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 8430, __extension__ __PRETTY_FUNCTION__));
8431 } else {
8432 // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
8433 // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
8434 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
8435 if (DefaultPolicy == TAIL_AGNOSTIC) {
8436 for (unsigned I = 0; I < NF; ++I)
8437 Operands.push_back(llvm::PoisonValue::get(ResultType));
8438 Operands.push_back(Ops[NF]);
8439 Operands.push_back(Ops[NF + 2]);
8440 NewVL = Ops[NF + 1];
8441 } else {
8442 for (unsigned I = 0; I < NF; ++I)
8443 Operands.push_back(Ops[NF + I]);
8444 Operands.push_back(Ops[2 * NF]);
8445 Operands.push_back(Ops[2 * NF + 2]);
8446 NewVL = Ops[2 * NF + 1];
8447 }
8448 }
8449 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
8450 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
8451 clang::CharUnits Align =
8452 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
8453 for (unsigned I = 0; I < NF; ++I) {
8454 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
8455 Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
8456 }
8457 // Store new_vl.
8458 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
8459 return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
8460 }
8461 break;
8462case RISCVVector::BI__builtin_rvv_vlseg4e8ff_v_ta:
8463case RISCVVector::BI__builtin_rvv_vlseg4e16ff_v_ta:
8464case RISCVVector::BI__builtin_rvv_vlseg4e32ff_v_ta:
8465case RISCVVector::BI__builtin_rvv_vlseg4e64ff_v_ta:
8466 ID = Intrinsic::riscv_vlseg4ff;
8467 NF = 4;
8468 DefaultPolicy = 1;
8469IsMasked = false;
8470
8471 {
8472 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
8473 IntrinsicTypes = {ResultType, Ops.back()->getType()};
8474 SmallVector<llvm::Value*, 12> Operands;
8475 Value *NewVL;
8476
8477 if (IsMasked) {
8478 // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
8479 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
8480 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
8481 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
8482 for (unsigned I = 0; I < NF; ++I)
8483 Operands.push_back(llvm::PoisonValue::get(ResultType));
8484 Operands.push_back(Ops[NF + 1]);
8485 Operands.push_back(Ops[NF]);
8486 Operands.push_back(Ops[NF + 3]);
8487 NewVL = Ops[NF + 2];
8488 } else {
8489 for (unsigned I = 0; I < NF; ++I)
8490 Operands.push_back(Ops[NF + I + 1]);
8491 Operands.push_back(Ops[2 * NF + 1]);
8492 Operands.push_back(Ops[NF]);
8493 Operands.push_back(Ops[2 * NF + 3]);
8494 NewVL = Ops[2 * NF + 2];
8495 }
8496 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
8497 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 8497, __extension__ __PRETTY_FUNCTION__));
8498 } else {
8499 // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
8500 // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
8501 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
8502 if (DefaultPolicy == TAIL_AGNOSTIC) {
8503 for (unsigned I = 0; I < NF; ++I)
8504 Operands.push_back(llvm::PoisonValue::get(ResultType));
8505 Operands.push_back(Ops[NF]);
8506 Operands.push_back(Ops[NF + 2]);
8507 NewVL = Ops[NF + 1];
8508 } else {
8509 for (unsigned I = 0; I < NF; ++I)
8510 Operands.push_back(Ops[NF + I]);
8511 Operands.push_back(Ops[2 * NF]);
8512 Operands.push_back(Ops[2 * NF + 2]);
8513 NewVL = Ops[2 * NF + 1];
8514 }
8515 }
8516 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
8517 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
8518 clang::CharUnits Align =
8519 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
8520 for (unsigned I = 0; I < NF; ++I) {
8521 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
8522 Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
8523 }
8524 // Store new_vl.
8525 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
8526 return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
8527 }
8528 break;
8529case RISCVVector::BI__builtin_rvv_vlseg4e8ff_v_tuma:
8530case RISCVVector::BI__builtin_rvv_vlseg4e16ff_v_tuma:
8531case RISCVVector::BI__builtin_rvv_vlseg4e32ff_v_tuma:
8532case RISCVVector::BI__builtin_rvv_vlseg4e64ff_v_tuma:
8533 ID = Intrinsic::riscv_vlseg4ff_mask;
8534 NF = 4;
8535 DefaultPolicy = 2;
8536IsMasked = true;
8537
8538 {
8539 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
8540 IntrinsicTypes = {ResultType, Ops.back()->getType()};
8541 SmallVector<llvm::Value*, 12> Operands;
8542 Value *NewVL;
8543
8544 if (IsMasked) {
8545 // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
8546 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
8547 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
8548 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
8549 for (unsigned I = 0; I < NF; ++I)
8550 Operands.push_back(llvm::PoisonValue::get(ResultType));
8551 Operands.push_back(Ops[NF + 1]);
8552 Operands.push_back(Ops[NF]);
8553 Operands.push_back(Ops[NF + 3]);
8554 NewVL = Ops[NF + 2];
8555 } else {
8556 for (unsigned I = 0; I < NF; ++I)
8557 Operands.push_back(Ops[NF + I + 1]);
8558 Operands.push_back(Ops[2 * NF + 1]);
8559 Operands.push_back(Ops[NF]);
8560 Operands.push_back(Ops[2 * NF + 3]);
8561 NewVL = Ops[2 * NF + 2];
8562 }
8563 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
8564 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 8564, __extension__ __PRETTY_FUNCTION__));
8565 } else {
8566 // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
8567 // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
8568 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
8569 if (DefaultPolicy == TAIL_AGNOSTIC) {
8570 for (unsigned I = 0; I < NF; ++I)
8571 Operands.push_back(llvm::PoisonValue::get(ResultType));
8572 Operands.push_back(Ops[NF]);
8573 Operands.push_back(Ops[NF + 2]);
8574 NewVL = Ops[NF + 1];
8575 } else {
8576 for (unsigned I = 0; I < NF; ++I)
8577 Operands.push_back(Ops[NF + I]);
8578 Operands.push_back(Ops[2 * NF]);
8579 Operands.push_back(Ops[2 * NF + 2]);
8580 NewVL = Ops[2 * NF + 1];
8581 }
8582 }
8583 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
8584 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
8585 clang::CharUnits Align =
8586 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
8587 for (unsigned I = 0; I < NF; ++I) {
8588 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
8589 Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
8590 }
8591 // Store new_vl.
8592 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
8593 return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
8594 }
8595 break;
8596case RISCVVector::BI__builtin_rvv_vlseg4e8ff_v_tama:
8597case RISCVVector::BI__builtin_rvv_vlseg4e16ff_v_tama:
8598case RISCVVector::BI__builtin_rvv_vlseg4e32ff_v_tama:
8599case RISCVVector::BI__builtin_rvv_vlseg4e64ff_v_tama:
8600 ID = Intrinsic::riscv_vlseg4ff_mask;
8601 NF = 4;
8602 DefaultPolicy = 3;
8603IsMasked = true;
8604
8605 {
8606 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
8607 IntrinsicTypes = {ResultType, Ops.back()->getType()};
8608 SmallVector<llvm::Value*, 12> Operands;
8609 Value *NewVL;
8610
8611 if (IsMasked) {
8612 // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
8613 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
8614 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
8615 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
8616 for (unsigned I = 0; I < NF; ++I)
8617 Operands.push_back(llvm::PoisonValue::get(ResultType));
8618 Operands.push_back(Ops[NF + 1]);
8619 Operands.push_back(Ops[NF]);
8620 Operands.push_back(Ops[NF + 3]);
8621 NewVL = Ops[NF + 2];
8622 } else {
8623 for (unsigned I = 0; I < NF; ++I)
8624 Operands.push_back(Ops[NF + I + 1]);
8625 Operands.push_back(Ops[2 * NF + 1]);
8626 Operands.push_back(Ops[NF]);
8627 Operands.push_back(Ops[2 * NF + 3]);
8628 NewVL = Ops[2 * NF + 2];
8629 }
8630 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
8631 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 8631, __extension__ __PRETTY_FUNCTION__));
8632 } else {
8633 // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
8634 // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
8635 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
8636 if (DefaultPolicy == TAIL_AGNOSTIC) {
8637 for (unsigned I = 0; I < NF; ++I)
8638 Operands.push_back(llvm::PoisonValue::get(ResultType));
8639 Operands.push_back(Ops[NF]);
8640 Operands.push_back(Ops[NF + 2]);
8641 NewVL = Ops[NF + 1];
8642 } else {
8643 for (unsigned I = 0; I < NF; ++I)
8644 Operands.push_back(Ops[NF + I]);
8645 Operands.push_back(Ops[2 * NF]);
8646 Operands.push_back(Ops[2 * NF + 2]);
8647 NewVL = Ops[2 * NF + 1];
8648 }
8649 }
8650 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
8651 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
8652 clang::CharUnits Align =
8653 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
8654 for (unsigned I = 0; I < NF; ++I) {
8655 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
8656 Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
8657 }
8658 // Store new_vl.
8659 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
8660 return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
8661 }
8662 break;
8663case RISCVVector::BI__builtin_rvv_vlseg4e8ff_v_tumu:
8664case RISCVVector::BI__builtin_rvv_vlseg4e16ff_v_tumu:
8665case RISCVVector::BI__builtin_rvv_vlseg4e32ff_v_tumu:
8666case RISCVVector::BI__builtin_rvv_vlseg4e64ff_v_tumu:
8667 ID = Intrinsic::riscv_vlseg4ff_mask;
8668 NF = 4;
8669 DefaultPolicy = 0;
8670IsMasked = true;
8671
8672 {
8673 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
8674 IntrinsicTypes = {ResultType, Ops.back()->getType()};
8675 SmallVector<llvm::Value*, 12> Operands;
8676 Value *NewVL;
8677
8678 if (IsMasked) {
8679 // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
8680 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
8681 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
8682 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
8683 for (unsigned I = 0; I < NF; ++I)
8684 Operands.push_back(llvm::PoisonValue::get(ResultType));
8685 Operands.push_back(Ops[NF + 1]);
8686 Operands.push_back(Ops[NF]);
8687 Operands.push_back(Ops[NF + 3]);
8688 NewVL = Ops[NF + 2];
8689 } else {
8690 for (unsigned I = 0; I < NF; ++I)
8691 Operands.push_back(Ops[NF + I + 1]);
8692 Operands.push_back(Ops[2 * NF + 1]);
8693 Operands.push_back(Ops[NF]);
8694 Operands.push_back(Ops[2 * NF + 3]);
8695 NewVL = Ops[2 * NF + 2];
8696 }
8697 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
8698 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 8698, __extension__ __PRETTY_FUNCTION__));
8699 } else {
8700 // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
8701 // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
8702 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
8703 if (DefaultPolicy == TAIL_AGNOSTIC) {
8704 for (unsigned I = 0; I < NF; ++I)
8705 Operands.push_back(llvm::PoisonValue::get(ResultType));
8706 Operands.push_back(Ops[NF]);
8707 Operands.push_back(Ops[NF + 2]);
8708 NewVL = Ops[NF + 1];
8709 } else {
8710 for (unsigned I = 0; I < NF; ++I)
8711 Operands.push_back(Ops[NF + I]);
8712 Operands.push_back(Ops[2 * NF]);
8713 Operands.push_back(Ops[2 * NF + 2]);
8714 NewVL = Ops[2 * NF + 1];
8715 }
8716 }
8717 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
8718 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
8719 clang::CharUnits Align =
8720 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
8721 for (unsigned I = 0; I < NF; ++I) {
8722 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
8723 Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
8724 }
8725 // Store new_vl.
8726 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
8727 return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
8728 }
8729 break;
8730case RISCVVector::BI__builtin_rvv_vlseg4e8ff_v_tamu:
8731case RISCVVector::BI__builtin_rvv_vlseg4e16ff_v_tamu:
8732case RISCVVector::BI__builtin_rvv_vlseg4e32ff_v_tamu:
8733case RISCVVector::BI__builtin_rvv_vlseg4e64ff_v_tamu:
8734 ID = Intrinsic::riscv_vlseg4ff_mask;
8735 NF = 4;
8736 DefaultPolicy = 1;
8737IsMasked = true;
8738
8739 {
8740 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
8741 IntrinsicTypes = {ResultType, Ops.back()->getType()};
8742 SmallVector<llvm::Value*, 12> Operands;
8743 Value *NewVL;
8744
8745 if (IsMasked) {
8746 // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
8747 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
8748 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
8749 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
8750 for (unsigned I = 0; I < NF; ++I)
8751 Operands.push_back(llvm::PoisonValue::get(ResultType));
8752 Operands.push_back(Ops[NF + 1]);
8753 Operands.push_back(Ops[NF]);
8754 Operands.push_back(Ops[NF + 3]);
8755 NewVL = Ops[NF + 2];
8756 } else {
8757 for (unsigned I = 0; I < NF; ++I)
8758 Operands.push_back(Ops[NF + I + 1]);
8759 Operands.push_back(Ops[2 * NF + 1]);
8760 Operands.push_back(Ops[NF]);
8761 Operands.push_back(Ops[2 * NF + 3]);
8762 NewVL = Ops[2 * NF + 2];
8763 }
8764 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
8765 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 8765, __extension__ __PRETTY_FUNCTION__));
8766 } else {
8767 // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
8768 // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
8769 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
8770 if (DefaultPolicy == TAIL_AGNOSTIC) {
8771 for (unsigned I = 0; I < NF; ++I)
8772 Operands.push_back(llvm::PoisonValue::get(ResultType));
8773 Operands.push_back(Ops[NF]);
8774 Operands.push_back(Ops[NF + 2]);
8775 NewVL = Ops[NF + 1];
8776 } else {
8777 for (unsigned I = 0; I < NF; ++I)
8778 Operands.push_back(Ops[NF + I]);
8779 Operands.push_back(Ops[2 * NF]);
8780 Operands.push_back(Ops[2 * NF + 2]);
8781 NewVL = Ops[2 * NF + 1];
8782 }
8783 }
8784 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
8785 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
8786 clang::CharUnits Align =
8787 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
8788 for (unsigned I = 0; I < NF; ++I) {
8789 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
8790 Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
8791 }
8792 // Store new_vl.
8793 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
8794 return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
8795 }
8796 break;
8797case RISCVVector::BI__builtin_rvv_vlseg5e8_v_tu:
8798case RISCVVector::BI__builtin_rvv_vlseg5e16_v_tu:
8799case RISCVVector::BI__builtin_rvv_vlseg5e32_v_tu:
8800case RISCVVector::BI__builtin_rvv_vlseg5e64_v_tu:
8801 ID = Intrinsic::riscv_vlseg5;
8802 NF = 5;
8803 DefaultPolicy = 0;
8804IsMasked = false;
8805
8806 {
8807 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
8808 IntrinsicTypes = {ResultType, Ops.back()->getType()};
8809 SmallVector<llvm::Value*, 10> Operands;
8810 if (IsMasked) {
8811 // TAMA builtin: (val0 address, ..., mask, ptr, vl)
8812 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
8813 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
8814 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
8815 for (unsigned I = 0; I < NF; ++I)
8816 Operands.push_back(llvm::PoisonValue::get(ResultType));
8817 Operands.push_back(Ops[NF + 1]);
8818 Operands.push_back(Ops[NF]);
8819 Operands.push_back(Ops[NF + 2]);
8820 } else {
8821 for (unsigned I = 0; I < NF; ++I)
8822 Operands.push_back(Ops[NF + I + 1]);
8823 Operands.push_back(Ops[2 * NF + 1]);
8824 Operands.push_back(Ops[NF]);
8825 Operands.push_back(Ops[2 * NF + 2]);
8826 }
8827 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
8828 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 8828, __extension__ __PRETTY_FUNCTION__));
8829 } else {
8830 // TA builtin: (val0 address, val1 address, ..., ptr, vl)
8831 // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
8832 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
8833 if (DefaultPolicy == TAIL_AGNOSTIC) {
8834 for (unsigned I = 0; I < NF; ++I)
8835 Operands.push_back(llvm::PoisonValue::get(ResultType));
8836 Operands.push_back(Ops[NF]);
8837 Operands.push_back(Ops[NF + 1]);
8838 } else {
8839 for (unsigned I = 0; I < NF; ++I)
8840 Operands.push_back(Ops[NF + I]);
8841 Operands.push_back(Ops[2 * NF]);
8842 Operands.push_back(Ops[2 * NF + 1]);
8843 }
8844 }
8845 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
8846 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
8847 clang::CharUnits Align =
8848 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
8849 llvm::Value *V;
8850 for (unsigned I = 0; I < NF; ++I) {
8851 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
8852 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
8853 }
8854 return V;
8855 }
8856 break;
8857case RISCVVector::BI__builtin_rvv_vlseg5e8_v_ta:
8858case RISCVVector::BI__builtin_rvv_vlseg5e16_v_ta:
8859case RISCVVector::BI__builtin_rvv_vlseg5e32_v_ta:
8860case RISCVVector::BI__builtin_rvv_vlseg5e64_v_ta:
8861 ID = Intrinsic::riscv_vlseg5;
8862 NF = 5;
8863 DefaultPolicy = 1;
8864IsMasked = false;
8865
8866 {
8867 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
8868 IntrinsicTypes = {ResultType, Ops.back()->getType()};
8869 SmallVector<llvm::Value*, 10> Operands;
8870 if (IsMasked) {
8871 // TAMA builtin: (val0 address, ..., mask, ptr, vl)
8872 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
8873 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
8874 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
8875 for (unsigned I = 0; I < NF; ++I)
8876 Operands.push_back(llvm::PoisonValue::get(ResultType));
8877 Operands.push_back(Ops[NF + 1]);
8878 Operands.push_back(Ops[NF]);
8879 Operands.push_back(Ops[NF + 2]);
8880 } else {
8881 for (unsigned I = 0; I < NF; ++I)
8882 Operands.push_back(Ops[NF + I + 1]);
8883 Operands.push_back(Ops[2 * NF + 1]);
8884 Operands.push_back(Ops[NF]);
8885 Operands.push_back(Ops[2 * NF + 2]);
8886 }
8887 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
8888 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 8888, __extension__ __PRETTY_FUNCTION__));
8889 } else {
8890 // TA builtin: (val0 address, val1 address, ..., ptr, vl)
8891 // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
8892 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
8893 if (DefaultPolicy == TAIL_AGNOSTIC) {
8894 for (unsigned I = 0; I < NF; ++I)
8895 Operands.push_back(llvm::PoisonValue::get(ResultType));
8896 Operands.push_back(Ops[NF]);
8897 Operands.push_back(Ops[NF + 1]);
8898 } else {
8899 for (unsigned I = 0; I < NF; ++I)
8900 Operands.push_back(Ops[NF + I]);
8901 Operands.push_back(Ops[2 * NF]);
8902 Operands.push_back(Ops[2 * NF + 1]);
8903 }
8904 }
8905 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
8906 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
8907 clang::CharUnits Align =
8908 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
8909 llvm::Value *V;
8910 for (unsigned I = 0; I < NF; ++I) {
8911 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
8912 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
8913 }
8914 return V;
8915 }
8916 break;
8917case RISCVVector::BI__builtin_rvv_vlseg5e8_v_tuma:
8918case RISCVVector::BI__builtin_rvv_vlseg5e16_v_tuma:
8919case RISCVVector::BI__builtin_rvv_vlseg5e32_v_tuma:
8920case RISCVVector::BI__builtin_rvv_vlseg5e64_v_tuma:
8921 ID = Intrinsic::riscv_vlseg5_mask;
8922 NF = 5;
8923 DefaultPolicy = 2;
8924IsMasked = true;
8925
8926 {
8927 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
8928 IntrinsicTypes = {ResultType, Ops.back()->getType()};
8929 SmallVector<llvm::Value*, 10> Operands;
8930 if (IsMasked) {
8931 // TAMA builtin: (val0 address, ..., mask, ptr, vl)
8932 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
8933 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
8934 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
8935 for (unsigned I = 0; I < NF; ++I)
8936 Operands.push_back(llvm::PoisonValue::get(ResultType));
8937 Operands.push_back(Ops[NF + 1]);
8938 Operands.push_back(Ops[NF]);
8939 Operands.push_back(Ops[NF + 2]);
8940 } else {
8941 for (unsigned I = 0; I < NF; ++I)
8942 Operands.push_back(Ops[NF + I + 1]);
8943 Operands.push_back(Ops[2 * NF + 1]);
8944 Operands.push_back(Ops[NF]);
8945 Operands.push_back(Ops[2 * NF + 2]);
8946 }
8947 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
8948 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 8948, __extension__ __PRETTY_FUNCTION__));
8949 } else {
8950 // TA builtin: (val0 address, val1 address, ..., ptr, vl)
8951 // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
8952 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
8953 if (DefaultPolicy == TAIL_AGNOSTIC) {
8954 for (unsigned I = 0; I < NF; ++I)
8955 Operands.push_back(llvm::PoisonValue::get(ResultType));
8956 Operands.push_back(Ops[NF]);
8957 Operands.push_back(Ops[NF + 1]);
8958 } else {
8959 for (unsigned I = 0; I < NF; ++I)
8960 Operands.push_back(Ops[NF + I]);
8961 Operands.push_back(Ops[2 * NF]);
8962 Operands.push_back(Ops[2 * NF + 1]);
8963 }
8964 }
8965 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
8966 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
8967 clang::CharUnits Align =
8968 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
8969 llvm::Value *V;
8970 for (unsigned I = 0; I < NF; ++I) {
8971 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
8972 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
8973 }
8974 return V;
8975 }
8976 break;
8977case RISCVVector::BI__builtin_rvv_vlseg5e8_v_tama:
8978case RISCVVector::BI__builtin_rvv_vlseg5e16_v_tama:
8979case RISCVVector::BI__builtin_rvv_vlseg5e32_v_tama:
8980case RISCVVector::BI__builtin_rvv_vlseg5e64_v_tama:
8981 ID = Intrinsic::riscv_vlseg5_mask;
8982 NF = 5;
8983 DefaultPolicy = 3;
8984IsMasked = true;
8985
8986 {
8987 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
8988 IntrinsicTypes = {ResultType, Ops.back()->getType()};
8989 SmallVector<llvm::Value*, 10> Operands;
8990 if (IsMasked) {
8991 // TAMA builtin: (val0 address, ..., mask, ptr, vl)
8992 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
8993 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
8994 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
8995 for (unsigned I = 0; I < NF; ++I)
8996 Operands.push_back(llvm::PoisonValue::get(ResultType));
8997 Operands.push_back(Ops[NF + 1]);
8998 Operands.push_back(Ops[NF]);
8999 Operands.push_back(Ops[NF + 2]);
9000 } else {
9001 for (unsigned I = 0; I < NF; ++I)
9002 Operands.push_back(Ops[NF + I + 1]);
9003 Operands.push_back(Ops[2 * NF + 1]);
9004 Operands.push_back(Ops[NF]);
9005 Operands.push_back(Ops[2 * NF + 2]);
9006 }
9007 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
9008 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 9008, __extension__ __PRETTY_FUNCTION__));
9009 } else {
9010 // TA builtin: (val0 address, val1 address, ..., ptr, vl)
9011 // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
9012 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
9013 if (DefaultPolicy == TAIL_AGNOSTIC) {
9014 for (unsigned I = 0; I < NF; ++I)
9015 Operands.push_back(llvm::PoisonValue::get(ResultType));
9016 Operands.push_back(Ops[NF]);
9017 Operands.push_back(Ops[NF + 1]);
9018 } else {
9019 for (unsigned I = 0; I < NF; ++I)
9020 Operands.push_back(Ops[NF + I]);
9021 Operands.push_back(Ops[2 * NF]);
9022 Operands.push_back(Ops[2 * NF + 1]);
9023 }
9024 }
9025 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
9026 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
9027 clang::CharUnits Align =
9028 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
9029 llvm::Value *V;
9030 for (unsigned I = 0; I < NF; ++I) {
9031 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
9032 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
9033 }
9034 return V;
9035 }
9036 break;
9037case RISCVVector::BI__builtin_rvv_vlseg5e8_v_tumu:
9038case RISCVVector::BI__builtin_rvv_vlseg5e16_v_tumu:
9039case RISCVVector::BI__builtin_rvv_vlseg5e32_v_tumu:
9040case RISCVVector::BI__builtin_rvv_vlseg5e64_v_tumu:
9041 ID = Intrinsic::riscv_vlseg5_mask;
9042 NF = 5;
9043 DefaultPolicy = 0;
9044IsMasked = true;
9045
9046 {
9047 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
9048 IntrinsicTypes = {ResultType, Ops.back()->getType()};
9049 SmallVector<llvm::Value*, 10> Operands;
9050 if (IsMasked) {
9051 // TAMA builtin: (val0 address, ..., mask, ptr, vl)
9052 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
9053 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
9054 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
9055 for (unsigned I = 0; I < NF; ++I)
9056 Operands.push_back(llvm::PoisonValue::get(ResultType));
9057 Operands.push_back(Ops[NF + 1]);
9058 Operands.push_back(Ops[NF]);
9059 Operands.push_back(Ops[NF + 2]);
9060 } else {
9061 for (unsigned I = 0; I < NF; ++I)
9062 Operands.push_back(Ops[NF + I + 1]);
9063 Operands.push_back(Ops[2 * NF + 1]);
9064 Operands.push_back(Ops[NF]);
9065 Operands.push_back(Ops[2 * NF + 2]);
9066 }
9067 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
9068 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 9068, __extension__ __PRETTY_FUNCTION__));
9069 } else {
9070 // TA builtin: (val0 address, val1 address, ..., ptr, vl)
9071 // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
9072 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
9073 if (DefaultPolicy == TAIL_AGNOSTIC) {
9074 for (unsigned I = 0; I < NF; ++I)
9075 Operands.push_back(llvm::PoisonValue::get(ResultType));
9076 Operands.push_back(Ops[NF]);
9077 Operands.push_back(Ops[NF + 1]);
9078 } else {
9079 for (unsigned I = 0; I < NF; ++I)
9080 Operands.push_back(Ops[NF + I]);
9081 Operands.push_back(Ops[2 * NF]);
9082 Operands.push_back(Ops[2 * NF + 1]);
9083 }
9084 }
9085 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
9086 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
9087 clang::CharUnits Align =
9088 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
9089 llvm::Value *V;
9090 for (unsigned I = 0; I < NF; ++I) {
9091 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
9092 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
9093 }
9094 return V;
9095 }
9096 break;
9097case RISCVVector::BI__builtin_rvv_vlseg5e8_v_tamu:
9098case RISCVVector::BI__builtin_rvv_vlseg5e16_v_tamu:
9099case RISCVVector::BI__builtin_rvv_vlseg5e32_v_tamu:
9100case RISCVVector::BI__builtin_rvv_vlseg5e64_v_tamu:
9101 ID = Intrinsic::riscv_vlseg5_mask;
9102 NF = 5;
9103 DefaultPolicy = 1;
9104IsMasked = true;
9105
9106 {
9107 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
9108 IntrinsicTypes = {ResultType, Ops.back()->getType()};
9109 SmallVector<llvm::Value*, 10> Operands;
9110 if (IsMasked) {
9111 // TAMA builtin: (val0 address, ..., mask, ptr, vl)
9112 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
9113 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
9114 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
9115 for (unsigned I = 0; I < NF; ++I)
9116 Operands.push_back(llvm::PoisonValue::get(ResultType));
9117 Operands.push_back(Ops[NF + 1]);
9118 Operands.push_back(Ops[NF]);
9119 Operands.push_back(Ops[NF + 2]);
9120 } else {
9121 for (unsigned I = 0; I < NF; ++I)
9122 Operands.push_back(Ops[NF + I + 1]);
9123 Operands.push_back(Ops[2 * NF + 1]);
9124 Operands.push_back(Ops[NF]);
9125 Operands.push_back(Ops[2 * NF + 2]);
9126 }
9127 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
9128 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 9128, __extension__ __PRETTY_FUNCTION__));
9129 } else {
9130 // TA builtin: (val0 address, val1 address, ..., ptr, vl)
9131 // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
9132 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
9133 if (DefaultPolicy == TAIL_AGNOSTIC) {
9134 for (unsigned I = 0; I < NF; ++I)
9135 Operands.push_back(llvm::PoisonValue::get(ResultType));
9136 Operands.push_back(Ops[NF]);
9137 Operands.push_back(Ops[NF + 1]);
9138 } else {
9139 for (unsigned I = 0; I < NF; ++I)
9140 Operands.push_back(Ops[NF + I]);
9141 Operands.push_back(Ops[2 * NF]);
9142 Operands.push_back(Ops[2 * NF + 1]);
9143 }
9144 }
9145 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
9146 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
9147 clang::CharUnits Align =
9148 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
9149 llvm::Value *V;
9150 for (unsigned I = 0; I < NF; ++I) {
9151 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
9152 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
9153 }
9154 return V;
9155 }
9156 break;
9157case RISCVVector::BI__builtin_rvv_vlseg5e8ff_v_tu:
9158case RISCVVector::BI__builtin_rvv_vlseg5e16ff_v_tu:
9159case RISCVVector::BI__builtin_rvv_vlseg5e32ff_v_tu:
9160case RISCVVector::BI__builtin_rvv_vlseg5e64ff_v_tu:
9161 ID = Intrinsic::riscv_vlseg5ff;
9162 NF = 5;
9163 DefaultPolicy = 0;
9164IsMasked = false;
9165
9166 {
9167 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
9168 IntrinsicTypes = {ResultType, Ops.back()->getType()};
9169 SmallVector<llvm::Value*, 12> Operands;
9170 Value *NewVL;
9171
9172 if (IsMasked) {
9173 // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
9174 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
9175 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
9176 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
9177 for (unsigned I = 0; I < NF; ++I)
9178 Operands.push_back(llvm::PoisonValue::get(ResultType));
9179 Operands.push_back(Ops[NF + 1]);
9180 Operands.push_back(Ops[NF]);
9181 Operands.push_back(Ops[NF + 3]);
9182 NewVL = Ops[NF + 2];
9183 } else {
9184 for (unsigned I = 0; I < NF; ++I)
9185 Operands.push_back(Ops[NF + I + 1]);
9186 Operands.push_back(Ops[2 * NF + 1]);
9187 Operands.push_back(Ops[NF]);
9188 Operands.push_back(Ops[2 * NF + 3]);
9189 NewVL = Ops[2 * NF + 2];
9190 }
9191 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
9192 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 9192, __extension__ __PRETTY_FUNCTION__));
9193 } else {
9194 // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
9195 // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
9196 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
9197 if (DefaultPolicy == TAIL_AGNOSTIC) {
9198 for (unsigned I = 0; I < NF; ++I)
9199 Operands.push_back(llvm::PoisonValue::get(ResultType));
9200 Operands.push_back(Ops[NF]);
9201 Operands.push_back(Ops[NF + 2]);
9202 NewVL = Ops[NF + 1];
9203 } else {
9204 for (unsigned I = 0; I < NF; ++I)
9205 Operands.push_back(Ops[NF + I]);
9206 Operands.push_back(Ops[2 * NF]);
9207 Operands.push_back(Ops[2 * NF + 2]);
9208 NewVL = Ops[2 * NF + 1];
9209 }
9210 }
9211 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
9212 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
9213 clang::CharUnits Align =
9214 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
9215 for (unsigned I = 0; I < NF; ++I) {
9216 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
9217 Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
9218 }
9219 // Store new_vl.
9220 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
9221 return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
9222 }
9223 break;
9224case RISCVVector::BI__builtin_rvv_vlseg5e8ff_v_ta:
9225case RISCVVector::BI__builtin_rvv_vlseg5e16ff_v_ta:
9226case RISCVVector::BI__builtin_rvv_vlseg5e32ff_v_ta:
9227case RISCVVector::BI__builtin_rvv_vlseg5e64ff_v_ta:
9228 ID = Intrinsic::riscv_vlseg5ff;
9229 NF = 5;
9230 DefaultPolicy = 1;
9231IsMasked = false;
9232
9233 {
9234 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
9235 IntrinsicTypes = {ResultType, Ops.back()->getType()};
9236 SmallVector<llvm::Value*, 12> Operands;
9237 Value *NewVL;
9238
9239 if (IsMasked) {
9240 // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
9241 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
9242 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
9243 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
9244 for (unsigned I = 0; I < NF; ++I)
9245 Operands.push_back(llvm::PoisonValue::get(ResultType));
9246 Operands.push_back(Ops[NF + 1]);
9247 Operands.push_back(Ops[NF]);
9248 Operands.push_back(Ops[NF + 3]);
9249 NewVL = Ops[NF + 2];
9250 } else {
9251 for (unsigned I = 0; I < NF; ++I)
9252 Operands.push_back(Ops[NF + I + 1]);
9253 Operands.push_back(Ops[2 * NF + 1]);
9254 Operands.push_back(Ops[NF]);
9255 Operands.push_back(Ops[2 * NF + 3]);
9256 NewVL = Ops[2 * NF + 2];
9257 }
9258 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
9259 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 9259, __extension__ __PRETTY_FUNCTION__));
9260 } else {
9261 // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
9262 // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
9263 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
9264 if (DefaultPolicy == TAIL_AGNOSTIC) {
9265 for (unsigned I = 0; I < NF; ++I)
9266 Operands.push_back(llvm::PoisonValue::get(ResultType));
9267 Operands.push_back(Ops[NF]);
9268 Operands.push_back(Ops[NF + 2]);
9269 NewVL = Ops[NF + 1];
9270 } else {
9271 for (unsigned I = 0; I < NF; ++I)
9272 Operands.push_back(Ops[NF + I]);
9273 Operands.push_back(Ops[2 * NF]);
9274 Operands.push_back(Ops[2 * NF + 2]);
9275 NewVL = Ops[2 * NF + 1];
9276 }
9277 }
9278 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
9279 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
9280 clang::CharUnits Align =
9281 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
9282 for (unsigned I = 0; I < NF; ++I) {
9283 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
9284 Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
9285 }
9286 // Store new_vl.
9287 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
9288 return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
9289 }
9290 break;
9291case RISCVVector::BI__builtin_rvv_vlseg5e8ff_v_tuma:
9292case RISCVVector::BI__builtin_rvv_vlseg5e16ff_v_tuma:
9293case RISCVVector::BI__builtin_rvv_vlseg5e32ff_v_tuma:
9294case RISCVVector::BI__builtin_rvv_vlseg5e64ff_v_tuma:
9295 ID = Intrinsic::riscv_vlseg5ff_mask;
9296 NF = 5;
9297 DefaultPolicy = 2;
9298IsMasked = true;
9299
9300 {
9301 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
9302 IntrinsicTypes = {ResultType, Ops.back()->getType()};
9303 SmallVector<llvm::Value*, 12> Operands;
9304 Value *NewVL;
9305
9306 if (IsMasked) {
9307 // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
9308 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
9309 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
9310 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
9311 for (unsigned I = 0; I < NF; ++I)
9312 Operands.push_back(llvm::PoisonValue::get(ResultType));
9313 Operands.push_back(Ops[NF + 1]);
9314 Operands.push_back(Ops[NF]);
9315 Operands.push_back(Ops[NF + 3]);
9316 NewVL = Ops[NF + 2];
9317 } else {
9318 for (unsigned I = 0; I < NF; ++I)
9319 Operands.push_back(Ops[NF + I + 1]);
9320 Operands.push_back(Ops[2 * NF + 1]);
9321 Operands.push_back(Ops[NF]);
9322 Operands.push_back(Ops[2 * NF + 3]);
9323 NewVL = Ops[2 * NF + 2];
9324 }
9325 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
9326 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 9326, __extension__ __PRETTY_FUNCTION__));
9327 } else {
9328 // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
9329 // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
9330 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
9331 if (DefaultPolicy == TAIL_AGNOSTIC) {
9332 for (unsigned I = 0; I < NF; ++I)
9333 Operands.push_back(llvm::PoisonValue::get(ResultType));
9334 Operands.push_back(Ops[NF]);
9335 Operands.push_back(Ops[NF + 2]);
9336 NewVL = Ops[NF + 1];
9337 } else {
9338 for (unsigned I = 0; I < NF; ++I)
9339 Operands.push_back(Ops[NF + I]);
9340 Operands.push_back(Ops[2 * NF]);
9341 Operands.push_back(Ops[2 * NF + 2]);
9342 NewVL = Ops[2 * NF + 1];
9343 }
9344 }
9345 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
9346 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
9347 clang::CharUnits Align =
9348 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
9349 for (unsigned I = 0; I < NF; ++I) {
9350 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
9351 Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
9352 }
9353 // Store new_vl.
9354 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
9355 return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
9356 }
9357 break;
9358case RISCVVector::BI__builtin_rvv_vlseg5e8ff_v_tama:
9359case RISCVVector::BI__builtin_rvv_vlseg5e16ff_v_tama:
9360case RISCVVector::BI__builtin_rvv_vlseg5e32ff_v_tama:
9361case RISCVVector::BI__builtin_rvv_vlseg5e64ff_v_tama:
9362 ID = Intrinsic::riscv_vlseg5ff_mask;
9363 NF = 5;
9364 DefaultPolicy = 3;
9365IsMasked = true;
9366
9367 {
9368 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
9369 IntrinsicTypes = {ResultType, Ops.back()->getType()};
9370 SmallVector<llvm::Value*, 12> Operands;
9371 Value *NewVL;
9372
9373 if (IsMasked) {
9374 // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
9375 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
9376 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
9377 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
9378 for (unsigned I = 0; I < NF; ++I)
9379 Operands.push_back(llvm::PoisonValue::get(ResultType));
9380 Operands.push_back(Ops[NF + 1]);
9381 Operands.push_back(Ops[NF]);
9382 Operands.push_back(Ops[NF + 3]);
9383 NewVL = Ops[NF + 2];
9384 } else {
9385 for (unsigned I = 0; I < NF; ++I)
9386 Operands.push_back(Ops[NF + I + 1]);
9387 Operands.push_back(Ops[2 * NF + 1]);
9388 Operands.push_back(Ops[NF]);
9389 Operands.push_back(Ops[2 * NF + 3]);
9390 NewVL = Ops[2 * NF + 2];
9391 }
9392 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
9393 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 9393, __extension__ __PRETTY_FUNCTION__));
9394 } else {
9395 // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
9396 // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
9397 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
9398 if (DefaultPolicy == TAIL_AGNOSTIC) {
9399 for (unsigned I = 0; I < NF; ++I)
9400 Operands.push_back(llvm::PoisonValue::get(ResultType));
9401 Operands.push_back(Ops[NF]);
9402 Operands.push_back(Ops[NF + 2]);
9403 NewVL = Ops[NF + 1];
9404 } else {
9405 for (unsigned I = 0; I < NF; ++I)
9406 Operands.push_back(Ops[NF + I]);
9407 Operands.push_back(Ops[2 * NF]);
9408 Operands.push_back(Ops[2 * NF + 2]);
9409 NewVL = Ops[2 * NF + 1];
9410 }
9411 }
9412 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
9413 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
9414 clang::CharUnits Align =
9415 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
9416 for (unsigned I = 0; I < NF; ++I) {
9417 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
9418 Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
9419 }
9420 // Store new_vl.
9421 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
9422 return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
9423 }
9424 break;
9425case RISCVVector::BI__builtin_rvv_vlseg5e8ff_v_tumu:
9426case RISCVVector::BI__builtin_rvv_vlseg5e16ff_v_tumu:
9427case RISCVVector::BI__builtin_rvv_vlseg5e32ff_v_tumu:
9428case RISCVVector::BI__builtin_rvv_vlseg5e64ff_v_tumu:
9429 ID = Intrinsic::riscv_vlseg5ff_mask;
9430 NF = 5;
9431 DefaultPolicy = 0;
9432IsMasked = true;
9433
9434 {
9435 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
9436 IntrinsicTypes = {ResultType, Ops.back()->getType()};
9437 SmallVector<llvm::Value*, 12> Operands;
9438 Value *NewVL;
9439
9440 if (IsMasked) {
9441 // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
9442 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
9443 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
9444 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
9445 for (unsigned I = 0; I < NF; ++I)
9446 Operands.push_back(llvm::PoisonValue::get(ResultType));
9447 Operands.push_back(Ops[NF + 1]);
9448 Operands.push_back(Ops[NF]);
9449 Operands.push_back(Ops[NF + 3]);
9450 NewVL = Ops[NF + 2];
9451 } else {
9452 for (unsigned I = 0; I < NF; ++I)
9453 Operands.push_back(Ops[NF + I + 1]);
9454 Operands.push_back(Ops[2 * NF + 1]);
9455 Operands.push_back(Ops[NF]);
9456 Operands.push_back(Ops[2 * NF + 3]);
9457 NewVL = Ops[2 * NF + 2];
9458 }
9459 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
9460 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 9460, __extension__ __PRETTY_FUNCTION__));
9461 } else {
9462 // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
9463 // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
9464 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
9465 if (DefaultPolicy == TAIL_AGNOSTIC) {
9466 for (unsigned I = 0; I < NF; ++I)
9467 Operands.push_back(llvm::PoisonValue::get(ResultType));
9468 Operands.push_back(Ops[NF]);
9469 Operands.push_back(Ops[NF + 2]);
9470 NewVL = Ops[NF + 1];
9471 } else {
9472 for (unsigned I = 0; I < NF; ++I)
9473 Operands.push_back(Ops[NF + I]);
9474 Operands.push_back(Ops[2 * NF]);
9475 Operands.push_back(Ops[2 * NF + 2]);
9476 NewVL = Ops[2 * NF + 1];
9477 }
9478 }
9479 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
9480 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
9481 clang::CharUnits Align =
9482 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
9483 for (unsigned I = 0; I < NF; ++I) {
9484 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
9485 Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
9486 }
9487 // Store new_vl.
9488 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
9489 return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
9490 }
9491 break;
9492case RISCVVector::BI__builtin_rvv_vlseg5e8ff_v_tamu:
9493case RISCVVector::BI__builtin_rvv_vlseg5e16ff_v_tamu:
9494case RISCVVector::BI__builtin_rvv_vlseg5e32ff_v_tamu:
9495case RISCVVector::BI__builtin_rvv_vlseg5e64ff_v_tamu:
9496 ID = Intrinsic::riscv_vlseg5ff_mask;
9497 NF = 5;
9498 DefaultPolicy = 1;
9499IsMasked = true;
9500
9501 {
9502 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
9503 IntrinsicTypes = {ResultType, Ops.back()->getType()};
9504 SmallVector<llvm::Value*, 12> Operands;
9505 Value *NewVL;
9506
9507 if (IsMasked) {
9508 // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
9509 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
9510 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
9511 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
9512 for (unsigned I = 0; I < NF; ++I)
9513 Operands.push_back(llvm::PoisonValue::get(ResultType));
9514 Operands.push_back(Ops[NF + 1]);
9515 Operands.push_back(Ops[NF]);
9516 Operands.push_back(Ops[NF + 3]);
9517 NewVL = Ops[NF + 2];
9518 } else {
9519 for (unsigned I = 0; I < NF; ++I)
9520 Operands.push_back(Ops[NF + I + 1]);
9521 Operands.push_back(Ops[2 * NF + 1]);
9522 Operands.push_back(Ops[NF]);
9523 Operands.push_back(Ops[2 * NF + 3]);
9524 NewVL = Ops[2 * NF + 2];
9525 }
9526 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
9527 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 9527, __extension__ __PRETTY_FUNCTION__));
9528 } else {
9529 // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
9530 // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
9531 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
9532 if (DefaultPolicy == TAIL_AGNOSTIC) {
9533 for (unsigned I = 0; I < NF; ++I)
9534 Operands.push_back(llvm::PoisonValue::get(ResultType));
9535 Operands.push_back(Ops[NF]);
9536 Operands.push_back(Ops[NF + 2]);
9537 NewVL = Ops[NF + 1];
9538 } else {
9539 for (unsigned I = 0; I < NF; ++I)
9540 Operands.push_back(Ops[NF + I]);
9541 Operands.push_back(Ops[2 * NF]);
9542 Operands.push_back(Ops[2 * NF + 2]);
9543 NewVL = Ops[2 * NF + 1];
9544 }
9545 }
9546 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
9547 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
9548 clang::CharUnits Align =
9549 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
9550 for (unsigned I = 0; I < NF; ++I) {
9551 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
9552 Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
9553 }
9554 // Store new_vl.
9555 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
9556 return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
9557 }
9558 break;
9559case RISCVVector::BI__builtin_rvv_vlseg6e8_v_tu:
9560case RISCVVector::BI__builtin_rvv_vlseg6e16_v_tu:
9561case RISCVVector::BI__builtin_rvv_vlseg6e32_v_tu:
9562case RISCVVector::BI__builtin_rvv_vlseg6e64_v_tu:
9563 ID = Intrinsic::riscv_vlseg6;
9564 NF = 6;
9565 DefaultPolicy = 0;
9566IsMasked = false;
9567
9568 {
9569 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
9570 IntrinsicTypes = {ResultType, Ops.back()->getType()};
9571 SmallVector<llvm::Value*, 10> Operands;
9572 if (IsMasked) {
9573 // TAMA builtin: (val0 address, ..., mask, ptr, vl)
9574 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
9575 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
9576 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
9577 for (unsigned I = 0; I < NF; ++I)
9578 Operands.push_back(llvm::PoisonValue::get(ResultType));
9579 Operands.push_back(Ops[NF + 1]);
9580 Operands.push_back(Ops[NF]);
9581 Operands.push_back(Ops[NF + 2]);
9582 } else {
9583 for (unsigned I = 0; I < NF; ++I)
9584 Operands.push_back(Ops[NF + I + 1]);
9585 Operands.push_back(Ops[2 * NF + 1]);
9586 Operands.push_back(Ops[NF]);
9587 Operands.push_back(Ops[2 * NF + 2]);
9588 }
9589 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
9590 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 9590, __extension__ __PRETTY_FUNCTION__));
9591 } else {
9592 // TA builtin: (val0 address, val1 address, ..., ptr, vl)
9593 // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
9594 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
9595 if (DefaultPolicy == TAIL_AGNOSTIC) {
9596 for (unsigned I = 0; I < NF; ++I)
9597 Operands.push_back(llvm::PoisonValue::get(ResultType));
9598 Operands.push_back(Ops[NF]);
9599 Operands.push_back(Ops[NF + 1]);
9600 } else {
9601 for (unsigned I = 0; I < NF; ++I)
9602 Operands.push_back(Ops[NF + I]);
9603 Operands.push_back(Ops[2 * NF]);
9604 Operands.push_back(Ops[2 * NF + 1]);
9605 }
9606 }
9607 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
9608 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
9609 clang::CharUnits Align =
9610 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
9611 llvm::Value *V;
9612 for (unsigned I = 0; I < NF; ++I) {
9613 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
9614 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
9615 }
9616 return V;
9617 }
9618 break;
9619case RISCVVector::BI__builtin_rvv_vlseg6e8_v_ta:
9620case RISCVVector::BI__builtin_rvv_vlseg6e16_v_ta:
9621case RISCVVector::BI__builtin_rvv_vlseg6e32_v_ta:
9622case RISCVVector::BI__builtin_rvv_vlseg6e64_v_ta:
9623 ID = Intrinsic::riscv_vlseg6;
9624 NF = 6;
9625 DefaultPolicy = 1;
9626IsMasked = false;
9627
9628 {
9629 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
9630 IntrinsicTypes = {ResultType, Ops.back()->getType()};
9631 SmallVector<llvm::Value*, 10> Operands;
9632 if (IsMasked) {
9633 // TAMA builtin: (val0 address, ..., mask, ptr, vl)
9634 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
9635 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
9636 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
9637 for (unsigned I = 0; I < NF; ++I)
9638 Operands.push_back(llvm::PoisonValue::get(ResultType));
9639 Operands.push_back(Ops[NF + 1]);
9640 Operands.push_back(Ops[NF]);
9641 Operands.push_back(Ops[NF + 2]);
9642 } else {
9643 for (unsigned I = 0; I < NF; ++I)
9644 Operands.push_back(Ops[NF + I + 1]);
9645 Operands.push_back(Ops[2 * NF + 1]);
9646 Operands.push_back(Ops[NF]);
9647 Operands.push_back(Ops[2 * NF + 2]);
9648 }
9649 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
9650 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 9650, __extension__ __PRETTY_FUNCTION__));
9651 } else {
9652 // TA builtin: (val0 address, val1 address, ..., ptr, vl)
9653 // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
9654 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
9655 if (DefaultPolicy == TAIL_AGNOSTIC) {
9656 for (unsigned I = 0; I < NF; ++I)
9657 Operands.push_back(llvm::PoisonValue::get(ResultType));
9658 Operands.push_back(Ops[NF]);
9659 Operands.push_back(Ops[NF + 1]);
9660 } else {
9661 for (unsigned I = 0; I < NF; ++I)
9662 Operands.push_back(Ops[NF + I]);
9663 Operands.push_back(Ops[2 * NF]);
9664 Operands.push_back(Ops[2 * NF + 1]);
9665 }
9666 }
9667 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
9668 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
9669 clang::CharUnits Align =
9670 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
9671 llvm::Value *V;
9672 for (unsigned I = 0; I < NF; ++I) {
9673 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
9674 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
9675 }
9676 return V;
9677 }
9678 break;
9679case RISCVVector::BI__builtin_rvv_vlseg6e8_v_tuma:
9680case RISCVVector::BI__builtin_rvv_vlseg6e16_v_tuma:
9681case RISCVVector::BI__builtin_rvv_vlseg6e32_v_tuma:
9682case RISCVVector::BI__builtin_rvv_vlseg6e64_v_tuma:
9683 ID = Intrinsic::riscv_vlseg6_mask;
9684 NF = 6;
9685 DefaultPolicy = 2;
9686IsMasked = true;
9687
9688 {
9689 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
9690 IntrinsicTypes = {ResultType, Ops.back()->getType()};
9691 SmallVector<llvm::Value*, 10> Operands;
9692 if (IsMasked) {
9693 // TAMA builtin: (val0 address, ..., mask, ptr, vl)
9694 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
9695 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
9696 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
9697 for (unsigned I = 0; I < NF; ++I)
9698 Operands.push_back(llvm::PoisonValue::get(ResultType));
9699 Operands.push_back(Ops[NF + 1]);
9700 Operands.push_back(Ops[NF]);
9701 Operands.push_back(Ops[NF + 2]);
9702 } else {
9703 for (unsigned I = 0; I < NF; ++I)
9704 Operands.push_back(Ops[NF + I + 1]);
9705 Operands.push_back(Ops[2 * NF + 1]);
9706 Operands.push_back(Ops[NF]);
9707 Operands.push_back(Ops[2 * NF + 2]);
9708 }
9709 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
9710 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 9710, __extension__ __PRETTY_FUNCTION__));
9711 } else {
9712 // TA builtin: (val0 address, val1 address, ..., ptr, vl)
9713 // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
9714 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
9715 if (DefaultPolicy == TAIL_AGNOSTIC) {
9716 for (unsigned I = 0; I < NF; ++I)
9717 Operands.push_back(llvm::PoisonValue::get(ResultType));
9718 Operands.push_back(Ops[NF]);
9719 Operands.push_back(Ops[NF + 1]);
9720 } else {
9721 for (unsigned I = 0; I < NF; ++I)
9722 Operands.push_back(Ops[NF + I]);
9723 Operands.push_back(Ops[2 * NF]);
9724 Operands.push_back(Ops[2 * NF + 1]);
9725 }
9726 }
9727 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
9728 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
9729 clang::CharUnits Align =
9730 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
9731 llvm::Value *V;
9732 for (unsigned I = 0; I < NF; ++I) {
9733 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
9734 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
9735 }
9736 return V;
9737 }
9738 break;
9739case RISCVVector::BI__builtin_rvv_vlseg6e8_v_tama:
9740case RISCVVector::BI__builtin_rvv_vlseg6e16_v_tama:
9741case RISCVVector::BI__builtin_rvv_vlseg6e32_v_tama:
9742case RISCVVector::BI__builtin_rvv_vlseg6e64_v_tama:
9743 ID = Intrinsic::riscv_vlseg6_mask;
9744 NF = 6;
9745 DefaultPolicy = 3;
9746IsMasked = true;
9747
9748 {
9749 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
9750 IntrinsicTypes = {ResultType, Ops.back()->getType()};
9751 SmallVector<llvm::Value*, 10> Operands;
9752 if (IsMasked) {
9753 // TAMA builtin: (val0 address, ..., mask, ptr, vl)
9754 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
9755 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
9756 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
9757 for (unsigned I = 0; I < NF; ++I)
9758 Operands.push_back(llvm::PoisonValue::get(ResultType));
9759 Operands.push_back(Ops[NF + 1]);
9760 Operands.push_back(Ops[NF]);
9761 Operands.push_back(Ops[NF + 2]);
9762 } else {
9763 for (unsigned I = 0; I < NF; ++I)
9764 Operands.push_back(Ops[NF + I + 1]);
9765 Operands.push_back(Ops[2 * NF + 1]);
9766 Operands.push_back(Ops[NF]);
9767 Operands.push_back(Ops[2 * NF + 2]);
9768 }
9769 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
9770 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 9770, __extension__ __PRETTY_FUNCTION__));
9771 } else {
9772 // TA builtin: (val0 address, val1 address, ..., ptr, vl)
9773 // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
9774 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
9775 if (DefaultPolicy == TAIL_AGNOSTIC) {
9776 for (unsigned I = 0; I < NF; ++I)
9777 Operands.push_back(llvm::PoisonValue::get(ResultType));
9778 Operands.push_back(Ops[NF]);
9779 Operands.push_back(Ops[NF + 1]);
9780 } else {
9781 for (unsigned I = 0; I < NF; ++I)
9782 Operands.push_back(Ops[NF + I]);
9783 Operands.push_back(Ops[2 * NF]);
9784 Operands.push_back(Ops[2 * NF + 1]);
9785 }
9786 }
9787 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
9788 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
9789 clang::CharUnits Align =
9790 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
9791 llvm::Value *V;
9792 for (unsigned I = 0; I < NF; ++I) {
9793 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
9794 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
9795 }
9796 return V;
9797 }
9798 break;
9799case RISCVVector::BI__builtin_rvv_vlseg6e8_v_tumu:
9800case RISCVVector::BI__builtin_rvv_vlseg6e16_v_tumu:
9801case RISCVVector::BI__builtin_rvv_vlseg6e32_v_tumu:
9802case RISCVVector::BI__builtin_rvv_vlseg6e64_v_tumu:
9803 ID = Intrinsic::riscv_vlseg6_mask;
9804 NF = 6;
9805 DefaultPolicy = 0;
9806IsMasked = true;
9807
9808 {
9809 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
9810 IntrinsicTypes = {ResultType, Ops.back()->getType()};
9811 SmallVector<llvm::Value*, 10> Operands;
9812 if (IsMasked) {
9813 // TAMA builtin: (val0 address, ..., mask, ptr, vl)
9814 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
9815 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
9816 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
9817 for (unsigned I = 0; I < NF; ++I)
9818 Operands.push_back(llvm::PoisonValue::get(ResultType));
9819 Operands.push_back(Ops[NF + 1]);
9820 Operands.push_back(Ops[NF]);
9821 Operands.push_back(Ops[NF + 2]);
9822 } else {
9823 for (unsigned I = 0; I < NF; ++I)
9824 Operands.push_back(Ops[NF + I + 1]);
9825 Operands.push_back(Ops[2 * NF + 1]);
9826 Operands.push_back(Ops[NF]);
9827 Operands.push_back(Ops[2 * NF + 2]);
9828 }
9829 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
9830 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 9830, __extension__ __PRETTY_FUNCTION__));
9831 } else {
9832 // TA builtin: (val0 address, val1 address, ..., ptr, vl)
9833 // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
9834 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
9835 if (DefaultPolicy == TAIL_AGNOSTIC) {
9836 for (unsigned I = 0; I < NF; ++I)
9837 Operands.push_back(llvm::PoisonValue::get(ResultType));
9838 Operands.push_back(Ops[NF]);
9839 Operands.push_back(Ops[NF + 1]);
9840 } else {
9841 for (unsigned I = 0; I < NF; ++I)
9842 Operands.push_back(Ops[NF + I]);
9843 Operands.push_back(Ops[2 * NF]);
9844 Operands.push_back(Ops[2 * NF + 1]);
9845 }
9846 }
9847 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
9848 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
9849 clang::CharUnits Align =
9850 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
9851 llvm::Value *V;
9852 for (unsigned I = 0; I < NF; ++I) {
9853 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
9854 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
9855 }
9856 return V;
9857 }
9858 break;
9859case RISCVVector::BI__builtin_rvv_vlseg6e8_v_tamu:
9860case RISCVVector::BI__builtin_rvv_vlseg6e16_v_tamu:
9861case RISCVVector::BI__builtin_rvv_vlseg6e32_v_tamu:
9862case RISCVVector::BI__builtin_rvv_vlseg6e64_v_tamu:
9863 ID = Intrinsic::riscv_vlseg6_mask;
9864 NF = 6;
9865 DefaultPolicy = 1;
9866IsMasked = true;
9867
9868 {
9869 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
9870 IntrinsicTypes = {ResultType, Ops.back()->getType()};
9871 SmallVector<llvm::Value*, 10> Operands;
9872 if (IsMasked) {
9873 // TAMA builtin: (val0 address, ..., mask, ptr, vl)
9874 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
9875 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
9876 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
9877 for (unsigned I = 0; I < NF; ++I)
9878 Operands.push_back(llvm::PoisonValue::get(ResultType));
9879 Operands.push_back(Ops[NF + 1]);
9880 Operands.push_back(Ops[NF]);
9881 Operands.push_back(Ops[NF + 2]);
9882 } else {
9883 for (unsigned I = 0; I < NF; ++I)
9884 Operands.push_back(Ops[NF + I + 1]);
9885 Operands.push_back(Ops[2 * NF + 1]);
9886 Operands.push_back(Ops[NF]);
9887 Operands.push_back(Ops[2 * NF + 2]);
9888 }
9889 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
9890 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 9890, __extension__ __PRETTY_FUNCTION__));
9891 } else {
9892 // TA builtin: (val0 address, val1 address, ..., ptr, vl)
9893 // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
9894 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
9895 if (DefaultPolicy == TAIL_AGNOSTIC) {
9896 for (unsigned I = 0; I < NF; ++I)
9897 Operands.push_back(llvm::PoisonValue::get(ResultType));
9898 Operands.push_back(Ops[NF]);
9899 Operands.push_back(Ops[NF + 1]);
9900 } else {
9901 for (unsigned I = 0; I < NF; ++I)
9902 Operands.push_back(Ops[NF + I]);
9903 Operands.push_back(Ops[2 * NF]);
9904 Operands.push_back(Ops[2 * NF + 1]);
9905 }
9906 }
9907 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
9908 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
9909 clang::CharUnits Align =
9910 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
9911 llvm::Value *V;
9912 for (unsigned I = 0; I < NF; ++I) {
9913 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
9914 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
9915 }
9916 return V;
9917 }
9918 break;
9919case RISCVVector::BI__builtin_rvv_vlseg6e8ff_v_tu:
9920case RISCVVector::BI__builtin_rvv_vlseg6e16ff_v_tu:
9921case RISCVVector::BI__builtin_rvv_vlseg6e32ff_v_tu:
9922case RISCVVector::BI__builtin_rvv_vlseg6e64ff_v_tu:
9923 ID = Intrinsic::riscv_vlseg6ff;
9924 NF = 6;
9925 DefaultPolicy = 0;
9926IsMasked = false;
9927
9928 {
9929 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
9930 IntrinsicTypes = {ResultType, Ops.back()->getType()};
9931 SmallVector<llvm::Value*, 12> Operands;
9932 Value *NewVL;
9933
9934 if (IsMasked) {
9935 // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
9936 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
9937 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
9938 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
9939 for (unsigned I = 0; I < NF; ++I)
9940 Operands.push_back(llvm::PoisonValue::get(ResultType));
9941 Operands.push_back(Ops[NF + 1]);
9942 Operands.push_back(Ops[NF]);
9943 Operands.push_back(Ops[NF + 3]);
9944 NewVL = Ops[NF + 2];
9945 } else {
9946 for (unsigned I = 0; I < NF; ++I)
9947 Operands.push_back(Ops[NF + I + 1]);
9948 Operands.push_back(Ops[2 * NF + 1]);
9949 Operands.push_back(Ops[NF]);
9950 Operands.push_back(Ops[2 * NF + 3]);
9951 NewVL = Ops[2 * NF + 2];
9952 }
9953 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
9954 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 9954, __extension__ __PRETTY_FUNCTION__));
9955 } else {
9956 // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
9957 // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
9958 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
9959 if (DefaultPolicy == TAIL_AGNOSTIC) {
9960 for (unsigned I = 0; I < NF; ++I)
9961 Operands.push_back(llvm::PoisonValue::get(ResultType));
9962 Operands.push_back(Ops[NF]);
9963 Operands.push_back(Ops[NF + 2]);
9964 NewVL = Ops[NF + 1];
9965 } else {
9966 for (unsigned I = 0; I < NF; ++I)
9967 Operands.push_back(Ops[NF + I]);
9968 Operands.push_back(Ops[2 * NF]);
9969 Operands.push_back(Ops[2 * NF + 2]);
9970 NewVL = Ops[2 * NF + 1];
9971 }
9972 }
9973 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
9974 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
9975 clang::CharUnits Align =
9976 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
9977 for (unsigned I = 0; I < NF; ++I) {
9978 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
9979 Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
9980 }
9981 // Store new_vl.
9982 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
9983 return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
9984 }
9985 break;
9986case RISCVVector::BI__builtin_rvv_vlseg6e8ff_v_ta:
9987case RISCVVector::BI__builtin_rvv_vlseg6e16ff_v_ta:
9988case RISCVVector::BI__builtin_rvv_vlseg6e32ff_v_ta:
9989case RISCVVector::BI__builtin_rvv_vlseg6e64ff_v_ta:
9990 ID = Intrinsic::riscv_vlseg6ff;
9991 NF = 6;
9992 DefaultPolicy = 1;
9993IsMasked = false;
9994
9995 {
9996 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
9997 IntrinsicTypes = {ResultType, Ops.back()->getType()};
9998 SmallVector<llvm::Value*, 12> Operands;
9999 Value *NewVL;
10000
10001 if (IsMasked) {
10002 // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
10003 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
10004 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
10005 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
10006 for (unsigned I = 0; I < NF; ++I)
10007 Operands.push_back(llvm::PoisonValue::get(ResultType));
10008 Operands.push_back(Ops[NF + 1]);
10009 Operands.push_back(Ops[NF]);
10010 Operands.push_back(Ops[NF + 3]);
10011 NewVL = Ops[NF + 2];
10012 } else {
10013 for (unsigned I = 0; I < NF; ++I)
10014 Operands.push_back(Ops[NF + I + 1]);
10015 Operands.push_back(Ops[2 * NF + 1]);
10016 Operands.push_back(Ops[NF]);
10017 Operands.push_back(Ops[2 * NF + 3]);
10018 NewVL = Ops[2 * NF + 2];
10019 }
10020 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
10021 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 10021, __extension__ __PRETTY_FUNCTION__));
10022 } else {
10023 // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
10024 // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
10025 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
10026 if (DefaultPolicy == TAIL_AGNOSTIC) {
10027 for (unsigned I = 0; I < NF; ++I)
10028 Operands.push_back(llvm::PoisonValue::get(ResultType));
10029 Operands.push_back(Ops[NF]);
10030 Operands.push_back(Ops[NF + 2]);
10031 NewVL = Ops[NF + 1];
10032 } else {
10033 for (unsigned I = 0; I < NF; ++I)
10034 Operands.push_back(Ops[NF + I]);
10035 Operands.push_back(Ops[2 * NF]);
10036 Operands.push_back(Ops[2 * NF + 2]);
10037 NewVL = Ops[2 * NF + 1];
10038 }
10039 }
10040 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
10041 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
10042 clang::CharUnits Align =
10043 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
10044 for (unsigned I = 0; I < NF; ++I) {
10045 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
10046 Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
10047 }
10048 // Store new_vl.
10049 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
10050 return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
10051 }
10052 break;
10053case RISCVVector::BI__builtin_rvv_vlseg6e8ff_v_tuma:
10054case RISCVVector::BI__builtin_rvv_vlseg6e16ff_v_tuma:
10055case RISCVVector::BI__builtin_rvv_vlseg6e32ff_v_tuma:
10056case RISCVVector::BI__builtin_rvv_vlseg6e64ff_v_tuma:
10057 ID = Intrinsic::riscv_vlseg6ff_mask;
10058 NF = 6;
10059 DefaultPolicy = 2;
10060IsMasked = true;
10061
10062 {
10063 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
10064 IntrinsicTypes = {ResultType, Ops.back()->getType()};
10065 SmallVector<llvm::Value*, 12> Operands;
10066 Value *NewVL;
10067
10068 if (IsMasked) {
10069 // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
10070 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
10071 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
10072 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
10073 for (unsigned I = 0; I < NF; ++I)
10074 Operands.push_back(llvm::PoisonValue::get(ResultType));
10075 Operands.push_back(Ops[NF + 1]);
10076 Operands.push_back(Ops[NF]);
10077 Operands.push_back(Ops[NF + 3]);
10078 NewVL = Ops[NF + 2];
10079 } else {
10080 for (unsigned I = 0; I < NF; ++I)
10081 Operands.push_back(Ops[NF + I + 1]);
10082 Operands.push_back(Ops[2 * NF + 1]);
10083 Operands.push_back(Ops[NF]);
10084 Operands.push_back(Ops[2 * NF + 3]);
10085 NewVL = Ops[2 * NF + 2];
10086 }
10087 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
10088 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 10088, __extension__ __PRETTY_FUNCTION__));
10089 } else {
10090 // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
10091 // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
10092 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
10093 if (DefaultPolicy == TAIL_AGNOSTIC) {
10094 for (unsigned I = 0; I < NF; ++I)
10095 Operands.push_back(llvm::PoisonValue::get(ResultType));
10096 Operands.push_back(Ops[NF]);
10097 Operands.push_back(Ops[NF + 2]);
10098 NewVL = Ops[NF + 1];
10099 } else {
10100 for (unsigned I = 0; I < NF; ++I)
10101 Operands.push_back(Ops[NF + I]);
10102 Operands.push_back(Ops[2 * NF]);
10103 Operands.push_back(Ops[2 * NF + 2]);
10104 NewVL = Ops[2 * NF + 1];
10105 }
10106 }
10107 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
10108 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
10109 clang::CharUnits Align =
10110 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
10111 for (unsigned I = 0; I < NF; ++I) {
10112 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
10113 Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
10114 }
10115 // Store new_vl.
10116 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
10117 return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
10118 }
10119 break;
10120case RISCVVector::BI__builtin_rvv_vlseg6e8ff_v_tama:
10121case RISCVVector::BI__builtin_rvv_vlseg6e16ff_v_tama:
10122case RISCVVector::BI__builtin_rvv_vlseg6e32ff_v_tama:
10123case RISCVVector::BI__builtin_rvv_vlseg6e64ff_v_tama:
10124 ID = Intrinsic::riscv_vlseg6ff_mask;
10125 NF = 6;
10126 DefaultPolicy = 3;
10127IsMasked = true;
10128
10129 {
10130 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
10131 IntrinsicTypes = {ResultType, Ops.back()->getType()};
10132 SmallVector<llvm::Value*, 12> Operands;
10133 Value *NewVL;
10134
10135 if (IsMasked) {
10136 // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
10137 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
10138 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
10139 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
10140 for (unsigned I = 0; I < NF; ++I)
10141 Operands.push_back(llvm::PoisonValue::get(ResultType));
10142 Operands.push_back(Ops[NF + 1]);
10143 Operands.push_back(Ops[NF]);
10144 Operands.push_back(Ops[NF + 3]);
10145 NewVL = Ops[NF + 2];
10146 } else {
10147 for (unsigned I = 0; I < NF; ++I)
10148 Operands.push_back(Ops[NF + I + 1]);
10149 Operands.push_back(Ops[2 * NF + 1]);
10150 Operands.push_back(Ops[NF]);
10151 Operands.push_back(Ops[2 * NF + 3]);
10152 NewVL = Ops[2 * NF + 2];
10153 }
10154 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
10155 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 10155, __extension__ __PRETTY_FUNCTION__));
10156 } else {
10157 // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
10158 // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
10159 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
10160 if (DefaultPolicy == TAIL_AGNOSTIC) {
10161 for (unsigned I = 0; I < NF; ++I)
10162 Operands.push_back(llvm::PoisonValue::get(ResultType));
10163 Operands.push_back(Ops[NF]);
10164 Operands.push_back(Ops[NF + 2]);
10165 NewVL = Ops[NF + 1];
10166 } else {
10167 for (unsigned I = 0; I < NF; ++I)
10168 Operands.push_back(Ops[NF + I]);
10169 Operands.push_back(Ops[2 * NF]);
10170 Operands.push_back(Ops[2 * NF + 2]);
10171 NewVL = Ops[2 * NF + 1];
10172 }
10173 }
10174 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
10175 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
10176 clang::CharUnits Align =
10177 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
10178 for (unsigned I = 0; I < NF; ++I) {
10179 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
10180 Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
10181 }
10182 // Store new_vl.
10183 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
10184 return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
10185 }
10186 break;
10187case RISCVVector::BI__builtin_rvv_vlseg6e8ff_v_tumu:
10188case RISCVVector::BI__builtin_rvv_vlseg6e16ff_v_tumu:
10189case RISCVVector::BI__builtin_rvv_vlseg6e32ff_v_tumu:
10190case RISCVVector::BI__builtin_rvv_vlseg6e64ff_v_tumu:
10191 ID = Intrinsic::riscv_vlseg6ff_mask;
10192 NF = 6;
10193 DefaultPolicy = 0;
10194IsMasked = true;
10195
10196 {
10197 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
10198 IntrinsicTypes = {ResultType, Ops.back()->getType()};
10199 SmallVector<llvm::Value*, 12> Operands;
10200 Value *NewVL;
10201
10202 if (IsMasked) {
10203 // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
10204 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
10205 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
10206 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
10207 for (unsigned I = 0; I < NF; ++I)
10208 Operands.push_back(llvm::PoisonValue::get(ResultType));
10209 Operands.push_back(Ops[NF + 1]);
10210 Operands.push_back(Ops[NF]);
10211 Operands.push_back(Ops[NF + 3]);
10212 NewVL = Ops[NF + 2];
10213 } else {
10214 for (unsigned I = 0; I < NF; ++I)
10215 Operands.push_back(Ops[NF + I + 1]);
10216 Operands.push_back(Ops[2 * NF + 1]);
10217 Operands.push_back(Ops[NF]);
10218 Operands.push_back(Ops[2 * NF + 3]);
10219 NewVL = Ops[2 * NF + 2];
10220 }
10221 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
10222 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 10222, __extension__ __PRETTY_FUNCTION__));
10223 } else {
10224 // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
10225 // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
10226 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
10227 if (DefaultPolicy == TAIL_AGNOSTIC) {
10228 for (unsigned I = 0; I < NF; ++I)
10229 Operands.push_back(llvm::PoisonValue::get(ResultType));
10230 Operands.push_back(Ops[NF]);
10231 Operands.push_back(Ops[NF + 2]);
10232 NewVL = Ops[NF + 1];
10233 } else {
10234 for (unsigned I = 0; I < NF; ++I)
10235 Operands.push_back(Ops[NF + I]);
10236 Operands.push_back(Ops[2 * NF]);
10237 Operands.push_back(Ops[2 * NF + 2]);
10238 NewVL = Ops[2 * NF + 1];
10239 }
10240 }
10241 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
10242 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
10243 clang::CharUnits Align =
10244 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
10245 for (unsigned I = 0; I < NF; ++I) {
10246 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
10247 Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
10248 }
10249 // Store new_vl.
10250 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
10251 return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
10252 }
10253 break;
10254case RISCVVector::BI__builtin_rvv_vlseg6e8ff_v_tamu:
10255case RISCVVector::BI__builtin_rvv_vlseg6e16ff_v_tamu:
10256case RISCVVector::BI__builtin_rvv_vlseg6e32ff_v_tamu:
10257case RISCVVector::BI__builtin_rvv_vlseg6e64ff_v_tamu:
10258 ID = Intrinsic::riscv_vlseg6ff_mask;
10259 NF = 6;
10260 DefaultPolicy = 1;
10261IsMasked = true;
10262
10263 {
10264 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
10265 IntrinsicTypes = {ResultType, Ops.back()->getType()};
10266 SmallVector<llvm::Value*, 12> Operands;
10267 Value *NewVL;
10268
10269 if (IsMasked) {
10270 // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
10271 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
10272 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
10273 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
10274 for (unsigned I = 0; I < NF; ++I)
10275 Operands.push_back(llvm::PoisonValue::get(ResultType));
10276 Operands.push_back(Ops[NF + 1]);
10277 Operands.push_back(Ops[NF]);
10278 Operands.push_back(Ops[NF + 3]);
10279 NewVL = Ops[NF + 2];
10280 } else {
10281 for (unsigned I = 0; I < NF; ++I)
10282 Operands.push_back(Ops[NF + I + 1]);
10283 Operands.push_back(Ops[2 * NF + 1]);
10284 Operands.push_back(Ops[NF]);
10285 Operands.push_back(Ops[2 * NF + 3]);
10286 NewVL = Ops[2 * NF + 2];
10287 }
10288 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
10289 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 10289, __extension__ __PRETTY_FUNCTION__));
10290 } else {
10291 // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
10292 // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
10293 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
10294 if (DefaultPolicy == TAIL_AGNOSTIC) {
10295 for (unsigned I = 0; I < NF; ++I)
10296 Operands.push_back(llvm::PoisonValue::get(ResultType));
10297 Operands.push_back(Ops[NF]);
10298 Operands.push_back(Ops[NF + 2]);
10299 NewVL = Ops[NF + 1];
10300 } else {
10301 for (unsigned I = 0; I < NF; ++I)
10302 Operands.push_back(Ops[NF + I]);
10303 Operands.push_back(Ops[2 * NF]);
10304 Operands.push_back(Ops[2 * NF + 2]);
10305 NewVL = Ops[2 * NF + 1];
10306 }
10307 }
10308 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
10309 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
10310 clang::CharUnits Align =
10311 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
10312 for (unsigned I = 0; I < NF; ++I) {
10313 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
10314 Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
10315 }
10316 // Store new_vl.
10317 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
10318 return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
10319 }
10320 break;
10321case RISCVVector::BI__builtin_rvv_vlseg7e8_v_tu:
10322case RISCVVector::BI__builtin_rvv_vlseg7e16_v_tu:
10323case RISCVVector::BI__builtin_rvv_vlseg7e32_v_tu:
10324case RISCVVector::BI__builtin_rvv_vlseg7e64_v_tu:
10325 ID = Intrinsic::riscv_vlseg7;
10326 NF = 7;
10327 DefaultPolicy = 0;
10328IsMasked = false;
10329
10330 {
10331 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
10332 IntrinsicTypes = {ResultType, Ops.back()->getType()};
10333 SmallVector<llvm::Value*, 10> Operands;
10334 if (IsMasked) {
10335 // TAMA builtin: (val0 address, ..., mask, ptr, vl)
10336 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
10337 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
10338 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
10339 for (unsigned I = 0; I < NF; ++I)
10340 Operands.push_back(llvm::PoisonValue::get(ResultType));
10341 Operands.push_back(Ops[NF + 1]);
10342 Operands.push_back(Ops[NF]);
10343 Operands.push_back(Ops[NF + 2]);
10344 } else {
10345 for (unsigned I = 0; I < NF; ++I)
10346 Operands.push_back(Ops[NF + I + 1]);
10347 Operands.push_back(Ops[2 * NF + 1]);
10348 Operands.push_back(Ops[NF]);
10349 Operands.push_back(Ops[2 * NF + 2]);
10350 }
10351 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
10352 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 10352, __extension__ __PRETTY_FUNCTION__));
10353 } else {
10354 // TA builtin: (val0 address, val1 address, ..., ptr, vl)
10355 // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
10356 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
10357 if (DefaultPolicy == TAIL_AGNOSTIC) {
10358 for (unsigned I = 0; I < NF; ++I)
10359 Operands.push_back(llvm::PoisonValue::get(ResultType));
10360 Operands.push_back(Ops[NF]);
10361 Operands.push_back(Ops[NF + 1]);
10362 } else {
10363 for (unsigned I = 0; I < NF; ++I)
10364 Operands.push_back(Ops[NF + I]);
10365 Operands.push_back(Ops[2 * NF]);
10366 Operands.push_back(Ops[2 * NF + 1]);
10367 }
10368 }
10369 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
10370 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
10371 clang::CharUnits Align =
10372 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
10373 llvm::Value *V;
10374 for (unsigned I = 0; I < NF; ++I) {
10375 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
10376 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
10377 }
10378 return V;
10379 }
10380 break;
10381case RISCVVector::BI__builtin_rvv_vlseg7e8_v_ta:
10382case RISCVVector::BI__builtin_rvv_vlseg7e16_v_ta:
10383case RISCVVector::BI__builtin_rvv_vlseg7e32_v_ta:
10384case RISCVVector::BI__builtin_rvv_vlseg7e64_v_ta:
10385 ID = Intrinsic::riscv_vlseg7;
10386 NF = 7;
10387 DefaultPolicy = 1;
10388IsMasked = false;
10389
10390 {
10391 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
10392 IntrinsicTypes = {ResultType, Ops.back()->getType()};
10393 SmallVector<llvm::Value*, 10> Operands;
10394 if (IsMasked) {
10395 // TAMA builtin: (val0 address, ..., mask, ptr, vl)
10396 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
10397 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
10398 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
10399 for (unsigned I = 0; I < NF; ++I)
10400 Operands.push_back(llvm::PoisonValue::get(ResultType));
10401 Operands.push_back(Ops[NF + 1]);
10402 Operands.push_back(Ops[NF]);
10403 Operands.push_back(Ops[NF + 2]);
10404 } else {
10405 for (unsigned I = 0; I < NF; ++I)
10406 Operands.push_back(Ops[NF + I + 1]);
10407 Operands.push_back(Ops[2 * NF + 1]);
10408 Operands.push_back(Ops[NF]);
10409 Operands.push_back(Ops[2 * NF + 2]);
10410 }
10411 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
10412 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 10412, __extension__ __PRETTY_FUNCTION__));
10413 } else {
10414 // TA builtin: (val0 address, val1 address, ..., ptr, vl)
10415 // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
10416 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
10417 if (DefaultPolicy == TAIL_AGNOSTIC) {
10418 for (unsigned I = 0; I < NF; ++I)
10419 Operands.push_back(llvm::PoisonValue::get(ResultType));
10420 Operands.push_back(Ops[NF]);
10421 Operands.push_back(Ops[NF + 1]);
10422 } else {
10423 for (unsigned I = 0; I < NF; ++I)
10424 Operands.push_back(Ops[NF + I]);
10425 Operands.push_back(Ops[2 * NF]);
10426 Operands.push_back(Ops[2 * NF + 1]);
10427 }
10428 }
10429 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
10430 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
10431 clang::CharUnits Align =
10432 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
10433 llvm::Value *V;
10434 for (unsigned I = 0; I < NF; ++I) {
10435 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
10436 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
10437 }
10438 return V;
10439 }
10440 break;
10441case RISCVVector::BI__builtin_rvv_vlseg7e8_v_tuma:
10442case RISCVVector::BI__builtin_rvv_vlseg7e16_v_tuma:
10443case RISCVVector::BI__builtin_rvv_vlseg7e32_v_tuma:
10444case RISCVVector::BI__builtin_rvv_vlseg7e64_v_tuma:
10445 ID = Intrinsic::riscv_vlseg7_mask;
10446 NF = 7;
10447 DefaultPolicy = 2;
10448IsMasked = true;
10449
10450 {
10451 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
10452 IntrinsicTypes = {ResultType, Ops.back()->getType()};
10453 SmallVector<llvm::Value*, 10> Operands;
10454 if (IsMasked) {
10455 // TAMA builtin: (val0 address, ..., mask, ptr, vl)
10456 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
10457 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
10458 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
10459 for (unsigned I = 0; I < NF; ++I)
10460 Operands.push_back(llvm::PoisonValue::get(ResultType));
10461 Operands.push_back(Ops[NF + 1]);
10462 Operands.push_back(Ops[NF]);
10463 Operands.push_back(Ops[NF + 2]);
10464 } else {
10465 for (unsigned I = 0; I < NF; ++I)
10466 Operands.push_back(Ops[NF + I + 1]);
10467 Operands.push_back(Ops[2 * NF + 1]);
10468 Operands.push_back(Ops[NF]);
10469 Operands.push_back(Ops[2 * NF + 2]);
10470 }
10471 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
10472 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 10472, __extension__ __PRETTY_FUNCTION__));
10473 } else {
10474 // TA builtin: (val0 address, val1 address, ..., ptr, vl)
10475 // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
10476 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
10477 if (DefaultPolicy == TAIL_AGNOSTIC) {
10478 for (unsigned I = 0; I < NF; ++I)
10479 Operands.push_back(llvm::PoisonValue::get(ResultType));
10480 Operands.push_back(Ops[NF]);
10481 Operands.push_back(Ops[NF + 1]);
10482 } else {
10483 for (unsigned I = 0; I < NF; ++I)
10484 Operands.push_back(Ops[NF + I]);
10485 Operands.push_back(Ops[2 * NF]);
10486 Operands.push_back(Ops[2 * NF + 1]);
10487 }
10488 }
10489 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
10490 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
10491 clang::CharUnits Align =
10492 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
10493 llvm::Value *V;
10494 for (unsigned I = 0; I < NF; ++I) {
10495 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
10496 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
10497 }
10498 return V;
10499 }
10500 break;
10501case RISCVVector::BI__builtin_rvv_vlseg7e8_v_tama:
10502case RISCVVector::BI__builtin_rvv_vlseg7e16_v_tama:
10503case RISCVVector::BI__builtin_rvv_vlseg7e32_v_tama:
10504case RISCVVector::BI__builtin_rvv_vlseg7e64_v_tama:
10505 ID = Intrinsic::riscv_vlseg7_mask;
10506 NF = 7;
10507 DefaultPolicy = 3;
10508IsMasked = true;
10509
10510 {
10511 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
10512 IntrinsicTypes = {ResultType, Ops.back()->getType()};
10513 SmallVector<llvm::Value*, 10> Operands;
10514 if (IsMasked) {
10515 // TAMA builtin: (val0 address, ..., mask, ptr, vl)
10516 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
10517 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
10518 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
10519 for (unsigned I = 0; I < NF; ++I)
10520 Operands.push_back(llvm::PoisonValue::get(ResultType));
10521 Operands.push_back(Ops[NF + 1]);
10522 Operands.push_back(Ops[NF]);
10523 Operands.push_back(Ops[NF + 2]);
10524 } else {
10525 for (unsigned I = 0; I < NF; ++I)
10526 Operands.push_back(Ops[NF + I + 1]);
10527 Operands.push_back(Ops[2 * NF + 1]);
10528 Operands.push_back(Ops[NF]);
10529 Operands.push_back(Ops[2 * NF + 2]);
10530 }
10531 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
10532 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 10532, __extension__ __PRETTY_FUNCTION__));
10533 } else {
10534 // TA builtin: (val0 address, val1 address, ..., ptr, vl)
10535 // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
10536 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
10537 if (DefaultPolicy == TAIL_AGNOSTIC) {
10538 for (unsigned I = 0; I < NF; ++I)
10539 Operands.push_back(llvm::PoisonValue::get(ResultType));
10540 Operands.push_back(Ops[NF]);
10541 Operands.push_back(Ops[NF + 1]);
10542 } else {
10543 for (unsigned I = 0; I < NF; ++I)
10544 Operands.push_back(Ops[NF + I]);
10545 Operands.push_back(Ops[2 * NF]);
10546 Operands.push_back(Ops[2 * NF + 1]);
10547 }
10548 }
10549 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
10550 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
10551 clang::CharUnits Align =
10552 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
10553 llvm::Value *V;
10554 for (unsigned I = 0; I < NF; ++I) {
10555 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
10556 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
10557 }
10558 return V;
10559 }
10560 break;
10561case RISCVVector::BI__builtin_rvv_vlseg7e8_v_tumu:
10562case RISCVVector::BI__builtin_rvv_vlseg7e16_v_tumu:
10563case RISCVVector::BI__builtin_rvv_vlseg7e32_v_tumu:
10564case RISCVVector::BI__builtin_rvv_vlseg7e64_v_tumu:
10565 ID = Intrinsic::riscv_vlseg7_mask;
10566 NF = 7;
10567 DefaultPolicy = 0;
10568IsMasked = true;
10569
10570 {
10571 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
10572 IntrinsicTypes = {ResultType, Ops.back()->getType()};
10573 SmallVector<llvm::Value*, 10> Operands;
10574 if (IsMasked) {
10575 // TAMA builtin: (val0 address, ..., mask, ptr, vl)
10576 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
10577 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
10578 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
10579 for (unsigned I = 0; I < NF; ++I)
10580 Operands.push_back(llvm::PoisonValue::get(ResultType));
10581 Operands.push_back(Ops[NF + 1]);
10582 Operands.push_back(Ops[NF]);
10583 Operands.push_back(Ops[NF + 2]);
10584 } else {
10585 for (unsigned I = 0; I < NF; ++I)
10586 Operands.push_back(Ops[NF + I + 1]);
10587 Operands.push_back(Ops[2 * NF + 1]);
10588 Operands.push_back(Ops[NF]);
10589 Operands.push_back(Ops[2 * NF + 2]);
10590 }
10591 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
10592 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 10592, __extension__ __PRETTY_FUNCTION__));
10593 } else {
10594 // TA builtin: (val0 address, val1 address, ..., ptr, vl)
10595 // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
10596 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
10597 if (DefaultPolicy == TAIL_AGNOSTIC) {
10598 for (unsigned I = 0; I < NF; ++I)
10599 Operands.push_back(llvm::PoisonValue::get(ResultType));
10600 Operands.push_back(Ops[NF]);
10601 Operands.push_back(Ops[NF + 1]);
10602 } else {
10603 for (unsigned I = 0; I < NF; ++I)
10604 Operands.push_back(Ops[NF + I]);
10605 Operands.push_back(Ops[2 * NF]);
10606 Operands.push_back(Ops[2 * NF + 1]);
10607 }
10608 }
10609 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
10610 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
10611 clang::CharUnits Align =
10612 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
10613 llvm::Value *V;
10614 for (unsigned I = 0; I < NF; ++I) {
10615 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
10616 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
10617 }
10618 return V;
10619 }
10620 break;
10621case RISCVVector::BI__builtin_rvv_vlseg7e8_v_tamu:
10622case RISCVVector::BI__builtin_rvv_vlseg7e16_v_tamu:
10623case RISCVVector::BI__builtin_rvv_vlseg7e32_v_tamu:
10624case RISCVVector::BI__builtin_rvv_vlseg7e64_v_tamu:
10625 ID = Intrinsic::riscv_vlseg7_mask;
10626 NF = 7;
10627 DefaultPolicy = 1;
10628IsMasked = true;
10629
10630 {
10631 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
10632 IntrinsicTypes = {ResultType, Ops.back()->getType()};
10633 SmallVector<llvm::Value*, 10> Operands;
10634 if (IsMasked) {
10635 // TAMA builtin: (val0 address, ..., mask, ptr, vl)
10636 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
10637 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
10638 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
10639 for (unsigned I = 0; I < NF; ++I)
10640 Operands.push_back(llvm::PoisonValue::get(ResultType));
10641 Operands.push_back(Ops[NF + 1]);
10642 Operands.push_back(Ops[NF]);
10643 Operands.push_back(Ops[NF + 2]);
10644 } else {
10645 for (unsigned I = 0; I < NF; ++I)
10646 Operands.push_back(Ops[NF + I + 1]);
10647 Operands.push_back(Ops[2 * NF + 1]);
10648 Operands.push_back(Ops[NF]);
10649 Operands.push_back(Ops[2 * NF + 2]);
10650 }
10651 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
10652 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 10652, __extension__ __PRETTY_FUNCTION__));
10653 } else {
10654 // TA builtin: (val0 address, val1 address, ..., ptr, vl)
10655 // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
10656 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
10657 if (DefaultPolicy == TAIL_AGNOSTIC) {
10658 for (unsigned I = 0; I < NF; ++I)
10659 Operands.push_back(llvm::PoisonValue::get(ResultType));
10660 Operands.push_back(Ops[NF]);
10661 Operands.push_back(Ops[NF + 1]);
10662 } else {
10663 for (unsigned I = 0; I < NF; ++I)
10664 Operands.push_back(Ops[NF + I]);
10665 Operands.push_back(Ops[2 * NF]);
10666 Operands.push_back(Ops[2 * NF + 1]);
10667 }
10668 }
10669 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
10670 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
10671 clang::CharUnits Align =
10672 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
10673 llvm::Value *V;
10674 for (unsigned I = 0; I < NF; ++I) {
10675 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
10676 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
10677 }
10678 return V;
10679 }
10680 break;
10681case RISCVVector::BI__builtin_rvv_vlseg7e8ff_v_tu:
10682case RISCVVector::BI__builtin_rvv_vlseg7e16ff_v_tu:
10683case RISCVVector::BI__builtin_rvv_vlseg7e32ff_v_tu:
10684case RISCVVector::BI__builtin_rvv_vlseg7e64ff_v_tu:
10685 ID = Intrinsic::riscv_vlseg7ff;
10686 NF = 7;
10687 DefaultPolicy = 0;
10688IsMasked = false;
10689
10690 {
10691 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
10692 IntrinsicTypes = {ResultType, Ops.back()->getType()};
10693 SmallVector<llvm::Value*, 12> Operands;
10694 Value *NewVL;
10695
10696 if (IsMasked) {
10697 // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
10698 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
10699 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
10700 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
10701 for (unsigned I = 0; I < NF; ++I)
10702 Operands.push_back(llvm::PoisonValue::get(ResultType));
10703 Operands.push_back(Ops[NF + 1]);
10704 Operands.push_back(Ops[NF]);
10705 Operands.push_back(Ops[NF + 3]);
10706 NewVL = Ops[NF + 2];
10707 } else {
10708 for (unsigned I = 0; I < NF; ++I)
10709 Operands.push_back(Ops[NF + I + 1]);
10710 Operands.push_back(Ops[2 * NF + 1]);
10711 Operands.push_back(Ops[NF]);
10712 Operands.push_back(Ops[2 * NF + 3]);
10713 NewVL = Ops[2 * NF + 2];
10714 }
10715 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
10716 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 10716, __extension__ __PRETTY_FUNCTION__));
10717 } else {
10718 // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
10719 // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
10720 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
10721 if (DefaultPolicy == TAIL_AGNOSTIC) {
10722 for (unsigned I = 0; I < NF; ++I)
10723 Operands.push_back(llvm::PoisonValue::get(ResultType));
10724 Operands.push_back(Ops[NF]);
10725 Operands.push_back(Ops[NF + 2]);
10726 NewVL = Ops[NF + 1];
10727 } else {
10728 for (unsigned I = 0; I < NF; ++I)
10729 Operands.push_back(Ops[NF + I]);
10730 Operands.push_back(Ops[2 * NF]);
10731 Operands.push_back(Ops[2 * NF + 2]);
10732 NewVL = Ops[2 * NF + 1];
10733 }
10734 }
10735 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
10736 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
10737 clang::CharUnits Align =
10738 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
10739 for (unsigned I = 0; I < NF; ++I) {
10740 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
10741 Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
10742 }
10743 // Store new_vl.
10744 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
10745 return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
10746 }
10747 break;
10748case RISCVVector::BI__builtin_rvv_vlseg7e8ff_v_ta:
10749case RISCVVector::BI__builtin_rvv_vlseg7e16ff_v_ta:
10750case RISCVVector::BI__builtin_rvv_vlseg7e32ff_v_ta:
10751case RISCVVector::BI__builtin_rvv_vlseg7e64ff_v_ta:
10752 ID = Intrinsic::riscv_vlseg7ff;
10753 NF = 7;
10754 DefaultPolicy = 1;
10755IsMasked = false;
10756
10757 {
10758 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
10759 IntrinsicTypes = {ResultType, Ops.back()->getType()};
10760 SmallVector<llvm::Value*, 12> Operands;
10761 Value *NewVL;
10762
10763 if (IsMasked) {
10764 // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
10765 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
10766 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
10767 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
10768 for (unsigned I = 0; I < NF; ++I)
10769 Operands.push_back(llvm::PoisonValue::get(ResultType));
10770 Operands.push_back(Ops[NF + 1]);
10771 Operands.push_back(Ops[NF]);
10772 Operands.push_back(Ops[NF + 3]);
10773 NewVL = Ops[NF + 2];
10774 } else {
10775 for (unsigned I = 0; I < NF; ++I)
10776 Operands.push_back(Ops[NF + I + 1]);
10777 Operands.push_back(Ops[2 * NF + 1]);
10778 Operands.push_back(Ops[NF]);
10779 Operands.push_back(Ops[2 * NF + 3]);
10780 NewVL = Ops[2 * NF + 2];
10781 }
10782 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
10783 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 10783, __extension__ __PRETTY_FUNCTION__));
10784 } else {
10785 // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
10786 // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
10787 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
10788 if (DefaultPolicy == TAIL_AGNOSTIC) {
10789 for (unsigned I = 0; I < NF; ++I)
10790 Operands.push_back(llvm::PoisonValue::get(ResultType));
10791 Operands.push_back(Ops[NF]);
10792 Operands.push_back(Ops[NF + 2]);
10793 NewVL = Ops[NF + 1];
10794 } else {
10795 for (unsigned I = 0; I < NF; ++I)
10796 Operands.push_back(Ops[NF + I]);
10797 Operands.push_back(Ops[2 * NF]);
10798 Operands.push_back(Ops[2 * NF + 2]);
10799 NewVL = Ops[2 * NF + 1];
10800 }
10801 }
10802 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
10803 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
10804 clang::CharUnits Align =
10805 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
10806 for (unsigned I = 0; I < NF; ++I) {
10807 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
10808 Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
10809 }
10810 // Store new_vl.
10811 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
10812 return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
10813 }
10814 break;
10815case RISCVVector::BI__builtin_rvv_vlseg7e8ff_v_tuma:
10816case RISCVVector::BI__builtin_rvv_vlseg7e16ff_v_tuma:
10817case RISCVVector::BI__builtin_rvv_vlseg7e32ff_v_tuma:
10818case RISCVVector::BI__builtin_rvv_vlseg7e64ff_v_tuma:
10819 ID = Intrinsic::riscv_vlseg7ff_mask;
10820 NF = 7;
10821 DefaultPolicy = 2;
10822IsMasked = true;
10823
10824 {
10825 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
10826 IntrinsicTypes = {ResultType, Ops.back()->getType()};
10827 SmallVector<llvm::Value*, 12> Operands;
10828 Value *NewVL;
10829
10830 if (IsMasked) {
10831 // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
10832 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
10833 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
10834 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
10835 for (unsigned I = 0; I < NF; ++I)
10836 Operands.push_back(llvm::PoisonValue::get(ResultType));
10837 Operands.push_back(Ops[NF + 1]);
10838 Operands.push_back(Ops[NF]);
10839 Operands.push_back(Ops[NF + 3]);
10840 NewVL = Ops[NF + 2];
10841 } else {
10842 for (unsigned I = 0; I < NF; ++I)
10843 Operands.push_back(Ops[NF + I + 1]);
10844 Operands.push_back(Ops[2 * NF + 1]);
10845 Operands.push_back(Ops[NF]);
10846 Operands.push_back(Ops[2 * NF + 3]);
10847 NewVL = Ops[2 * NF + 2];
10848 }
10849 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
10850 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 10850, __extension__ __PRETTY_FUNCTION__));
10851 } else {
10852 // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
10853 // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
10854 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
10855 if (DefaultPolicy == TAIL_AGNOSTIC) {
10856 for (unsigned I = 0; I < NF; ++I)
10857 Operands.push_back(llvm::PoisonValue::get(ResultType));
10858 Operands.push_back(Ops[NF]);
10859 Operands.push_back(Ops[NF + 2]);
10860 NewVL = Ops[NF + 1];
10861 } else {
10862 for (unsigned I = 0; I < NF; ++I)
10863 Operands.push_back(Ops[NF + I]);
10864 Operands.push_back(Ops[2 * NF]);
10865 Operands.push_back(Ops[2 * NF + 2]);
10866 NewVL = Ops[2 * NF + 1];
10867 }
10868 }
10869 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
10870 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
10871 clang::CharUnits Align =
10872 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
10873 for (unsigned I = 0; I < NF; ++I) {
10874 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
10875 Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
10876 }
10877 // Store new_vl.
10878 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
10879 return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
10880 }
10881 break;
10882case RISCVVector::BI__builtin_rvv_vlseg7e8ff_v_tama:
10883case RISCVVector::BI__builtin_rvv_vlseg7e16ff_v_tama:
10884case RISCVVector::BI__builtin_rvv_vlseg7e32ff_v_tama:
10885case RISCVVector::BI__builtin_rvv_vlseg7e64ff_v_tama:
10886 ID = Intrinsic::riscv_vlseg7ff_mask;
10887 NF = 7;
10888 DefaultPolicy = 3;
10889IsMasked = true;
10890
10891 {
10892 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
10893 IntrinsicTypes = {ResultType, Ops.back()->getType()};
10894 SmallVector<llvm::Value*, 12> Operands;
10895 Value *NewVL;
10896
10897 if (IsMasked) {
10898 // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
10899 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
10900 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
10901 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
10902 for (unsigned I = 0; I < NF; ++I)
10903 Operands.push_back(llvm::PoisonValue::get(ResultType));
10904 Operands.push_back(Ops[NF + 1]);
10905 Operands.push_back(Ops[NF]);
10906 Operands.push_back(Ops[NF + 3]);
10907 NewVL = Ops[NF + 2];
10908 } else {
10909 for (unsigned I = 0; I < NF; ++I)
10910 Operands.push_back(Ops[NF + I + 1]);
10911 Operands.push_back(Ops[2 * NF + 1]);
10912 Operands.push_back(Ops[NF]);
10913 Operands.push_back(Ops[2 * NF + 3]);
10914 NewVL = Ops[2 * NF + 2];
10915 }
10916 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
10917 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 10917, __extension__ __PRETTY_FUNCTION__));
10918 } else {
10919 // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
10920 // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
10921 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
10922 if (DefaultPolicy == TAIL_AGNOSTIC) {
10923 for (unsigned I = 0; I < NF; ++I)
10924 Operands.push_back(llvm::PoisonValue::get(ResultType));
10925 Operands.push_back(Ops[NF]);
10926 Operands.push_back(Ops[NF + 2]);
10927 NewVL = Ops[NF + 1];
10928 } else {
10929 for (unsigned I = 0; I < NF; ++I)
10930 Operands.push_back(Ops[NF + I]);
10931 Operands.push_back(Ops[2 * NF]);
10932 Operands.push_back(Ops[2 * NF + 2]);
10933 NewVL = Ops[2 * NF + 1];
10934 }
10935 }
10936 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
10937 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
10938 clang::CharUnits Align =
10939 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
10940 for (unsigned I = 0; I < NF; ++I) {
10941 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
10942 Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
10943 }
10944 // Store new_vl.
10945 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
10946 return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
10947 }
10948 break;
10949case RISCVVector::BI__builtin_rvv_vlseg7e8ff_v_tumu:
10950case RISCVVector::BI__builtin_rvv_vlseg7e16ff_v_tumu:
10951case RISCVVector::BI__builtin_rvv_vlseg7e32ff_v_tumu:
10952case RISCVVector::BI__builtin_rvv_vlseg7e64ff_v_tumu:
10953 ID = Intrinsic::riscv_vlseg7ff_mask;
10954 NF = 7;
10955 DefaultPolicy = 0;
10956IsMasked = true;
10957
10958 {
10959 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
10960 IntrinsicTypes = {ResultType, Ops.back()->getType()};
10961 SmallVector<llvm::Value*, 12> Operands;
10962 Value *NewVL;
10963
10964 if (IsMasked) {
10965 // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
10966 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
10967 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
10968 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
10969 for (unsigned I = 0; I < NF; ++I)
10970 Operands.push_back(llvm::PoisonValue::get(ResultType));
10971 Operands.push_back(Ops[NF + 1]);
10972 Operands.push_back(Ops[NF]);
10973 Operands.push_back(Ops[NF + 3]);
10974 NewVL = Ops[NF + 2];
10975 } else {
10976 for (unsigned I = 0; I < NF; ++I)
10977 Operands.push_back(Ops[NF + I + 1]);
10978 Operands.push_back(Ops[2 * NF + 1]);
10979 Operands.push_back(Ops[NF]);
10980 Operands.push_back(Ops[2 * NF + 3]);
10981 NewVL = Ops[2 * NF + 2];
10982 }
10983 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
10984 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 10984, __extension__ __PRETTY_FUNCTION__));
10985 } else {
10986 // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
10987 // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
10988 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
10989 if (DefaultPolicy == TAIL_AGNOSTIC) {
10990 for (unsigned I = 0; I < NF; ++I)
10991 Operands.push_back(llvm::PoisonValue::get(ResultType));
10992 Operands.push_back(Ops[NF]);
10993 Operands.push_back(Ops[NF + 2]);
10994 NewVL = Ops[NF + 1];
10995 } else {
10996 for (unsigned I = 0; I < NF; ++I)
10997 Operands.push_back(Ops[NF + I]);
10998 Operands.push_back(Ops[2 * NF]);
10999 Operands.push_back(Ops[2 * NF + 2]);
11000 NewVL = Ops[2 * NF + 1];
11001 }
11002 }
11003 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
11004 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
11005 clang::CharUnits Align =
11006 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
11007 for (unsigned I = 0; I < NF; ++I) {
11008 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
11009 Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
11010 }
11011 // Store new_vl.
11012 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
11013 return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
11014 }
11015 break;
11016case RISCVVector::BI__builtin_rvv_vlseg7e8ff_v_tamu:
11017case RISCVVector::BI__builtin_rvv_vlseg7e16ff_v_tamu:
11018case RISCVVector::BI__builtin_rvv_vlseg7e32ff_v_tamu:
11019case RISCVVector::BI__builtin_rvv_vlseg7e64ff_v_tamu:
11020 ID = Intrinsic::riscv_vlseg7ff_mask;
11021 NF = 7;
11022 DefaultPolicy = 1;
11023IsMasked = true;
11024
11025 {
11026 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
11027 IntrinsicTypes = {ResultType, Ops.back()->getType()};
11028 SmallVector<llvm::Value*, 12> Operands;
11029 Value *NewVL;
11030
11031 if (IsMasked) {
11032 // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
11033 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
11034 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
11035 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
11036 for (unsigned I = 0; I < NF; ++I)
11037 Operands.push_back(llvm::PoisonValue::get(ResultType));
11038 Operands.push_back(Ops[NF + 1]);
11039 Operands.push_back(Ops[NF]);
11040 Operands.push_back(Ops[NF + 3]);
11041 NewVL = Ops[NF + 2];
11042 } else {
11043 for (unsigned I = 0; I < NF; ++I)
11044 Operands.push_back(Ops[NF + I + 1]);
11045 Operands.push_back(Ops[2 * NF + 1]);
11046 Operands.push_back(Ops[NF]);
11047 Operands.push_back(Ops[2 * NF + 3]);
11048 NewVL = Ops[2 * NF + 2];
11049 }
11050 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
11051 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 11051, __extension__ __PRETTY_FUNCTION__));
11052 } else {
11053 // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
11054 // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
11055 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
11056 if (DefaultPolicy == TAIL_AGNOSTIC) {
11057 for (unsigned I = 0; I < NF; ++I)
11058 Operands.push_back(llvm::PoisonValue::get(ResultType));
11059 Operands.push_back(Ops[NF]);
11060 Operands.push_back(Ops[NF + 2]);
11061 NewVL = Ops[NF + 1];
11062 } else {
11063 for (unsigned I = 0; I < NF; ++I)
11064 Operands.push_back(Ops[NF + I]);
11065 Operands.push_back(Ops[2 * NF]);
11066 Operands.push_back(Ops[2 * NF + 2]);
11067 NewVL = Ops[2 * NF + 1];
11068 }
11069 }
11070 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
11071 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
11072 clang::CharUnits Align =
11073 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
11074 for (unsigned I = 0; I < NF; ++I) {
11075 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
11076 Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
11077 }
11078 // Store new_vl.
11079 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
11080 return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
11081 }
11082 break;
11083case RISCVVector::BI__builtin_rvv_vlseg8e8_v_tu:
11084case RISCVVector::BI__builtin_rvv_vlseg8e16_v_tu:
11085case RISCVVector::BI__builtin_rvv_vlseg8e32_v_tu:
11086case RISCVVector::BI__builtin_rvv_vlseg8e64_v_tu:
11087 ID = Intrinsic::riscv_vlseg8;
11088 NF = 8;
11089 DefaultPolicy = 0;
11090IsMasked = false;
11091
11092 {
11093 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
11094 IntrinsicTypes = {ResultType, Ops.back()->getType()};
11095 SmallVector<llvm::Value*, 10> Operands;
11096 if (IsMasked) {
11097 // TAMA builtin: (val0 address, ..., mask, ptr, vl)
11098 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
11099 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
11100 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
11101 for (unsigned I = 0; I < NF; ++I)
11102 Operands.push_back(llvm::PoisonValue::get(ResultType));
11103 Operands.push_back(Ops[NF + 1]);
11104 Operands.push_back(Ops[NF]);
11105 Operands.push_back(Ops[NF + 2]);
11106 } else {
11107 for (unsigned I = 0; I < NF; ++I)
11108 Operands.push_back(Ops[NF + I + 1]);
11109 Operands.push_back(Ops[2 * NF + 1]);
11110 Operands.push_back(Ops[NF]);
11111 Operands.push_back(Ops[2 * NF + 2]);
11112 }
11113 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
11114 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 11114, __extension__ __PRETTY_FUNCTION__));
11115 } else {
11116 // TA builtin: (val0 address, val1 address, ..., ptr, vl)
11117 // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
11118 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
11119 if (DefaultPolicy == TAIL_AGNOSTIC) {
11120 for (unsigned I = 0; I < NF; ++I)
11121 Operands.push_back(llvm::PoisonValue::get(ResultType));
11122 Operands.push_back(Ops[NF]);
11123 Operands.push_back(Ops[NF + 1]);
11124 } else {
11125 for (unsigned I = 0; I < NF; ++I)
11126 Operands.push_back(Ops[NF + I]);
11127 Operands.push_back(Ops[2 * NF]);
11128 Operands.push_back(Ops[2 * NF + 1]);
11129 }
11130 }
11131 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
11132 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
11133 clang::CharUnits Align =
11134 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
11135 llvm::Value *V;
11136 for (unsigned I = 0; I < NF; ++I) {
11137 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
11138 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
11139 }
11140 return V;
11141 }
11142 break;
11143case RISCVVector::BI__builtin_rvv_vlseg8e8_v_ta:
11144case RISCVVector::BI__builtin_rvv_vlseg8e16_v_ta:
11145case RISCVVector::BI__builtin_rvv_vlseg8e32_v_ta:
11146case RISCVVector::BI__builtin_rvv_vlseg8e64_v_ta:
11147 ID = Intrinsic::riscv_vlseg8;
11148 NF = 8;
11149 DefaultPolicy = 1;
11150IsMasked = false;
11151
11152 {
11153 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
11154 IntrinsicTypes = {ResultType, Ops.back()->getType()};
11155 SmallVector<llvm::Value*, 10> Operands;
11156 if (IsMasked) {
11157 // TAMA builtin: (val0 address, ..., mask, ptr, vl)
11158 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
11159 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
11160 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
11161 for (unsigned I = 0; I < NF; ++I)
11162 Operands.push_back(llvm::PoisonValue::get(ResultType));
11163 Operands.push_back(Ops[NF + 1]);
11164 Operands.push_back(Ops[NF]);
11165 Operands.push_back(Ops[NF + 2]);
11166 } else {
11167 for (unsigned I = 0; I < NF; ++I)
11168 Operands.push_back(Ops[NF + I + 1]);
11169 Operands.push_back(Ops[2 * NF + 1]);
11170 Operands.push_back(Ops[NF]);
11171 Operands.push_back(Ops[2 * NF + 2]);
11172 }
11173 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
11174 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 11174, __extension__ __PRETTY_FUNCTION__));
11175 } else {
11176 // TA builtin: (val0 address, val1 address, ..., ptr, vl)
11177 // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
11178 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
11179 if (DefaultPolicy == TAIL_AGNOSTIC) {
11180 for (unsigned I = 0; I < NF; ++I)
11181 Operands.push_back(llvm::PoisonValue::get(ResultType));
11182 Operands.push_back(Ops[NF]);
11183 Operands.push_back(Ops[NF + 1]);
11184 } else {
11185 for (unsigned I = 0; I < NF; ++I)
11186 Operands.push_back(Ops[NF + I]);
11187 Operands.push_back(Ops[2 * NF]);
11188 Operands.push_back(Ops[2 * NF + 1]);
11189 }
11190 }
11191 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
11192 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
11193 clang::CharUnits Align =
11194 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
11195 llvm::Value *V;
11196 for (unsigned I = 0; I < NF; ++I) {
11197 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
11198 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
11199 }
11200 return V;
11201 }
11202 break;
11203case RISCVVector::BI__builtin_rvv_vlseg8e8_v_tuma:
11204case RISCVVector::BI__builtin_rvv_vlseg8e16_v_tuma:
11205case RISCVVector::BI__builtin_rvv_vlseg8e32_v_tuma:
11206case RISCVVector::BI__builtin_rvv_vlseg8e64_v_tuma:
11207 ID = Intrinsic::riscv_vlseg8_mask;
11208 NF = 8;
11209 DefaultPolicy = 2;
11210IsMasked = true;
11211
11212 {
11213 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
11214 IntrinsicTypes = {ResultType, Ops.back()->getType()};
11215 SmallVector<llvm::Value*, 10> Operands;
11216 if (IsMasked) {
11217 // TAMA builtin: (val0 address, ..., mask, ptr, vl)
11218 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
11219 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
11220 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
11221 for (unsigned I = 0; I < NF; ++I)
11222 Operands.push_back(llvm::PoisonValue::get(ResultType));
11223 Operands.push_back(Ops[NF + 1]);
11224 Operands.push_back(Ops[NF]);
11225 Operands.push_back(Ops[NF + 2]);
11226 } else {
11227 for (unsigned I = 0; I < NF; ++I)
11228 Operands.push_back(Ops[NF + I + 1]);
11229 Operands.push_back(Ops[2 * NF + 1]);
11230 Operands.push_back(Ops[NF]);
11231 Operands.push_back(Ops[2 * NF + 2]);
11232 }
11233 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
11234 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 11234, __extension__ __PRETTY_FUNCTION__));
11235 } else {
11236 // TA builtin: (val0 address, val1 address, ..., ptr, vl)
11237 // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
11238 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
11239 if (DefaultPolicy == TAIL_AGNOSTIC) {
11240 for (unsigned I = 0; I < NF; ++I)
11241 Operands.push_back(llvm::PoisonValue::get(ResultType));
11242 Operands.push_back(Ops[NF]);
11243 Operands.push_back(Ops[NF + 1]);
11244 } else {
11245 for (unsigned I = 0; I < NF; ++I)
11246 Operands.push_back(Ops[NF + I]);
11247 Operands.push_back(Ops[2 * NF]);
11248 Operands.push_back(Ops[2 * NF + 1]);
11249 }
11250 }
11251 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
11252 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
11253 clang::CharUnits Align =
11254 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
11255 llvm::Value *V;
11256 for (unsigned I = 0; I < NF; ++I) {
11257 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
11258 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
11259 }
11260 return V;
11261 }
11262 break;
11263case RISCVVector::BI__builtin_rvv_vlseg8e8_v_tama:
11264case RISCVVector::BI__builtin_rvv_vlseg8e16_v_tama:
11265case RISCVVector::BI__builtin_rvv_vlseg8e32_v_tama:
11266case RISCVVector::BI__builtin_rvv_vlseg8e64_v_tama:
11267 ID = Intrinsic::riscv_vlseg8_mask;
11268 NF = 8;
11269 DefaultPolicy = 3;
11270IsMasked = true;
11271
11272 {
11273 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
11274 IntrinsicTypes = {ResultType, Ops.back()->getType()};
11275 SmallVector<llvm::Value*, 10> Operands;
11276 if (IsMasked) {
11277 // TAMA builtin: (val0 address, ..., mask, ptr, vl)
11278 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
11279 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
11280 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
11281 for (unsigned I = 0; I < NF; ++I)
11282 Operands.push_back(llvm::PoisonValue::get(ResultType));
11283 Operands.push_back(Ops[NF + 1]);
11284 Operands.push_back(Ops[NF]);
11285 Operands.push_back(Ops[NF + 2]);
11286 } else {
11287 for (unsigned I = 0; I < NF; ++I)
11288 Operands.push_back(Ops[NF + I + 1]);
11289 Operands.push_back(Ops[2 * NF + 1]);
11290 Operands.push_back(Ops[NF]);
11291 Operands.push_back(Ops[2 * NF + 2]);
11292 }
11293 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
11294 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 11294, __extension__ __PRETTY_FUNCTION__));
11295 } else {
11296 // TA builtin: (val0 address, val1 address, ..., ptr, vl)
11297 // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
11298 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
11299 if (DefaultPolicy == TAIL_AGNOSTIC) {
11300 for (unsigned I = 0; I < NF; ++I)
11301 Operands.push_back(llvm::PoisonValue::get(ResultType));
11302 Operands.push_back(Ops[NF]);
11303 Operands.push_back(Ops[NF + 1]);
11304 } else {
11305 for (unsigned I = 0; I < NF; ++I)
11306 Operands.push_back(Ops[NF + I]);
11307 Operands.push_back(Ops[2 * NF]);
11308 Operands.push_back(Ops[2 * NF + 1]);
11309 }
11310 }
11311 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
11312 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
11313 clang::CharUnits Align =
11314 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
11315 llvm::Value *V;
11316 for (unsigned I = 0; I < NF; ++I) {
11317 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
11318 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
11319 }
11320 return V;
11321 }
11322 break;
11323case RISCVVector::BI__builtin_rvv_vlseg8e8_v_tumu:
11324case RISCVVector::BI__builtin_rvv_vlseg8e16_v_tumu:
11325case RISCVVector::BI__builtin_rvv_vlseg8e32_v_tumu:
11326case RISCVVector::BI__builtin_rvv_vlseg8e64_v_tumu:
11327 ID = Intrinsic::riscv_vlseg8_mask;
11328 NF = 8;
11329 DefaultPolicy = 0;
11330IsMasked = true;
11331
11332 {
11333 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
11334 IntrinsicTypes = {ResultType, Ops.back()->getType()};
11335 SmallVector<llvm::Value*, 10> Operands;
11336 if (IsMasked) {
11337 // TAMA builtin: (val0 address, ..., mask, ptr, vl)
11338 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
11339 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
11340 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
11341 for (unsigned I = 0; I < NF; ++I)
11342 Operands.push_back(llvm::PoisonValue::get(ResultType));
11343 Operands.push_back(Ops[NF + 1]);
11344 Operands.push_back(Ops[NF]);
11345 Operands.push_back(Ops[NF + 2]);
11346 } else {
11347 for (unsigned I = 0; I < NF; ++I)
11348 Operands.push_back(Ops[NF + I + 1]);
11349 Operands.push_back(Ops[2 * NF + 1]);
11350 Operands.push_back(Ops[NF]);
11351 Operands.push_back(Ops[2 * NF + 2]);
11352 }
11353 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
11354 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 11354, __extension__ __PRETTY_FUNCTION__));
11355 } else {
11356 // TA builtin: (val0 address, val1 address, ..., ptr, vl)
11357 // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
11358 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
11359 if (DefaultPolicy == TAIL_AGNOSTIC) {
11360 for (unsigned I = 0; I < NF; ++I)
11361 Operands.push_back(llvm::PoisonValue::get(ResultType));
11362 Operands.push_back(Ops[NF]);
11363 Operands.push_back(Ops[NF + 1]);
11364 } else {
11365 for (unsigned I = 0; I < NF; ++I)
11366 Operands.push_back(Ops[NF + I]);
11367 Operands.push_back(Ops[2 * NF]);
11368 Operands.push_back(Ops[2 * NF + 1]);
11369 }
11370 }
11371 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
11372 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
11373 clang::CharUnits Align =
11374 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
11375 llvm::Value *V;
11376 for (unsigned I = 0; I < NF; ++I) {
11377 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
11378 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
11379 }
11380 return V;
11381 }
11382 break;
11383case RISCVVector::BI__builtin_rvv_vlseg8e8_v_tamu:
11384case RISCVVector::BI__builtin_rvv_vlseg8e16_v_tamu:
11385case RISCVVector::BI__builtin_rvv_vlseg8e32_v_tamu:
11386case RISCVVector::BI__builtin_rvv_vlseg8e64_v_tamu:
11387 ID = Intrinsic::riscv_vlseg8_mask;
11388 NF = 8;
11389 DefaultPolicy = 1;
11390IsMasked = true;
11391
11392 {
11393 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
11394 IntrinsicTypes = {ResultType, Ops.back()->getType()};
11395 SmallVector<llvm::Value*, 10> Operands;
11396 if (IsMasked) {
11397 // TAMA builtin: (val0 address, ..., mask, ptr, vl)
11398 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
11399 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
11400 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
11401 for (unsigned I = 0; I < NF; ++I)
11402 Operands.push_back(llvm::PoisonValue::get(ResultType));
11403 Operands.push_back(Ops[NF + 1]);
11404 Operands.push_back(Ops[NF]);
11405 Operands.push_back(Ops[NF + 2]);
11406 } else {
11407 for (unsigned I = 0; I < NF; ++I)
11408 Operands.push_back(Ops[NF + I + 1]);
11409 Operands.push_back(Ops[2 * NF + 1]);
11410 Operands.push_back(Ops[NF]);
11411 Operands.push_back(Ops[2 * NF + 2]);
11412 }
11413 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
11414 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 11414, __extension__ __PRETTY_FUNCTION__));
11415 } else {
11416 // TA builtin: (val0 address, val1 address, ..., ptr, vl)
11417 // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
11418 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
11419 if (DefaultPolicy == TAIL_AGNOSTIC) {
11420 for (unsigned I = 0; I < NF; ++I)
11421 Operands.push_back(llvm::PoisonValue::get(ResultType));
11422 Operands.push_back(Ops[NF]);
11423 Operands.push_back(Ops[NF + 1]);
11424 } else {
11425 for (unsigned I = 0; I < NF; ++I)
11426 Operands.push_back(Ops[NF + I]);
11427 Operands.push_back(Ops[2 * NF]);
11428 Operands.push_back(Ops[2 * NF + 1]);
11429 }
11430 }
11431 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
11432 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
11433 clang::CharUnits Align =
11434 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
11435 llvm::Value *V;
11436 for (unsigned I = 0; I < NF; ++I) {
11437 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
11438 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
11439 }
11440 return V;
11441 }
11442 break;
11443case RISCVVector::BI__builtin_rvv_vlseg8e8ff_v_tu:
11444case RISCVVector::BI__builtin_rvv_vlseg8e16ff_v_tu:
11445case RISCVVector::BI__builtin_rvv_vlseg8e32ff_v_tu:
11446case RISCVVector::BI__builtin_rvv_vlseg8e64ff_v_tu:
11447 ID = Intrinsic::riscv_vlseg8ff;
11448 NF = 8;
11449 DefaultPolicy = 0;
11450IsMasked = false;
11451
11452 {
11453 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
11454 IntrinsicTypes = {ResultType, Ops.back()->getType()};
11455 SmallVector<llvm::Value*, 12> Operands;
11456 Value *NewVL;
11457
11458 if (IsMasked) {
11459 // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
11460 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
11461 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
11462 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
11463 for (unsigned I = 0; I < NF; ++I)
11464 Operands.push_back(llvm::PoisonValue::get(ResultType));
11465 Operands.push_back(Ops[NF + 1]);
11466 Operands.push_back(Ops[NF]);
11467 Operands.push_back(Ops[NF + 3]);
11468 NewVL = Ops[NF + 2];
11469 } else {
11470 for (unsigned I = 0; I < NF; ++I)
11471 Operands.push_back(Ops[NF + I + 1]);
11472 Operands.push_back(Ops[2 * NF + 1]);
11473 Operands.push_back(Ops[NF]);
11474 Operands.push_back(Ops[2 * NF + 3]);
11475 NewVL = Ops[2 * NF + 2];
11476 }
11477 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
11478 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 11478, __extension__ __PRETTY_FUNCTION__));
11479 } else {
11480 // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
11481 // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
11482 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
11483 if (DefaultPolicy == TAIL_AGNOSTIC) {
11484 for (unsigned I = 0; I < NF; ++I)
11485 Operands.push_back(llvm::PoisonValue::get(ResultType));
11486 Operands.push_back(Ops[NF]);
11487 Operands.push_back(Ops[NF + 2]);
11488 NewVL = Ops[NF + 1];
11489 } else {
11490 for (unsigned I = 0; I < NF; ++I)
11491 Operands.push_back(Ops[NF + I]);
11492 Operands.push_back(Ops[2 * NF]);
11493 Operands.push_back(Ops[2 * NF + 2]);
11494 NewVL = Ops[2 * NF + 1];
11495 }
11496 }
11497 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
11498 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
11499 clang::CharUnits Align =
11500 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
11501 for (unsigned I = 0; I < NF; ++I) {
11502 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
11503 Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
11504 }
11505 // Store new_vl.
11506 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
11507 return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
11508 }
11509 break;
11510case RISCVVector::BI__builtin_rvv_vlseg8e8ff_v_ta:
11511case RISCVVector::BI__builtin_rvv_vlseg8e16ff_v_ta:
11512case RISCVVector::BI__builtin_rvv_vlseg8e32ff_v_ta:
11513case RISCVVector::BI__builtin_rvv_vlseg8e64ff_v_ta:
11514 ID = Intrinsic::riscv_vlseg8ff;
11515 NF = 8;
11516 DefaultPolicy = 1;
11517IsMasked = false;
11518
11519 {
11520 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
11521 IntrinsicTypes = {ResultType, Ops.back()->getType()};
11522 SmallVector<llvm::Value*, 12> Operands;
11523 Value *NewVL;
11524
11525 if (IsMasked) {
11526 // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
11527 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
11528 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
11529 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
11530 for (unsigned I = 0; I < NF; ++I)
11531 Operands.push_back(llvm::PoisonValue::get(ResultType));
11532 Operands.push_back(Ops[NF + 1]);
11533 Operands.push_back(Ops[NF]);
11534 Operands.push_back(Ops[NF + 3]);
11535 NewVL = Ops[NF + 2];
11536 } else {
11537 for (unsigned I = 0; I < NF; ++I)
11538 Operands.push_back(Ops[NF + I + 1]);
11539 Operands.push_back(Ops[2 * NF + 1]);
11540 Operands.push_back(Ops[NF]);
11541 Operands.push_back(Ops[2 * NF + 3]);
11542 NewVL = Ops[2 * NF + 2];
11543 }
11544 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
11545 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 11545, __extension__ __PRETTY_FUNCTION__));
11546 } else {
11547 // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
11548 // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
11549 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
11550 if (DefaultPolicy == TAIL_AGNOSTIC) {
11551 for (unsigned I = 0; I < NF; ++I)
11552 Operands.push_back(llvm::PoisonValue::get(ResultType));
11553 Operands.push_back(Ops[NF]);
11554 Operands.push_back(Ops[NF + 2]);
11555 NewVL = Ops[NF + 1];
11556 } else {
11557 for (unsigned I = 0; I < NF; ++I)
11558 Operands.push_back(Ops[NF + I]);
11559 Operands.push_back(Ops[2 * NF]);
11560 Operands.push_back(Ops[2 * NF + 2]);
11561 NewVL = Ops[2 * NF + 1];
11562 }
11563 }
11564 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
11565 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
11566 clang::CharUnits Align =
11567 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
11568 for (unsigned I = 0; I < NF; ++I) {
11569 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
11570 Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
11571 }
11572 // Store new_vl.
11573 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
11574 return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
11575 }
11576 break;
11577case RISCVVector::BI__builtin_rvv_vlseg8e8ff_v_tuma:
11578case RISCVVector::BI__builtin_rvv_vlseg8e16ff_v_tuma:
11579case RISCVVector::BI__builtin_rvv_vlseg8e32ff_v_tuma:
11580case RISCVVector::BI__builtin_rvv_vlseg8e64ff_v_tuma:
11581 ID = Intrinsic::riscv_vlseg8ff_mask;
11582 NF = 8;
11583 DefaultPolicy = 2;
11584IsMasked = true;
11585
11586 {
11587 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
11588 IntrinsicTypes = {ResultType, Ops.back()->getType()};
11589 SmallVector<llvm::Value*, 12> Operands;
11590 Value *NewVL;
11591
11592 if (IsMasked) {
11593 // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
11594 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
11595 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
11596 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
11597 for (unsigned I = 0; I < NF; ++I)
11598 Operands.push_back(llvm::PoisonValue::get(ResultType));
11599 Operands.push_back(Ops[NF + 1]);
11600 Operands.push_back(Ops[NF]);
11601 Operands.push_back(Ops[NF + 3]);
11602 NewVL = Ops[NF + 2];
11603 } else {
11604 for (unsigned I = 0; I < NF; ++I)
11605 Operands.push_back(Ops[NF + I + 1]);
11606 Operands.push_back(Ops[2 * NF + 1]);
11607 Operands.push_back(Ops[NF]);
11608 Operands.push_back(Ops[2 * NF + 3]);
11609 NewVL = Ops[2 * NF + 2];
11610 }
11611 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
11612 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 11612, __extension__ __PRETTY_FUNCTION__));
11613 } else {
11614 // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
11615 // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
11616 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
11617 if (DefaultPolicy == TAIL_AGNOSTIC) {
11618 for (unsigned I = 0; I < NF; ++I)
11619 Operands.push_back(llvm::PoisonValue::get(ResultType));
11620 Operands.push_back(Ops[NF]);
11621 Operands.push_back(Ops[NF + 2]);
11622 NewVL = Ops[NF + 1];
11623 } else {
11624 for (unsigned I = 0; I < NF; ++I)
11625 Operands.push_back(Ops[NF + I]);
11626 Operands.push_back(Ops[2 * NF]);
11627 Operands.push_back(Ops[2 * NF + 2]);
11628 NewVL = Ops[2 * NF + 1];
11629 }
11630 }
11631 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
11632 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
11633 clang::CharUnits Align =
11634 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
11635 for (unsigned I = 0; I < NF; ++I) {
11636 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
11637 Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
11638 }
11639 // Store new_vl.
11640 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
11641 return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
11642 }
11643 break;
11644case RISCVVector::BI__builtin_rvv_vlseg8e8ff_v_tama:
11645case RISCVVector::BI__builtin_rvv_vlseg8e16ff_v_tama:
11646case RISCVVector::BI__builtin_rvv_vlseg8e32ff_v_tama:
11647case RISCVVector::BI__builtin_rvv_vlseg8e64ff_v_tama:
11648 ID = Intrinsic::riscv_vlseg8ff_mask;
11649 NF = 8;
11650 DefaultPolicy = 3;
11651IsMasked = true;
11652
11653 {
11654 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
11655 IntrinsicTypes = {ResultType, Ops.back()->getType()};
11656 SmallVector<llvm::Value*, 12> Operands;
11657 Value *NewVL;
11658
11659 if (IsMasked) {
11660 // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
11661 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
11662 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
11663 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
11664 for (unsigned I = 0; I < NF; ++I)
11665 Operands.push_back(llvm::PoisonValue::get(ResultType));
11666 Operands.push_back(Ops[NF + 1]);
11667 Operands.push_back(Ops[NF]);
11668 Operands.push_back(Ops[NF + 3]);
11669 NewVL = Ops[NF + 2];
11670 } else {
11671 for (unsigned I = 0; I < NF; ++I)
11672 Operands.push_back(Ops[NF + I + 1]);
11673 Operands.push_back(Ops[2 * NF + 1]);
11674 Operands.push_back(Ops[NF]);
11675 Operands.push_back(Ops[2 * NF + 3]);
11676 NewVL = Ops[2 * NF + 2];
11677 }
11678 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
11679 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 11679, __extension__ __PRETTY_FUNCTION__));
11680 } else {
11681 // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
11682 // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
11683 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
11684 if (DefaultPolicy == TAIL_AGNOSTIC) {
11685 for (unsigned I = 0; I < NF; ++I)
11686 Operands.push_back(llvm::PoisonValue::get(ResultType));
11687 Operands.push_back(Ops[NF]);
11688 Operands.push_back(Ops[NF + 2]);
11689 NewVL = Ops[NF + 1];
11690 } else {
11691 for (unsigned I = 0; I < NF; ++I)
11692 Operands.push_back(Ops[NF + I]);
11693 Operands.push_back(Ops[2 * NF]);
11694 Operands.push_back(Ops[2 * NF + 2]);
11695 NewVL = Ops[2 * NF + 1];
11696 }
11697 }
11698 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
11699 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
11700 clang::CharUnits Align =
11701 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
11702 for (unsigned I = 0; I < NF; ++I) {
11703 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
11704 Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
11705 }
11706 // Store new_vl.
11707 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
11708 return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
11709 }
11710 break;
11711case RISCVVector::BI__builtin_rvv_vlseg8e8ff_v_tumu:
11712case RISCVVector::BI__builtin_rvv_vlseg8e16ff_v_tumu:
11713case RISCVVector::BI__builtin_rvv_vlseg8e32ff_v_tumu:
11714case RISCVVector::BI__builtin_rvv_vlseg8e64ff_v_tumu:
11715 ID = Intrinsic::riscv_vlseg8ff_mask;
11716 NF = 8;
11717 DefaultPolicy = 0;
11718IsMasked = true;
11719
11720 {
11721 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
11722 IntrinsicTypes = {ResultType, Ops.back()->getType()};
11723 SmallVector<llvm::Value*, 12> Operands;
11724 Value *NewVL;
11725
11726 if (IsMasked) {
11727 // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
11728 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
11729 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
11730 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
11731 for (unsigned I = 0; I < NF; ++I)
11732 Operands.push_back(llvm::PoisonValue::get(ResultType));
11733 Operands.push_back(Ops[NF + 1]);
11734 Operands.push_back(Ops[NF]);
11735 Operands.push_back(Ops[NF + 3]);
11736 NewVL = Ops[NF + 2];
11737 } else {
11738 for (unsigned I = 0; I < NF; ++I)
11739 Operands.push_back(Ops[NF + I + 1]);
11740 Operands.push_back(Ops[2 * NF + 1]);
11741 Operands.push_back(Ops[NF]);
11742 Operands.push_back(Ops[2 * NF + 3]);
11743 NewVL = Ops[2 * NF + 2];
11744 }
11745 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
11746 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 11746, __extension__ __PRETTY_FUNCTION__));
11747 } else {
11748 // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
11749 // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
11750 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
11751 if (DefaultPolicy == TAIL_AGNOSTIC) {
11752 for (unsigned I = 0; I < NF; ++I)
11753 Operands.push_back(llvm::PoisonValue::get(ResultType));
11754 Operands.push_back(Ops[NF]);
11755 Operands.push_back(Ops[NF + 2]);
11756 NewVL = Ops[NF + 1];
11757 } else {
11758 for (unsigned I = 0; I < NF; ++I)
11759 Operands.push_back(Ops[NF + I]);
11760 Operands.push_back(Ops[2 * NF]);
11761 Operands.push_back(Ops[2 * NF + 2]);
11762 NewVL = Ops[2 * NF + 1];
11763 }
11764 }
11765 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
11766 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
11767 clang::CharUnits Align =
11768 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
11769 for (unsigned I = 0; I < NF; ++I) {
11770 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
11771 Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
11772 }
11773 // Store new_vl.
11774 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
11775 return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
11776 }
11777 break;
11778case RISCVVector::BI__builtin_rvv_vlseg8e8ff_v_tamu:
11779case RISCVVector::BI__builtin_rvv_vlseg8e16ff_v_tamu:
11780case RISCVVector::BI__builtin_rvv_vlseg8e32ff_v_tamu:
11781case RISCVVector::BI__builtin_rvv_vlseg8e64ff_v_tamu:
11782 ID = Intrinsic::riscv_vlseg8ff_mask;
11783 NF = 8;
11784 DefaultPolicy = 1;
11785IsMasked = true;
11786
11787 {
11788 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
11789 IntrinsicTypes = {ResultType, Ops.back()->getType()};
11790 SmallVector<llvm::Value*, 12> Operands;
11791 Value *NewVL;
11792
11793 if (IsMasked) {
11794 // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
11795 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
11796 // intrinsic: (maskedoff0, ..., ptr, mask, vl)
11797 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
11798 for (unsigned I = 0; I < NF; ++I)
11799 Operands.push_back(llvm::PoisonValue::get(ResultType));
11800 Operands.push_back(Ops[NF + 1]);
11801 Operands.push_back(Ops[NF]);
11802 Operands.push_back(Ops[NF + 3]);
11803 NewVL = Ops[NF + 2];
11804 } else {
11805 for (unsigned I = 0; I < NF; ++I)
11806 Operands.push_back(Ops[NF + I + 1]);
11807 Operands.push_back(Ops[2 * NF + 1]);
11808 Operands.push_back(Ops[NF]);
11809 Operands.push_back(Ops[2 * NF + 3]);
11810 NewVL = Ops[2 * NF + 2];
11811 }
11812 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
11813 assert(Operands.size() == NF + 4)(static_cast <bool> (Operands.size() == NF + 4) ? void (
0) : __assert_fail ("Operands.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 11813, __extension__ __PRETTY_FUNCTION__));
11814 } else {
11815 // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
11816 // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
11817 // intrinsic: (passthru0, passthru1, ..., ptr, vl)
11818 if (DefaultPolicy == TAIL_AGNOSTIC) {
11819 for (unsigned I = 0; I < NF; ++I)
11820 Operands.push_back(llvm::PoisonValue::get(ResultType));
11821 Operands.push_back(Ops[NF]);
11822 Operands.push_back(Ops[NF + 2]);
11823 NewVL = Ops[NF + 1];
11824 } else {
11825 for (unsigned I = 0; I < NF; ++I)
11826 Operands.push_back(Ops[NF + I]);
11827 Operands.push_back(Ops[2 * NF]);
11828 Operands.push_back(Ops[2 * NF + 2]);
11829 NewVL = Ops[2 * NF + 1];
11830 }
11831 }
11832 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
11833 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
11834 clang::CharUnits Align =
11835 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
11836 for (unsigned I = 0; I < NF; ++I) {
11837 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
11838 Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
11839 }
11840 // Store new_vl.
11841 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {NF});
11842 return Builder.CreateStore(Val, Address(NewVL, Val->getType(), Align));
11843 }
11844 break;
11845case RISCVVector::BI__builtin_rvv_vlsseg2e16_v_tu:
11846case RISCVVector::BI__builtin_rvv_vlsseg2e8_v_tu:
11847case RISCVVector::BI__builtin_rvv_vlsseg2e32_v_tu:
11848case RISCVVector::BI__builtin_rvv_vlsseg2e64_v_tu:
11849 ID = Intrinsic::riscv_vlsseg2;
11850 NF = 2;
11851 DefaultPolicy = 0;
11852IsMasked = false;
11853
11854 {
11855 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
11856 IntrinsicTypes = {ResultType, Ops.back()->getType()};
11857 SmallVector<llvm::Value*, 12> Operands;
11858
11859 if (IsMasked) {
11860 // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
11861 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
11862 // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
11863 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
11864 for (unsigned I = 0; I < NF; ++I)
11865 Operands.push_back(llvm::PoisonValue::get(ResultType));
11866 Operands.push_back(Ops[NF + 1]);
11867 Operands.push_back(Ops[NF + 2]);
11868 Operands.push_back(Ops[NF]);
11869 Operands.push_back(Ops[NF + 3]);
11870 } else {
11871 for (unsigned I = 0; I < NF; ++I)
11872 Operands.push_back(Ops[NF + I + 1]);
11873 Operands.push_back(Ops[2 * NF + 1]);
11874 Operands.push_back(Ops[2 * NF + 2]);
11875 Operands.push_back(Ops[NF]);
11876 Operands.push_back(Ops[2 * NF + 3]);
11877 }
11878 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
11879 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 11879, __extension__ __PRETTY_FUNCTION__));
11880 } else {
11881 // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
11882 // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
11883 // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
11884 if (DefaultPolicy == TAIL_AGNOSTIC) {
11885 for (unsigned I = 0; I < NF; ++I)
11886 Operands.push_back(llvm::PoisonValue::get(ResultType));
11887 Operands.push_back(Ops[NF]);
11888 Operands.push_back(Ops[NF + 1]);
11889 Operands.push_back(Ops[NF + 2]);
11890 } else {
11891 for (unsigned I = 0; I < NF; ++I)
11892 Operands.push_back(Ops[NF + I]);
11893 Operands.push_back(Ops[2 * NF]);
11894 Operands.push_back(Ops[2 * NF + 1]);
11895 Operands.push_back(Ops[2 * NF + 2]);
11896 }
11897 }
11898 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
11899 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
11900 clang::CharUnits Align =
11901 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
11902 llvm::Value *V;
11903 for (unsigned I = 0; I < NF; ++I) {
11904 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
11905 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
11906 }
11907 return V;
11908 }
11909 break;
11910case RISCVVector::BI__builtin_rvv_vlsseg2e16_v_ta:
11911case RISCVVector::BI__builtin_rvv_vlsseg2e8_v_ta:
11912case RISCVVector::BI__builtin_rvv_vlsseg2e32_v_ta:
11913case RISCVVector::BI__builtin_rvv_vlsseg2e64_v_ta:
11914 ID = Intrinsic::riscv_vlsseg2;
11915 NF = 2;
11916 DefaultPolicy = 1;
11917IsMasked = false;
11918
11919 {
11920 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
11921 IntrinsicTypes = {ResultType, Ops.back()->getType()};
11922 SmallVector<llvm::Value*, 12> Operands;
11923
11924 if (IsMasked) {
11925 // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
11926 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
11927 // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
11928 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
11929 for (unsigned I = 0; I < NF; ++I)
11930 Operands.push_back(llvm::PoisonValue::get(ResultType));
11931 Operands.push_back(Ops[NF + 1]);
11932 Operands.push_back(Ops[NF + 2]);
11933 Operands.push_back(Ops[NF]);
11934 Operands.push_back(Ops[NF + 3]);
11935 } else {
11936 for (unsigned I = 0; I < NF; ++I)
11937 Operands.push_back(Ops[NF + I + 1]);
11938 Operands.push_back(Ops[2 * NF + 1]);
11939 Operands.push_back(Ops[2 * NF + 2]);
11940 Operands.push_back(Ops[NF]);
11941 Operands.push_back(Ops[2 * NF + 3]);
11942 }
11943 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
11944 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 11944, __extension__ __PRETTY_FUNCTION__));
11945 } else {
11946 // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
11947 // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
11948 // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
11949 if (DefaultPolicy == TAIL_AGNOSTIC) {
11950 for (unsigned I = 0; I < NF; ++I)
11951 Operands.push_back(llvm::PoisonValue::get(ResultType));
11952 Operands.push_back(Ops[NF]);
11953 Operands.push_back(Ops[NF + 1]);
11954 Operands.push_back(Ops[NF + 2]);
11955 } else {
11956 for (unsigned I = 0; I < NF; ++I)
11957 Operands.push_back(Ops[NF + I]);
11958 Operands.push_back(Ops[2 * NF]);
11959 Operands.push_back(Ops[2 * NF + 1]);
11960 Operands.push_back(Ops[2 * NF + 2]);
11961 }
11962 }
11963 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
11964 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
11965 clang::CharUnits Align =
11966 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
11967 llvm::Value *V;
11968 for (unsigned I = 0; I < NF; ++I) {
11969 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
11970 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
11971 }
11972 return V;
11973 }
11974 break;
11975case RISCVVector::BI__builtin_rvv_vlsseg2e16_v_tuma:
11976case RISCVVector::BI__builtin_rvv_vlsseg2e8_v_tuma:
11977case RISCVVector::BI__builtin_rvv_vlsseg2e32_v_tuma:
11978case RISCVVector::BI__builtin_rvv_vlsseg2e64_v_tuma:
11979 ID = Intrinsic::riscv_vlsseg2_mask;
11980 NF = 2;
11981 DefaultPolicy = 2;
11982IsMasked = true;
11983
11984 {
11985 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
11986 IntrinsicTypes = {ResultType, Ops.back()->getType()};
11987 SmallVector<llvm::Value*, 12> Operands;
11988
11989 if (IsMasked) {
11990 // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
11991 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
11992 // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
11993 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
11994 for (unsigned I = 0; I < NF; ++I)
11995 Operands.push_back(llvm::PoisonValue::get(ResultType));
11996 Operands.push_back(Ops[NF + 1]);
11997 Operands.push_back(Ops[NF + 2]);
11998 Operands.push_back(Ops[NF]);
11999 Operands.push_back(Ops[NF + 3]);
12000 } else {
12001 for (unsigned I = 0; I < NF; ++I)
12002 Operands.push_back(Ops[NF + I + 1]);
12003 Operands.push_back(Ops[2 * NF + 1]);
12004 Operands.push_back(Ops[2 * NF + 2]);
12005 Operands.push_back(Ops[NF]);
12006 Operands.push_back(Ops[2 * NF + 3]);
12007 }
12008 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
12009 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 12009, __extension__ __PRETTY_FUNCTION__));
12010 } else {
12011 // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
12012 // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
12013 // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
12014 if (DefaultPolicy == TAIL_AGNOSTIC) {
12015 for (unsigned I = 0; I < NF; ++I)
12016 Operands.push_back(llvm::PoisonValue::get(ResultType));
12017 Operands.push_back(Ops[NF]);
12018 Operands.push_back(Ops[NF + 1]);
12019 Operands.push_back(Ops[NF + 2]);
12020 } else {
12021 for (unsigned I = 0; I < NF; ++I)
12022 Operands.push_back(Ops[NF + I]);
12023 Operands.push_back(Ops[2 * NF]);
12024 Operands.push_back(Ops[2 * NF + 1]);
12025 Operands.push_back(Ops[2 * NF + 2]);
12026 }
12027 }
12028 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
12029 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
12030 clang::CharUnits Align =
12031 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
12032 llvm::Value *V;
12033 for (unsigned I = 0; I < NF; ++I) {
12034 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
12035 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
12036 }
12037 return V;
12038 }
12039 break;
12040case RISCVVector::BI__builtin_rvv_vlsseg2e16_v_tama:
12041case RISCVVector::BI__builtin_rvv_vlsseg2e8_v_tama:
12042case RISCVVector::BI__builtin_rvv_vlsseg2e32_v_tama:
12043case RISCVVector::BI__builtin_rvv_vlsseg2e64_v_tama:
12044 ID = Intrinsic::riscv_vlsseg2_mask;
12045 NF = 2;
12046 DefaultPolicy = 3;
12047IsMasked = true;
12048
12049 {
12050 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
12051 IntrinsicTypes = {ResultType, Ops.back()->getType()};
12052 SmallVector<llvm::Value*, 12> Operands;
12053
12054 if (IsMasked) {
12055 // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
12056 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
12057 // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
12058 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
12059 for (unsigned I = 0; I < NF; ++I)
12060 Operands.push_back(llvm::PoisonValue::get(ResultType));
12061 Operands.push_back(Ops[NF + 1]);
12062 Operands.push_back(Ops[NF + 2]);
12063 Operands.push_back(Ops[NF]);
12064 Operands.push_back(Ops[NF + 3]);
12065 } else {
12066 for (unsigned I = 0; I < NF; ++I)
12067 Operands.push_back(Ops[NF + I + 1]);
12068 Operands.push_back(Ops[2 * NF + 1]);
12069 Operands.push_back(Ops[2 * NF + 2]);
12070 Operands.push_back(Ops[NF]);
12071 Operands.push_back(Ops[2 * NF + 3]);
12072 }
12073 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
12074 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 12074, __extension__ __PRETTY_FUNCTION__));
12075 } else {
12076 // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
12077 // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
12078 // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
12079 if (DefaultPolicy == TAIL_AGNOSTIC) {
12080 for (unsigned I = 0; I < NF; ++I)
12081 Operands.push_back(llvm::PoisonValue::get(ResultType));
12082 Operands.push_back(Ops[NF]);
12083 Operands.push_back(Ops[NF + 1]);
12084 Operands.push_back(Ops[NF + 2]);
12085 } else {
12086 for (unsigned I = 0; I < NF; ++I)
12087 Operands.push_back(Ops[NF + I]);
12088 Operands.push_back(Ops[2 * NF]);
12089 Operands.push_back(Ops[2 * NF + 1]);
12090 Operands.push_back(Ops[2 * NF + 2]);
12091 }
12092 }
12093 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
12094 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
12095 clang::CharUnits Align =
12096 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
12097 llvm::Value *V;
12098 for (unsigned I = 0; I < NF; ++I) {
12099 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
12100 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
12101 }
12102 return V;
12103 }
12104 break;
12105case RISCVVector::BI__builtin_rvv_vlsseg2e16_v_tumu:
12106case RISCVVector::BI__builtin_rvv_vlsseg2e8_v_tumu:
12107case RISCVVector::BI__builtin_rvv_vlsseg2e32_v_tumu:
12108case RISCVVector::BI__builtin_rvv_vlsseg2e64_v_tumu:
12109 ID = Intrinsic::riscv_vlsseg2_mask;
12110 NF = 2;
12111 DefaultPolicy = 0;
12112IsMasked = true;
12113
12114 {
12115 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
12116 IntrinsicTypes = {ResultType, Ops.back()->getType()};
12117 SmallVector<llvm::Value*, 12> Operands;
12118
12119 if (IsMasked) {
12120 // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
12121 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
12122 // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
12123 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
12124 for (unsigned I = 0; I < NF; ++I)
12125 Operands.push_back(llvm::PoisonValue::get(ResultType));
12126 Operands.push_back(Ops[NF + 1]);
12127 Operands.push_back(Ops[NF + 2]);
12128 Operands.push_back(Ops[NF]);
12129 Operands.push_back(Ops[NF + 3]);
12130 } else {
12131 for (unsigned I = 0; I < NF; ++I)
12132 Operands.push_back(Ops[NF + I + 1]);
12133 Operands.push_back(Ops[2 * NF + 1]);
12134 Operands.push_back(Ops[2 * NF + 2]);
12135 Operands.push_back(Ops[NF]);
12136 Operands.push_back(Ops[2 * NF + 3]);
12137 }
12138 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
12139 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 12139, __extension__ __PRETTY_FUNCTION__));
12140 } else {
12141 // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
12142 // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
12143 // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
12144 if (DefaultPolicy == TAIL_AGNOSTIC) {
12145 for (unsigned I = 0; I < NF; ++I)
12146 Operands.push_back(llvm::PoisonValue::get(ResultType));
12147 Operands.push_back(Ops[NF]);
12148 Operands.push_back(Ops[NF + 1]);
12149 Operands.push_back(Ops[NF + 2]);
12150 } else {
12151 for (unsigned I = 0; I < NF; ++I)
12152 Operands.push_back(Ops[NF + I]);
12153 Operands.push_back(Ops[2 * NF]);
12154 Operands.push_back(Ops[2 * NF + 1]);
12155 Operands.push_back(Ops[2 * NF + 2]);
12156 }
12157 }
12158 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
12159 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
12160 clang::CharUnits Align =
12161 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
12162 llvm::Value *V;
12163 for (unsigned I = 0; I < NF; ++I) {
12164 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
12165 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
12166 }
12167 return V;
12168 }
12169 break;
12170case RISCVVector::BI__builtin_rvv_vlsseg2e16_v_tamu:
12171case RISCVVector::BI__builtin_rvv_vlsseg2e8_v_tamu:
12172case RISCVVector::BI__builtin_rvv_vlsseg2e32_v_tamu:
12173case RISCVVector::BI__builtin_rvv_vlsseg2e64_v_tamu:
12174 ID = Intrinsic::riscv_vlsseg2_mask;
12175 NF = 2;
12176 DefaultPolicy = 1;
12177IsMasked = true;
12178
12179 {
12180 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
12181 IntrinsicTypes = {ResultType, Ops.back()->getType()};
12182 SmallVector<llvm::Value*, 12> Operands;
12183
12184 if (IsMasked) {
12185 // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
12186 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
12187 // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
12188 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
12189 for (unsigned I = 0; I < NF; ++I)
12190 Operands.push_back(llvm::PoisonValue::get(ResultType));
12191 Operands.push_back(Ops[NF + 1]);
12192 Operands.push_back(Ops[NF + 2]);
12193 Operands.push_back(Ops[NF]);
12194 Operands.push_back(Ops[NF + 3]);
12195 } else {
12196 for (unsigned I = 0; I < NF; ++I)
12197 Operands.push_back(Ops[NF + I + 1]);
12198 Operands.push_back(Ops[2 * NF + 1]);
12199 Operands.push_back(Ops[2 * NF + 2]);
12200 Operands.push_back(Ops[NF]);
12201 Operands.push_back(Ops[2 * NF + 3]);
12202 }
12203 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
12204 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 12204, __extension__ __PRETTY_FUNCTION__));
12205 } else {
12206 // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
12207 // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
12208 // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
12209 if (DefaultPolicy == TAIL_AGNOSTIC) {
12210 for (unsigned I = 0; I < NF; ++I)
12211 Operands.push_back(llvm::PoisonValue::get(ResultType));
12212 Operands.push_back(Ops[NF]);
12213 Operands.push_back(Ops[NF + 1]);
12214 Operands.push_back(Ops[NF + 2]);
12215 } else {
12216 for (unsigned I = 0; I < NF; ++I)
12217 Operands.push_back(Ops[NF + I]);
12218 Operands.push_back(Ops[2 * NF]);
12219 Operands.push_back(Ops[2 * NF + 1]);
12220 Operands.push_back(Ops[2 * NF + 2]);
12221 }
12222 }
12223 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
12224 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
12225 clang::CharUnits Align =
12226 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
12227 llvm::Value *V;
12228 for (unsigned I = 0; I < NF; ++I) {
12229 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
12230 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
12231 }
12232 return V;
12233 }
12234 break;
12235case RISCVVector::BI__builtin_rvv_vlsseg3e8_v_tu:
12236case RISCVVector::BI__builtin_rvv_vlsseg3e16_v_tu:
12237case RISCVVector::BI__builtin_rvv_vlsseg3e32_v_tu:
12238case RISCVVector::BI__builtin_rvv_vlsseg3e64_v_tu:
12239 ID = Intrinsic::riscv_vlsseg3;
12240 NF = 3;
12241 DefaultPolicy = 0;
12242IsMasked = false;
12243
12244 {
12245 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
12246 IntrinsicTypes = {ResultType, Ops.back()->getType()};
12247 SmallVector<llvm::Value*, 12> Operands;
12248
12249 if (IsMasked) {
12250 // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
12251 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
12252 // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
12253 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
12254 for (unsigned I = 0; I < NF; ++I)
12255 Operands.push_back(llvm::PoisonValue::get(ResultType));
12256 Operands.push_back(Ops[NF + 1]);
12257 Operands.push_back(Ops[NF + 2]);
12258 Operands.push_back(Ops[NF]);
12259 Operands.push_back(Ops[NF + 3]);
12260 } else {
12261 for (unsigned I = 0; I < NF; ++I)
12262 Operands.push_back(Ops[NF + I + 1]);
12263 Operands.push_back(Ops[2 * NF + 1]);
12264 Operands.push_back(Ops[2 * NF + 2]);
12265 Operands.push_back(Ops[NF]);
12266 Operands.push_back(Ops[2 * NF + 3]);
12267 }
12268 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
12269 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 12269, __extension__ __PRETTY_FUNCTION__));
12270 } else {
12271 // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
12272 // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
12273 // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
12274 if (DefaultPolicy == TAIL_AGNOSTIC) {
12275 for (unsigned I = 0; I < NF; ++I)
12276 Operands.push_back(llvm::PoisonValue::get(ResultType));
12277 Operands.push_back(Ops[NF]);
12278 Operands.push_back(Ops[NF + 1]);
12279 Operands.push_back(Ops[NF + 2]);
12280 } else {
12281 for (unsigned I = 0; I < NF; ++I)
12282 Operands.push_back(Ops[NF + I]);
12283 Operands.push_back(Ops[2 * NF]);
12284 Operands.push_back(Ops[2 * NF + 1]);
12285 Operands.push_back(Ops[2 * NF + 2]);
12286 }
12287 }
12288 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
12289 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
12290 clang::CharUnits Align =
12291 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
12292 llvm::Value *V;
12293 for (unsigned I = 0; I < NF; ++I) {
12294 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
12295 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
12296 }
12297 return V;
12298 }
12299 break;
12300case RISCVVector::BI__builtin_rvv_vlsseg3e8_v_ta:
12301case RISCVVector::BI__builtin_rvv_vlsseg3e16_v_ta:
12302case RISCVVector::BI__builtin_rvv_vlsseg3e32_v_ta:
12303case RISCVVector::BI__builtin_rvv_vlsseg3e64_v_ta:
12304 ID = Intrinsic::riscv_vlsseg3;
12305 NF = 3;
12306 DefaultPolicy = 1;
12307IsMasked = false;
12308
12309 {
12310 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
12311 IntrinsicTypes = {ResultType, Ops.back()->getType()};
12312 SmallVector<llvm::Value*, 12> Operands;
12313
12314 if (IsMasked) {
12315 // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
12316 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
12317 // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
12318 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
12319 for (unsigned I = 0; I < NF; ++I)
12320 Operands.push_back(llvm::PoisonValue::get(ResultType));
12321 Operands.push_back(Ops[NF + 1]);
12322 Operands.push_back(Ops[NF + 2]);
12323 Operands.push_back(Ops[NF]);
12324 Operands.push_back(Ops[NF + 3]);
12325 } else {
12326 for (unsigned I = 0; I < NF; ++I)
12327 Operands.push_back(Ops[NF + I + 1]);
12328 Operands.push_back(Ops[2 * NF + 1]);
12329 Operands.push_back(Ops[2 * NF + 2]);
12330 Operands.push_back(Ops[NF]);
12331 Operands.push_back(Ops[2 * NF + 3]);
12332 }
12333 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
12334 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 12334, __extension__ __PRETTY_FUNCTION__));
12335 } else {
12336 // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
12337 // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
12338 // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
12339 if (DefaultPolicy == TAIL_AGNOSTIC) {
12340 for (unsigned I = 0; I < NF; ++I)
12341 Operands.push_back(llvm::PoisonValue::get(ResultType));
12342 Operands.push_back(Ops[NF]);
12343 Operands.push_back(Ops[NF + 1]);
12344 Operands.push_back(Ops[NF + 2]);
12345 } else {
12346 for (unsigned I = 0; I < NF; ++I)
12347 Operands.push_back(Ops[NF + I]);
12348 Operands.push_back(Ops[2 * NF]);
12349 Operands.push_back(Ops[2 * NF + 1]);
12350 Operands.push_back(Ops[2 * NF + 2]);
12351 }
12352 }
12353 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
12354 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
12355 clang::CharUnits Align =
12356 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
12357 llvm::Value *V;
12358 for (unsigned I = 0; I < NF; ++I) {
12359 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
12360 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
12361 }
12362 return V;
12363 }
12364 break;
12365case RISCVVector::BI__builtin_rvv_vlsseg3e8_v_tuma:
12366case RISCVVector::BI__builtin_rvv_vlsseg3e16_v_tuma:
12367case RISCVVector::BI__builtin_rvv_vlsseg3e32_v_tuma:
12368case RISCVVector::BI__builtin_rvv_vlsseg3e64_v_tuma:
12369 ID = Intrinsic::riscv_vlsseg3_mask;
12370 NF = 3;
12371 DefaultPolicy = 2;
12372IsMasked = true;
12373
12374 {
12375 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
12376 IntrinsicTypes = {ResultType, Ops.back()->getType()};
12377 SmallVector<llvm::Value*, 12> Operands;
12378
12379 if (IsMasked) {
12380 // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
12381 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
12382 // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
12383 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
12384 for (unsigned I = 0; I < NF; ++I)
12385 Operands.push_back(llvm::PoisonValue::get(ResultType));
12386 Operands.push_back(Ops[NF + 1]);
12387 Operands.push_back(Ops[NF + 2]);
12388 Operands.push_back(Ops[NF]);
12389 Operands.push_back(Ops[NF + 3]);
12390 } else {
12391 for (unsigned I = 0; I < NF; ++I)
12392 Operands.push_back(Ops[NF + I + 1]);
12393 Operands.push_back(Ops[2 * NF + 1]);
12394 Operands.push_back(Ops[2 * NF + 2]);
12395 Operands.push_back(Ops[NF]);
12396 Operands.push_back(Ops[2 * NF + 3]);
12397 }
12398 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
12399 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 12399, __extension__ __PRETTY_FUNCTION__));
12400 } else {
12401 // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
12402 // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
12403 // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
12404 if (DefaultPolicy == TAIL_AGNOSTIC) {
12405 for (unsigned I = 0; I < NF; ++I)
12406 Operands.push_back(llvm::PoisonValue::get(ResultType));
12407 Operands.push_back(Ops[NF]);
12408 Operands.push_back(Ops[NF + 1]);
12409 Operands.push_back(Ops[NF + 2]);
12410 } else {
12411 for (unsigned I = 0; I < NF; ++I)
12412 Operands.push_back(Ops[NF + I]);
12413 Operands.push_back(Ops[2 * NF]);
12414 Operands.push_back(Ops[2 * NF + 1]);
12415 Operands.push_back(Ops[2 * NF + 2]);
12416 }
12417 }
12418 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
12419 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
12420 clang::CharUnits Align =
12421 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
12422 llvm::Value *V;
12423 for (unsigned I = 0; I < NF; ++I) {
12424 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
12425 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
12426 }
12427 return V;
12428 }
12429 break;
12430case RISCVVector::BI__builtin_rvv_vlsseg3e8_v_tama:
12431case RISCVVector::BI__builtin_rvv_vlsseg3e16_v_tama:
12432case RISCVVector::BI__builtin_rvv_vlsseg3e32_v_tama:
12433case RISCVVector::BI__builtin_rvv_vlsseg3e64_v_tama:
12434 ID = Intrinsic::riscv_vlsseg3_mask;
12435 NF = 3;
12436 DefaultPolicy = 3;
12437IsMasked = true;
12438
12439 {
12440 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
12441 IntrinsicTypes = {ResultType, Ops.back()->getType()};
12442 SmallVector<llvm::Value*, 12> Operands;
12443
12444 if (IsMasked) {
12445 // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
12446 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
12447 // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
12448 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
12449 for (unsigned I = 0; I < NF; ++I)
12450 Operands.push_back(llvm::PoisonValue::get(ResultType));
12451 Operands.push_back(Ops[NF + 1]);
12452 Operands.push_back(Ops[NF + 2]);
12453 Operands.push_back(Ops[NF]);
12454 Operands.push_back(Ops[NF + 3]);
12455 } else {
12456 for (unsigned I = 0; I < NF; ++I)
12457 Operands.push_back(Ops[NF + I + 1]);
12458 Operands.push_back(Ops[2 * NF + 1]);
12459 Operands.push_back(Ops[2 * NF + 2]);
12460 Operands.push_back(Ops[NF]);
12461 Operands.push_back(Ops[2 * NF + 3]);
12462 }
12463 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
12464 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 12464, __extension__ __PRETTY_FUNCTION__));
12465 } else {
12466 // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
12467 // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
12468 // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
12469 if (DefaultPolicy == TAIL_AGNOSTIC) {
12470 for (unsigned I = 0; I < NF; ++I)
12471 Operands.push_back(llvm::PoisonValue::get(ResultType));
12472 Operands.push_back(Ops[NF]);
12473 Operands.push_back(Ops[NF + 1]);
12474 Operands.push_back(Ops[NF + 2]);
12475 } else {
12476 for (unsigned I = 0; I < NF; ++I)
12477 Operands.push_back(Ops[NF + I]);
12478 Operands.push_back(Ops[2 * NF]);
12479 Operands.push_back(Ops[2 * NF + 1]);
12480 Operands.push_back(Ops[2 * NF + 2]);
12481 }
12482 }
12483 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
12484 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
12485 clang::CharUnits Align =
12486 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
12487 llvm::Value *V;
12488 for (unsigned I = 0; I < NF; ++I) {
12489 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
12490 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
12491 }
12492 return V;
12493 }
12494 break;
12495case RISCVVector::BI__builtin_rvv_vlsseg3e8_v_tumu:
12496case RISCVVector::BI__builtin_rvv_vlsseg3e16_v_tumu:
12497case RISCVVector::BI__builtin_rvv_vlsseg3e32_v_tumu:
12498case RISCVVector::BI__builtin_rvv_vlsseg3e64_v_tumu:
12499 ID = Intrinsic::riscv_vlsseg3_mask;
12500 NF = 3;
12501 DefaultPolicy = 0;
12502IsMasked = true;
12503
12504 {
12505 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
12506 IntrinsicTypes = {ResultType, Ops.back()->getType()};
12507 SmallVector<llvm::Value*, 12> Operands;
12508
12509 if (IsMasked) {
12510 // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
12511 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
12512 // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
12513 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
12514 for (unsigned I = 0; I < NF; ++I)
12515 Operands.push_back(llvm::PoisonValue::get(ResultType));
12516 Operands.push_back(Ops[NF + 1]);
12517 Operands.push_back(Ops[NF + 2]);
12518 Operands.push_back(Ops[NF]);
12519 Operands.push_back(Ops[NF + 3]);
12520 } else {
12521 for (unsigned I = 0; I < NF; ++I)
12522 Operands.push_back(Ops[NF + I + 1]);
12523 Operands.push_back(Ops[2 * NF + 1]);
12524 Operands.push_back(Ops[2 * NF + 2]);
12525 Operands.push_back(Ops[NF]);
12526 Operands.push_back(Ops[2 * NF + 3]);
12527 }
12528 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
12529 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 12529, __extension__ __PRETTY_FUNCTION__));
12530 } else {
12531 // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
12532 // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
12533 // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
12534 if (DefaultPolicy == TAIL_AGNOSTIC) {
12535 for (unsigned I = 0; I < NF; ++I)
12536 Operands.push_back(llvm::PoisonValue::get(ResultType));
12537 Operands.push_back(Ops[NF]);
12538 Operands.push_back(Ops[NF + 1]);
12539 Operands.push_back(Ops[NF + 2]);
12540 } else {
12541 for (unsigned I = 0; I < NF; ++I)
12542 Operands.push_back(Ops[NF + I]);
12543 Operands.push_back(Ops[2 * NF]);
12544 Operands.push_back(Ops[2 * NF + 1]);
12545 Operands.push_back(Ops[2 * NF + 2]);
12546 }
12547 }
12548 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
12549 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
12550 clang::CharUnits Align =
12551 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
12552 llvm::Value *V;
12553 for (unsigned I = 0; I < NF; ++I) {
12554 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
12555 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
12556 }
12557 return V;
12558 }
12559 break;
12560case RISCVVector::BI__builtin_rvv_vlsseg3e8_v_tamu:
12561case RISCVVector::BI__builtin_rvv_vlsseg3e16_v_tamu:
12562case RISCVVector::BI__builtin_rvv_vlsseg3e32_v_tamu:
12563case RISCVVector::BI__builtin_rvv_vlsseg3e64_v_tamu:
12564 ID = Intrinsic::riscv_vlsseg3_mask;
12565 NF = 3;
12566 DefaultPolicy = 1;
12567IsMasked = true;
12568
12569 {
12570 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
12571 IntrinsicTypes = {ResultType, Ops.back()->getType()};
12572 SmallVector<llvm::Value*, 12> Operands;
12573
12574 if (IsMasked) {
12575 // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
12576 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
12577 // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
12578 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
12579 for (unsigned I = 0; I < NF; ++I)
12580 Operands.push_back(llvm::PoisonValue::get(ResultType));
12581 Operands.push_back(Ops[NF + 1]);
12582 Operands.push_back(Ops[NF + 2]);
12583 Operands.push_back(Ops[NF]);
12584 Operands.push_back(Ops[NF + 3]);
12585 } else {
12586 for (unsigned I = 0; I < NF; ++I)
12587 Operands.push_back(Ops[NF + I + 1]);
12588 Operands.push_back(Ops[2 * NF + 1]);
12589 Operands.push_back(Ops[2 * NF + 2]);
12590 Operands.push_back(Ops[NF]);
12591 Operands.push_back(Ops[2 * NF + 3]);
12592 }
12593 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
12594 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 12594, __extension__ __PRETTY_FUNCTION__));
12595 } else {
12596 // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
12597 // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
12598 // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
12599 if (DefaultPolicy == TAIL_AGNOSTIC) {
12600 for (unsigned I = 0; I < NF; ++I)
12601 Operands.push_back(llvm::PoisonValue::get(ResultType));
12602 Operands.push_back(Ops[NF]);
12603 Operands.push_back(Ops[NF + 1]);
12604 Operands.push_back(Ops[NF + 2]);
12605 } else {
12606 for (unsigned I = 0; I < NF; ++I)
12607 Operands.push_back(Ops[NF + I]);
12608 Operands.push_back(Ops[2 * NF]);
12609 Operands.push_back(Ops[2 * NF + 1]);
12610 Operands.push_back(Ops[2 * NF + 2]);
12611 }
12612 }
12613 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
12614 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
12615 clang::CharUnits Align =
12616 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
12617 llvm::Value *V;
12618 for (unsigned I = 0; I < NF; ++I) {
12619 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
12620 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
12621 }
12622 return V;
12623 }
12624 break;
12625case RISCVVector::BI__builtin_rvv_vlsseg4e8_v_tu:
12626case RISCVVector::BI__builtin_rvv_vlsseg4e16_v_tu:
12627case RISCVVector::BI__builtin_rvv_vlsseg4e32_v_tu:
12628case RISCVVector::BI__builtin_rvv_vlsseg4e64_v_tu:
12629 ID = Intrinsic::riscv_vlsseg4;
12630 NF = 4;
12631 DefaultPolicy = 0;
12632IsMasked = false;
12633
12634 {
12635 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
12636 IntrinsicTypes = {ResultType, Ops.back()->getType()};
12637 SmallVector<llvm::Value*, 12> Operands;
12638
12639 if (IsMasked) {
12640 // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
12641 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
12642 // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
12643 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
12644 for (unsigned I = 0; I < NF; ++I)
12645 Operands.push_back(llvm::PoisonValue::get(ResultType));
12646 Operands.push_back(Ops[NF + 1]);
12647 Operands.push_back(Ops[NF + 2]);
12648 Operands.push_back(Ops[NF]);
12649 Operands.push_back(Ops[NF + 3]);
12650 } else {
12651 for (unsigned I = 0; I < NF; ++I)
12652 Operands.push_back(Ops[NF + I + 1]);
12653 Operands.push_back(Ops[2 * NF + 1]);
12654 Operands.push_back(Ops[2 * NF + 2]);
12655 Operands.push_back(Ops[NF]);
12656 Operands.push_back(Ops[2 * NF + 3]);
12657 }
12658 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
12659 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 12659, __extension__ __PRETTY_FUNCTION__));
12660 } else {
12661 // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
12662 // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
12663 // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
12664 if (DefaultPolicy == TAIL_AGNOSTIC) {
12665 for (unsigned I = 0; I < NF; ++I)
12666 Operands.push_back(llvm::PoisonValue::get(ResultType));
12667 Operands.push_back(Ops[NF]);
12668 Operands.push_back(Ops[NF + 1]);
12669 Operands.push_back(Ops[NF + 2]);
12670 } else {
12671 for (unsigned I = 0; I < NF; ++I)
12672 Operands.push_back(Ops[NF + I]);
12673 Operands.push_back(Ops[2 * NF]);
12674 Operands.push_back(Ops[2 * NF + 1]);
12675 Operands.push_back(Ops[2 * NF + 2]);
12676 }
12677 }
12678 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
12679 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
12680 clang::CharUnits Align =
12681 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
12682 llvm::Value *V;
12683 for (unsigned I = 0; I < NF; ++I) {
12684 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
12685 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
12686 }
12687 return V;
12688 }
12689 break;
12690case RISCVVector::BI__builtin_rvv_vlsseg4e8_v_ta:
12691case RISCVVector::BI__builtin_rvv_vlsseg4e16_v_ta:
12692case RISCVVector::BI__builtin_rvv_vlsseg4e32_v_ta:
12693case RISCVVector::BI__builtin_rvv_vlsseg4e64_v_ta:
12694 ID = Intrinsic::riscv_vlsseg4;
12695 NF = 4;
12696 DefaultPolicy = 1;
12697IsMasked = false;
12698
12699 {
12700 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
12701 IntrinsicTypes = {ResultType, Ops.back()->getType()};
12702 SmallVector<llvm::Value*, 12> Operands;
12703
12704 if (IsMasked) {
12705 // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
12706 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
12707 // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
12708 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
12709 for (unsigned I = 0; I < NF; ++I)
12710 Operands.push_back(llvm::PoisonValue::get(ResultType));
12711 Operands.push_back(Ops[NF + 1]);
12712 Operands.push_back(Ops[NF + 2]);
12713 Operands.push_back(Ops[NF]);
12714 Operands.push_back(Ops[NF + 3]);
12715 } else {
12716 for (unsigned I = 0; I < NF; ++I)
12717 Operands.push_back(Ops[NF + I + 1]);
12718 Operands.push_back(Ops[2 * NF + 1]);
12719 Operands.push_back(Ops[2 * NF + 2]);
12720 Operands.push_back(Ops[NF]);
12721 Operands.push_back(Ops[2 * NF + 3]);
12722 }
12723 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
12724 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 12724, __extension__ __PRETTY_FUNCTION__));
12725 } else {
12726 // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
12727 // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
12728 // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
12729 if (DefaultPolicy == TAIL_AGNOSTIC) {
12730 for (unsigned I = 0; I < NF; ++I)
12731 Operands.push_back(llvm::PoisonValue::get(ResultType));
12732 Operands.push_back(Ops[NF]);
12733 Operands.push_back(Ops[NF + 1]);
12734 Operands.push_back(Ops[NF + 2]);
12735 } else {
12736 for (unsigned I = 0; I < NF; ++I)
12737 Operands.push_back(Ops[NF + I]);
12738 Operands.push_back(Ops[2 * NF]);
12739 Operands.push_back(Ops[2 * NF + 1]);
12740 Operands.push_back(Ops[2 * NF + 2]);
12741 }
12742 }
12743 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
12744 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
12745 clang::CharUnits Align =
12746 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
12747 llvm::Value *V;
12748 for (unsigned I = 0; I < NF; ++I) {
12749 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
12750 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
12751 }
12752 return V;
12753 }
12754 break;
12755case RISCVVector::BI__builtin_rvv_vlsseg4e8_v_tuma:
12756case RISCVVector::BI__builtin_rvv_vlsseg4e16_v_tuma:
12757case RISCVVector::BI__builtin_rvv_vlsseg4e32_v_tuma:
12758case RISCVVector::BI__builtin_rvv_vlsseg4e64_v_tuma:
12759 ID = Intrinsic::riscv_vlsseg4_mask;
12760 NF = 4;
12761 DefaultPolicy = 2;
12762IsMasked = true;
12763
12764 {
12765 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
12766 IntrinsicTypes = {ResultType, Ops.back()->getType()};
12767 SmallVector<llvm::Value*, 12> Operands;
12768
12769 if (IsMasked) {
12770 // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
12771 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
12772 // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
12773 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
12774 for (unsigned I = 0; I < NF; ++I)
12775 Operands.push_back(llvm::PoisonValue::get(ResultType));
12776 Operands.push_back(Ops[NF + 1]);
12777 Operands.push_back(Ops[NF + 2]);
12778 Operands.push_back(Ops[NF]);
12779 Operands.push_back(Ops[NF + 3]);
12780 } else {
12781 for (unsigned I = 0; I < NF; ++I)
12782 Operands.push_back(Ops[NF + I + 1]);
12783 Operands.push_back(Ops[2 * NF + 1]);
12784 Operands.push_back(Ops[2 * NF + 2]);
12785 Operands.push_back(Ops[NF]);
12786 Operands.push_back(Ops[2 * NF + 3]);
12787 }
12788 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
12789 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 12789, __extension__ __PRETTY_FUNCTION__));
12790 } else {
12791 // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
12792 // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
12793 // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
12794 if (DefaultPolicy == TAIL_AGNOSTIC) {
12795 for (unsigned I = 0; I < NF; ++I)
12796 Operands.push_back(llvm::PoisonValue::get(ResultType));
12797 Operands.push_back(Ops[NF]);
12798 Operands.push_back(Ops[NF + 1]);
12799 Operands.push_back(Ops[NF + 2]);
12800 } else {
12801 for (unsigned I = 0; I < NF; ++I)
12802 Operands.push_back(Ops[NF + I]);
12803 Operands.push_back(Ops[2 * NF]);
12804 Operands.push_back(Ops[2 * NF + 1]);
12805 Operands.push_back(Ops[2 * NF + 2]);
12806 }
12807 }
12808 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
12809 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
12810 clang::CharUnits Align =
12811 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
12812 llvm::Value *V;
12813 for (unsigned I = 0; I < NF; ++I) {
12814 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
12815 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
12816 }
12817 return V;
12818 }
12819 break;
12820case RISCVVector::BI__builtin_rvv_vlsseg4e8_v_tama:
12821case RISCVVector::BI__builtin_rvv_vlsseg4e16_v_tama:
12822case RISCVVector::BI__builtin_rvv_vlsseg4e32_v_tama:
12823case RISCVVector::BI__builtin_rvv_vlsseg4e64_v_tama:
12824 ID = Intrinsic::riscv_vlsseg4_mask;
12825 NF = 4;
12826 DefaultPolicy = 3;
12827IsMasked = true;
12828
12829 {
12830 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
12831 IntrinsicTypes = {ResultType, Ops.back()->getType()};
12832 SmallVector<llvm::Value*, 12> Operands;
12833
12834 if (IsMasked) {
12835 // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
12836 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
12837 // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
12838 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
12839 for (unsigned I = 0; I < NF; ++I)
12840 Operands.push_back(llvm::PoisonValue::get(ResultType));
12841 Operands.push_back(Ops[NF + 1]);
12842 Operands.push_back(Ops[NF + 2]);
12843 Operands.push_back(Ops[NF]);
12844 Operands.push_back(Ops[NF + 3]);
12845 } else {
12846 for (unsigned I = 0; I < NF; ++I)
12847 Operands.push_back(Ops[NF + I + 1]);
12848 Operands.push_back(Ops[2 * NF + 1]);
12849 Operands.push_back(Ops[2 * NF + 2]);
12850 Operands.push_back(Ops[NF]);
12851 Operands.push_back(Ops[2 * NF + 3]);
12852 }
12853 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
12854 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 12854, __extension__ __PRETTY_FUNCTION__));
12855 } else {
12856 // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
12857 // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
12858 // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
12859 if (DefaultPolicy == TAIL_AGNOSTIC) {
12860 for (unsigned I = 0; I < NF; ++I)
12861 Operands.push_back(llvm::PoisonValue::get(ResultType));
12862 Operands.push_back(Ops[NF]);
12863 Operands.push_back(Ops[NF + 1]);
12864 Operands.push_back(Ops[NF + 2]);
12865 } else {
12866 for (unsigned I = 0; I < NF; ++I)
12867 Operands.push_back(Ops[NF + I]);
12868 Operands.push_back(Ops[2 * NF]);
12869 Operands.push_back(Ops[2 * NF + 1]);
12870 Operands.push_back(Ops[2 * NF + 2]);
12871 }
12872 }
12873 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
12874 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
12875 clang::CharUnits Align =
12876 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
12877 llvm::Value *V;
12878 for (unsigned I = 0; I < NF; ++I) {
12879 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
12880 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
12881 }
12882 return V;
12883 }
12884 break;
12885case RISCVVector::BI__builtin_rvv_vlsseg4e8_v_tumu:
12886case RISCVVector::BI__builtin_rvv_vlsseg4e16_v_tumu:
12887case RISCVVector::BI__builtin_rvv_vlsseg4e32_v_tumu:
12888case RISCVVector::BI__builtin_rvv_vlsseg4e64_v_tumu:
12889 ID = Intrinsic::riscv_vlsseg4_mask;
12890 NF = 4;
12891 DefaultPolicy = 0;
12892IsMasked = true;
12893
12894 {
12895 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
12896 IntrinsicTypes = {ResultType, Ops.back()->getType()};
12897 SmallVector<llvm::Value*, 12> Operands;
12898
12899 if (IsMasked) {
12900 // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
12901 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
12902 // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
12903 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
12904 for (unsigned I = 0; I < NF; ++I)
12905 Operands.push_back(llvm::PoisonValue::get(ResultType));
12906 Operands.push_back(Ops[NF + 1]);
12907 Operands.push_back(Ops[NF + 2]);
12908 Operands.push_back(Ops[NF]);
12909 Operands.push_back(Ops[NF + 3]);
12910 } else {
12911 for (unsigned I = 0; I < NF; ++I)
12912 Operands.push_back(Ops[NF + I + 1]);
12913 Operands.push_back(Ops[2 * NF + 1]);
12914 Operands.push_back(Ops[2 * NF + 2]);
12915 Operands.push_back(Ops[NF]);
12916 Operands.push_back(Ops[2 * NF + 3]);
12917 }
12918 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
12919 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 12919, __extension__ __PRETTY_FUNCTION__));
12920 } else {
12921 // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
12922 // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
12923 // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
12924 if (DefaultPolicy == TAIL_AGNOSTIC) {
12925 for (unsigned I = 0; I < NF; ++I)
12926 Operands.push_back(llvm::PoisonValue::get(ResultType));
12927 Operands.push_back(Ops[NF]);
12928 Operands.push_back(Ops[NF + 1]);
12929 Operands.push_back(Ops[NF + 2]);
12930 } else {
12931 for (unsigned I = 0; I < NF; ++I)
12932 Operands.push_back(Ops[NF + I]);
12933 Operands.push_back(Ops[2 * NF]);
12934 Operands.push_back(Ops[2 * NF + 1]);
12935 Operands.push_back(Ops[2 * NF + 2]);
12936 }
12937 }
12938 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
12939 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
12940 clang::CharUnits Align =
12941 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
12942 llvm::Value *V;
12943 for (unsigned I = 0; I < NF; ++I) {
12944 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
12945 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
12946 }
12947 return V;
12948 }
12949 break;
12950case RISCVVector::BI__builtin_rvv_vlsseg4e8_v_tamu:
12951case RISCVVector::BI__builtin_rvv_vlsseg4e16_v_tamu:
12952case RISCVVector::BI__builtin_rvv_vlsseg4e32_v_tamu:
12953case RISCVVector::BI__builtin_rvv_vlsseg4e64_v_tamu:
12954 ID = Intrinsic::riscv_vlsseg4_mask;
12955 NF = 4;
12956 DefaultPolicy = 1;
12957IsMasked = true;
12958
12959 {
12960 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
12961 IntrinsicTypes = {ResultType, Ops.back()->getType()};
12962 SmallVector<llvm::Value*, 12> Operands;
12963
12964 if (IsMasked) {
12965 // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
12966 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
12967 // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
12968 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
12969 for (unsigned I = 0; I < NF; ++I)
12970 Operands.push_back(llvm::PoisonValue::get(ResultType));
12971 Operands.push_back(Ops[NF + 1]);
12972 Operands.push_back(Ops[NF + 2]);
12973 Operands.push_back(Ops[NF]);
12974 Operands.push_back(Ops[NF + 3]);
12975 } else {
12976 for (unsigned I = 0; I < NF; ++I)
12977 Operands.push_back(Ops[NF + I + 1]);
12978 Operands.push_back(Ops[2 * NF + 1]);
12979 Operands.push_back(Ops[2 * NF + 2]);
12980 Operands.push_back(Ops[NF]);
12981 Operands.push_back(Ops[2 * NF + 3]);
12982 }
12983 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
12984 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 12984, __extension__ __PRETTY_FUNCTION__));
12985 } else {
12986 // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
12987 // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
12988 // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
12989 if (DefaultPolicy == TAIL_AGNOSTIC) {
12990 for (unsigned I = 0; I < NF; ++I)
12991 Operands.push_back(llvm::PoisonValue::get(ResultType));
12992 Operands.push_back(Ops[NF]);
12993 Operands.push_back(Ops[NF + 1]);
12994 Operands.push_back(Ops[NF + 2]);
12995 } else {
12996 for (unsigned I = 0; I < NF; ++I)
12997 Operands.push_back(Ops[NF + I]);
12998 Operands.push_back(Ops[2 * NF]);
12999 Operands.push_back(Ops[2 * NF + 1]);
13000 Operands.push_back(Ops[2 * NF + 2]);
13001 }
13002 }
13003 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
13004 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
13005 clang::CharUnits Align =
13006 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
13007 llvm::Value *V;
13008 for (unsigned I = 0; I < NF; ++I) {
13009 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
13010 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
13011 }
13012 return V;
13013 }
13014 break;
13015case RISCVVector::BI__builtin_rvv_vlsseg5e8_v_tu:
13016case RISCVVector::BI__builtin_rvv_vlsseg5e16_v_tu:
13017case RISCVVector::BI__builtin_rvv_vlsseg5e32_v_tu:
13018case RISCVVector::BI__builtin_rvv_vlsseg5e64_v_tu:
13019 ID = Intrinsic::riscv_vlsseg5;
13020 NF = 5;
13021 DefaultPolicy = 0;
13022IsMasked = false;
13023
13024 {
13025 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
13026 IntrinsicTypes = {ResultType, Ops.back()->getType()};
13027 SmallVector<llvm::Value*, 12> Operands;
13028
13029 if (IsMasked) {
13030 // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
13031 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
13032 // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
13033 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
13034 for (unsigned I = 0; I < NF; ++I)
13035 Operands.push_back(llvm::PoisonValue::get(ResultType));
13036 Operands.push_back(Ops[NF + 1]);
13037 Operands.push_back(Ops[NF + 2]);
13038 Operands.push_back(Ops[NF]);
13039 Operands.push_back(Ops[NF + 3]);
13040 } else {
13041 for (unsigned I = 0; I < NF; ++I)
13042 Operands.push_back(Ops[NF + I + 1]);
13043 Operands.push_back(Ops[2 * NF + 1]);
13044 Operands.push_back(Ops[2 * NF + 2]);
13045 Operands.push_back(Ops[NF]);
13046 Operands.push_back(Ops[2 * NF + 3]);
13047 }
13048 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
13049 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 13049, __extension__ __PRETTY_FUNCTION__));
13050 } else {
13051 // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
13052 // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
13053 // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
13054 if (DefaultPolicy == TAIL_AGNOSTIC) {
13055 for (unsigned I = 0; I < NF; ++I)
13056 Operands.push_back(llvm::PoisonValue::get(ResultType));
13057 Operands.push_back(Ops[NF]);
13058 Operands.push_back(Ops[NF + 1]);
13059 Operands.push_back(Ops[NF + 2]);
13060 } else {
13061 for (unsigned I = 0; I < NF; ++I)
13062 Operands.push_back(Ops[NF + I]);
13063 Operands.push_back(Ops[2 * NF]);
13064 Operands.push_back(Ops[2 * NF + 1]);
13065 Operands.push_back(Ops[2 * NF + 2]);
13066 }
13067 }
13068 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
13069 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
13070 clang::CharUnits Align =
13071 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
13072 llvm::Value *V;
13073 for (unsigned I = 0; I < NF; ++I) {
13074 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
13075 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
13076 }
13077 return V;
13078 }
13079 break;
13080case RISCVVector::BI__builtin_rvv_vlsseg5e8_v_ta:
13081case RISCVVector::BI__builtin_rvv_vlsseg5e16_v_ta:
13082case RISCVVector::BI__builtin_rvv_vlsseg5e32_v_ta:
13083case RISCVVector::BI__builtin_rvv_vlsseg5e64_v_ta:
13084 ID = Intrinsic::riscv_vlsseg5;
13085 NF = 5;
13086 DefaultPolicy = 1;
13087IsMasked = false;
13088
13089 {
13090 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
13091 IntrinsicTypes = {ResultType, Ops.back()->getType()};
13092 SmallVector<llvm::Value*, 12> Operands;
13093
13094 if (IsMasked) {
13095 // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
13096 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
13097 // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
13098 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
13099 for (unsigned I = 0; I < NF; ++I)
13100 Operands.push_back(llvm::PoisonValue::get(ResultType));
13101 Operands.push_back(Ops[NF + 1]);
13102 Operands.push_back(Ops[NF + 2]);
13103 Operands.push_back(Ops[NF]);
13104 Operands.push_back(Ops[NF + 3]);
13105 } else {
13106 for (unsigned I = 0; I < NF; ++I)
13107 Operands.push_back(Ops[NF + I + 1]);
13108 Operands.push_back(Ops[2 * NF + 1]);
13109 Operands.push_back(Ops[2 * NF + 2]);
13110 Operands.push_back(Ops[NF]);
13111 Operands.push_back(Ops[2 * NF + 3]);
13112 }
13113 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
13114 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 13114, __extension__ __PRETTY_FUNCTION__));
13115 } else {
13116 // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
13117 // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
13118 // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
13119 if (DefaultPolicy == TAIL_AGNOSTIC) {
13120 for (unsigned I = 0; I < NF; ++I)
13121 Operands.push_back(llvm::PoisonValue::get(ResultType));
13122 Operands.push_back(Ops[NF]);
13123 Operands.push_back(Ops[NF + 1]);
13124 Operands.push_back(Ops[NF + 2]);
13125 } else {
13126 for (unsigned I = 0; I < NF; ++I)
13127 Operands.push_back(Ops[NF + I]);
13128 Operands.push_back(Ops[2 * NF]);
13129 Operands.push_back(Ops[2 * NF + 1]);
13130 Operands.push_back(Ops[2 * NF + 2]);
13131 }
13132 }
13133 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
13134 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
13135 clang::CharUnits Align =
13136 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
13137 llvm::Value *V;
13138 for (unsigned I = 0; I < NF; ++I) {
13139 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
13140 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
13141 }
13142 return V;
13143 }
13144 break;
13145case RISCVVector::BI__builtin_rvv_vlsseg5e8_v_tuma:
13146case RISCVVector::BI__builtin_rvv_vlsseg5e16_v_tuma:
13147case RISCVVector::BI__builtin_rvv_vlsseg5e32_v_tuma:
13148case RISCVVector::BI__builtin_rvv_vlsseg5e64_v_tuma:
13149 ID = Intrinsic::riscv_vlsseg5_mask;
13150 NF = 5;
13151 DefaultPolicy = 2;
13152IsMasked = true;
13153
13154 {
13155 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
13156 IntrinsicTypes = {ResultType, Ops.back()->getType()};
13157 SmallVector<llvm::Value*, 12> Operands;
13158
13159 if (IsMasked) {
13160 // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
13161 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
13162 // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
13163 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
13164 for (unsigned I = 0; I < NF; ++I)
13165 Operands.push_back(llvm::PoisonValue::get(ResultType));
13166 Operands.push_back(Ops[NF + 1]);
13167 Operands.push_back(Ops[NF + 2]);
13168 Operands.push_back(Ops[NF]);
13169 Operands.push_back(Ops[NF + 3]);
13170 } else {
13171 for (unsigned I = 0; I < NF; ++I)
13172 Operands.push_back(Ops[NF + I + 1]);
13173 Operands.push_back(Ops[2 * NF + 1]);
13174 Operands.push_back(Ops[2 * NF + 2]);
13175 Operands.push_back(Ops[NF]);
13176 Operands.push_back(Ops[2 * NF + 3]);
13177 }
13178 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
13179 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 13179, __extension__ __PRETTY_FUNCTION__));
13180 } else {
13181 // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
13182 // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
13183 // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
13184 if (DefaultPolicy == TAIL_AGNOSTIC) {
13185 for (unsigned I = 0; I < NF; ++I)
13186 Operands.push_back(llvm::PoisonValue::get(ResultType));
13187 Operands.push_back(Ops[NF]);
13188 Operands.push_back(Ops[NF + 1]);
13189 Operands.push_back(Ops[NF + 2]);
13190 } else {
13191 for (unsigned I = 0; I < NF; ++I)
13192 Operands.push_back(Ops[NF + I]);
13193 Operands.push_back(Ops[2 * NF]);
13194 Operands.push_back(Ops[2 * NF + 1]);
13195 Operands.push_back(Ops[2 * NF + 2]);
13196 }
13197 }
13198 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
13199 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
13200 clang::CharUnits Align =
13201 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
13202 llvm::Value *V;
13203 for (unsigned I = 0; I < NF; ++I) {
13204 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
13205 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
13206 }
13207 return V;
13208 }
13209 break;
13210case RISCVVector::BI__builtin_rvv_vlsseg5e8_v_tama:
13211case RISCVVector::BI__builtin_rvv_vlsseg5e16_v_tama:
13212case RISCVVector::BI__builtin_rvv_vlsseg5e32_v_tama:
13213case RISCVVector::BI__builtin_rvv_vlsseg5e64_v_tama:
13214 ID = Intrinsic::riscv_vlsseg5_mask;
13215 NF = 5;
13216 DefaultPolicy = 3;
13217IsMasked = true;
13218
13219 {
13220 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
13221 IntrinsicTypes = {ResultType, Ops.back()->getType()};
13222 SmallVector<llvm::Value*, 12> Operands;
13223
13224 if (IsMasked) {
13225 // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
13226 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
13227 // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
13228 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
13229 for (unsigned I = 0; I < NF; ++I)
13230 Operands.push_back(llvm::PoisonValue::get(ResultType));
13231 Operands.push_back(Ops[NF + 1]);
13232 Operands.push_back(Ops[NF + 2]);
13233 Operands.push_back(Ops[NF]);
13234 Operands.push_back(Ops[NF + 3]);
13235 } else {
13236 for (unsigned I = 0; I < NF; ++I)
13237 Operands.push_back(Ops[NF + I + 1]);
13238 Operands.push_back(Ops[2 * NF + 1]);
13239 Operands.push_back(Ops[2 * NF + 2]);
13240 Operands.push_back(Ops[NF]);
13241 Operands.push_back(Ops[2 * NF + 3]);
13242 }
13243 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
13244 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 13244, __extension__ __PRETTY_FUNCTION__));
13245 } else {
13246 // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
13247 // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
13248 // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
13249 if (DefaultPolicy == TAIL_AGNOSTIC) {
13250 for (unsigned I = 0; I < NF; ++I)
13251 Operands.push_back(llvm::PoisonValue::get(ResultType));
13252 Operands.push_back(Ops[NF]);
13253 Operands.push_back(Ops[NF + 1]);
13254 Operands.push_back(Ops[NF + 2]);
13255 } else {
13256 for (unsigned I = 0; I < NF; ++I)
13257 Operands.push_back(Ops[NF + I]);
13258 Operands.push_back(Ops[2 * NF]);
13259 Operands.push_back(Ops[2 * NF + 1]);
13260 Operands.push_back(Ops[2 * NF + 2]);
13261 }
13262 }
13263 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
13264 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
13265 clang::CharUnits Align =
13266 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
13267 llvm::Value *V;
13268 for (unsigned I = 0; I < NF; ++I) {
13269 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
13270 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
13271 }
13272 return V;
13273 }
13274 break;
13275case RISCVVector::BI__builtin_rvv_vlsseg5e8_v_tumu:
13276case RISCVVector::BI__builtin_rvv_vlsseg5e16_v_tumu:
13277case RISCVVector::BI__builtin_rvv_vlsseg5e32_v_tumu:
13278case RISCVVector::BI__builtin_rvv_vlsseg5e64_v_tumu:
13279 ID = Intrinsic::riscv_vlsseg5_mask;
13280 NF = 5;
13281 DefaultPolicy = 0;
13282IsMasked = true;
13283
13284 {
13285 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
13286 IntrinsicTypes = {ResultType, Ops.back()->getType()};
13287 SmallVector<llvm::Value*, 12> Operands;
13288
13289 if (IsMasked) {
13290 // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
13291 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
13292 // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
13293 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
13294 for (unsigned I = 0; I < NF; ++I)
13295 Operands.push_back(llvm::PoisonValue::get(ResultType));
13296 Operands.push_back(Ops[NF + 1]);
13297 Operands.push_back(Ops[NF + 2]);
13298 Operands.push_back(Ops[NF]);
13299 Operands.push_back(Ops[NF + 3]);
13300 } else {
13301 for (unsigned I = 0; I < NF; ++I)
13302 Operands.push_back(Ops[NF + I + 1]);
13303 Operands.push_back(Ops[2 * NF + 1]);
13304 Operands.push_back(Ops[2 * NF + 2]);
13305 Operands.push_back(Ops[NF]);
13306 Operands.push_back(Ops[2 * NF + 3]);
13307 }
13308 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
13309 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 13309, __extension__ __PRETTY_FUNCTION__));
13310 } else {
13311 // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
13312 // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
13313 // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
13314 if (DefaultPolicy == TAIL_AGNOSTIC) {
13315 for (unsigned I = 0; I < NF; ++I)
13316 Operands.push_back(llvm::PoisonValue::get(ResultType));
13317 Operands.push_back(Ops[NF]);
13318 Operands.push_back(Ops[NF + 1]);
13319 Operands.push_back(Ops[NF + 2]);
13320 } else {
13321 for (unsigned I = 0; I < NF; ++I)
13322 Operands.push_back(Ops[NF + I]);
13323 Operands.push_back(Ops[2 * NF]);
13324 Operands.push_back(Ops[2 * NF + 1]);
13325 Operands.push_back(Ops[2 * NF + 2]);
13326 }
13327 }
13328 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
13329 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
13330 clang::CharUnits Align =
13331 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
13332 llvm::Value *V;
13333 for (unsigned I = 0; I < NF; ++I) {
13334 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
13335 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
13336 }
13337 return V;
13338 }
13339 break;
13340case RISCVVector::BI__builtin_rvv_vlsseg5e8_v_tamu:
13341case RISCVVector::BI__builtin_rvv_vlsseg5e16_v_tamu:
13342case RISCVVector::BI__builtin_rvv_vlsseg5e32_v_tamu:
13343case RISCVVector::BI__builtin_rvv_vlsseg5e64_v_tamu:
13344 ID = Intrinsic::riscv_vlsseg5_mask;
13345 NF = 5;
13346 DefaultPolicy = 1;
13347IsMasked = true;
13348
13349 {
13350 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
13351 IntrinsicTypes = {ResultType, Ops.back()->getType()};
13352 SmallVector<llvm::Value*, 12> Operands;
13353
13354 if (IsMasked) {
13355 // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
13356 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
13357 // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
13358 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
13359 for (unsigned I = 0; I < NF; ++I)
13360 Operands.push_back(llvm::PoisonValue::get(ResultType));
13361 Operands.push_back(Ops[NF + 1]);
13362 Operands.push_back(Ops[NF + 2]);
13363 Operands.push_back(Ops[NF]);
13364 Operands.push_back(Ops[NF + 3]);
13365 } else {
13366 for (unsigned I = 0; I < NF; ++I)
13367 Operands.push_back(Ops[NF + I + 1]);
13368 Operands.push_back(Ops[2 * NF + 1]);
13369 Operands.push_back(Ops[2 * NF + 2]);
13370 Operands.push_back(Ops[NF]);
13371 Operands.push_back(Ops[2 * NF + 3]);
13372 }
13373 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
13374 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 13374, __extension__ __PRETTY_FUNCTION__));
13375 } else {
13376 // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
13377 // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
13378 // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
13379 if (DefaultPolicy == TAIL_AGNOSTIC) {
13380 for (unsigned I = 0; I < NF; ++I)
13381 Operands.push_back(llvm::PoisonValue::get(ResultType));
13382 Operands.push_back(Ops[NF]);
13383 Operands.push_back(Ops[NF + 1]);
13384 Operands.push_back(Ops[NF + 2]);
13385 } else {
13386 for (unsigned I = 0; I < NF; ++I)
13387 Operands.push_back(Ops[NF + I]);
13388 Operands.push_back(Ops[2 * NF]);
13389 Operands.push_back(Ops[2 * NF + 1]);
13390 Operands.push_back(Ops[2 * NF + 2]);
13391 }
13392 }
13393 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
13394 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
13395 clang::CharUnits Align =
13396 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
13397 llvm::Value *V;
13398 for (unsigned I = 0; I < NF; ++I) {
13399 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
13400 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
13401 }
13402 return V;
13403 }
13404 break;
13405case RISCVVector::BI__builtin_rvv_vlsseg6e8_v_tu:
13406case RISCVVector::BI__builtin_rvv_vlsseg6e16_v_tu:
13407case RISCVVector::BI__builtin_rvv_vlsseg6e32_v_tu:
13408case RISCVVector::BI__builtin_rvv_vlsseg6e64_v_tu:
13409 ID = Intrinsic::riscv_vlsseg6;
13410 NF = 6;
13411 DefaultPolicy = 0;
13412IsMasked = false;
13413
13414 {
13415 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
13416 IntrinsicTypes = {ResultType, Ops.back()->getType()};
13417 SmallVector<llvm::Value*, 12> Operands;
13418
13419 if (IsMasked) {
13420 // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
13421 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
13422 // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
13423 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
13424 for (unsigned I = 0; I < NF; ++I)
13425 Operands.push_back(llvm::PoisonValue::get(ResultType));
13426 Operands.push_back(Ops[NF + 1]);
13427 Operands.push_back(Ops[NF + 2]);
13428 Operands.push_back(Ops[NF]);
13429 Operands.push_back(Ops[NF + 3]);
13430 } else {
13431 for (unsigned I = 0; I < NF; ++I)
13432 Operands.push_back(Ops[NF + I + 1]);
13433 Operands.push_back(Ops[2 * NF + 1]);
13434 Operands.push_back(Ops[2 * NF + 2]);
13435 Operands.push_back(Ops[NF]);
13436 Operands.push_back(Ops[2 * NF + 3]);
13437 }
13438 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
13439 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 13439, __extension__ __PRETTY_FUNCTION__));
13440 } else {
13441 // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
13442 // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
13443 // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
13444 if (DefaultPolicy == TAIL_AGNOSTIC) {
13445 for (unsigned I = 0; I < NF; ++I)
13446 Operands.push_back(llvm::PoisonValue::get(ResultType));
13447 Operands.push_back(Ops[NF]);
13448 Operands.push_back(Ops[NF + 1]);
13449 Operands.push_back(Ops[NF + 2]);
13450 } else {
13451 for (unsigned I = 0; I < NF; ++I)
13452 Operands.push_back(Ops[NF + I]);
13453 Operands.push_back(Ops[2 * NF]);
13454 Operands.push_back(Ops[2 * NF + 1]);
13455 Operands.push_back(Ops[2 * NF + 2]);
13456 }
13457 }
13458 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
13459 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
13460 clang::CharUnits Align =
13461 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
13462 llvm::Value *V;
13463 for (unsigned I = 0; I < NF; ++I) {
13464 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
13465 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
13466 }
13467 return V;
13468 }
13469 break;
13470case RISCVVector::BI__builtin_rvv_vlsseg6e8_v_ta:
13471case RISCVVector::BI__builtin_rvv_vlsseg6e16_v_ta:
13472case RISCVVector::BI__builtin_rvv_vlsseg6e32_v_ta:
13473case RISCVVector::BI__builtin_rvv_vlsseg6e64_v_ta:
13474 ID = Intrinsic::riscv_vlsseg6;
13475 NF = 6;
13476 DefaultPolicy = 1;
13477IsMasked = false;
13478
13479 {
13480 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
13481 IntrinsicTypes = {ResultType, Ops.back()->getType()};
13482 SmallVector<llvm::Value*, 12> Operands;
13483
13484 if (IsMasked) {
13485 // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
13486 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
13487 // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
13488 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
13489 for (unsigned I = 0; I < NF; ++I)
13490 Operands.push_back(llvm::PoisonValue::get(ResultType));
13491 Operands.push_back(Ops[NF + 1]);
13492 Operands.push_back(Ops[NF + 2]);
13493 Operands.push_back(Ops[NF]);
13494 Operands.push_back(Ops[NF + 3]);
13495 } else {
13496 for (unsigned I = 0; I < NF; ++I)
13497 Operands.push_back(Ops[NF + I + 1]);
13498 Operands.push_back(Ops[2 * NF + 1]);
13499 Operands.push_back(Ops[2 * NF + 2]);
13500 Operands.push_back(Ops[NF]);
13501 Operands.push_back(Ops[2 * NF + 3]);
13502 }
13503 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
13504 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 13504, __extension__ __PRETTY_FUNCTION__));
13505 } else {
13506 // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
13507 // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
13508 // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
13509 if (DefaultPolicy == TAIL_AGNOSTIC) {
13510 for (unsigned I = 0; I < NF; ++I)
13511 Operands.push_back(llvm::PoisonValue::get(ResultType));
13512 Operands.push_back(Ops[NF]);
13513 Operands.push_back(Ops[NF + 1]);
13514 Operands.push_back(Ops[NF + 2]);
13515 } else {
13516 for (unsigned I = 0; I < NF; ++I)
13517 Operands.push_back(Ops[NF + I]);
13518 Operands.push_back(Ops[2 * NF]);
13519 Operands.push_back(Ops[2 * NF + 1]);
13520 Operands.push_back(Ops[2 * NF + 2]);
13521 }
13522 }
13523 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
13524 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
13525 clang::CharUnits Align =
13526 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
13527 llvm::Value *V;
13528 for (unsigned I = 0; I < NF; ++I) {
13529 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
13530 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
13531 }
13532 return V;
13533 }
13534 break;
13535case RISCVVector::BI__builtin_rvv_vlsseg6e8_v_tuma:
13536case RISCVVector::BI__builtin_rvv_vlsseg6e16_v_tuma:
13537case RISCVVector::BI__builtin_rvv_vlsseg6e32_v_tuma:
13538case RISCVVector::BI__builtin_rvv_vlsseg6e64_v_tuma:
13539 ID = Intrinsic::riscv_vlsseg6_mask;
13540 NF = 6;
13541 DefaultPolicy = 2;
13542IsMasked = true;
13543
13544 {
13545 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
13546 IntrinsicTypes = {ResultType, Ops.back()->getType()};
13547 SmallVector<llvm::Value*, 12> Operands;
13548
13549 if (IsMasked) {
13550 // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
13551 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
13552 // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
13553 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
13554 for (unsigned I = 0; I < NF; ++I)
13555 Operands.push_back(llvm::PoisonValue::get(ResultType));
13556 Operands.push_back(Ops[NF + 1]);
13557 Operands.push_back(Ops[NF + 2]);
13558 Operands.push_back(Ops[NF]);
13559 Operands.push_back(Ops[NF + 3]);
13560 } else {
13561 for (unsigned I = 0; I < NF; ++I)
13562 Operands.push_back(Ops[NF + I + 1]);
13563 Operands.push_back(Ops[2 * NF + 1]);
13564 Operands.push_back(Ops[2 * NF + 2]);
13565 Operands.push_back(Ops[NF]);
13566 Operands.push_back(Ops[2 * NF + 3]);
13567 }
13568 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
13569 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 13569, __extension__ __PRETTY_FUNCTION__));
13570 } else {
13571 // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
13572 // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
13573 // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
13574 if (DefaultPolicy == TAIL_AGNOSTIC) {
13575 for (unsigned I = 0; I < NF; ++I)
13576 Operands.push_back(llvm::PoisonValue::get(ResultType));
13577 Operands.push_back(Ops[NF]);
13578 Operands.push_back(Ops[NF + 1]);
13579 Operands.push_back(Ops[NF + 2]);
13580 } else {
13581 for (unsigned I = 0; I < NF; ++I)
13582 Operands.push_back(Ops[NF + I]);
13583 Operands.push_back(Ops[2 * NF]);
13584 Operands.push_back(Ops[2 * NF + 1]);
13585 Operands.push_back(Ops[2 * NF + 2]);
13586 }
13587 }
13588 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
13589 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
13590 clang::CharUnits Align =
13591 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
13592 llvm::Value *V;
13593 for (unsigned I = 0; I < NF; ++I) {
13594 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
13595 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
13596 }
13597 return V;
13598 }
13599 break;
13600case RISCVVector::BI__builtin_rvv_vlsseg6e8_v_tama:
13601case RISCVVector::BI__builtin_rvv_vlsseg6e16_v_tama:
13602case RISCVVector::BI__builtin_rvv_vlsseg6e32_v_tama:
13603case RISCVVector::BI__builtin_rvv_vlsseg6e64_v_tama:
13604 ID = Intrinsic::riscv_vlsseg6_mask;
13605 NF = 6;
13606 DefaultPolicy = 3;
13607IsMasked = true;
13608
13609 {
13610 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
13611 IntrinsicTypes = {ResultType, Ops.back()->getType()};
13612 SmallVector<llvm::Value*, 12> Operands;
13613
13614 if (IsMasked) {
13615 // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
13616 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
13617 // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
13618 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
13619 for (unsigned I = 0; I < NF; ++I)
13620 Operands.push_back(llvm::PoisonValue::get(ResultType));
13621 Operands.push_back(Ops[NF + 1]);
13622 Operands.push_back(Ops[NF + 2]);
13623 Operands.push_back(Ops[NF]);
13624 Operands.push_back(Ops[NF + 3]);
13625 } else {
13626 for (unsigned I = 0; I < NF; ++I)
13627 Operands.push_back(Ops[NF + I + 1]);
13628 Operands.push_back(Ops[2 * NF + 1]);
13629 Operands.push_back(Ops[2 * NF + 2]);
13630 Operands.push_back(Ops[NF]);
13631 Operands.push_back(Ops[2 * NF + 3]);
13632 }
13633 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
13634 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 13634, __extension__ __PRETTY_FUNCTION__));
13635 } else {
13636 // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
13637 // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
13638 // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
13639 if (DefaultPolicy == TAIL_AGNOSTIC) {
13640 for (unsigned I = 0; I < NF; ++I)
13641 Operands.push_back(llvm::PoisonValue::get(ResultType));
13642 Operands.push_back(Ops[NF]);
13643 Operands.push_back(Ops[NF + 1]);
13644 Operands.push_back(Ops[NF + 2]);
13645 } else {
13646 for (unsigned I = 0; I < NF; ++I)
13647 Operands.push_back(Ops[NF + I]);
13648 Operands.push_back(Ops[2 * NF]);
13649 Operands.push_back(Ops[2 * NF + 1]);
13650 Operands.push_back(Ops[2 * NF + 2]);
13651 }
13652 }
13653 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
13654 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
13655 clang::CharUnits Align =
13656 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
13657 llvm::Value *V;
13658 for (unsigned I = 0; I < NF; ++I) {
13659 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
13660 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
13661 }
13662 return V;
13663 }
13664 break;
13665case RISCVVector::BI__builtin_rvv_vlsseg6e8_v_tumu:
13666case RISCVVector::BI__builtin_rvv_vlsseg6e16_v_tumu:
13667case RISCVVector::BI__builtin_rvv_vlsseg6e32_v_tumu:
13668case RISCVVector::BI__builtin_rvv_vlsseg6e64_v_tumu:
13669 ID = Intrinsic::riscv_vlsseg6_mask;
13670 NF = 6;
13671 DefaultPolicy = 0;
13672IsMasked = true;
13673
13674 {
13675 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
13676 IntrinsicTypes = {ResultType, Ops.back()->getType()};
13677 SmallVector<llvm::Value*, 12> Operands;
13678
13679 if (IsMasked) {
13680 // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
13681 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
13682 // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
13683 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
13684 for (unsigned I = 0; I < NF; ++I)
13685 Operands.push_back(llvm::PoisonValue::get(ResultType));
13686 Operands.push_back(Ops[NF + 1]);
13687 Operands.push_back(Ops[NF + 2]);
13688 Operands.push_back(Ops[NF]);
13689 Operands.push_back(Ops[NF + 3]);
13690 } else {
13691 for (unsigned I = 0; I < NF; ++I)
13692 Operands.push_back(Ops[NF + I + 1]);
13693 Operands.push_back(Ops[2 * NF + 1]);
13694 Operands.push_back(Ops[2 * NF + 2]);
13695 Operands.push_back(Ops[NF]);
13696 Operands.push_back(Ops[2 * NF + 3]);
13697 }
13698 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
13699 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 13699, __extension__ __PRETTY_FUNCTION__));
13700 } else {
13701 // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
13702 // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
13703 // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
13704 if (DefaultPolicy == TAIL_AGNOSTIC) {
13705 for (unsigned I = 0; I < NF; ++I)
13706 Operands.push_back(llvm::PoisonValue::get(ResultType));
13707 Operands.push_back(Ops[NF]);
13708 Operands.push_back(Ops[NF + 1]);
13709 Operands.push_back(Ops[NF + 2]);
13710 } else {
13711 for (unsigned I = 0; I < NF; ++I)
13712 Operands.push_back(Ops[NF + I]);
13713 Operands.push_back(Ops[2 * NF]);
13714 Operands.push_back(Ops[2 * NF + 1]);
13715 Operands.push_back(Ops[2 * NF + 2]);
13716 }
13717 }
13718 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
13719 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
13720 clang::CharUnits Align =
13721 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
13722 llvm::Value *V;
13723 for (unsigned I = 0; I < NF; ++I) {
13724 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
13725 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
13726 }
13727 return V;
13728 }
13729 break;
13730case RISCVVector::BI__builtin_rvv_vlsseg6e8_v_tamu:
13731case RISCVVector::BI__builtin_rvv_vlsseg6e16_v_tamu:
13732case RISCVVector::BI__builtin_rvv_vlsseg6e32_v_tamu:
13733case RISCVVector::BI__builtin_rvv_vlsseg6e64_v_tamu:
13734 ID = Intrinsic::riscv_vlsseg6_mask;
13735 NF = 6;
13736 DefaultPolicy = 1;
13737IsMasked = true;
13738
13739 {
13740 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
13741 IntrinsicTypes = {ResultType, Ops.back()->getType()};
13742 SmallVector<llvm::Value*, 12> Operands;
13743
13744 if (IsMasked) {
13745 // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
13746 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
13747 // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
13748 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
13749 for (unsigned I = 0; I < NF; ++I)
13750 Operands.push_back(llvm::PoisonValue::get(ResultType));
13751 Operands.push_back(Ops[NF + 1]);
13752 Operands.push_back(Ops[NF + 2]);
13753 Operands.push_back(Ops[NF]);
13754 Operands.push_back(Ops[NF + 3]);
13755 } else {
13756 for (unsigned I = 0; I < NF; ++I)
13757 Operands.push_back(Ops[NF + I + 1]);
13758 Operands.push_back(Ops[2 * NF + 1]);
13759 Operands.push_back(Ops[2 * NF + 2]);
13760 Operands.push_back(Ops[NF]);
13761 Operands.push_back(Ops[2 * NF + 3]);
13762 }
13763 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
13764 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 13764, __extension__ __PRETTY_FUNCTION__));
13765 } else {
13766 // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
13767 // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
13768 // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
13769 if (DefaultPolicy == TAIL_AGNOSTIC) {
13770 for (unsigned I = 0; I < NF; ++I)
13771 Operands.push_back(llvm::PoisonValue::get(ResultType));
13772 Operands.push_back(Ops[NF]);
13773 Operands.push_back(Ops[NF + 1]);
13774 Operands.push_back(Ops[NF + 2]);
13775 } else {
13776 for (unsigned I = 0; I < NF; ++I)
13777 Operands.push_back(Ops[NF + I]);
13778 Operands.push_back(Ops[2 * NF]);
13779 Operands.push_back(Ops[2 * NF + 1]);
13780 Operands.push_back(Ops[2 * NF + 2]);
13781 }
13782 }
13783 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
13784 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
13785 clang::CharUnits Align =
13786 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
13787 llvm::Value *V;
13788 for (unsigned I = 0; I < NF; ++I) {
13789 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
13790 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
13791 }
13792 return V;
13793 }
13794 break;
13795case RISCVVector::BI__builtin_rvv_vlsseg7e8_v_tu:
13796case RISCVVector::BI__builtin_rvv_vlsseg7e16_v_tu:
13797case RISCVVector::BI__builtin_rvv_vlsseg7e32_v_tu:
13798case RISCVVector::BI__builtin_rvv_vlsseg7e64_v_tu:
13799 ID = Intrinsic::riscv_vlsseg7;
13800 NF = 7;
13801 DefaultPolicy = 0;
13802IsMasked = false;
13803
13804 {
13805 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
13806 IntrinsicTypes = {ResultType, Ops.back()->getType()};
13807 SmallVector<llvm::Value*, 12> Operands;
13808
13809 if (IsMasked) {
13810 // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
13811 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
13812 // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
13813 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
13814 for (unsigned I = 0; I < NF; ++I)
13815 Operands.push_back(llvm::PoisonValue::get(ResultType));
13816 Operands.push_back(Ops[NF + 1]);
13817 Operands.push_back(Ops[NF + 2]);
13818 Operands.push_back(Ops[NF]);
13819 Operands.push_back(Ops[NF + 3]);
13820 } else {
13821 for (unsigned I = 0; I < NF; ++I)
13822 Operands.push_back(Ops[NF + I + 1]);
13823 Operands.push_back(Ops[2 * NF + 1]);
13824 Operands.push_back(Ops[2 * NF + 2]);
13825 Operands.push_back(Ops[NF]);
13826 Operands.push_back(Ops[2 * NF + 3]);
13827 }
13828 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
13829 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 13829, __extension__ __PRETTY_FUNCTION__));
13830 } else {
13831 // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
13832 // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
13833 // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
13834 if (DefaultPolicy == TAIL_AGNOSTIC) {
13835 for (unsigned I = 0; I < NF; ++I)
13836 Operands.push_back(llvm::PoisonValue::get(ResultType));
13837 Operands.push_back(Ops[NF]);
13838 Operands.push_back(Ops[NF + 1]);
13839 Operands.push_back(Ops[NF + 2]);
13840 } else {
13841 for (unsigned I = 0; I < NF; ++I)
13842 Operands.push_back(Ops[NF + I]);
13843 Operands.push_back(Ops[2 * NF]);
13844 Operands.push_back(Ops[2 * NF + 1]);
13845 Operands.push_back(Ops[2 * NF + 2]);
13846 }
13847 }
13848 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
13849 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
13850 clang::CharUnits Align =
13851 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
13852 llvm::Value *V;
13853 for (unsigned I = 0; I < NF; ++I) {
13854 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
13855 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
13856 }
13857 return V;
13858 }
13859 break;
13860case RISCVVector::BI__builtin_rvv_vlsseg7e8_v_ta:
13861case RISCVVector::BI__builtin_rvv_vlsseg7e16_v_ta:
13862case RISCVVector::BI__builtin_rvv_vlsseg7e32_v_ta:
13863case RISCVVector::BI__builtin_rvv_vlsseg7e64_v_ta:
13864 ID = Intrinsic::riscv_vlsseg7;
13865 NF = 7;
13866 DefaultPolicy = 1;
13867IsMasked = false;
13868
13869 {
13870 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
13871 IntrinsicTypes = {ResultType, Ops.back()->getType()};
13872 SmallVector<llvm::Value*, 12> Operands;
13873
13874 if (IsMasked) {
13875 // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
13876 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
13877 // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
13878 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
13879 for (unsigned I = 0; I < NF; ++I)
13880 Operands.push_back(llvm::PoisonValue::get(ResultType));
13881 Operands.push_back(Ops[NF + 1]);
13882 Operands.push_back(Ops[NF + 2]);
13883 Operands.push_back(Ops[NF]);
13884 Operands.push_back(Ops[NF + 3]);
13885 } else {
13886 for (unsigned I = 0; I < NF; ++I)
13887 Operands.push_back(Ops[NF + I + 1]);
13888 Operands.push_back(Ops[2 * NF + 1]);
13889 Operands.push_back(Ops[2 * NF + 2]);
13890 Operands.push_back(Ops[NF]);
13891 Operands.push_back(Ops[2 * NF + 3]);
13892 }
13893 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
13894 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 13894, __extension__ __PRETTY_FUNCTION__));
13895 } else {
13896 // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
13897 // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
13898 // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
13899 if (DefaultPolicy == TAIL_AGNOSTIC) {
13900 for (unsigned I = 0; I < NF; ++I)
13901 Operands.push_back(llvm::PoisonValue::get(ResultType));
13902 Operands.push_back(Ops[NF]);
13903 Operands.push_back(Ops[NF + 1]);
13904 Operands.push_back(Ops[NF + 2]);
13905 } else {
13906 for (unsigned I = 0; I < NF; ++I)
13907 Operands.push_back(Ops[NF + I]);
13908 Operands.push_back(Ops[2 * NF]);
13909 Operands.push_back(Ops[2 * NF + 1]);
13910 Operands.push_back(Ops[2 * NF + 2]);
13911 }
13912 }
13913 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
13914 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
13915 clang::CharUnits Align =
13916 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
13917 llvm::Value *V;
13918 for (unsigned I = 0; I < NF; ++I) {
13919 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
13920 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
13921 }
13922 return V;
13923 }
13924 break;
13925case RISCVVector::BI__builtin_rvv_vlsseg7e8_v_tuma:
13926case RISCVVector::BI__builtin_rvv_vlsseg7e16_v_tuma:
13927case RISCVVector::BI__builtin_rvv_vlsseg7e32_v_tuma:
13928case RISCVVector::BI__builtin_rvv_vlsseg7e64_v_tuma:
13929 ID = Intrinsic::riscv_vlsseg7_mask;
13930 NF = 7;
13931 DefaultPolicy = 2;
13932IsMasked = true;
13933
13934 {
13935 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
13936 IntrinsicTypes = {ResultType, Ops.back()->getType()};
13937 SmallVector<llvm::Value*, 12> Operands;
13938
13939 if (IsMasked) {
13940 // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
13941 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
13942 // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
13943 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
13944 for (unsigned I = 0; I < NF; ++I)
13945 Operands.push_back(llvm::PoisonValue::get(ResultType));
13946 Operands.push_back(Ops[NF + 1]);
13947 Operands.push_back(Ops[NF + 2]);
13948 Operands.push_back(Ops[NF]);
13949 Operands.push_back(Ops[NF + 3]);
13950 } else {
13951 for (unsigned I = 0; I < NF; ++I)
13952 Operands.push_back(Ops[NF + I + 1]);
13953 Operands.push_back(Ops[2 * NF + 1]);
13954 Operands.push_back(Ops[2 * NF + 2]);
13955 Operands.push_back(Ops[NF]);
13956 Operands.push_back(Ops[2 * NF + 3]);
13957 }
13958 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
13959 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 13959, __extension__ __PRETTY_FUNCTION__));
13960 } else {
13961 // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
13962 // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
13963 // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
13964 if (DefaultPolicy == TAIL_AGNOSTIC) {
13965 for (unsigned I = 0; I < NF; ++I)
13966 Operands.push_back(llvm::PoisonValue::get(ResultType));
13967 Operands.push_back(Ops[NF]);
13968 Operands.push_back(Ops[NF + 1]);
13969 Operands.push_back(Ops[NF + 2]);
13970 } else {
13971 for (unsigned I = 0; I < NF; ++I)
13972 Operands.push_back(Ops[NF + I]);
13973 Operands.push_back(Ops[2 * NF]);
13974 Operands.push_back(Ops[2 * NF + 1]);
13975 Operands.push_back(Ops[2 * NF + 2]);
13976 }
13977 }
13978 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
13979 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
13980 clang::CharUnits Align =
13981 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
13982 llvm::Value *V;
13983 for (unsigned I = 0; I < NF; ++I) {
13984 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
13985 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
13986 }
13987 return V;
13988 }
13989 break;
13990case RISCVVector::BI__builtin_rvv_vlsseg7e8_v_tama:
13991case RISCVVector::BI__builtin_rvv_vlsseg7e16_v_tama:
13992case RISCVVector::BI__builtin_rvv_vlsseg7e32_v_tama:
13993case RISCVVector::BI__builtin_rvv_vlsseg7e64_v_tama:
13994 ID = Intrinsic::riscv_vlsseg7_mask;
13995 NF = 7;
13996 DefaultPolicy = 3;
13997IsMasked = true;
13998
13999 {
14000 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
14001 IntrinsicTypes = {ResultType, Ops.back()->getType()};
14002 SmallVector<llvm::Value*, 12> Operands;
14003
14004 if (IsMasked) {
14005 // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
14006 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
14007 // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
14008 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
14009 for (unsigned I = 0; I < NF; ++I)
14010 Operands.push_back(llvm::PoisonValue::get(ResultType));
14011 Operands.push_back(Ops[NF + 1]);
14012 Operands.push_back(Ops[NF + 2]);
14013 Operands.push_back(Ops[NF]);
14014 Operands.push_back(Ops[NF + 3]);
14015 } else {
14016 for (unsigned I = 0; I < NF; ++I)
14017 Operands.push_back(Ops[NF + I + 1]);
14018 Operands.push_back(Ops[2 * NF + 1]);
14019 Operands.push_back(Ops[2 * NF + 2]);
14020 Operands.push_back(Ops[NF]);
14021 Operands.push_back(Ops[2 * NF + 3]);
14022 }
14023 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
14024 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 14024, __extension__ __PRETTY_FUNCTION__));
14025 } else {
14026 // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
14027 // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
14028 // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
14029 if (DefaultPolicy == TAIL_AGNOSTIC) {
14030 for (unsigned I = 0; I < NF; ++I)
14031 Operands.push_back(llvm::PoisonValue::get(ResultType));
14032 Operands.push_back(Ops[NF]);
14033 Operands.push_back(Ops[NF + 1]);
14034 Operands.push_back(Ops[NF + 2]);
14035 } else {
14036 for (unsigned I = 0; I < NF; ++I)
14037 Operands.push_back(Ops[NF + I]);
14038 Operands.push_back(Ops[2 * NF]);
14039 Operands.push_back(Ops[2 * NF + 1]);
14040 Operands.push_back(Ops[2 * NF + 2]);
14041 }
14042 }
14043 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
14044 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
14045 clang::CharUnits Align =
14046 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
14047 llvm::Value *V;
14048 for (unsigned I = 0; I < NF; ++I) {
14049 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
14050 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
14051 }
14052 return V;
14053 }
14054 break;
14055case RISCVVector::BI__builtin_rvv_vlsseg7e8_v_tumu:
14056case RISCVVector::BI__builtin_rvv_vlsseg7e16_v_tumu:
14057case RISCVVector::BI__builtin_rvv_vlsseg7e32_v_tumu:
14058case RISCVVector::BI__builtin_rvv_vlsseg7e64_v_tumu:
14059 ID = Intrinsic::riscv_vlsseg7_mask;
14060 NF = 7;
14061 DefaultPolicy = 0;
14062IsMasked = true;
14063
14064 {
14065 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
14066 IntrinsicTypes = {ResultType, Ops.back()->getType()};
14067 SmallVector<llvm::Value*, 12> Operands;
14068
14069 if (IsMasked) {
14070 // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
14071 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
14072 // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
14073 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
14074 for (unsigned I = 0; I < NF; ++I)
14075 Operands.push_back(llvm::PoisonValue::get(ResultType));
14076 Operands.push_back(Ops[NF + 1]);
14077 Operands.push_back(Ops[NF + 2]);
14078 Operands.push_back(Ops[NF]);
14079 Operands.push_back(Ops[NF + 3]);
14080 } else {
14081 for (unsigned I = 0; I < NF; ++I)
14082 Operands.push_back(Ops[NF + I + 1]);
14083 Operands.push_back(Ops[2 * NF + 1]);
14084 Operands.push_back(Ops[2 * NF + 2]);
14085 Operands.push_back(Ops[NF]);
14086 Operands.push_back(Ops[2 * NF + 3]);
14087 }
14088 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
14089 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 14089, __extension__ __PRETTY_FUNCTION__));
14090 } else {
14091 // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
14092 // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
14093 // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
14094 if (DefaultPolicy == TAIL_AGNOSTIC) {
14095 for (unsigned I = 0; I < NF; ++I)
14096 Operands.push_back(llvm::PoisonValue::get(ResultType));
14097 Operands.push_back(Ops[NF]);
14098 Operands.push_back(Ops[NF + 1]);
14099 Operands.push_back(Ops[NF + 2]);
14100 } else {
14101 for (unsigned I = 0; I < NF; ++I)
14102 Operands.push_back(Ops[NF + I]);
14103 Operands.push_back(Ops[2 * NF]);
14104 Operands.push_back(Ops[2 * NF + 1]);
14105 Operands.push_back(Ops[2 * NF + 2]);
14106 }
14107 }
14108 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
14109 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
14110 clang::CharUnits Align =
14111 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
14112 llvm::Value *V;
14113 for (unsigned I = 0; I < NF; ++I) {
14114 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
14115 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
14116 }
14117 return V;
14118 }
14119 break;
14120case RISCVVector::BI__builtin_rvv_vlsseg7e8_v_tamu:
14121case RISCVVector::BI__builtin_rvv_vlsseg7e16_v_tamu:
14122case RISCVVector::BI__builtin_rvv_vlsseg7e32_v_tamu:
14123case RISCVVector::BI__builtin_rvv_vlsseg7e64_v_tamu:
14124 ID = Intrinsic::riscv_vlsseg7_mask;
14125 NF = 7;
14126 DefaultPolicy = 1;
14127IsMasked = true;
14128
14129 {
14130 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
14131 IntrinsicTypes = {ResultType, Ops.back()->getType()};
14132 SmallVector<llvm::Value*, 12> Operands;
14133
14134 if (IsMasked) {
14135 // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
14136 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
14137 // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
14138 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
14139 for (unsigned I = 0; I < NF; ++I)
14140 Operands.push_back(llvm::PoisonValue::get(ResultType));
14141 Operands.push_back(Ops[NF + 1]);
14142 Operands.push_back(Ops[NF + 2]);
14143 Operands.push_back(Ops[NF]);
14144 Operands.push_back(Ops[NF + 3]);
14145 } else {
14146 for (unsigned I = 0; I < NF; ++I)
14147 Operands.push_back(Ops[NF + I + 1]);
14148 Operands.push_back(Ops[2 * NF + 1]);
14149 Operands.push_back(Ops[2 * NF + 2]);
14150 Operands.push_back(Ops[NF]);
14151 Operands.push_back(Ops[2 * NF + 3]);
14152 }
14153 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
14154 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 14154, __extension__ __PRETTY_FUNCTION__));
14155 } else {
14156 // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
14157 // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
14158 // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
14159 if (DefaultPolicy == TAIL_AGNOSTIC) {
14160 for (unsigned I = 0; I < NF; ++I)
14161 Operands.push_back(llvm::PoisonValue::get(ResultType));
14162 Operands.push_back(Ops[NF]);
14163 Operands.push_back(Ops[NF + 1]);
14164 Operands.push_back(Ops[NF + 2]);
14165 } else {
14166 for (unsigned I = 0; I < NF; ++I)
14167 Operands.push_back(Ops[NF + I]);
14168 Operands.push_back(Ops[2 * NF]);
14169 Operands.push_back(Ops[2 * NF + 1]);
14170 Operands.push_back(Ops[2 * NF + 2]);
14171 }
14172 }
14173 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
14174 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
14175 clang::CharUnits Align =
14176 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
14177 llvm::Value *V;
14178 for (unsigned I = 0; I < NF; ++I) {
14179 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
14180 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
14181 }
14182 return V;
14183 }
14184 break;
14185case RISCVVector::BI__builtin_rvv_vlsseg8e8_v_tu:
14186case RISCVVector::BI__builtin_rvv_vlsseg8e16_v_tu:
14187case RISCVVector::BI__builtin_rvv_vlsseg8e32_v_tu:
14188case RISCVVector::BI__builtin_rvv_vlsseg8e64_v_tu:
14189 ID = Intrinsic::riscv_vlsseg8;
14190 NF = 8;
14191 DefaultPolicy = 0;
14192IsMasked = false;
14193
14194 {
14195 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
14196 IntrinsicTypes = {ResultType, Ops.back()->getType()};
14197 SmallVector<llvm::Value*, 12> Operands;
14198
14199 if (IsMasked) {
14200 // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
14201 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
14202 // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
14203 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
14204 for (unsigned I = 0; I < NF; ++I)
14205 Operands.push_back(llvm::PoisonValue::get(ResultType));
14206 Operands.push_back(Ops[NF + 1]);
14207 Operands.push_back(Ops[NF + 2]);
14208 Operands.push_back(Ops[NF]);
14209 Operands.push_back(Ops[NF + 3]);
14210 } else {
14211 for (unsigned I = 0; I < NF; ++I)
14212 Operands.push_back(Ops[NF + I + 1]);
14213 Operands.push_back(Ops[2 * NF + 1]);
14214 Operands.push_back(Ops[2 * NF + 2]);
14215 Operands.push_back(Ops[NF]);
14216 Operands.push_back(Ops[2 * NF + 3]);
14217 }
14218 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
14219 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 14219, __extension__ __PRETTY_FUNCTION__));
14220 } else {
14221 // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
14222 // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
14223 // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
14224 if (DefaultPolicy == TAIL_AGNOSTIC) {
14225 for (unsigned I = 0; I < NF; ++I)
14226 Operands.push_back(llvm::PoisonValue::get(ResultType));
14227 Operands.push_back(Ops[NF]);
14228 Operands.push_back(Ops[NF + 1]);
14229 Operands.push_back(Ops[NF + 2]);
14230 } else {
14231 for (unsigned I = 0; I < NF; ++I)
14232 Operands.push_back(Ops[NF + I]);
14233 Operands.push_back(Ops[2 * NF]);
14234 Operands.push_back(Ops[2 * NF + 1]);
14235 Operands.push_back(Ops[2 * NF + 2]);
14236 }
14237 }
14238 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
14239 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
14240 clang::CharUnits Align =
14241 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
14242 llvm::Value *V;
14243 for (unsigned I = 0; I < NF; ++I) {
14244 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
14245 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
14246 }
14247 return V;
14248 }
14249 break;
14250case RISCVVector::BI__builtin_rvv_vlsseg8e8_v_ta:
14251case RISCVVector::BI__builtin_rvv_vlsseg8e16_v_ta:
14252case RISCVVector::BI__builtin_rvv_vlsseg8e32_v_ta:
14253case RISCVVector::BI__builtin_rvv_vlsseg8e64_v_ta:
14254 ID = Intrinsic::riscv_vlsseg8;
14255 NF = 8;
14256 DefaultPolicy = 1;
14257IsMasked = false;
14258
14259 {
14260 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
14261 IntrinsicTypes = {ResultType, Ops.back()->getType()};
14262 SmallVector<llvm::Value*, 12> Operands;
14263
14264 if (IsMasked) {
14265 // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
14266 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
14267 // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
14268 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
14269 for (unsigned I = 0; I < NF; ++I)
14270 Operands.push_back(llvm::PoisonValue::get(ResultType));
14271 Operands.push_back(Ops[NF + 1]);
14272 Operands.push_back(Ops[NF + 2]);
14273 Operands.push_back(Ops[NF]);
14274 Operands.push_back(Ops[NF + 3]);
14275 } else {
14276 for (unsigned I = 0; I < NF; ++I)
14277 Operands.push_back(Ops[NF + I + 1]);
14278 Operands.push_back(Ops[2 * NF + 1]);
14279 Operands.push_back(Ops[2 * NF + 2]);
14280 Operands.push_back(Ops[NF]);
14281 Operands.push_back(Ops[2 * NF + 3]);
14282 }
14283 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
14284 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 14284, __extension__ __PRETTY_FUNCTION__));
14285 } else {
14286 // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
14287 // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
14288 // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
14289 if (DefaultPolicy == TAIL_AGNOSTIC) {
14290 for (unsigned I = 0; I < NF; ++I)
14291 Operands.push_back(llvm::PoisonValue::get(ResultType));
14292 Operands.push_back(Ops[NF]);
14293 Operands.push_back(Ops[NF + 1]);
14294 Operands.push_back(Ops[NF + 2]);
14295 } else {
14296 for (unsigned I = 0; I < NF; ++I)
14297 Operands.push_back(Ops[NF + I]);
14298 Operands.push_back(Ops[2 * NF]);
14299 Operands.push_back(Ops[2 * NF + 1]);
14300 Operands.push_back(Ops[2 * NF + 2]);
14301 }
14302 }
14303 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
14304 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
14305 clang::CharUnits Align =
14306 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
14307 llvm::Value *V;
14308 for (unsigned I = 0; I < NF; ++I) {
14309 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
14310 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
14311 }
14312 return V;
14313 }
14314 break;
14315case RISCVVector::BI__builtin_rvv_vlsseg8e8_v_tuma:
14316case RISCVVector::BI__builtin_rvv_vlsseg8e16_v_tuma:
14317case RISCVVector::BI__builtin_rvv_vlsseg8e32_v_tuma:
14318case RISCVVector::BI__builtin_rvv_vlsseg8e64_v_tuma:
14319 ID = Intrinsic::riscv_vlsseg8_mask;
14320 NF = 8;
14321 DefaultPolicy = 2;
14322IsMasked = true;
14323
14324 {
14325 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
14326 IntrinsicTypes = {ResultType, Ops.back()->getType()};
14327 SmallVector<llvm::Value*, 12> Operands;
14328
14329 if (IsMasked) {
14330 // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
14331 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
14332 // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
14333 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
14334 for (unsigned I = 0; I < NF; ++I)
14335 Operands.push_back(llvm::PoisonValue::get(ResultType));
14336 Operands.push_back(Ops[NF + 1]);
14337 Operands.push_back(Ops[NF + 2]);
14338 Operands.push_back(Ops[NF]);
14339 Operands.push_back(Ops[NF + 3]);
14340 } else {
14341 for (unsigned I = 0; I < NF; ++I)
14342 Operands.push_back(Ops[NF + I + 1]);
14343 Operands.push_back(Ops[2 * NF + 1]);
14344 Operands.push_back(Ops[2 * NF + 2]);
14345 Operands.push_back(Ops[NF]);
14346 Operands.push_back(Ops[2 * NF + 3]);
14347 }
14348 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
14349 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 14349, __extension__ __PRETTY_FUNCTION__));
14350 } else {
14351 // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
14352 // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
14353 // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
14354 if (DefaultPolicy == TAIL_AGNOSTIC) {
14355 for (unsigned I = 0; I < NF; ++I)
14356 Operands.push_back(llvm::PoisonValue::get(ResultType));
14357 Operands.push_back(Ops[NF]);
14358 Operands.push_back(Ops[NF + 1]);
14359 Operands.push_back(Ops[NF + 2]);
14360 } else {
14361 for (unsigned I = 0; I < NF; ++I)
14362 Operands.push_back(Ops[NF + I]);
14363 Operands.push_back(Ops[2 * NF]);
14364 Operands.push_back(Ops[2 * NF + 1]);
14365 Operands.push_back(Ops[2 * NF + 2]);
14366 }
14367 }
14368 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
14369 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
14370 clang::CharUnits Align =
14371 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
14372 llvm::Value *V;
14373 for (unsigned I = 0; I < NF; ++I) {
14374 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
14375 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
14376 }
14377 return V;
14378 }
14379 break;
14380case RISCVVector::BI__builtin_rvv_vlsseg8e8_v_tama:
14381case RISCVVector::BI__builtin_rvv_vlsseg8e16_v_tama:
14382case RISCVVector::BI__builtin_rvv_vlsseg8e32_v_tama:
14383case RISCVVector::BI__builtin_rvv_vlsseg8e64_v_tama:
14384 ID = Intrinsic::riscv_vlsseg8_mask;
14385 NF = 8;
14386 DefaultPolicy = 3;
14387IsMasked = true;
14388
14389 {
14390 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
14391 IntrinsicTypes = {ResultType, Ops.back()->getType()};
14392 SmallVector<llvm::Value*, 12> Operands;
14393
14394 if (IsMasked) {
14395 // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
14396 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
14397 // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
14398 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
14399 for (unsigned I = 0; I < NF; ++I)
14400 Operands.push_back(llvm::PoisonValue::get(ResultType));
14401 Operands.push_back(Ops[NF + 1]);
14402 Operands.push_back(Ops[NF + 2]);
14403 Operands.push_back(Ops[NF]);
14404 Operands.push_back(Ops[NF + 3]);
14405 } else {
14406 for (unsigned I = 0; I < NF; ++I)
14407 Operands.push_back(Ops[NF + I + 1]);
14408 Operands.push_back(Ops[2 * NF + 1]);
14409 Operands.push_back(Ops[2 * NF + 2]);
14410 Operands.push_back(Ops[NF]);
14411 Operands.push_back(Ops[2 * NF + 3]);
14412 }
14413 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
14414 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 14414, __extension__ __PRETTY_FUNCTION__));
14415 } else {
14416 // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
14417 // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
14418 // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
14419 if (DefaultPolicy == TAIL_AGNOSTIC) {
14420 for (unsigned I = 0; I < NF; ++I)
14421 Operands.push_back(llvm::PoisonValue::get(ResultType));
14422 Operands.push_back(Ops[NF]);
14423 Operands.push_back(Ops[NF + 1]);
14424 Operands.push_back(Ops[NF + 2]);
14425 } else {
14426 for (unsigned I = 0; I < NF; ++I)
14427 Operands.push_back(Ops[NF + I]);
14428 Operands.push_back(Ops[2 * NF]);
14429 Operands.push_back(Ops[2 * NF + 1]);
14430 Operands.push_back(Ops[2 * NF + 2]);
14431 }
14432 }
14433 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
14434 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
14435 clang::CharUnits Align =
14436 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
14437 llvm::Value *V;
14438 for (unsigned I = 0; I < NF; ++I) {
14439 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
14440 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
14441 }
14442 return V;
14443 }
14444 break;
14445case RISCVVector::BI__builtin_rvv_vlsseg8e8_v_tumu:
14446case RISCVVector::BI__builtin_rvv_vlsseg8e16_v_tumu:
14447case RISCVVector::BI__builtin_rvv_vlsseg8e32_v_tumu:
14448case RISCVVector::BI__builtin_rvv_vlsseg8e64_v_tumu:
14449 ID = Intrinsic::riscv_vlsseg8_mask;
14450 NF = 8;
14451 DefaultPolicy = 0;
14452IsMasked = true;
14453
14454 {
14455 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
14456 IntrinsicTypes = {ResultType, Ops.back()->getType()};
14457 SmallVector<llvm::Value*, 12> Operands;
14458
14459 if (IsMasked) {
14460 // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
14461 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
14462 // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
14463 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
14464 for (unsigned I = 0; I < NF; ++I)
14465 Operands.push_back(llvm::PoisonValue::get(ResultType));
14466 Operands.push_back(Ops[NF + 1]);
14467 Operands.push_back(Ops[NF + 2]);
14468 Operands.push_back(Ops[NF]);
14469 Operands.push_back(Ops[NF + 3]);
14470 } else {
14471 for (unsigned I = 0; I < NF; ++I)
14472 Operands.push_back(Ops[NF + I + 1]);
14473 Operands.push_back(Ops[2 * NF + 1]);
14474 Operands.push_back(Ops[2 * NF + 2]);
14475 Operands.push_back(Ops[NF]);
14476 Operands.push_back(Ops[2 * NF + 3]);
14477 }
14478 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
14479 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 14479, __extension__ __PRETTY_FUNCTION__));
14480 } else {
14481 // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
14482 // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
14483 // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
14484 if (DefaultPolicy == TAIL_AGNOSTIC) {
14485 for (unsigned I = 0; I < NF; ++I)
14486 Operands.push_back(llvm::PoisonValue::get(ResultType));
14487 Operands.push_back(Ops[NF]);
14488 Operands.push_back(Ops[NF + 1]);
14489 Operands.push_back(Ops[NF + 2]);
14490 } else {
14491 for (unsigned I = 0; I < NF; ++I)
14492 Operands.push_back(Ops[NF + I]);
14493 Operands.push_back(Ops[2 * NF]);
14494 Operands.push_back(Ops[2 * NF + 1]);
14495 Operands.push_back(Ops[2 * NF + 2]);
14496 }
14497 }
14498 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
14499 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
14500 clang::CharUnits Align =
14501 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
14502 llvm::Value *V;
14503 for (unsigned I = 0; I < NF; ++I) {
14504 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
14505 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
14506 }
14507 return V;
14508 }
14509 break;
14510case RISCVVector::BI__builtin_rvv_vlsseg8e8_v_tamu:
14511case RISCVVector::BI__builtin_rvv_vlsseg8e16_v_tamu:
14512case RISCVVector::BI__builtin_rvv_vlsseg8e32_v_tamu:
14513case RISCVVector::BI__builtin_rvv_vlsseg8e64_v_tamu:
14514 ID = Intrinsic::riscv_vlsseg8_mask;
14515 NF = 8;
14516 DefaultPolicy = 1;
14517IsMasked = true;
14518
14519 {
14520 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
14521 IntrinsicTypes = {ResultType, Ops.back()->getType()};
14522 SmallVector<llvm::Value*, 12> Operands;
14523
14524 if (IsMasked) {
14525 // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
14526 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
14527 // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
14528 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
14529 for (unsigned I = 0; I < NF; ++I)
14530 Operands.push_back(llvm::PoisonValue::get(ResultType));
14531 Operands.push_back(Ops[NF + 1]);
14532 Operands.push_back(Ops[NF + 2]);
14533 Operands.push_back(Ops[NF]);
14534 Operands.push_back(Ops[NF + 3]);
14535 } else {
14536 for (unsigned I = 0; I < NF; ++I)
14537 Operands.push_back(Ops[NF + I + 1]);
14538 Operands.push_back(Ops[2 * NF + 1]);
14539 Operands.push_back(Ops[2 * NF + 2]);
14540 Operands.push_back(Ops[NF]);
14541 Operands.push_back(Ops[2 * NF + 3]);
14542 }
14543 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
14544 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 14544, __extension__ __PRETTY_FUNCTION__));
14545 } else {
14546 // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
14547 // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
14548 // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
14549 if (DefaultPolicy == TAIL_AGNOSTIC) {
14550 for (unsigned I = 0; I < NF; ++I)
14551 Operands.push_back(llvm::PoisonValue::get(ResultType));
14552 Operands.push_back(Ops[NF]);
14553 Operands.push_back(Ops[NF + 1]);
14554 Operands.push_back(Ops[NF + 2]);
14555 } else {
14556 for (unsigned I = 0; I < NF; ++I)
14557 Operands.push_back(Ops[NF + I]);
14558 Operands.push_back(Ops[2 * NF]);
14559 Operands.push_back(Ops[2 * NF + 1]);
14560 Operands.push_back(Ops[2 * NF + 2]);
14561 }
14562 }
14563 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
14564 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
14565 clang::CharUnits Align =
14566 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
14567 llvm::Value *V;
14568 for (unsigned I = 0; I < NF; ++I) {
14569 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
14570 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
14571 }
14572 return V;
14573 }
14574 break;
14575case RISCVVector::BI__builtin_rvv_vluxei8_v_tu:
14576case RISCVVector::BI__builtin_rvv_vluxei64_v_tu:
14577case RISCVVector::BI__builtin_rvv_vluxei16_v_tu:
14578case RISCVVector::BI__builtin_rvv_vluxei32_v_tu:
14579 ID = Intrinsic::riscv_vluxei;
14580 Ops[1] = Builder.CreateBitCast(Ops[1], ResultType->getPointerTo());
14581 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
14582 break;
14583case RISCVVector::BI__builtin_rvv_vluxei8_v_ta:
14584case RISCVVector::BI__builtin_rvv_vluxei64_v_ta:
14585case RISCVVector::BI__builtin_rvv_vluxei16_v_ta:
14586case RISCVVector::BI__builtin_rvv_vluxei32_v_ta:
14587 ID = Intrinsic::riscv_vluxei;
14588 Ops[0] = Builder.CreateBitCast(Ops[0], ResultType->getPointerTo());
14589 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
14590 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
14591 break;
14592case RISCVVector::BI__builtin_rvv_vluxei8_v_tuma:
14593case RISCVVector::BI__builtin_rvv_vluxei64_v_tuma:
14594case RISCVVector::BI__builtin_rvv_vluxei16_v_tuma:
14595case RISCVVector::BI__builtin_rvv_vluxei32_v_tuma:
14596 ID = Intrinsic::riscv_vluxei_mask;
14597 DefaultPolicy = 2;
14598 Ops[2] = Builder.CreateBitCast(Ops[2], ResultType->getPointerTo());
14599 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
14600 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
14601 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
14602 break;
14603case RISCVVector::BI__builtin_rvv_vluxei8_v_tama:
14604case RISCVVector::BI__builtin_rvv_vluxei64_v_tama:
14605case RISCVVector::BI__builtin_rvv_vluxei16_v_tama:
14606case RISCVVector::BI__builtin_rvv_vluxei32_v_tama:
14607 ID = Intrinsic::riscv_vluxei_mask;
14608 DefaultPolicy = 3;
14609 Ops[1] = Builder.CreateBitCast(Ops[1], ResultType->getPointerTo());
14610 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
14611 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
14612 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
14613 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
14614 break;
14615case RISCVVector::BI__builtin_rvv_vluxei8_v_tumu:
14616case RISCVVector::BI__builtin_rvv_vluxei64_v_tumu:
14617case RISCVVector::BI__builtin_rvv_vluxei16_v_tumu:
14618case RISCVVector::BI__builtin_rvv_vluxei32_v_tumu:
14619 ID = Intrinsic::riscv_vluxei_mask;
14620 Ops[2] = Builder.CreateBitCast(Ops[2], ResultType->getPointerTo());
14621 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
14622 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
14623 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
14624 break;
14625case RISCVVector::BI__builtin_rvv_vluxei8_v_tamu:
14626case RISCVVector::BI__builtin_rvv_vluxei64_v_tamu:
14627case RISCVVector::BI__builtin_rvv_vluxei16_v_tamu:
14628case RISCVVector::BI__builtin_rvv_vluxei32_v_tamu:
14629 ID = Intrinsic::riscv_vluxei_mask;
14630 DefaultPolicy = 1;
14631 Ops[2] = Builder.CreateBitCast(Ops[2], ResultType->getPointerTo());
14632 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
14633 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
14634 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
14635 break;
14636case RISCVVector::BI__builtin_rvv_vluxseg2ei8_v_tu:
14637case RISCVVector::BI__builtin_rvv_vluxseg2ei16_v_tu:
14638case RISCVVector::BI__builtin_rvv_vluxseg2ei32_v_tu:
14639case RISCVVector::BI__builtin_rvv_vluxseg2ei64_v_tu:
14640 ID = Intrinsic::riscv_vluxseg2;
14641 NF = 2;
14642 DefaultPolicy = 0;
14643IsMasked = false;
14644
14645 {
14646 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
14647 SmallVector<llvm::Value*, 12> Operands;
14648 if (IsMasked) {
14649 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
14650 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
14651 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
14652 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
14653 for (unsigned I = 0; I < NF; ++I)
14654 Operands.push_back(llvm::PoisonValue::get(ResultType));
14655 Operands.push_back(Ops[NF + 1]);
14656 Operands.push_back(Ops[NF + 2]);
14657 Operands.push_back(Ops[NF]);
14658 Operands.push_back(Ops[NF + 3]);
14659 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
14660 } else {
14661 for (unsigned I = 0; I < NF; ++I)
14662 Operands.push_back(Ops[NF + I + 1]);
14663 Operands.push_back(Ops[2 * NF + 1]);
14664 Operands.push_back(Ops[2 * NF + 2]);
14665 Operands.push_back(Ops[NF]);
14666 Operands.push_back(Ops[2 * NF + 3]);
14667 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
14668 }
14669 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
14670 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 14670, __extension__ __PRETTY_FUNCTION__));
14671 } else {
14672 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
14673 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
14674 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
14675 if (DefaultPolicy == TAIL_AGNOSTIC) {
14676 for (unsigned I = 0; I < NF; ++I)
14677 Operands.push_back(llvm::PoisonValue::get(ResultType));
14678 Operands.push_back(Ops[NF]);
14679 Operands.push_back(Ops[NF + 1]);
14680 Operands.push_back(Ops[NF + 2]);
14681 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
14682 } else {
14683 for (unsigned I = 0; I < NF; ++I)
14684 Operands.push_back(Ops[NF + I]);
14685 Operands.push_back(Ops[2 * NF]);
14686 Operands.push_back(Ops[2 * NF + 1]);
14687 Operands.push_back(Ops[2 * NF + 2]);
14688 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
14689 }
14690 }
14691 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
14692 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
14693 clang::CharUnits Align =
14694 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
14695 llvm::Value *V;
14696 for (unsigned I = 0; I < NF; ++I) {
14697 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
14698 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
14699 }
14700 return V;
14701 }
14702 break;
14703case RISCVVector::BI__builtin_rvv_vluxseg2ei8_v_ta:
14704case RISCVVector::BI__builtin_rvv_vluxseg2ei16_v_ta:
14705case RISCVVector::BI__builtin_rvv_vluxseg2ei32_v_ta:
14706case RISCVVector::BI__builtin_rvv_vluxseg2ei64_v_ta:
14707 ID = Intrinsic::riscv_vluxseg2;
14708 NF = 2;
14709 DefaultPolicy = 1;
14710IsMasked = false;
14711
14712 {
14713 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
14714 SmallVector<llvm::Value*, 12> Operands;
14715 if (IsMasked) {
14716 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
14717 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
14718 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
14719 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
14720 for (unsigned I = 0; I < NF; ++I)
14721 Operands.push_back(llvm::PoisonValue::get(ResultType));
14722 Operands.push_back(Ops[NF + 1]);
14723 Operands.push_back(Ops[NF + 2]);
14724 Operands.push_back(Ops[NF]);
14725 Operands.push_back(Ops[NF + 3]);
14726 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
14727 } else {
14728 for (unsigned I = 0; I < NF; ++I)
14729 Operands.push_back(Ops[NF + I + 1]);
14730 Operands.push_back(Ops[2 * NF + 1]);
14731 Operands.push_back(Ops[2 * NF + 2]);
14732 Operands.push_back(Ops[NF]);
14733 Operands.push_back(Ops[2 * NF + 3]);
14734 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
14735 }
14736 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
14737 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 14737, __extension__ __PRETTY_FUNCTION__));
14738 } else {
14739 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
14740 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
14741 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
14742 if (DefaultPolicy == TAIL_AGNOSTIC) {
14743 for (unsigned I = 0; I < NF; ++I)
14744 Operands.push_back(llvm::PoisonValue::get(ResultType));
14745 Operands.push_back(Ops[NF]);
14746 Operands.push_back(Ops[NF + 1]);
14747 Operands.push_back(Ops[NF + 2]);
14748 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
14749 } else {
14750 for (unsigned I = 0; I < NF; ++I)
14751 Operands.push_back(Ops[NF + I]);
14752 Operands.push_back(Ops[2 * NF]);
14753 Operands.push_back(Ops[2 * NF + 1]);
14754 Operands.push_back(Ops[2 * NF + 2]);
14755 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
14756 }
14757 }
14758 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
14759 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
14760 clang::CharUnits Align =
14761 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
14762 llvm::Value *V;
14763 for (unsigned I = 0; I < NF; ++I) {
14764 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
14765 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
14766 }
14767 return V;
14768 }
14769 break;
14770case RISCVVector::BI__builtin_rvv_vluxseg2ei8_v_tuma:
14771case RISCVVector::BI__builtin_rvv_vluxseg2ei16_v_tuma:
14772case RISCVVector::BI__builtin_rvv_vluxseg2ei32_v_tuma:
14773case RISCVVector::BI__builtin_rvv_vluxseg2ei64_v_tuma:
14774 ID = Intrinsic::riscv_vluxseg2_mask;
14775 NF = 2;
14776 DefaultPolicy = 2;
14777IsMasked = true;
14778
14779 {
14780 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
14781 SmallVector<llvm::Value*, 12> Operands;
14782 if (IsMasked) {
14783 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
14784 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
14785 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
14786 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
14787 for (unsigned I = 0; I < NF; ++I)
14788 Operands.push_back(llvm::PoisonValue::get(ResultType));
14789 Operands.push_back(Ops[NF + 1]);
14790 Operands.push_back(Ops[NF + 2]);
14791 Operands.push_back(Ops[NF]);
14792 Operands.push_back(Ops[NF + 3]);
14793 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
14794 } else {
14795 for (unsigned I = 0; I < NF; ++I)
14796 Operands.push_back(Ops[NF + I + 1]);
14797 Operands.push_back(Ops[2 * NF + 1]);
14798 Operands.push_back(Ops[2 * NF + 2]);
14799 Operands.push_back(Ops[NF]);
14800 Operands.push_back(Ops[2 * NF + 3]);
14801 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
14802 }
14803 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
14804 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 14804, __extension__ __PRETTY_FUNCTION__));
14805 } else {
14806 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
14807 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
14808 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
14809 if (DefaultPolicy == TAIL_AGNOSTIC) {
14810 for (unsigned I = 0; I < NF; ++I)
14811 Operands.push_back(llvm::PoisonValue::get(ResultType));
14812 Operands.push_back(Ops[NF]);
14813 Operands.push_back(Ops[NF + 1]);
14814 Operands.push_back(Ops[NF + 2]);
14815 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
14816 } else {
14817 for (unsigned I = 0; I < NF; ++I)
14818 Operands.push_back(Ops[NF + I]);
14819 Operands.push_back(Ops[2 * NF]);
14820 Operands.push_back(Ops[2 * NF + 1]);
14821 Operands.push_back(Ops[2 * NF + 2]);
14822 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
14823 }
14824 }
14825 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
14826 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
14827 clang::CharUnits Align =
14828 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
14829 llvm::Value *V;
14830 for (unsigned I = 0; I < NF; ++I) {
14831 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
14832 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
14833 }
14834 return V;
14835 }
14836 break;
14837case RISCVVector::BI__builtin_rvv_vluxseg2ei8_v_tama:
14838case RISCVVector::BI__builtin_rvv_vluxseg2ei16_v_tama:
14839case RISCVVector::BI__builtin_rvv_vluxseg2ei32_v_tama:
14840case RISCVVector::BI__builtin_rvv_vluxseg2ei64_v_tama:
14841 ID = Intrinsic::riscv_vluxseg2_mask;
14842 NF = 2;
14843 DefaultPolicy = 3;
14844IsMasked = true;
14845
14846 {
14847 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
14848 SmallVector<llvm::Value*, 12> Operands;
14849 if (IsMasked) {
14850 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
14851 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
14852 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
14853 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
14854 for (unsigned I = 0; I < NF; ++I)
14855 Operands.push_back(llvm::PoisonValue::get(ResultType));
14856 Operands.push_back(Ops[NF + 1]);
14857 Operands.push_back(Ops[NF + 2]);
14858 Operands.push_back(Ops[NF]);
14859 Operands.push_back(Ops[NF + 3]);
14860 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
14861 } else {
14862 for (unsigned I = 0; I < NF; ++I)
14863 Operands.push_back(Ops[NF + I + 1]);
14864 Operands.push_back(Ops[2 * NF + 1]);
14865 Operands.push_back(Ops[2 * NF + 2]);
14866 Operands.push_back(Ops[NF]);
14867 Operands.push_back(Ops[2 * NF + 3]);
14868 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
14869 }
14870 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
14871 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 14871, __extension__ __PRETTY_FUNCTION__));
14872 } else {
14873 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
14874 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
14875 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
14876 if (DefaultPolicy == TAIL_AGNOSTIC) {
14877 for (unsigned I = 0; I < NF; ++I)
14878 Operands.push_back(llvm::PoisonValue::get(ResultType));
14879 Operands.push_back(Ops[NF]);
14880 Operands.push_back(Ops[NF + 1]);
14881 Operands.push_back(Ops[NF + 2]);
14882 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
14883 } else {
14884 for (unsigned I = 0; I < NF; ++I)
14885 Operands.push_back(Ops[NF + I]);
14886 Operands.push_back(Ops[2 * NF]);
14887 Operands.push_back(Ops[2 * NF + 1]);
14888 Operands.push_back(Ops[2 * NF + 2]);
14889 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
14890 }
14891 }
14892 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
14893 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
14894 clang::CharUnits Align =
14895 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
14896 llvm::Value *V;
14897 for (unsigned I = 0; I < NF; ++I) {
14898 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
14899 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
14900 }
14901 return V;
14902 }
14903 break;
14904case RISCVVector::BI__builtin_rvv_vluxseg2ei8_v_tumu:
14905case RISCVVector::BI__builtin_rvv_vluxseg2ei16_v_tumu:
14906case RISCVVector::BI__builtin_rvv_vluxseg2ei32_v_tumu:
14907case RISCVVector::BI__builtin_rvv_vluxseg2ei64_v_tumu:
14908 ID = Intrinsic::riscv_vluxseg2_mask;
14909 NF = 2;
14910 DefaultPolicy = 0;
14911IsMasked = true;
14912
14913 {
14914 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
14915 SmallVector<llvm::Value*, 12> Operands;
14916 if (IsMasked) {
14917 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
14918 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
14919 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
14920 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
14921 for (unsigned I = 0; I < NF; ++I)
14922 Operands.push_back(llvm::PoisonValue::get(ResultType));
14923 Operands.push_back(Ops[NF + 1]);
14924 Operands.push_back(Ops[NF + 2]);
14925 Operands.push_back(Ops[NF]);
14926 Operands.push_back(Ops[NF + 3]);
14927 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
14928 } else {
14929 for (unsigned I = 0; I < NF; ++I)
14930 Operands.push_back(Ops[NF + I + 1]);
14931 Operands.push_back(Ops[2 * NF + 1]);
14932 Operands.push_back(Ops[2 * NF + 2]);
14933 Operands.push_back(Ops[NF]);
14934 Operands.push_back(Ops[2 * NF + 3]);
14935 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
14936 }
14937 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
14938 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 14938, __extension__ __PRETTY_FUNCTION__));
14939 } else {
14940 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
14941 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
14942 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
14943 if (DefaultPolicy == TAIL_AGNOSTIC) {
14944 for (unsigned I = 0; I < NF; ++I)
14945 Operands.push_back(llvm::PoisonValue::get(ResultType));
14946 Operands.push_back(Ops[NF]);
14947 Operands.push_back(Ops[NF + 1]);
14948 Operands.push_back(Ops[NF + 2]);
14949 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
14950 } else {
14951 for (unsigned I = 0; I < NF; ++I)
14952 Operands.push_back(Ops[NF + I]);
14953 Operands.push_back(Ops[2 * NF]);
14954 Operands.push_back(Ops[2 * NF + 1]);
14955 Operands.push_back(Ops[2 * NF + 2]);
14956 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
14957 }
14958 }
14959 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
14960 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
14961 clang::CharUnits Align =
14962 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
14963 llvm::Value *V;
14964 for (unsigned I = 0; I < NF; ++I) {
14965 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
14966 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
14967 }
14968 return V;
14969 }
14970 break;
14971case RISCVVector::BI__builtin_rvv_vluxseg2ei8_v_tamu:
14972case RISCVVector::BI__builtin_rvv_vluxseg2ei16_v_tamu:
14973case RISCVVector::BI__builtin_rvv_vluxseg2ei32_v_tamu:
14974case RISCVVector::BI__builtin_rvv_vluxseg2ei64_v_tamu:
14975 ID = Intrinsic::riscv_vluxseg2_mask;
14976 NF = 2;
14977 DefaultPolicy = 1;
14978IsMasked = true;
14979
14980 {
14981 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
14982 SmallVector<llvm::Value*, 12> Operands;
14983 if (IsMasked) {
14984 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
14985 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
14986 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
14987 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
14988 for (unsigned I = 0; I < NF; ++I)
14989 Operands.push_back(llvm::PoisonValue::get(ResultType));
14990 Operands.push_back(Ops[NF + 1]);
14991 Operands.push_back(Ops[NF + 2]);
14992 Operands.push_back(Ops[NF]);
14993 Operands.push_back(Ops[NF + 3]);
14994 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
14995 } else {
14996 for (unsigned I = 0; I < NF; ++I)
14997 Operands.push_back(Ops[NF + I + 1]);
14998 Operands.push_back(Ops[2 * NF + 1]);
14999 Operands.push_back(Ops[2 * NF + 2]);
15000 Operands.push_back(Ops[NF]);
15001 Operands.push_back(Ops[2 * NF + 3]);
15002 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
15003 }
15004 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
15005 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 15005, __extension__ __PRETTY_FUNCTION__));
15006 } else {
15007 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
15008 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
15009 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
15010 if (DefaultPolicy == TAIL_AGNOSTIC) {
15011 for (unsigned I = 0; I < NF; ++I)
15012 Operands.push_back(llvm::PoisonValue::get(ResultType));
15013 Operands.push_back(Ops[NF]);
15014 Operands.push_back(Ops[NF + 1]);
15015 Operands.push_back(Ops[NF + 2]);
15016 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
15017 } else {
15018 for (unsigned I = 0; I < NF; ++I)
15019 Operands.push_back(Ops[NF + I]);
15020 Operands.push_back(Ops[2 * NF]);
15021 Operands.push_back(Ops[2 * NF + 1]);
15022 Operands.push_back(Ops[2 * NF + 2]);
15023 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
15024 }
15025 }
15026 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
15027 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
15028 clang::CharUnits Align =
15029 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
15030 llvm::Value *V;
15031 for (unsigned I = 0; I < NF; ++I) {
15032 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
15033 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
15034 }
15035 return V;
15036 }
15037 break;
15038case RISCVVector::BI__builtin_rvv_vluxseg3ei8_v_tu:
15039case RISCVVector::BI__builtin_rvv_vluxseg3ei16_v_tu:
15040case RISCVVector::BI__builtin_rvv_vluxseg3ei32_v_tu:
15041case RISCVVector::BI__builtin_rvv_vluxseg3ei64_v_tu:
15042 ID = Intrinsic::riscv_vluxseg3;
15043 NF = 3;
15044 DefaultPolicy = 0;
15045IsMasked = false;
15046
15047 {
15048 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
15049 SmallVector<llvm::Value*, 12> Operands;
15050 if (IsMasked) {
15051 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
15052 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
15053 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
15054 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
15055 for (unsigned I = 0; I < NF; ++I)
15056 Operands.push_back(llvm::PoisonValue::get(ResultType));
15057 Operands.push_back(Ops[NF + 1]);
15058 Operands.push_back(Ops[NF + 2]);
15059 Operands.push_back(Ops[NF]);
15060 Operands.push_back(Ops[NF + 3]);
15061 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
15062 } else {
15063 for (unsigned I = 0; I < NF; ++I)
15064 Operands.push_back(Ops[NF + I + 1]);
15065 Operands.push_back(Ops[2 * NF + 1]);
15066 Operands.push_back(Ops[2 * NF + 2]);
15067 Operands.push_back(Ops[NF]);
15068 Operands.push_back(Ops[2 * NF + 3]);
15069 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
15070 }
15071 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
15072 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 15072, __extension__ __PRETTY_FUNCTION__));
15073 } else {
15074 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
15075 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
15076 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
15077 if (DefaultPolicy == TAIL_AGNOSTIC) {
15078 for (unsigned I = 0; I < NF; ++I)
15079 Operands.push_back(llvm::PoisonValue::get(ResultType));
15080 Operands.push_back(Ops[NF]);
15081 Operands.push_back(Ops[NF + 1]);
15082 Operands.push_back(Ops[NF + 2]);
15083 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
15084 } else {
15085 for (unsigned I = 0; I < NF; ++I)
15086 Operands.push_back(Ops[NF + I]);
15087 Operands.push_back(Ops[2 * NF]);
15088 Operands.push_back(Ops[2 * NF + 1]);
15089 Operands.push_back(Ops[2 * NF + 2]);
15090 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
15091 }
15092 }
15093 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
15094 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
15095 clang::CharUnits Align =
15096 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
15097 llvm::Value *V;
15098 for (unsigned I = 0; I < NF; ++I) {
15099 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
15100 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
15101 }
15102 return V;
15103 }
15104 break;
15105case RISCVVector::BI__builtin_rvv_vluxseg3ei8_v_ta:
15106case RISCVVector::BI__builtin_rvv_vluxseg3ei16_v_ta:
15107case RISCVVector::BI__builtin_rvv_vluxseg3ei32_v_ta:
15108case RISCVVector::BI__builtin_rvv_vluxseg3ei64_v_ta:
15109 ID = Intrinsic::riscv_vluxseg3;
15110 NF = 3;
15111 DefaultPolicy = 1;
15112IsMasked = false;
15113
15114 {
15115 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
15116 SmallVector<llvm::Value*, 12> Operands;
15117 if (IsMasked) {
15118 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
15119 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
15120 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
15121 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
15122 for (unsigned I = 0; I < NF; ++I)
15123 Operands.push_back(llvm::PoisonValue::get(ResultType));
15124 Operands.push_back(Ops[NF + 1]);
15125 Operands.push_back(Ops[NF + 2]);
15126 Operands.push_back(Ops[NF]);
15127 Operands.push_back(Ops[NF + 3]);
15128 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
15129 } else {
15130 for (unsigned I = 0; I < NF; ++I)
15131 Operands.push_back(Ops[NF + I + 1]);
15132 Operands.push_back(Ops[2 * NF + 1]);
15133 Operands.push_back(Ops[2 * NF + 2]);
15134 Operands.push_back(Ops[NF]);
15135 Operands.push_back(Ops[2 * NF + 3]);
15136 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
15137 }
15138 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
15139 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 15139, __extension__ __PRETTY_FUNCTION__));
15140 } else {
15141 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
15142 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
15143 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
15144 if (DefaultPolicy == TAIL_AGNOSTIC) {
15145 for (unsigned I = 0; I < NF; ++I)
15146 Operands.push_back(llvm::PoisonValue::get(ResultType));
15147 Operands.push_back(Ops[NF]);
15148 Operands.push_back(Ops[NF + 1]);
15149 Operands.push_back(Ops[NF + 2]);
15150 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
15151 } else {
15152 for (unsigned I = 0; I < NF; ++I)
15153 Operands.push_back(Ops[NF + I]);
15154 Operands.push_back(Ops[2 * NF]);
15155 Operands.push_back(Ops[2 * NF + 1]);
15156 Operands.push_back(Ops[2 * NF + 2]);
15157 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
15158 }
15159 }
15160 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
15161 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
15162 clang::CharUnits Align =
15163 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
15164 llvm::Value *V;
15165 for (unsigned I = 0; I < NF; ++I) {
15166 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
15167 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
15168 }
15169 return V;
15170 }
15171 break;
15172case RISCVVector::BI__builtin_rvv_vluxseg3ei8_v_tuma:
15173case RISCVVector::BI__builtin_rvv_vluxseg3ei16_v_tuma:
15174case RISCVVector::BI__builtin_rvv_vluxseg3ei32_v_tuma:
15175case RISCVVector::BI__builtin_rvv_vluxseg3ei64_v_tuma:
15176 ID = Intrinsic::riscv_vluxseg3_mask;
15177 NF = 3;
15178 DefaultPolicy = 2;
15179IsMasked = true;
15180
15181 {
15182 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
15183 SmallVector<llvm::Value*, 12> Operands;
15184 if (IsMasked) {
15185 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
15186 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
15187 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
15188 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
15189 for (unsigned I = 0; I < NF; ++I)
15190 Operands.push_back(llvm::PoisonValue::get(ResultType));
15191 Operands.push_back(Ops[NF + 1]);
15192 Operands.push_back(Ops[NF + 2]);
15193 Operands.push_back(Ops[NF]);
15194 Operands.push_back(Ops[NF + 3]);
15195 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
15196 } else {
15197 for (unsigned I = 0; I < NF; ++I)
15198 Operands.push_back(Ops[NF + I + 1]);
15199 Operands.push_back(Ops[2 * NF + 1]);
15200 Operands.push_back(Ops[2 * NF + 2]);
15201 Operands.push_back(Ops[NF]);
15202 Operands.push_back(Ops[2 * NF + 3]);
15203 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
15204 }
15205 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
15206 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 15206, __extension__ __PRETTY_FUNCTION__));
15207 } else {
15208 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
15209 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
15210 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
15211 if (DefaultPolicy == TAIL_AGNOSTIC) {
15212 for (unsigned I = 0; I < NF; ++I)
15213 Operands.push_back(llvm::PoisonValue::get(ResultType));
15214 Operands.push_back(Ops[NF]);
15215 Operands.push_back(Ops[NF + 1]);
15216 Operands.push_back(Ops[NF + 2]);
15217 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
15218 } else {
15219 for (unsigned I = 0; I < NF; ++I)
15220 Operands.push_back(Ops[NF + I]);
15221 Operands.push_back(Ops[2 * NF]);
15222 Operands.push_back(Ops[2 * NF + 1]);
15223 Operands.push_back(Ops[2 * NF + 2]);
15224 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
15225 }
15226 }
15227 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
15228 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
15229 clang::CharUnits Align =
15230 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
15231 llvm::Value *V;
15232 for (unsigned I = 0; I < NF; ++I) {
15233 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
15234 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
15235 }
15236 return V;
15237 }
15238 break;
15239case RISCVVector::BI__builtin_rvv_vluxseg3ei8_v_tama:
15240case RISCVVector::BI__builtin_rvv_vluxseg3ei16_v_tama:
15241case RISCVVector::BI__builtin_rvv_vluxseg3ei32_v_tama:
15242case RISCVVector::BI__builtin_rvv_vluxseg3ei64_v_tama:
15243 ID = Intrinsic::riscv_vluxseg3_mask;
15244 NF = 3;
15245 DefaultPolicy = 3;
15246IsMasked = true;
15247
15248 {
15249 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
15250 SmallVector<llvm::Value*, 12> Operands;
15251 if (IsMasked) {
15252 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
15253 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
15254 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
15255 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
15256 for (unsigned I = 0; I < NF; ++I)
15257 Operands.push_back(llvm::PoisonValue::get(ResultType));
15258 Operands.push_back(Ops[NF + 1]);
15259 Operands.push_back(Ops[NF + 2]);
15260 Operands.push_back(Ops[NF]);
15261 Operands.push_back(Ops[NF + 3]);
15262 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
15263 } else {
15264 for (unsigned I = 0; I < NF; ++I)
15265 Operands.push_back(Ops[NF + I + 1]);
15266 Operands.push_back(Ops[2 * NF + 1]);
15267 Operands.push_back(Ops[2 * NF + 2]);
15268 Operands.push_back(Ops[NF]);
15269 Operands.push_back(Ops[2 * NF + 3]);
15270 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
15271 }
15272 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
15273 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 15273, __extension__ __PRETTY_FUNCTION__));
15274 } else {
15275 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
15276 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
15277 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
15278 if (DefaultPolicy == TAIL_AGNOSTIC) {
15279 for (unsigned I = 0; I < NF; ++I)
15280 Operands.push_back(llvm::PoisonValue::get(ResultType));
15281 Operands.push_back(Ops[NF]);
15282 Operands.push_back(Ops[NF + 1]);
15283 Operands.push_back(Ops[NF + 2]);
15284 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
15285 } else {
15286 for (unsigned I = 0; I < NF; ++I)
15287 Operands.push_back(Ops[NF + I]);
15288 Operands.push_back(Ops[2 * NF]);
15289 Operands.push_back(Ops[2 * NF + 1]);
15290 Operands.push_back(Ops[2 * NF + 2]);
15291 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
15292 }
15293 }
15294 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
15295 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
15296 clang::CharUnits Align =
15297 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
15298 llvm::Value *V;
15299 for (unsigned I = 0; I < NF; ++I) {
15300 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
15301 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
15302 }
15303 return V;
15304 }
15305 break;
15306case RISCVVector::BI__builtin_rvv_vluxseg3ei8_v_tumu:
15307case RISCVVector::BI__builtin_rvv_vluxseg3ei16_v_tumu:
15308case RISCVVector::BI__builtin_rvv_vluxseg3ei32_v_tumu:
15309case RISCVVector::BI__builtin_rvv_vluxseg3ei64_v_tumu:
15310 ID = Intrinsic::riscv_vluxseg3_mask;
15311 NF = 3;
15312 DefaultPolicy = 0;
15313IsMasked = true;
15314
15315 {
15316 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
15317 SmallVector<llvm::Value*, 12> Operands;
15318 if (IsMasked) {
15319 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
15320 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
15321 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
15322 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
15323 for (unsigned I = 0; I < NF; ++I)
15324 Operands.push_back(llvm::PoisonValue::get(ResultType));
15325 Operands.push_back(Ops[NF + 1]);
15326 Operands.push_back(Ops[NF + 2]);
15327 Operands.push_back(Ops[NF]);
15328 Operands.push_back(Ops[NF + 3]);
15329 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
15330 } else {
15331 for (unsigned I = 0; I < NF; ++I)
15332 Operands.push_back(Ops[NF + I + 1]);
15333 Operands.push_back(Ops[2 * NF + 1]);
15334 Operands.push_back(Ops[2 * NF + 2]);
15335 Operands.push_back(Ops[NF]);
15336 Operands.push_back(Ops[2 * NF + 3]);
15337 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
15338 }
15339 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
15340 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 15340, __extension__ __PRETTY_FUNCTION__));
15341 } else {
15342 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
15343 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
15344 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
15345 if (DefaultPolicy == TAIL_AGNOSTIC) {
15346 for (unsigned I = 0; I < NF; ++I)
15347 Operands.push_back(llvm::PoisonValue::get(ResultType));
15348 Operands.push_back(Ops[NF]);
15349 Operands.push_back(Ops[NF + 1]);
15350 Operands.push_back(Ops[NF + 2]);
15351 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
15352 } else {
15353 for (unsigned I = 0; I < NF; ++I)
15354 Operands.push_back(Ops[NF + I]);
15355 Operands.push_back(Ops[2 * NF]);
15356 Operands.push_back(Ops[2 * NF + 1]);
15357 Operands.push_back(Ops[2 * NF + 2]);
15358 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
15359 }
15360 }
15361 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
15362 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
15363 clang::CharUnits Align =
15364 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
15365 llvm::Value *V;
15366 for (unsigned I = 0; I < NF; ++I) {
15367 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
15368 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
15369 }
15370 return V;
15371 }
15372 break;
15373case RISCVVector::BI__builtin_rvv_vluxseg3ei8_v_tamu:
15374case RISCVVector::BI__builtin_rvv_vluxseg3ei16_v_tamu:
15375case RISCVVector::BI__builtin_rvv_vluxseg3ei32_v_tamu:
15376case RISCVVector::BI__builtin_rvv_vluxseg3ei64_v_tamu:
15377 ID = Intrinsic::riscv_vluxseg3_mask;
15378 NF = 3;
15379 DefaultPolicy = 1;
15380IsMasked = true;
15381
15382 {
15383 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
15384 SmallVector<llvm::Value*, 12> Operands;
15385 if (IsMasked) {
15386 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
15387 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
15388 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
15389 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
15390 for (unsigned I = 0; I < NF; ++I)
15391 Operands.push_back(llvm::PoisonValue::get(ResultType));
15392 Operands.push_back(Ops[NF + 1]);
15393 Operands.push_back(Ops[NF + 2]);
15394 Operands.push_back(Ops[NF]);
15395 Operands.push_back(Ops[NF + 3]);
15396 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
15397 } else {
15398 for (unsigned I = 0; I < NF; ++I)
15399 Operands.push_back(Ops[NF + I + 1]);
15400 Operands.push_back(Ops[2 * NF + 1]);
15401 Operands.push_back(Ops[2 * NF + 2]);
15402 Operands.push_back(Ops[NF]);
15403 Operands.push_back(Ops[2 * NF + 3]);
15404 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
15405 }
15406 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
15407 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 15407, __extension__ __PRETTY_FUNCTION__));
15408 } else {
15409 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
15410 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
15411 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
15412 if (DefaultPolicy == TAIL_AGNOSTIC) {
15413 for (unsigned I = 0; I < NF; ++I)
15414 Operands.push_back(llvm::PoisonValue::get(ResultType));
15415 Operands.push_back(Ops[NF]);
15416 Operands.push_back(Ops[NF + 1]);
15417 Operands.push_back(Ops[NF + 2]);
15418 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
15419 } else {
15420 for (unsigned I = 0; I < NF; ++I)
15421 Operands.push_back(Ops[NF + I]);
15422 Operands.push_back(Ops[2 * NF]);
15423 Operands.push_back(Ops[2 * NF + 1]);
15424 Operands.push_back(Ops[2 * NF + 2]);
15425 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
15426 }
15427 }
15428 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
15429 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
15430 clang::CharUnits Align =
15431 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
15432 llvm::Value *V;
15433 for (unsigned I = 0; I < NF; ++I) {
15434 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
15435 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
15436 }
15437 return V;
15438 }
15439 break;
15440case RISCVVector::BI__builtin_rvv_vluxseg4ei8_v_tu:
15441case RISCVVector::BI__builtin_rvv_vluxseg4ei16_v_tu:
15442case RISCVVector::BI__builtin_rvv_vluxseg4ei32_v_tu:
15443case RISCVVector::BI__builtin_rvv_vluxseg4ei64_v_tu:
15444 ID = Intrinsic::riscv_vluxseg4;
15445 NF = 4;
15446 DefaultPolicy = 0;
15447IsMasked = false;
15448
15449 {
15450 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
15451 SmallVector<llvm::Value*, 12> Operands;
15452 if (IsMasked) {
15453 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
15454 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
15455 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
15456 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
15457 for (unsigned I = 0; I < NF; ++I)
15458 Operands.push_back(llvm::PoisonValue::get(ResultType));
15459 Operands.push_back(Ops[NF + 1]);
15460 Operands.push_back(Ops[NF + 2]);
15461 Operands.push_back(Ops[NF]);
15462 Operands.push_back(Ops[NF + 3]);
15463 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
15464 } else {
15465 for (unsigned I = 0; I < NF; ++I)
15466 Operands.push_back(Ops[NF + I + 1]);
15467 Operands.push_back(Ops[2 * NF + 1]);
15468 Operands.push_back(Ops[2 * NF + 2]);
15469 Operands.push_back(Ops[NF]);
15470 Operands.push_back(Ops[2 * NF + 3]);
15471 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
15472 }
15473 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
15474 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 15474, __extension__ __PRETTY_FUNCTION__));
15475 } else {
15476 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
15477 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
15478 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
15479 if (DefaultPolicy == TAIL_AGNOSTIC) {
15480 for (unsigned I = 0; I < NF; ++I)
15481 Operands.push_back(llvm::PoisonValue::get(ResultType));
15482 Operands.push_back(Ops[NF]);
15483 Operands.push_back(Ops[NF + 1]);
15484 Operands.push_back(Ops[NF + 2]);
15485 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
15486 } else {
15487 for (unsigned I = 0; I < NF; ++I)
15488 Operands.push_back(Ops[NF + I]);
15489 Operands.push_back(Ops[2 * NF]);
15490 Operands.push_back(Ops[2 * NF + 1]);
15491 Operands.push_back(Ops[2 * NF + 2]);
15492 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
15493 }
15494 }
15495 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
15496 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
15497 clang::CharUnits Align =
15498 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
15499 llvm::Value *V;
15500 for (unsigned I = 0; I < NF; ++I) {
15501 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
15502 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
15503 }
15504 return V;
15505 }
15506 break;
15507case RISCVVector::BI__builtin_rvv_vluxseg4ei8_v_ta:
15508case RISCVVector::BI__builtin_rvv_vluxseg4ei16_v_ta:
15509case RISCVVector::BI__builtin_rvv_vluxseg4ei32_v_ta:
15510case RISCVVector::BI__builtin_rvv_vluxseg4ei64_v_ta:
15511 ID = Intrinsic::riscv_vluxseg4;
15512 NF = 4;
15513 DefaultPolicy = 1;
15514IsMasked = false;
15515
15516 {
15517 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
15518 SmallVector<llvm::Value*, 12> Operands;
15519 if (IsMasked) {
15520 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
15521 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
15522 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
15523 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
15524 for (unsigned I = 0; I < NF; ++I)
15525 Operands.push_back(llvm::PoisonValue::get(ResultType));
15526 Operands.push_back(Ops[NF + 1]);
15527 Operands.push_back(Ops[NF + 2]);
15528 Operands.push_back(Ops[NF]);
15529 Operands.push_back(Ops[NF + 3]);
15530 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
15531 } else {
15532 for (unsigned I = 0; I < NF; ++I)
15533 Operands.push_back(Ops[NF + I + 1]);
15534 Operands.push_back(Ops[2 * NF + 1]);
15535 Operands.push_back(Ops[2 * NF + 2]);
15536 Operands.push_back(Ops[NF]);
15537 Operands.push_back(Ops[2 * NF + 3]);
15538 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
15539 }
15540 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
15541 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 15541, __extension__ __PRETTY_FUNCTION__));
15542 } else {
15543 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
15544 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
15545 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
15546 if (DefaultPolicy == TAIL_AGNOSTIC) {
15547 for (unsigned I = 0; I < NF; ++I)
15548 Operands.push_back(llvm::PoisonValue::get(ResultType));
15549 Operands.push_back(Ops[NF]);
15550 Operands.push_back(Ops[NF + 1]);
15551 Operands.push_back(Ops[NF + 2]);
15552 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
15553 } else {
15554 for (unsigned I = 0; I < NF; ++I)
15555 Operands.push_back(Ops[NF + I]);
15556 Operands.push_back(Ops[2 * NF]);
15557 Operands.push_back(Ops[2 * NF + 1]);
15558 Operands.push_back(Ops[2 * NF + 2]);
15559 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
15560 }
15561 }
15562 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
15563 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
15564 clang::CharUnits Align =
15565 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
15566 llvm::Value *V;
15567 for (unsigned I = 0; I < NF; ++I) {
15568 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
15569 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
15570 }
15571 return V;
15572 }
15573 break;
15574case RISCVVector::BI__builtin_rvv_vluxseg4ei8_v_tuma:
15575case RISCVVector::BI__builtin_rvv_vluxseg4ei16_v_tuma:
15576case RISCVVector::BI__builtin_rvv_vluxseg4ei32_v_tuma:
15577case RISCVVector::BI__builtin_rvv_vluxseg4ei64_v_tuma:
15578 ID = Intrinsic::riscv_vluxseg4_mask;
15579 NF = 4;
15580 DefaultPolicy = 2;
15581IsMasked = true;
15582
15583 {
15584 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
15585 SmallVector<llvm::Value*, 12> Operands;
15586 if (IsMasked) {
15587 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
15588 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
15589 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
15590 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
15591 for (unsigned I = 0; I < NF; ++I)
15592 Operands.push_back(llvm::PoisonValue::get(ResultType));
15593 Operands.push_back(Ops[NF + 1]);
15594 Operands.push_back(Ops[NF + 2]);
15595 Operands.push_back(Ops[NF]);
15596 Operands.push_back(Ops[NF + 3]);
15597 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
15598 } else {
15599 for (unsigned I = 0; I < NF; ++I)
15600 Operands.push_back(Ops[NF + I + 1]);
15601 Operands.push_back(Ops[2 * NF + 1]);
15602 Operands.push_back(Ops[2 * NF + 2]);
15603 Operands.push_back(Ops[NF]);
15604 Operands.push_back(Ops[2 * NF + 3]);
15605 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
15606 }
15607 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
15608 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 15608, __extension__ __PRETTY_FUNCTION__));
15609 } else {
15610 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
15611 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
15612 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
15613 if (DefaultPolicy == TAIL_AGNOSTIC) {
15614 for (unsigned I = 0; I < NF; ++I)
15615 Operands.push_back(llvm::PoisonValue::get(ResultType));
15616 Operands.push_back(Ops[NF]);
15617 Operands.push_back(Ops[NF + 1]);
15618 Operands.push_back(Ops[NF + 2]);
15619 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
15620 } else {
15621 for (unsigned I = 0; I < NF; ++I)
15622 Operands.push_back(Ops[NF + I]);
15623 Operands.push_back(Ops[2 * NF]);
15624 Operands.push_back(Ops[2 * NF + 1]);
15625 Operands.push_back(Ops[2 * NF + 2]);
15626 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
15627 }
15628 }
15629 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
15630 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
15631 clang::CharUnits Align =
15632 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
15633 llvm::Value *V;
15634 for (unsigned I = 0; I < NF; ++I) {
15635 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
15636 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
15637 }
15638 return V;
15639 }
15640 break;
15641case RISCVVector::BI__builtin_rvv_vluxseg4ei8_v_tama:
15642case RISCVVector::BI__builtin_rvv_vluxseg4ei16_v_tama:
15643case RISCVVector::BI__builtin_rvv_vluxseg4ei32_v_tama:
15644case RISCVVector::BI__builtin_rvv_vluxseg4ei64_v_tama:
15645 ID = Intrinsic::riscv_vluxseg4_mask;
15646 NF = 4;
15647 DefaultPolicy = 3;
15648IsMasked = true;
15649
15650 {
15651 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
15652 SmallVector<llvm::Value*, 12> Operands;
15653 if (IsMasked) {
15654 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
15655 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
15656 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
15657 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
15658 for (unsigned I = 0; I < NF; ++I)
15659 Operands.push_back(llvm::PoisonValue::get(ResultType));
15660 Operands.push_back(Ops[NF + 1]);
15661 Operands.push_back(Ops[NF + 2]);
15662 Operands.push_back(Ops[NF]);
15663 Operands.push_back(Ops[NF + 3]);
15664 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
15665 } else {
15666 for (unsigned I = 0; I < NF; ++I)
15667 Operands.push_back(Ops[NF + I + 1]);
15668 Operands.push_back(Ops[2 * NF + 1]);
15669 Operands.push_back(Ops[2 * NF + 2]);
15670 Operands.push_back(Ops[NF]);
15671 Operands.push_back(Ops[2 * NF + 3]);
15672 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
15673 }
15674 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
15675 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 15675, __extension__ __PRETTY_FUNCTION__));
15676 } else {
15677 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
15678 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
15679 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
15680 if (DefaultPolicy == TAIL_AGNOSTIC) {
15681 for (unsigned I = 0; I < NF; ++I)
15682 Operands.push_back(llvm::PoisonValue::get(ResultType));
15683 Operands.push_back(Ops[NF]);
15684 Operands.push_back(Ops[NF + 1]);
15685 Operands.push_back(Ops[NF + 2]);
15686 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
15687 } else {
15688 for (unsigned I = 0; I < NF; ++I)
15689 Operands.push_back(Ops[NF + I]);
15690 Operands.push_back(Ops[2 * NF]);
15691 Operands.push_back(Ops[2 * NF + 1]);
15692 Operands.push_back(Ops[2 * NF + 2]);
15693 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
15694 }
15695 }
15696 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
15697 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
15698 clang::CharUnits Align =
15699 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
15700 llvm::Value *V;
15701 for (unsigned I = 0; I < NF; ++I) {
15702 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
15703 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
15704 }
15705 return V;
15706 }
15707 break;
15708case RISCVVector::BI__builtin_rvv_vluxseg4ei8_v_tumu:
15709case RISCVVector::BI__builtin_rvv_vluxseg4ei16_v_tumu:
15710case RISCVVector::BI__builtin_rvv_vluxseg4ei32_v_tumu:
15711case RISCVVector::BI__builtin_rvv_vluxseg4ei64_v_tumu:
15712 ID = Intrinsic::riscv_vluxseg4_mask;
15713 NF = 4;
15714 DefaultPolicy = 0;
15715IsMasked = true;
15716
15717 {
15718 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
15719 SmallVector<llvm::Value*, 12> Operands;
15720 if (IsMasked) {
15721 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
15722 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
15723 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
15724 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
15725 for (unsigned I = 0; I < NF; ++I)
15726 Operands.push_back(llvm::PoisonValue::get(ResultType));
15727 Operands.push_back(Ops[NF + 1]);
15728 Operands.push_back(Ops[NF + 2]);
15729 Operands.push_back(Ops[NF]);
15730 Operands.push_back(Ops[NF + 3]);
15731 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
15732 } else {
15733 for (unsigned I = 0; I < NF; ++I)
15734 Operands.push_back(Ops[NF + I + 1]);
15735 Operands.push_back(Ops[2 * NF + 1]);
15736 Operands.push_back(Ops[2 * NF + 2]);
15737 Operands.push_back(Ops[NF]);
15738 Operands.push_back(Ops[2 * NF + 3]);
15739 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
15740 }
15741 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
15742 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 15742, __extension__ __PRETTY_FUNCTION__));
15743 } else {
15744 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
15745 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
15746 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
15747 if (DefaultPolicy == TAIL_AGNOSTIC) {
15748 for (unsigned I = 0; I < NF; ++I)
15749 Operands.push_back(llvm::PoisonValue::get(ResultType));
15750 Operands.push_back(Ops[NF]);
15751 Operands.push_back(Ops[NF + 1]);
15752 Operands.push_back(Ops[NF + 2]);
15753 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
15754 } else {
15755 for (unsigned I = 0; I < NF; ++I)
15756 Operands.push_back(Ops[NF + I]);
15757 Operands.push_back(Ops[2 * NF]);
15758 Operands.push_back(Ops[2 * NF + 1]);
15759 Operands.push_back(Ops[2 * NF + 2]);
15760 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
15761 }
15762 }
15763 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
15764 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
15765 clang::CharUnits Align =
15766 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
15767 llvm::Value *V;
15768 for (unsigned I = 0; I < NF; ++I) {
15769 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
15770 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
15771 }
15772 return V;
15773 }
15774 break;
15775case RISCVVector::BI__builtin_rvv_vluxseg4ei8_v_tamu:
15776case RISCVVector::BI__builtin_rvv_vluxseg4ei16_v_tamu:
15777case RISCVVector::BI__builtin_rvv_vluxseg4ei32_v_tamu:
15778case RISCVVector::BI__builtin_rvv_vluxseg4ei64_v_tamu:
15779 ID = Intrinsic::riscv_vluxseg4_mask;
15780 NF = 4;
15781 DefaultPolicy = 1;
15782IsMasked = true;
15783
15784 {
15785 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
15786 SmallVector<llvm::Value*, 12> Operands;
15787 if (IsMasked) {
15788 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
15789 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
15790 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
15791 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
15792 for (unsigned I = 0; I < NF; ++I)
15793 Operands.push_back(llvm::PoisonValue::get(ResultType));
15794 Operands.push_back(Ops[NF + 1]);
15795 Operands.push_back(Ops[NF + 2]);
15796 Operands.push_back(Ops[NF]);
15797 Operands.push_back(Ops[NF + 3]);
15798 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
15799 } else {
15800 for (unsigned I = 0; I < NF; ++I)
15801 Operands.push_back(Ops[NF + I + 1]);
15802 Operands.push_back(Ops[2 * NF + 1]);
15803 Operands.push_back(Ops[2 * NF + 2]);
15804 Operands.push_back(Ops[NF]);
15805 Operands.push_back(Ops[2 * NF + 3]);
15806 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
15807 }
15808 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
15809 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 15809, __extension__ __PRETTY_FUNCTION__));
15810 } else {
15811 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
15812 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
15813 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
15814 if (DefaultPolicy == TAIL_AGNOSTIC) {
15815 for (unsigned I = 0; I < NF; ++I)
15816 Operands.push_back(llvm::PoisonValue::get(ResultType));
15817 Operands.push_back(Ops[NF]);
15818 Operands.push_back(Ops[NF + 1]);
15819 Operands.push_back(Ops[NF + 2]);
15820 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
15821 } else {
15822 for (unsigned I = 0; I < NF; ++I)
15823 Operands.push_back(Ops[NF + I]);
15824 Operands.push_back(Ops[2 * NF]);
15825 Operands.push_back(Ops[2 * NF + 1]);
15826 Operands.push_back(Ops[2 * NF + 2]);
15827 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
15828 }
15829 }
15830 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
15831 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
15832 clang::CharUnits Align =
15833 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
15834 llvm::Value *V;
15835 for (unsigned I = 0; I < NF; ++I) {
15836 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
15837 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
15838 }
15839 return V;
15840 }
15841 break;
15842case RISCVVector::BI__builtin_rvv_vluxseg5ei8_v_tu:
15843case RISCVVector::BI__builtin_rvv_vluxseg5ei16_v_tu:
15844case RISCVVector::BI__builtin_rvv_vluxseg5ei32_v_tu:
15845case RISCVVector::BI__builtin_rvv_vluxseg5ei64_v_tu:
15846 ID = Intrinsic::riscv_vluxseg5;
15847 NF = 5;
15848 DefaultPolicy = 0;
15849IsMasked = false;
15850
15851 {
15852 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
15853 SmallVector<llvm::Value*, 12> Operands;
15854 if (IsMasked) {
15855 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
15856 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
15857 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
15858 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
15859 for (unsigned I = 0; I < NF; ++I)
15860 Operands.push_back(llvm::PoisonValue::get(ResultType));
15861 Operands.push_back(Ops[NF + 1]);
15862 Operands.push_back(Ops[NF + 2]);
15863 Operands.push_back(Ops[NF]);
15864 Operands.push_back(Ops[NF + 3]);
15865 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
15866 } else {
15867 for (unsigned I = 0; I < NF; ++I)
15868 Operands.push_back(Ops[NF + I + 1]);
15869 Operands.push_back(Ops[2 * NF + 1]);
15870 Operands.push_back(Ops[2 * NF + 2]);
15871 Operands.push_back(Ops[NF]);
15872 Operands.push_back(Ops[2 * NF + 3]);
15873 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
15874 }
15875 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
15876 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 15876, __extension__ __PRETTY_FUNCTION__));
15877 } else {
15878 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
15879 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
15880 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
15881 if (DefaultPolicy == TAIL_AGNOSTIC) {
15882 for (unsigned I = 0; I < NF; ++I)
15883 Operands.push_back(llvm::PoisonValue::get(ResultType));
15884 Operands.push_back(Ops[NF]);
15885 Operands.push_back(Ops[NF + 1]);
15886 Operands.push_back(Ops[NF + 2]);
15887 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
15888 } else {
15889 for (unsigned I = 0; I < NF; ++I)
15890 Operands.push_back(Ops[NF + I]);
15891 Operands.push_back(Ops[2 * NF]);
15892 Operands.push_back(Ops[2 * NF + 1]);
15893 Operands.push_back(Ops[2 * NF + 2]);
15894 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
15895 }
15896 }
15897 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
15898 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
15899 clang::CharUnits Align =
15900 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
15901 llvm::Value *V;
15902 for (unsigned I = 0; I < NF; ++I) {
15903 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
15904 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
15905 }
15906 return V;
15907 }
15908 break;
15909case RISCVVector::BI__builtin_rvv_vluxseg5ei8_v_ta:
15910case RISCVVector::BI__builtin_rvv_vluxseg5ei16_v_ta:
15911case RISCVVector::BI__builtin_rvv_vluxseg5ei32_v_ta:
15912case RISCVVector::BI__builtin_rvv_vluxseg5ei64_v_ta:
15913 ID = Intrinsic::riscv_vluxseg5;
15914 NF = 5;
15915 DefaultPolicy = 1;
15916IsMasked = false;
15917
15918 {
15919 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
15920 SmallVector<llvm::Value*, 12> Operands;
15921 if (IsMasked) {
15922 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
15923 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
15924 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
15925 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
15926 for (unsigned I = 0; I < NF; ++I)
15927 Operands.push_back(llvm::PoisonValue::get(ResultType));
15928 Operands.push_back(Ops[NF + 1]);
15929 Operands.push_back(Ops[NF + 2]);
15930 Operands.push_back(Ops[NF]);
15931 Operands.push_back(Ops[NF + 3]);
15932 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
15933 } else {
15934 for (unsigned I = 0; I < NF; ++I)
15935 Operands.push_back(Ops[NF + I + 1]);
15936 Operands.push_back(Ops[2 * NF + 1]);
15937 Operands.push_back(Ops[2 * NF + 2]);
15938 Operands.push_back(Ops[NF]);
15939 Operands.push_back(Ops[2 * NF + 3]);
15940 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
15941 }
15942 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
15943 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 15943, __extension__ __PRETTY_FUNCTION__));
15944 } else {
15945 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
15946 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
15947 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
15948 if (DefaultPolicy == TAIL_AGNOSTIC) {
15949 for (unsigned I = 0; I < NF; ++I)
15950 Operands.push_back(llvm::PoisonValue::get(ResultType));
15951 Operands.push_back(Ops[NF]);
15952 Operands.push_back(Ops[NF + 1]);
15953 Operands.push_back(Ops[NF + 2]);
15954 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
15955 } else {
15956 for (unsigned I = 0; I < NF; ++I)
15957 Operands.push_back(Ops[NF + I]);
15958 Operands.push_back(Ops[2 * NF]);
15959 Operands.push_back(Ops[2 * NF + 1]);
15960 Operands.push_back(Ops[2 * NF + 2]);
15961 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
15962 }
15963 }
15964 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
15965 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
15966 clang::CharUnits Align =
15967 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
15968 llvm::Value *V;
15969 for (unsigned I = 0; I < NF; ++I) {
15970 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
15971 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
15972 }
15973 return V;
15974 }
15975 break;
15976case RISCVVector::BI__builtin_rvv_vluxseg5ei8_v_tuma:
15977case RISCVVector::BI__builtin_rvv_vluxseg5ei16_v_tuma:
15978case RISCVVector::BI__builtin_rvv_vluxseg5ei32_v_tuma:
15979case RISCVVector::BI__builtin_rvv_vluxseg5ei64_v_tuma:
15980 ID = Intrinsic::riscv_vluxseg5_mask;
15981 NF = 5;
15982 DefaultPolicy = 2;
15983IsMasked = true;
15984
15985 {
15986 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
15987 SmallVector<llvm::Value*, 12> Operands;
15988 if (IsMasked) {
15989 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
15990 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
15991 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
15992 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
15993 for (unsigned I = 0; I < NF; ++I)
15994 Operands.push_back(llvm::PoisonValue::get(ResultType));
15995 Operands.push_back(Ops[NF + 1]);
15996 Operands.push_back(Ops[NF + 2]);
15997 Operands.push_back(Ops[NF]);
15998 Operands.push_back(Ops[NF + 3]);
15999 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
16000 } else {
16001 for (unsigned I = 0; I < NF; ++I)
16002 Operands.push_back(Ops[NF + I + 1]);
16003 Operands.push_back(Ops[2 * NF + 1]);
16004 Operands.push_back(Ops[2 * NF + 2]);
16005 Operands.push_back(Ops[NF]);
16006 Operands.push_back(Ops[2 * NF + 3]);
16007 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
16008 }
16009 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
16010 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 16010, __extension__ __PRETTY_FUNCTION__));
16011 } else {
16012 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
16013 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
16014 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
16015 if (DefaultPolicy == TAIL_AGNOSTIC) {
16016 for (unsigned I = 0; I < NF; ++I)
16017 Operands.push_back(llvm::PoisonValue::get(ResultType));
16018 Operands.push_back(Ops[NF]);
16019 Operands.push_back(Ops[NF + 1]);
16020 Operands.push_back(Ops[NF + 2]);
16021 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
16022 } else {
16023 for (unsigned I = 0; I < NF; ++I)
16024 Operands.push_back(Ops[NF + I]);
16025 Operands.push_back(Ops[2 * NF]);
16026 Operands.push_back(Ops[2 * NF + 1]);
16027 Operands.push_back(Ops[2 * NF + 2]);
16028 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
16029 }
16030 }
16031 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
16032 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
16033 clang::CharUnits Align =
16034 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
16035 llvm::Value *V;
16036 for (unsigned I = 0; I < NF; ++I) {
16037 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
16038 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
16039 }
16040 return V;
16041 }
16042 break;
16043case RISCVVector::BI__builtin_rvv_vluxseg5ei8_v_tama:
16044case RISCVVector::BI__builtin_rvv_vluxseg5ei16_v_tama:
16045case RISCVVector::BI__builtin_rvv_vluxseg5ei32_v_tama:
16046case RISCVVector::BI__builtin_rvv_vluxseg5ei64_v_tama:
16047 ID = Intrinsic::riscv_vluxseg5_mask;
16048 NF = 5;
16049 DefaultPolicy = 3;
16050IsMasked = true;
16051
16052 {
16053 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
16054 SmallVector<llvm::Value*, 12> Operands;
16055 if (IsMasked) {
16056 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
16057 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
16058 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
16059 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
16060 for (unsigned I = 0; I < NF; ++I)
16061 Operands.push_back(llvm::PoisonValue::get(ResultType));
16062 Operands.push_back(Ops[NF + 1]);
16063 Operands.push_back(Ops[NF + 2]);
16064 Operands.push_back(Ops[NF]);
16065 Operands.push_back(Ops[NF + 3]);
16066 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
16067 } else {
16068 for (unsigned I = 0; I < NF; ++I)
16069 Operands.push_back(Ops[NF + I + 1]);
16070 Operands.push_back(Ops[2 * NF + 1]);
16071 Operands.push_back(Ops[2 * NF + 2]);
16072 Operands.push_back(Ops[NF]);
16073 Operands.push_back(Ops[2 * NF + 3]);
16074 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
16075 }
16076 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
16077 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 16077, __extension__ __PRETTY_FUNCTION__));
16078 } else {
16079 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
16080 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
16081 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
16082 if (DefaultPolicy == TAIL_AGNOSTIC) {
16083 for (unsigned I = 0; I < NF; ++I)
16084 Operands.push_back(llvm::PoisonValue::get(ResultType));
16085 Operands.push_back(Ops[NF]);
16086 Operands.push_back(Ops[NF + 1]);
16087 Operands.push_back(Ops[NF + 2]);
16088 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
16089 } else {
16090 for (unsigned I = 0; I < NF; ++I)
16091 Operands.push_back(Ops[NF + I]);
16092 Operands.push_back(Ops[2 * NF]);
16093 Operands.push_back(Ops[2 * NF + 1]);
16094 Operands.push_back(Ops[2 * NF + 2]);
16095 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
16096 }
16097 }
16098 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
16099 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
16100 clang::CharUnits Align =
16101 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
16102 llvm::Value *V;
16103 for (unsigned I = 0; I < NF; ++I) {
16104 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
16105 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
16106 }
16107 return V;
16108 }
16109 break;
16110case RISCVVector::BI__builtin_rvv_vluxseg5ei8_v_tumu:
16111case RISCVVector::BI__builtin_rvv_vluxseg5ei16_v_tumu:
16112case RISCVVector::BI__builtin_rvv_vluxseg5ei32_v_tumu:
16113case RISCVVector::BI__builtin_rvv_vluxseg5ei64_v_tumu:
16114 ID = Intrinsic::riscv_vluxseg5_mask;
16115 NF = 5;
16116 DefaultPolicy = 0;
16117IsMasked = true;
16118
16119 {
16120 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
16121 SmallVector<llvm::Value*, 12> Operands;
16122 if (IsMasked) {
16123 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
16124 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
16125 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
16126 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
16127 for (unsigned I = 0; I < NF; ++I)
16128 Operands.push_back(llvm::PoisonValue::get(ResultType));
16129 Operands.push_back(Ops[NF + 1]);
16130 Operands.push_back(Ops[NF + 2]);
16131 Operands.push_back(Ops[NF]);
16132 Operands.push_back(Ops[NF + 3]);
16133 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
16134 } else {
16135 for (unsigned I = 0; I < NF; ++I)
16136 Operands.push_back(Ops[NF + I + 1]);
16137 Operands.push_back(Ops[2 * NF + 1]);
16138 Operands.push_back(Ops[2 * NF + 2]);
16139 Operands.push_back(Ops[NF]);
16140 Operands.push_back(Ops[2 * NF + 3]);
16141 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
16142 }
16143 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
16144 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 16144, __extension__ __PRETTY_FUNCTION__));
16145 } else {
16146 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
16147 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
16148 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
16149 if (DefaultPolicy == TAIL_AGNOSTIC) {
16150 for (unsigned I = 0; I < NF; ++I)
16151 Operands.push_back(llvm::PoisonValue::get(ResultType));
16152 Operands.push_back(Ops[NF]);
16153 Operands.push_back(Ops[NF + 1]);
16154 Operands.push_back(Ops[NF + 2]);
16155 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
16156 } else {
16157 for (unsigned I = 0; I < NF; ++I)
16158 Operands.push_back(Ops[NF + I]);
16159 Operands.push_back(Ops[2 * NF]);
16160 Operands.push_back(Ops[2 * NF + 1]);
16161 Operands.push_back(Ops[2 * NF + 2]);
16162 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
16163 }
16164 }
16165 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
16166 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
16167 clang::CharUnits Align =
16168 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
16169 llvm::Value *V;
16170 for (unsigned I = 0; I < NF; ++I) {
16171 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
16172 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
16173 }
16174 return V;
16175 }
16176 break;
16177case RISCVVector::BI__builtin_rvv_vluxseg5ei8_v_tamu:
16178case RISCVVector::BI__builtin_rvv_vluxseg5ei16_v_tamu:
16179case RISCVVector::BI__builtin_rvv_vluxseg5ei32_v_tamu:
16180case RISCVVector::BI__builtin_rvv_vluxseg5ei64_v_tamu:
16181 ID = Intrinsic::riscv_vluxseg5_mask;
16182 NF = 5;
16183 DefaultPolicy = 1;
16184IsMasked = true;
16185
16186 {
16187 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
16188 SmallVector<llvm::Value*, 12> Operands;
16189 if (IsMasked) {
16190 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
16191 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
16192 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
16193 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
16194 for (unsigned I = 0; I < NF; ++I)
16195 Operands.push_back(llvm::PoisonValue::get(ResultType));
16196 Operands.push_back(Ops[NF + 1]);
16197 Operands.push_back(Ops[NF + 2]);
16198 Operands.push_back(Ops[NF]);
16199 Operands.push_back(Ops[NF + 3]);
16200 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
16201 } else {
16202 for (unsigned I = 0; I < NF; ++I)
16203 Operands.push_back(Ops[NF + I + 1]);
16204 Operands.push_back(Ops[2 * NF + 1]);
16205 Operands.push_back(Ops[2 * NF + 2]);
16206 Operands.push_back(Ops[NF]);
16207 Operands.push_back(Ops[2 * NF + 3]);
16208 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
16209 }
16210 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
16211 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 16211, __extension__ __PRETTY_FUNCTION__));
16212 } else {
16213 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
16214 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
16215 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
16216 if (DefaultPolicy == TAIL_AGNOSTIC) {
16217 for (unsigned I = 0; I < NF; ++I)
16218 Operands.push_back(llvm::PoisonValue::get(ResultType));
16219 Operands.push_back(Ops[NF]);
16220 Operands.push_back(Ops[NF + 1]);
16221 Operands.push_back(Ops[NF + 2]);
16222 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
16223 } else {
16224 for (unsigned I = 0; I < NF; ++I)
16225 Operands.push_back(Ops[NF + I]);
16226 Operands.push_back(Ops[2 * NF]);
16227 Operands.push_back(Ops[2 * NF + 1]);
16228 Operands.push_back(Ops[2 * NF + 2]);
16229 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
16230 }
16231 }
16232 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
16233 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
16234 clang::CharUnits Align =
16235 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
16236 llvm::Value *V;
16237 for (unsigned I = 0; I < NF; ++I) {
16238 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
16239 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
16240 }
16241 return V;
16242 }
16243 break;
16244case RISCVVector::BI__builtin_rvv_vluxseg6ei8_v_tu:
16245case RISCVVector::BI__builtin_rvv_vluxseg6ei16_v_tu:
16246case RISCVVector::BI__builtin_rvv_vluxseg6ei32_v_tu:
16247case RISCVVector::BI__builtin_rvv_vluxseg6ei64_v_tu:
16248 ID = Intrinsic::riscv_vluxseg6;
16249 NF = 6;
16250 DefaultPolicy = 0;
16251IsMasked = false;
16252
16253 {
16254 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
16255 SmallVector<llvm::Value*, 12> Operands;
16256 if (IsMasked) {
16257 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
16258 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
16259 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
16260 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
16261 for (unsigned I = 0; I < NF; ++I)
16262 Operands.push_back(llvm::PoisonValue::get(ResultType));
16263 Operands.push_back(Ops[NF + 1]);
16264 Operands.push_back(Ops[NF + 2]);
16265 Operands.push_back(Ops[NF]);
16266 Operands.push_back(Ops[NF + 3]);
16267 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
16268 } else {
16269 for (unsigned I = 0; I < NF; ++I)
16270 Operands.push_back(Ops[NF + I + 1]);
16271 Operands.push_back(Ops[2 * NF + 1]);
16272 Operands.push_back(Ops[2 * NF + 2]);
16273 Operands.push_back(Ops[NF]);
16274 Operands.push_back(Ops[2 * NF + 3]);
16275 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
16276 }
16277 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
16278 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 16278, __extension__ __PRETTY_FUNCTION__));
16279 } else {
16280 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
16281 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
16282 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
16283 if (DefaultPolicy == TAIL_AGNOSTIC) {
16284 for (unsigned I = 0; I < NF; ++I)
16285 Operands.push_back(llvm::PoisonValue::get(ResultType));
16286 Operands.push_back(Ops[NF]);
16287 Operands.push_back(Ops[NF + 1]);
16288 Operands.push_back(Ops[NF + 2]);
16289 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
16290 } else {
16291 for (unsigned I = 0; I < NF; ++I)
16292 Operands.push_back(Ops[NF + I]);
16293 Operands.push_back(Ops[2 * NF]);
16294 Operands.push_back(Ops[2 * NF + 1]);
16295 Operands.push_back(Ops[2 * NF + 2]);
16296 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
16297 }
16298 }
16299 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
16300 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
16301 clang::CharUnits Align =
16302 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
16303 llvm::Value *V;
16304 for (unsigned I = 0; I < NF; ++I) {
16305 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
16306 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
16307 }
16308 return V;
16309 }
16310 break;
16311case RISCVVector::BI__builtin_rvv_vluxseg6ei8_v_ta:
16312case RISCVVector::BI__builtin_rvv_vluxseg6ei16_v_ta:
16313case RISCVVector::BI__builtin_rvv_vluxseg6ei32_v_ta:
16314case RISCVVector::BI__builtin_rvv_vluxseg6ei64_v_ta:
16315 ID = Intrinsic::riscv_vluxseg6;
16316 NF = 6;
16317 DefaultPolicy = 1;
16318IsMasked = false;
16319
16320 {
16321 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
16322 SmallVector<llvm::Value*, 12> Operands;
16323 if (IsMasked) {
16324 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
16325 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
16326 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
16327 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
16328 for (unsigned I = 0; I < NF; ++I)
16329 Operands.push_back(llvm::PoisonValue::get(ResultType));
16330 Operands.push_back(Ops[NF + 1]);
16331 Operands.push_back(Ops[NF + 2]);
16332 Operands.push_back(Ops[NF]);
16333 Operands.push_back(Ops[NF + 3]);
16334 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
16335 } else {
16336 for (unsigned I = 0; I < NF; ++I)
16337 Operands.push_back(Ops[NF + I + 1]);
16338 Operands.push_back(Ops[2 * NF + 1]);
16339 Operands.push_back(Ops[2 * NF + 2]);
16340 Operands.push_back(Ops[NF]);
16341 Operands.push_back(Ops[2 * NF + 3]);
16342 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
16343 }
16344 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
16345 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 16345, __extension__ __PRETTY_FUNCTION__));
16346 } else {
16347 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
16348 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
16349 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
16350 if (DefaultPolicy == TAIL_AGNOSTIC) {
16351 for (unsigned I = 0; I < NF; ++I)
16352 Operands.push_back(llvm::PoisonValue::get(ResultType));
16353 Operands.push_back(Ops[NF]);
16354 Operands.push_back(Ops[NF + 1]);
16355 Operands.push_back(Ops[NF + 2]);
16356 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
16357 } else {
16358 for (unsigned I = 0; I < NF; ++I)
16359 Operands.push_back(Ops[NF + I]);
16360 Operands.push_back(Ops[2 * NF]);
16361 Operands.push_back(Ops[2 * NF + 1]);
16362 Operands.push_back(Ops[2 * NF + 2]);
16363 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
16364 }
16365 }
16366 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
16367 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
16368 clang::CharUnits Align =
16369 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
16370 llvm::Value *V;
16371 for (unsigned I = 0; I < NF; ++I) {
16372 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
16373 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
16374 }
16375 return V;
16376 }
16377 break;
16378case RISCVVector::BI__builtin_rvv_vluxseg6ei8_v_tuma:
16379case RISCVVector::BI__builtin_rvv_vluxseg6ei16_v_tuma:
16380case RISCVVector::BI__builtin_rvv_vluxseg6ei32_v_tuma:
16381case RISCVVector::BI__builtin_rvv_vluxseg6ei64_v_tuma:
16382 ID = Intrinsic::riscv_vluxseg6_mask;
16383 NF = 6;
16384 DefaultPolicy = 2;
16385IsMasked = true;
16386
16387 {
16388 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
16389 SmallVector<llvm::Value*, 12> Operands;
16390 if (IsMasked) {
16391 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
16392 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
16393 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
16394 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
16395 for (unsigned I = 0; I < NF; ++I)
16396 Operands.push_back(llvm::PoisonValue::get(ResultType));
16397 Operands.push_back(Ops[NF + 1]);
16398 Operands.push_back(Ops[NF + 2]);
16399 Operands.push_back(Ops[NF]);
16400 Operands.push_back(Ops[NF + 3]);
16401 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
16402 } else {
16403 for (unsigned I = 0; I < NF; ++I)
16404 Operands.push_back(Ops[NF + I + 1]);
16405 Operands.push_back(Ops[2 * NF + 1]);
16406 Operands.push_back(Ops[2 * NF + 2]);
16407 Operands.push_back(Ops[NF]);
16408 Operands.push_back(Ops[2 * NF + 3]);
16409 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
16410 }
16411 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
16412 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 16412, __extension__ __PRETTY_FUNCTION__));
16413 } else {
16414 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
16415 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
16416 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
16417 if (DefaultPolicy == TAIL_AGNOSTIC) {
16418 for (unsigned I = 0; I < NF; ++I)
16419 Operands.push_back(llvm::PoisonValue::get(ResultType));
16420 Operands.push_back(Ops[NF]);
16421 Operands.push_back(Ops[NF + 1]);
16422 Operands.push_back(Ops[NF + 2]);
16423 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
16424 } else {
16425 for (unsigned I = 0; I < NF; ++I)
16426 Operands.push_back(Ops[NF + I]);
16427 Operands.push_back(Ops[2 * NF]);
16428 Operands.push_back(Ops[2 * NF + 1]);
16429 Operands.push_back(Ops[2 * NF + 2]);
16430 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
16431 }
16432 }
16433 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
16434 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
16435 clang::CharUnits Align =
16436 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
16437 llvm::Value *V;
16438 for (unsigned I = 0; I < NF; ++I) {
16439 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
16440 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
16441 }
16442 return V;
16443 }
16444 break;
16445case RISCVVector::BI__builtin_rvv_vluxseg6ei8_v_tama:
16446case RISCVVector::BI__builtin_rvv_vluxseg6ei16_v_tama:
16447case RISCVVector::BI__builtin_rvv_vluxseg6ei32_v_tama:
16448case RISCVVector::BI__builtin_rvv_vluxseg6ei64_v_tama:
16449 ID = Intrinsic::riscv_vluxseg6_mask;
16450 NF = 6;
16451 DefaultPolicy = 3;
16452IsMasked = true;
16453
16454 {
16455 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
16456 SmallVector<llvm::Value*, 12> Operands;
16457 if (IsMasked) {
16458 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
16459 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
16460 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
16461 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
16462 for (unsigned I = 0; I < NF; ++I)
16463 Operands.push_back(llvm::PoisonValue::get(ResultType));
16464 Operands.push_back(Ops[NF + 1]);
16465 Operands.push_back(Ops[NF + 2]);
16466 Operands.push_back(Ops[NF]);
16467 Operands.push_back(Ops[NF + 3]);
16468 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
16469 } else {
16470 for (unsigned I = 0; I < NF; ++I)
16471 Operands.push_back(Ops[NF + I + 1]);
16472 Operands.push_back(Ops[2 * NF + 1]);
16473 Operands.push_back(Ops[2 * NF + 2]);
16474 Operands.push_back(Ops[NF]);
16475 Operands.push_back(Ops[2 * NF + 3]);
16476 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
16477 }
16478 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
16479 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 16479, __extension__ __PRETTY_FUNCTION__));
16480 } else {
16481 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
16482 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
16483 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
16484 if (DefaultPolicy == TAIL_AGNOSTIC) {
16485 for (unsigned I = 0; I < NF; ++I)
16486 Operands.push_back(llvm::PoisonValue::get(ResultType));
16487 Operands.push_back(Ops[NF]);
16488 Operands.push_back(Ops[NF + 1]);
16489 Operands.push_back(Ops[NF + 2]);
16490 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
16491 } else {
16492 for (unsigned I = 0; I < NF; ++I)
16493 Operands.push_back(Ops[NF + I]);
16494 Operands.push_back(Ops[2 * NF]);
16495 Operands.push_back(Ops[2 * NF + 1]);
16496 Operands.push_back(Ops[2 * NF + 2]);
16497 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
16498 }
16499 }
16500 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
16501 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
16502 clang::CharUnits Align =
16503 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
16504 llvm::Value *V;
16505 for (unsigned I = 0; I < NF; ++I) {
16506 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
16507 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
16508 }
16509 return V;
16510 }
16511 break;
16512case RISCVVector::BI__builtin_rvv_vluxseg6ei8_v_tumu:
16513case RISCVVector::BI__builtin_rvv_vluxseg6ei16_v_tumu:
16514case RISCVVector::BI__builtin_rvv_vluxseg6ei32_v_tumu:
16515case RISCVVector::BI__builtin_rvv_vluxseg6ei64_v_tumu:
16516 ID = Intrinsic::riscv_vluxseg6_mask;
16517 NF = 6;
16518 DefaultPolicy = 0;
16519IsMasked = true;
16520
16521 {
16522 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
16523 SmallVector<llvm::Value*, 12> Operands;
16524 if (IsMasked) {
16525 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
16526 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
16527 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
16528 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
16529 for (unsigned I = 0; I < NF; ++I)
16530 Operands.push_back(llvm::PoisonValue::get(ResultType));
16531 Operands.push_back(Ops[NF + 1]);
16532 Operands.push_back(Ops[NF + 2]);
16533 Operands.push_back(Ops[NF]);
16534 Operands.push_back(Ops[NF + 3]);
16535 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
16536 } else {
16537 for (unsigned I = 0; I < NF; ++I)
16538 Operands.push_back(Ops[NF + I + 1]);
16539 Operands.push_back(Ops[2 * NF + 1]);
16540 Operands.push_back(Ops[2 * NF + 2]);
16541 Operands.push_back(Ops[NF]);
16542 Operands.push_back(Ops[2 * NF + 3]);
16543 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
16544 }
16545 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
16546 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 16546, __extension__ __PRETTY_FUNCTION__));
16547 } else {
16548 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
16549 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
16550 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
16551 if (DefaultPolicy == TAIL_AGNOSTIC) {
16552 for (unsigned I = 0; I < NF; ++I)
16553 Operands.push_back(llvm::PoisonValue::get(ResultType));
16554 Operands.push_back(Ops[NF]);
16555 Operands.push_back(Ops[NF + 1]);
16556 Operands.push_back(Ops[NF + 2]);
16557 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
16558 } else {
16559 for (unsigned I = 0; I < NF; ++I)
16560 Operands.push_back(Ops[NF + I]);
16561 Operands.push_back(Ops[2 * NF]);
16562 Operands.push_back(Ops[2 * NF + 1]);
16563 Operands.push_back(Ops[2 * NF + 2]);
16564 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
16565 }
16566 }
16567 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
16568 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
16569 clang::CharUnits Align =
16570 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
16571 llvm::Value *V;
16572 for (unsigned I = 0; I < NF; ++I) {
16573 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
16574 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
16575 }
16576 return V;
16577 }
16578 break;
16579case RISCVVector::BI__builtin_rvv_vluxseg6ei8_v_tamu:
16580case RISCVVector::BI__builtin_rvv_vluxseg6ei16_v_tamu:
16581case RISCVVector::BI__builtin_rvv_vluxseg6ei32_v_tamu:
16582case RISCVVector::BI__builtin_rvv_vluxseg6ei64_v_tamu:
16583 ID = Intrinsic::riscv_vluxseg6_mask;
16584 NF = 6;
16585 DefaultPolicy = 1;
16586IsMasked = true;
16587
16588 {
16589 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
16590 SmallVector<llvm::Value*, 12> Operands;
16591 if (IsMasked) {
16592 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
16593 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
16594 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
16595 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
16596 for (unsigned I = 0; I < NF; ++I)
16597 Operands.push_back(llvm::PoisonValue::get(ResultType));
16598 Operands.push_back(Ops[NF + 1]);
16599 Operands.push_back(Ops[NF + 2]);
16600 Operands.push_back(Ops[NF]);
16601 Operands.push_back(Ops[NF + 3]);
16602 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
16603 } else {
16604 for (unsigned I = 0; I < NF; ++I)
16605 Operands.push_back(Ops[NF + I + 1]);
16606 Operands.push_back(Ops[2 * NF + 1]);
16607 Operands.push_back(Ops[2 * NF + 2]);
16608 Operands.push_back(Ops[NF]);
16609 Operands.push_back(Ops[2 * NF + 3]);
16610 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
16611 }
16612 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
16613 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 16613, __extension__ __PRETTY_FUNCTION__));
16614 } else {
16615 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
16616 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
16617 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
16618 if (DefaultPolicy == TAIL_AGNOSTIC) {
16619 for (unsigned I = 0; I < NF; ++I)
16620 Operands.push_back(llvm::PoisonValue::get(ResultType));
16621 Operands.push_back(Ops[NF]);
16622 Operands.push_back(Ops[NF + 1]);
16623 Operands.push_back(Ops[NF + 2]);
16624 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
16625 } else {
16626 for (unsigned I = 0; I < NF; ++I)
16627 Operands.push_back(Ops[NF + I]);
16628 Operands.push_back(Ops[2 * NF]);
16629 Operands.push_back(Ops[2 * NF + 1]);
16630 Operands.push_back(Ops[2 * NF + 2]);
16631 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
16632 }
16633 }
16634 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
16635 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
16636 clang::CharUnits Align =
16637 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
16638 llvm::Value *V;
16639 for (unsigned I = 0; I < NF; ++I) {
16640 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
16641 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
16642 }
16643 return V;
16644 }
16645 break;
16646case RISCVVector::BI__builtin_rvv_vluxseg7ei8_v_tu:
16647case RISCVVector::BI__builtin_rvv_vluxseg7ei16_v_tu:
16648case RISCVVector::BI__builtin_rvv_vluxseg7ei32_v_tu:
16649case RISCVVector::BI__builtin_rvv_vluxseg7ei64_v_tu:
16650 ID = Intrinsic::riscv_vluxseg7;
16651 NF = 7;
16652 DefaultPolicy = 0;
16653IsMasked = false;
16654
16655 {
16656 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
16657 SmallVector<llvm::Value*, 12> Operands;
16658 if (IsMasked) {
16659 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
16660 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
16661 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
16662 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
16663 for (unsigned I = 0; I < NF; ++I)
16664 Operands.push_back(llvm::PoisonValue::get(ResultType));
16665 Operands.push_back(Ops[NF + 1]);
16666 Operands.push_back(Ops[NF + 2]);
16667 Operands.push_back(Ops[NF]);
16668 Operands.push_back(Ops[NF + 3]);
16669 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
16670 } else {
16671 for (unsigned I = 0; I < NF; ++I)
16672 Operands.push_back(Ops[NF + I + 1]);
16673 Operands.push_back(Ops[2 * NF + 1]);
16674 Operands.push_back(Ops[2 * NF + 2]);
16675 Operands.push_back(Ops[NF]);
16676 Operands.push_back(Ops[2 * NF + 3]);
16677 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
16678 }
16679 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
16680 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 16680, __extension__ __PRETTY_FUNCTION__));
16681 } else {
16682 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
16683 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
16684 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
16685 if (DefaultPolicy == TAIL_AGNOSTIC) {
16686 for (unsigned I = 0; I < NF; ++I)
16687 Operands.push_back(llvm::PoisonValue::get(ResultType));
16688 Operands.push_back(Ops[NF]);
16689 Operands.push_back(Ops[NF + 1]);
16690 Operands.push_back(Ops[NF + 2]);
16691 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
16692 } else {
16693 for (unsigned I = 0; I < NF; ++I)
16694 Operands.push_back(Ops[NF + I]);
16695 Operands.push_back(Ops[2 * NF]);
16696 Operands.push_back(Ops[2 * NF + 1]);
16697 Operands.push_back(Ops[2 * NF + 2]);
16698 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
16699 }
16700 }
16701 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
16702 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
16703 clang::CharUnits Align =
16704 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
16705 llvm::Value *V;
16706 for (unsigned I = 0; I < NF; ++I) {
16707 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
16708 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
16709 }
16710 return V;
16711 }
16712 break;
16713case RISCVVector::BI__builtin_rvv_vluxseg7ei8_v_ta:
16714case RISCVVector::BI__builtin_rvv_vluxseg7ei16_v_ta:
16715case RISCVVector::BI__builtin_rvv_vluxseg7ei32_v_ta:
16716case RISCVVector::BI__builtin_rvv_vluxseg7ei64_v_ta:
16717 ID = Intrinsic::riscv_vluxseg7;
16718 NF = 7;
16719 DefaultPolicy = 1;
16720IsMasked = false;
16721
16722 {
16723 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
16724 SmallVector<llvm::Value*, 12> Operands;
16725 if (IsMasked) {
16726 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
16727 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
16728 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
16729 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
16730 for (unsigned I = 0; I < NF; ++I)
16731 Operands.push_back(llvm::PoisonValue::get(ResultType));
16732 Operands.push_back(Ops[NF + 1]);
16733 Operands.push_back(Ops[NF + 2]);
16734 Operands.push_back(Ops[NF]);
16735 Operands.push_back(Ops[NF + 3]);
16736 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
16737 } else {
16738 for (unsigned I = 0; I < NF; ++I)
16739 Operands.push_back(Ops[NF + I + 1]);
16740 Operands.push_back(Ops[2 * NF + 1]);
16741 Operands.push_back(Ops[2 * NF + 2]);
16742 Operands.push_back(Ops[NF]);
16743 Operands.push_back(Ops[2 * NF + 3]);
16744 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
16745 }
16746 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
16747 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 16747, __extension__ __PRETTY_FUNCTION__));
16748 } else {
16749 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
16750 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
16751 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
16752 if (DefaultPolicy == TAIL_AGNOSTIC) {
16753 for (unsigned I = 0; I < NF; ++I)
16754 Operands.push_back(llvm::PoisonValue::get(ResultType));
16755 Operands.push_back(Ops[NF]);
16756 Operands.push_back(Ops[NF + 1]);
16757 Operands.push_back(Ops[NF + 2]);
16758 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
16759 } else {
16760 for (unsigned I = 0; I < NF; ++I)
16761 Operands.push_back(Ops[NF + I]);
16762 Operands.push_back(Ops[2 * NF]);
16763 Operands.push_back(Ops[2 * NF + 1]);
16764 Operands.push_back(Ops[2 * NF + 2]);
16765 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
16766 }
16767 }
16768 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
16769 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
16770 clang::CharUnits Align =
16771 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
16772 llvm::Value *V;
16773 for (unsigned I = 0; I < NF; ++I) {
16774 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
16775 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
16776 }
16777 return V;
16778 }
16779 break;
16780case RISCVVector::BI__builtin_rvv_vluxseg7ei8_v_tuma:
16781case RISCVVector::BI__builtin_rvv_vluxseg7ei16_v_tuma:
16782case RISCVVector::BI__builtin_rvv_vluxseg7ei32_v_tuma:
16783case RISCVVector::BI__builtin_rvv_vluxseg7ei64_v_tuma:
16784 ID = Intrinsic::riscv_vluxseg7_mask;
16785 NF = 7;
16786 DefaultPolicy = 2;
16787IsMasked = true;
16788
16789 {
16790 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
16791 SmallVector<llvm::Value*, 12> Operands;
16792 if (IsMasked) {
16793 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
16794 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
16795 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
16796 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
16797 for (unsigned I = 0; I < NF; ++I)
16798 Operands.push_back(llvm::PoisonValue::get(ResultType));
16799 Operands.push_back(Ops[NF + 1]);
16800 Operands.push_back(Ops[NF + 2]);
16801 Operands.push_back(Ops[NF]);
16802 Operands.push_back(Ops[NF + 3]);
16803 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
16804 } else {
16805 for (unsigned I = 0; I < NF; ++I)
16806 Operands.push_back(Ops[NF + I + 1]);
16807 Operands.push_back(Ops[2 * NF + 1]);
16808 Operands.push_back(Ops[2 * NF + 2]);
16809 Operands.push_back(Ops[NF]);
16810 Operands.push_back(Ops[2 * NF + 3]);
16811 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
16812 }
16813 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
16814 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 16814, __extension__ __PRETTY_FUNCTION__));
16815 } else {
16816 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
16817 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
16818 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
16819 if (DefaultPolicy == TAIL_AGNOSTIC) {
16820 for (unsigned I = 0; I < NF; ++I)
16821 Operands.push_back(llvm::PoisonValue::get(ResultType));
16822 Operands.push_back(Ops[NF]);
16823 Operands.push_back(Ops[NF + 1]);
16824 Operands.push_back(Ops[NF + 2]);
16825 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
16826 } else {
16827 for (unsigned I = 0; I < NF; ++I)
16828 Operands.push_back(Ops[NF + I]);
16829 Operands.push_back(Ops[2 * NF]);
16830 Operands.push_back(Ops[2 * NF + 1]);
16831 Operands.push_back(Ops[2 * NF + 2]);
16832 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
16833 }
16834 }
16835 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
16836 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
16837 clang::CharUnits Align =
16838 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
16839 llvm::Value *V;
16840 for (unsigned I = 0; I < NF; ++I) {
16841 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
16842 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
16843 }
16844 return V;
16845 }
16846 break;
16847case RISCVVector::BI__builtin_rvv_vluxseg7ei8_v_tama:
16848case RISCVVector::BI__builtin_rvv_vluxseg7ei16_v_tama:
16849case RISCVVector::BI__builtin_rvv_vluxseg7ei32_v_tama:
16850case RISCVVector::BI__builtin_rvv_vluxseg7ei64_v_tama:
16851 ID = Intrinsic::riscv_vluxseg7_mask;
16852 NF = 7;
16853 DefaultPolicy = 3;
16854IsMasked = true;
16855
16856 {
16857 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
16858 SmallVector<llvm::Value*, 12> Operands;
16859 if (IsMasked) {
16860 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
16861 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
16862 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
16863 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
16864 for (unsigned I = 0; I < NF; ++I)
16865 Operands.push_back(llvm::PoisonValue::get(ResultType));
16866 Operands.push_back(Ops[NF + 1]);
16867 Operands.push_back(Ops[NF + 2]);
16868 Operands.push_back(Ops[NF]);
16869 Operands.push_back(Ops[NF + 3]);
16870 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
16871 } else {
16872 for (unsigned I = 0; I < NF; ++I)
16873 Operands.push_back(Ops[NF + I + 1]);
16874 Operands.push_back(Ops[2 * NF + 1]);
16875 Operands.push_back(Ops[2 * NF + 2]);
16876 Operands.push_back(Ops[NF]);
16877 Operands.push_back(Ops[2 * NF + 3]);
16878 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
16879 }
16880 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
16881 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 16881, __extension__ __PRETTY_FUNCTION__));
16882 } else {
16883 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
16884 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
16885 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
16886 if (DefaultPolicy == TAIL_AGNOSTIC) {
16887 for (unsigned I = 0; I < NF; ++I)
16888 Operands.push_back(llvm::PoisonValue::get(ResultType));
16889 Operands.push_back(Ops[NF]);
16890 Operands.push_back(Ops[NF + 1]);
16891 Operands.push_back(Ops[NF + 2]);
16892 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
16893 } else {
16894 for (unsigned I = 0; I < NF; ++I)
16895 Operands.push_back(Ops[NF + I]);
16896 Operands.push_back(Ops[2 * NF]);
16897 Operands.push_back(Ops[2 * NF + 1]);
16898 Operands.push_back(Ops[2 * NF + 2]);
16899 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
16900 }
16901 }
16902 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
16903 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
16904 clang::CharUnits Align =
16905 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
16906 llvm::Value *V;
16907 for (unsigned I = 0; I < NF; ++I) {
16908 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
16909 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
16910 }
16911 return V;
16912 }
16913 break;
16914case RISCVVector::BI__builtin_rvv_vluxseg7ei8_v_tumu:
16915case RISCVVector::BI__builtin_rvv_vluxseg7ei16_v_tumu:
16916case RISCVVector::BI__builtin_rvv_vluxseg7ei32_v_tumu:
16917case RISCVVector::BI__builtin_rvv_vluxseg7ei64_v_tumu:
16918 ID = Intrinsic::riscv_vluxseg7_mask;
16919 NF = 7;
16920 DefaultPolicy = 0;
16921IsMasked = true;
16922
16923 {
16924 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
16925 SmallVector<llvm::Value*, 12> Operands;
16926 if (IsMasked) {
16927 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
16928 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
16929 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
16930 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
16931 for (unsigned I = 0; I < NF; ++I)
16932 Operands.push_back(llvm::PoisonValue::get(ResultType));
16933 Operands.push_back(Ops[NF + 1]);
16934 Operands.push_back(Ops[NF + 2]);
16935 Operands.push_back(Ops[NF]);
16936 Operands.push_back(Ops[NF + 3]);
16937 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
16938 } else {
16939 for (unsigned I = 0; I < NF; ++I)
16940 Operands.push_back(Ops[NF + I + 1]);
16941 Operands.push_back(Ops[2 * NF + 1]);
16942 Operands.push_back(Ops[2 * NF + 2]);
16943 Operands.push_back(Ops[NF]);
16944 Operands.push_back(Ops[2 * NF + 3]);
16945 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
16946 }
16947 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
16948 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 16948, __extension__ __PRETTY_FUNCTION__));
16949 } else {
16950 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
16951 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
16952 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
16953 if (DefaultPolicy == TAIL_AGNOSTIC) {
16954 for (unsigned I = 0; I < NF; ++I)
16955 Operands.push_back(llvm::PoisonValue::get(ResultType));
16956 Operands.push_back(Ops[NF]);
16957 Operands.push_back(Ops[NF + 1]);
16958 Operands.push_back(Ops[NF + 2]);
16959 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
16960 } else {
16961 for (unsigned I = 0; I < NF; ++I)
16962 Operands.push_back(Ops[NF + I]);
16963 Operands.push_back(Ops[2 * NF]);
16964 Operands.push_back(Ops[2 * NF + 1]);
16965 Operands.push_back(Ops[2 * NF + 2]);
16966 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
16967 }
16968 }
16969 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
16970 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
16971 clang::CharUnits Align =
16972 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
16973 llvm::Value *V;
16974 for (unsigned I = 0; I < NF; ++I) {
16975 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
16976 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
16977 }
16978 return V;
16979 }
16980 break;
16981case RISCVVector::BI__builtin_rvv_vluxseg7ei8_v_tamu:
16982case RISCVVector::BI__builtin_rvv_vluxseg7ei16_v_tamu:
16983case RISCVVector::BI__builtin_rvv_vluxseg7ei32_v_tamu:
16984case RISCVVector::BI__builtin_rvv_vluxseg7ei64_v_tamu:
16985 ID = Intrinsic::riscv_vluxseg7_mask;
16986 NF = 7;
16987 DefaultPolicy = 1;
16988IsMasked = true;
16989
16990 {
16991 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
16992 SmallVector<llvm::Value*, 12> Operands;
16993 if (IsMasked) {
16994 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
16995 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
16996 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
16997 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
16998 for (unsigned I = 0; I < NF; ++I)
16999 Operands.push_back(llvm::PoisonValue::get(ResultType));
17000 Operands.push_back(Ops[NF + 1]);
17001 Operands.push_back(Ops[NF + 2]);
17002 Operands.push_back(Ops[NF]);
17003 Operands.push_back(Ops[NF + 3]);
17004 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
17005 } else {
17006 for (unsigned I = 0; I < NF; ++I)
17007 Operands.push_back(Ops[NF + I + 1]);
17008 Operands.push_back(Ops[2 * NF + 1]);
17009 Operands.push_back(Ops[2 * NF + 2]);
17010 Operands.push_back(Ops[NF]);
17011 Operands.push_back(Ops[2 * NF + 3]);
17012 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
17013 }
17014 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
17015 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 17015, __extension__ __PRETTY_FUNCTION__));
17016 } else {
17017 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
17018 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
17019 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
17020 if (DefaultPolicy == TAIL_AGNOSTIC) {
17021 for (unsigned I = 0; I < NF; ++I)
17022 Operands.push_back(llvm::PoisonValue::get(ResultType));
17023 Operands.push_back(Ops[NF]);
17024 Operands.push_back(Ops[NF + 1]);
17025 Operands.push_back(Ops[NF + 2]);
17026 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
17027 } else {
17028 for (unsigned I = 0; I < NF; ++I)
17029 Operands.push_back(Ops[NF + I]);
17030 Operands.push_back(Ops[2 * NF]);
17031 Operands.push_back(Ops[2 * NF + 1]);
17032 Operands.push_back(Ops[2 * NF + 2]);
17033 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
17034 }
17035 }
17036 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
17037 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
17038 clang::CharUnits Align =
17039 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
17040 llvm::Value *V;
17041 for (unsigned I = 0; I < NF; ++I) {
17042 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
17043 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
17044 }
17045 return V;
17046 }
17047 break;
17048case RISCVVector::BI__builtin_rvv_vluxseg8ei8_v_tu:
17049case RISCVVector::BI__builtin_rvv_vluxseg8ei16_v_tu:
17050case RISCVVector::BI__builtin_rvv_vluxseg8ei32_v_tu:
17051case RISCVVector::BI__builtin_rvv_vluxseg8ei64_v_tu:
17052 ID = Intrinsic::riscv_vluxseg8;
17053 NF = 8;
17054 DefaultPolicy = 0;
17055IsMasked = false;
17056
17057 {
17058 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
17059 SmallVector<llvm::Value*, 12> Operands;
17060 if (IsMasked) {
17061 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
17062 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
17063 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
17064 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
17065 for (unsigned I = 0; I < NF; ++I)
17066 Operands.push_back(llvm::PoisonValue::get(ResultType));
17067 Operands.push_back(Ops[NF + 1]);
17068 Operands.push_back(Ops[NF + 2]);
17069 Operands.push_back(Ops[NF]);
17070 Operands.push_back(Ops[NF + 3]);
17071 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
17072 } else {
17073 for (unsigned I = 0; I < NF; ++I)
17074 Operands.push_back(Ops[NF + I + 1]);
17075 Operands.push_back(Ops[2 * NF + 1]);
17076 Operands.push_back(Ops[2 * NF + 2]);
17077 Operands.push_back(Ops[NF]);
17078 Operands.push_back(Ops[2 * NF + 3]);
17079 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
17080 }
17081 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
17082 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 17082, __extension__ __PRETTY_FUNCTION__));
17083 } else {
17084 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
17085 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
17086 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
17087 if (DefaultPolicy == TAIL_AGNOSTIC) {
17088 for (unsigned I = 0; I < NF; ++I)
17089 Operands.push_back(llvm::PoisonValue::get(ResultType));
17090 Operands.push_back(Ops[NF]);
17091 Operands.push_back(Ops[NF + 1]);
17092 Operands.push_back(Ops[NF + 2]);
17093 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
17094 } else {
17095 for (unsigned I = 0; I < NF; ++I)
17096 Operands.push_back(Ops[NF + I]);
17097 Operands.push_back(Ops[2 * NF]);
17098 Operands.push_back(Ops[2 * NF + 1]);
17099 Operands.push_back(Ops[2 * NF + 2]);
17100 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
17101 }
17102 }
17103 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
17104 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
17105 clang::CharUnits Align =
17106 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
17107 llvm::Value *V;
17108 for (unsigned I = 0; I < NF; ++I) {
17109 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
17110 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
17111 }
17112 return V;
17113 }
17114 break;
17115case RISCVVector::BI__builtin_rvv_vluxseg8ei8_v_ta:
17116case RISCVVector::BI__builtin_rvv_vluxseg8ei16_v_ta:
17117case RISCVVector::BI__builtin_rvv_vluxseg8ei32_v_ta:
17118case RISCVVector::BI__builtin_rvv_vluxseg8ei64_v_ta:
17119 ID = Intrinsic::riscv_vluxseg8;
17120 NF = 8;
17121 DefaultPolicy = 1;
17122IsMasked = false;
17123
17124 {
17125 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
17126 SmallVector<llvm::Value*, 12> Operands;
17127 if (IsMasked) {
17128 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
17129 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
17130 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
17131 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
17132 for (unsigned I = 0; I < NF; ++I)
17133 Operands.push_back(llvm::PoisonValue::get(ResultType));
17134 Operands.push_back(Ops[NF + 1]);
17135 Operands.push_back(Ops[NF + 2]);
17136 Operands.push_back(Ops[NF]);
17137 Operands.push_back(Ops[NF + 3]);
17138 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
17139 } else {
17140 for (unsigned I = 0; I < NF; ++I)
17141 Operands.push_back(Ops[NF + I + 1]);
17142 Operands.push_back(Ops[2 * NF + 1]);
17143 Operands.push_back(Ops[2 * NF + 2]);
17144 Operands.push_back(Ops[NF]);
17145 Operands.push_back(Ops[2 * NF + 3]);
17146 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
17147 }
17148 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
17149 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 17149, __extension__ __PRETTY_FUNCTION__));
17150 } else {
17151 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
17152 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
17153 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
17154 if (DefaultPolicy == TAIL_AGNOSTIC) {
17155 for (unsigned I = 0; I < NF; ++I)
17156 Operands.push_back(llvm::PoisonValue::get(ResultType));
17157 Operands.push_back(Ops[NF]);
17158 Operands.push_back(Ops[NF + 1]);
17159 Operands.push_back(Ops[NF + 2]);
17160 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
17161 } else {
17162 for (unsigned I = 0; I < NF; ++I)
17163 Operands.push_back(Ops[NF + I]);
17164 Operands.push_back(Ops[2 * NF]);
17165 Operands.push_back(Ops[2 * NF + 1]);
17166 Operands.push_back(Ops[2 * NF + 2]);
17167 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
17168 }
17169 }
17170 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
17171 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
17172 clang::CharUnits Align =
17173 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
17174 llvm::Value *V;
17175 for (unsigned I = 0; I < NF; ++I) {
17176 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
17177 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
17178 }
17179 return V;
17180 }
17181 break;
17182case RISCVVector::BI__builtin_rvv_vluxseg8ei8_v_tuma:
17183case RISCVVector::BI__builtin_rvv_vluxseg8ei16_v_tuma:
17184case RISCVVector::BI__builtin_rvv_vluxseg8ei32_v_tuma:
17185case RISCVVector::BI__builtin_rvv_vluxseg8ei64_v_tuma:
17186 ID = Intrinsic::riscv_vluxseg8_mask;
17187 NF = 8;
17188 DefaultPolicy = 2;
17189IsMasked = true;
17190
17191 {
17192 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
17193 SmallVector<llvm::Value*, 12> Operands;
17194 if (IsMasked) {
17195 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
17196 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
17197 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
17198 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
17199 for (unsigned I = 0; I < NF; ++I)
17200 Operands.push_back(llvm::PoisonValue::get(ResultType));
17201 Operands.push_back(Ops[NF + 1]);
17202 Operands.push_back(Ops[NF + 2]);
17203 Operands.push_back(Ops[NF]);
17204 Operands.push_back(Ops[NF + 3]);
17205 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
17206 } else {
17207 for (unsigned I = 0; I < NF; ++I)
17208 Operands.push_back(Ops[NF + I + 1]);
17209 Operands.push_back(Ops[2 * NF + 1]);
17210 Operands.push_back(Ops[2 * NF + 2]);
17211 Operands.push_back(Ops[NF]);
17212 Operands.push_back(Ops[2 * NF + 3]);
17213 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
17214 }
17215 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
17216 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 17216, __extension__ __PRETTY_FUNCTION__));
17217 } else {
17218 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
17219 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
17220 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
17221 if (DefaultPolicy == TAIL_AGNOSTIC) {
17222 for (unsigned I = 0; I < NF; ++I)
17223 Operands.push_back(llvm::PoisonValue::get(ResultType));
17224 Operands.push_back(Ops[NF]);
17225 Operands.push_back(Ops[NF + 1]);
17226 Operands.push_back(Ops[NF + 2]);
17227 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
17228 } else {
17229 for (unsigned I = 0; I < NF; ++I)
17230 Operands.push_back(Ops[NF + I]);
17231 Operands.push_back(Ops[2 * NF]);
17232 Operands.push_back(Ops[2 * NF + 1]);
17233 Operands.push_back(Ops[2 * NF + 2]);
17234 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
17235 }
17236 }
17237 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
17238 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
17239 clang::CharUnits Align =
17240 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
17241 llvm::Value *V;
17242 for (unsigned I = 0; I < NF; ++I) {
17243 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
17244 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
17245 }
17246 return V;
17247 }
17248 break;
17249case RISCVVector::BI__builtin_rvv_vluxseg8ei8_v_tama:
17250case RISCVVector::BI__builtin_rvv_vluxseg8ei16_v_tama:
17251case RISCVVector::BI__builtin_rvv_vluxseg8ei32_v_tama:
17252case RISCVVector::BI__builtin_rvv_vluxseg8ei64_v_tama:
17253 ID = Intrinsic::riscv_vluxseg8_mask;
17254 NF = 8;
17255 DefaultPolicy = 3;
17256IsMasked = true;
17257
17258 {
17259 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
17260 SmallVector<llvm::Value*, 12> Operands;
17261 if (IsMasked) {
17262 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
17263 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
17264 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
17265 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
17266 for (unsigned I = 0; I < NF; ++I)
17267 Operands.push_back(llvm::PoisonValue::get(ResultType));
17268 Operands.push_back(Ops[NF + 1]);
17269 Operands.push_back(Ops[NF + 2]);
17270 Operands.push_back(Ops[NF]);
17271 Operands.push_back(Ops[NF + 3]);
17272 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
17273 } else {
17274 for (unsigned I = 0; I < NF; ++I)
17275 Operands.push_back(Ops[NF + I + 1]);
17276 Operands.push_back(Ops[2 * NF + 1]);
17277 Operands.push_back(Ops[2 * NF + 2]);
17278 Operands.push_back(Ops[NF]);
17279 Operands.push_back(Ops[2 * NF + 3]);
17280 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
17281 }
17282 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
17283 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 17283, __extension__ __PRETTY_FUNCTION__));
17284 } else {
17285 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
17286 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
17287 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
17288 if (DefaultPolicy == TAIL_AGNOSTIC) {
17289 for (unsigned I = 0; I < NF; ++I)
17290 Operands.push_back(llvm::PoisonValue::get(ResultType));
17291 Operands.push_back(Ops[NF]);
17292 Operands.push_back(Ops[NF + 1]);
17293 Operands.push_back(Ops[NF + 2]);
17294 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
17295 } else {
17296 for (unsigned I = 0; I < NF; ++I)
17297 Operands.push_back(Ops[NF + I]);
17298 Operands.push_back(Ops[2 * NF]);
17299 Operands.push_back(Ops[2 * NF + 1]);
17300 Operands.push_back(Ops[2 * NF + 2]);
17301 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
17302 }
17303 }
17304 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
17305 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
17306 clang::CharUnits Align =
17307 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
17308 llvm::Value *V;
17309 for (unsigned I = 0; I < NF; ++I) {
17310 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
17311 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
17312 }
17313 return V;
17314 }
17315 break;
17316case RISCVVector::BI__builtin_rvv_vluxseg8ei8_v_tumu:
17317case RISCVVector::BI__builtin_rvv_vluxseg8ei16_v_tumu:
17318case RISCVVector::BI__builtin_rvv_vluxseg8ei32_v_tumu:
17319case RISCVVector::BI__builtin_rvv_vluxseg8ei64_v_tumu:
17320 ID = Intrinsic::riscv_vluxseg8_mask;
17321 NF = 8;
17322 DefaultPolicy = 0;
17323IsMasked = true;
17324
17325 {
17326 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
17327 SmallVector<llvm::Value*, 12> Operands;
17328 if (IsMasked) {
17329 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
17330 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
17331 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
17332 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
17333 for (unsigned I = 0; I < NF; ++I)
17334 Operands.push_back(llvm::PoisonValue::get(ResultType));
17335 Operands.push_back(Ops[NF + 1]);
17336 Operands.push_back(Ops[NF + 2]);
17337 Operands.push_back(Ops[NF]);
17338 Operands.push_back(Ops[NF + 3]);
17339 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
17340 } else {
17341 for (unsigned I = 0; I < NF; ++I)
17342 Operands.push_back(Ops[NF + I + 1]);
17343 Operands.push_back(Ops[2 * NF + 1]);
17344 Operands.push_back(Ops[2 * NF + 2]);
17345 Operands.push_back(Ops[NF]);
17346 Operands.push_back(Ops[2 * NF + 3]);
17347 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
17348 }
17349 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
17350 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 17350, __extension__ __PRETTY_FUNCTION__));
17351 } else {
17352 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
17353 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
17354 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
17355 if (DefaultPolicy == TAIL_AGNOSTIC) {
17356 for (unsigned I = 0; I < NF; ++I)
17357 Operands.push_back(llvm::PoisonValue::get(ResultType));
17358 Operands.push_back(Ops[NF]);
17359 Operands.push_back(Ops[NF + 1]);
17360 Operands.push_back(Ops[NF + 2]);
17361 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
17362 } else {
17363 for (unsigned I = 0; I < NF; ++I)
17364 Operands.push_back(Ops[NF + I]);
17365 Operands.push_back(Ops[2 * NF]);
17366 Operands.push_back(Ops[2 * NF + 1]);
17367 Operands.push_back(Ops[2 * NF + 2]);
17368 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
17369 }
17370 }
17371 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
17372 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
17373 clang::CharUnits Align =
17374 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
17375 llvm::Value *V;
17376 for (unsigned I = 0; I < NF; ++I) {
17377 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
17378 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
17379 }
17380 return V;
17381 }
17382 break;
17383case RISCVVector::BI__builtin_rvv_vluxseg8ei8_v_tamu:
17384case RISCVVector::BI__builtin_rvv_vluxseg8ei16_v_tamu:
17385case RISCVVector::BI__builtin_rvv_vluxseg8ei32_v_tamu:
17386case RISCVVector::BI__builtin_rvv_vluxseg8ei64_v_tamu:
17387 ID = Intrinsic::riscv_vluxseg8_mask;
17388 NF = 8;
17389 DefaultPolicy = 1;
17390IsMasked = true;
17391
17392 {
17393 ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
17394 SmallVector<llvm::Value*, 12> Operands;
17395 if (IsMasked) {
17396 // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
17397 // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
17398 // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
17399 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
17400 for (unsigned I = 0; I < NF; ++I)
17401 Operands.push_back(llvm::PoisonValue::get(ResultType));
17402 Operands.push_back(Ops[NF + 1]);
17403 Operands.push_back(Ops[NF + 2]);
17404 Operands.push_back(Ops[NF]);
17405 Operands.push_back(Ops[NF + 3]);
17406 IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
17407 } else {
17408 for (unsigned I = 0; I < NF; ++I)
17409 Operands.push_back(Ops[NF + I + 1]);
17410 Operands.push_back(Ops[2 * NF + 1]);
17411 Operands.push_back(Ops[2 * NF + 2]);
17412 Operands.push_back(Ops[NF]);
17413 Operands.push_back(Ops[2 * NF + 3]);
17414 IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
17415 }
17416 Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
17417 assert(Operands.size() == NF + 5)(static_cast <bool> (Operands.size() == NF + 5) ? void (
0) : __assert_fail ("Operands.size() == NF + 5", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 17417, __extension__ __PRETTY_FUNCTION__));
17418 } else {
17419 // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
17420 // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
17421 // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
17422 if (DefaultPolicy == TAIL_AGNOSTIC) {
17423 for (unsigned I = 0; I < NF; ++I)
17424 Operands.push_back(llvm::PoisonValue::get(ResultType));
17425 Operands.push_back(Ops[NF]);
17426 Operands.push_back(Ops[NF + 1]);
17427 Operands.push_back(Ops[NF + 2]);
17428 IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
17429 } else {
17430 for (unsigned I = 0; I < NF; ++I)
17431 Operands.push_back(Ops[NF + I]);
17432 Operands.push_back(Ops[2 * NF]);
17433 Operands.push_back(Ops[2 * NF + 1]);
17434 Operands.push_back(Ops[2 * NF + 2]);
17435 IntrinsicTypes = {ResultType, Ops[2 * NF + 1]->getType(), Ops.back()->getType()};
17436 }
17437 }
17438 llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
17439 llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
17440 clang::CharUnits Align =
17441 CGM.getNaturalPointeeTypeAlignment(E->getArg(0)->getType());
17442 llvm::Value *V;
17443 for (unsigned I = 0; I < NF; ++I) {
17444 llvm::Value *Val = Builder.CreateExtractValue(LoadValue, {I});
17445 V = Builder.CreateStore(Val, Address(Ops[I], Val->getType(), Align));
17446 }
17447 return V;
17448 }
17449 break;
17450case RISCVVector::BI__builtin_rvv_vmacc_vv_tu:
17451case RISCVVector::BI__builtin_rvv_vmacc_vx_tu:
17452 ID = Intrinsic::riscv_vmacc;
17453 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
17454 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
17455 break;
17456case RISCVVector::BI__builtin_rvv_vmacc_vv_ta:
17457case RISCVVector::BI__builtin_rvv_vmacc_vx_ta:
17458 ID = Intrinsic::riscv_vmacc;
17459 DefaultPolicy = 1;
17460 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
17461 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
17462 break;
17463case RISCVVector::BI__builtin_rvv_vmacc_vv_tuma:
17464case RISCVVector::BI__builtin_rvv_vmacc_vx_tuma:
17465 ID = Intrinsic::riscv_vmacc_mask;
17466 DefaultPolicy = 2;
17467 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17468 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
17469 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
17470 break;
17471case RISCVVector::BI__builtin_rvv_vmacc_vv_tama:
17472case RISCVVector::BI__builtin_rvv_vmacc_vx_tama:
17473 ID = Intrinsic::riscv_vmacc_mask;
17474 DefaultPolicy = 3;
17475 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17476 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
17477 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
17478 break;
17479case RISCVVector::BI__builtin_rvv_vmacc_vv_tumu:
17480case RISCVVector::BI__builtin_rvv_vmacc_vx_tumu:
17481 ID = Intrinsic::riscv_vmacc_mask;
17482 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17483 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
17484 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
17485 break;
17486case RISCVVector::BI__builtin_rvv_vmacc_vv_tamu:
17487case RISCVVector::BI__builtin_rvv_vmacc_vx_tamu:
17488 ID = Intrinsic::riscv_vmacc_mask;
17489 DefaultPolicy = 1;
17490 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17491 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
17492 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
17493 break;
17494case RISCVVector::BI__builtin_rvv_vmadc_vv:
17495case RISCVVector::BI__builtin_rvv_vmadc_vx:
17496 ID = Intrinsic::riscv_vmadc;
17497 DefaultPolicy = 1;
17498 IntrinsicTypes = {Ops[0]->getType(), Ops[1]->getType(), Ops.back()->getType()};
17499 break;
17500case RISCVVector::BI__builtin_rvv_vmadc_vvm:
17501case RISCVVector::BI__builtin_rvv_vmadc_vxm:
17502 ID = Intrinsic::riscv_vmadc_carry_in;
17503 DefaultPolicy = 1;
17504 IntrinsicTypes = {Ops[0]->getType(), Ops[1]->getType(), Ops.back()->getType()};
17505 break;
17506case RISCVVector::BI__builtin_rvv_vmadd_vv_tu:
17507case RISCVVector::BI__builtin_rvv_vmadd_vx_tu:
17508 ID = Intrinsic::riscv_vmadd;
17509 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
17510 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
17511 break;
17512case RISCVVector::BI__builtin_rvv_vmadd_vv_ta:
17513case RISCVVector::BI__builtin_rvv_vmadd_vx_ta:
17514 ID = Intrinsic::riscv_vmadd;
17515 DefaultPolicy = 1;
17516 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
17517 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
17518 break;
17519case RISCVVector::BI__builtin_rvv_vmadd_vv_tuma:
17520case RISCVVector::BI__builtin_rvv_vmadd_vx_tuma:
17521 ID = Intrinsic::riscv_vmadd_mask;
17522 DefaultPolicy = 2;
17523 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17524 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
17525 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
17526 break;
17527case RISCVVector::BI__builtin_rvv_vmadd_vv_tama:
17528case RISCVVector::BI__builtin_rvv_vmadd_vx_tama:
17529 ID = Intrinsic::riscv_vmadd_mask;
17530 DefaultPolicy = 3;
17531 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17532 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
17533 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
17534 break;
17535case RISCVVector::BI__builtin_rvv_vmadd_vv_tumu:
17536case RISCVVector::BI__builtin_rvv_vmadd_vx_tumu:
17537 ID = Intrinsic::riscv_vmadd_mask;
17538 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17539 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
17540 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
17541 break;
17542case RISCVVector::BI__builtin_rvv_vmadd_vv_tamu:
17543case RISCVVector::BI__builtin_rvv_vmadd_vx_tamu:
17544 ID = Intrinsic::riscv_vmadd_mask;
17545 DefaultPolicy = 1;
17546 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17547 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
17548 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
17549 break;
17550case RISCVVector::BI__builtin_rvv_vmmv_m:
17551 ID = Intrinsic::riscv_vmand;
17552 DefaultPolicy = 1;
17553IsMasked = false;
17554
17555 {
17556 // op1, vl
17557 IntrinsicTypes = {ResultType,
17558 Ops[1]->getType()};
17559 Ops.insert(Ops.begin() + 1, Ops[0]);
17560 break;
17561 }
17562 break;
17563case RISCVVector::BI__builtin_rvv_vmand_mm:
17564 ID = Intrinsic::riscv_vmand;
17565 DefaultPolicy = 1;
17566 IntrinsicTypes = {ResultType, Ops.back()->getType()};
17567 break;
17568case RISCVVector::BI__builtin_rvv_vmandn_mm:
17569 ID = Intrinsic::riscv_vmandn;
17570 DefaultPolicy = 1;
17571 IntrinsicTypes = {ResultType, Ops.back()->getType()};
17572 break;
17573case RISCVVector::BI__builtin_rvv_vmax_vv_tu:
17574case RISCVVector::BI__builtin_rvv_vmax_vx_tu:
17575 ID = Intrinsic::riscv_vmax;
17576 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
17577 break;
17578case RISCVVector::BI__builtin_rvv_vmax_vv_ta:
17579case RISCVVector::BI__builtin_rvv_vmax_vx_ta:
17580 ID = Intrinsic::riscv_vmax;
17581 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
17582 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
17583 break;
17584case RISCVVector::BI__builtin_rvv_vmax_vv_tuma:
17585case RISCVVector::BI__builtin_rvv_vmax_vx_tuma:
17586 ID = Intrinsic::riscv_vmax_mask;
17587 DefaultPolicy = 2;
17588 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17589 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
17590 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
17591 break;
17592case RISCVVector::BI__builtin_rvv_vmax_vv_tama:
17593case RISCVVector::BI__builtin_rvv_vmax_vx_tama:
17594 ID = Intrinsic::riscv_vmax_mask;
17595 DefaultPolicy = 3;
17596 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17597 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
17598 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
17599 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
17600 break;
17601case RISCVVector::BI__builtin_rvv_vmax_vv_tumu:
17602case RISCVVector::BI__builtin_rvv_vmax_vx_tumu:
17603 ID = Intrinsic::riscv_vmax_mask;
17604 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17605 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
17606 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
17607 break;
17608case RISCVVector::BI__builtin_rvv_vmax_vv_tamu:
17609case RISCVVector::BI__builtin_rvv_vmax_vx_tamu:
17610 ID = Intrinsic::riscv_vmax_mask;
17611 DefaultPolicy = 1;
17612 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17613 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
17614 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
17615 break;
17616case RISCVVector::BI__builtin_rvv_vmaxu_vv_tu:
17617case RISCVVector::BI__builtin_rvv_vmaxu_vx_tu:
17618 ID = Intrinsic::riscv_vmaxu;
17619 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
17620 break;
17621case RISCVVector::BI__builtin_rvv_vmaxu_vv_ta:
17622case RISCVVector::BI__builtin_rvv_vmaxu_vx_ta:
17623 ID = Intrinsic::riscv_vmaxu;
17624 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
17625 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
17626 break;
17627case RISCVVector::BI__builtin_rvv_vmaxu_vv_tuma:
17628case RISCVVector::BI__builtin_rvv_vmaxu_vx_tuma:
17629 ID = Intrinsic::riscv_vmaxu_mask;
17630 DefaultPolicy = 2;
17631 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17632 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
17633 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
17634 break;
17635case RISCVVector::BI__builtin_rvv_vmaxu_vv_tama:
17636case RISCVVector::BI__builtin_rvv_vmaxu_vx_tama:
17637 ID = Intrinsic::riscv_vmaxu_mask;
17638 DefaultPolicy = 3;
17639 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17640 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
17641 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
17642 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
17643 break;
17644case RISCVVector::BI__builtin_rvv_vmaxu_vv_tumu:
17645case RISCVVector::BI__builtin_rvv_vmaxu_vx_tumu:
17646 ID = Intrinsic::riscv_vmaxu_mask;
17647 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17648 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
17649 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
17650 break;
17651case RISCVVector::BI__builtin_rvv_vmaxu_vv_tamu:
17652case RISCVVector::BI__builtin_rvv_vmaxu_vx_tamu:
17653 ID = Intrinsic::riscv_vmaxu_mask;
17654 DefaultPolicy = 1;
17655 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17656 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
17657 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
17658 break;
17659case RISCVVector::BI__builtin_rvv_vmclr_m:
17660 ID = Intrinsic::riscv_vmclr;
17661 DefaultPolicy = 1;
17662 IntrinsicTypes = {ResultType, Ops.back()->getType()};
17663 break;
17664case RISCVVector::BI__builtin_rvv_vmerge_vvm_tu:
17665case RISCVVector::BI__builtin_rvv_vmerge_vxm_tu:
17666 ID = Intrinsic::riscv_vmerge;
17667 DefaultPolicy = 0;
17668IsMasked = false;
17669
17670 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17671 // insert poison passthru
17672 if (DefaultPolicy == TAIL_AGNOSTIC)
17673 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
17674 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
17675 break;
17676case RISCVVector::BI__builtin_rvv_vmerge_vvm_ta:
17677case RISCVVector::BI__builtin_rvv_vmerge_vxm_ta:
17678 ID = Intrinsic::riscv_vmerge;
17679 DefaultPolicy = 1;
17680IsMasked = false;
17681
17682 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17683 // insert poison passthru
17684 if (DefaultPolicy == TAIL_AGNOSTIC)
17685 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
17686 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
17687 break;
17688case RISCVVector::BI__builtin_rvv_vmfeq_vv:
17689case RISCVVector::BI__builtin_rvv_vmfeq_vf:
17690 ID = Intrinsic::riscv_vmfeq;
17691 DefaultPolicy = 1;
17692 IntrinsicTypes = {Ops[0]->getType(), Ops[1]->getType(), Ops.back()->getType()};
17693 break;
17694case RISCVVector::BI__builtin_rvv_vmfeq_vv_ma:
17695case RISCVVector::BI__builtin_rvv_vmfeq_vf_ma:
17696 ID = Intrinsic::riscv_vmfeq_mask;
17697 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17698 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
17699 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
17700 break;
17701case RISCVVector::BI__builtin_rvv_vmfeq_vv_tumu:
17702case RISCVVector::BI__builtin_rvv_vmfeq_vf_tumu:
17703 ID = Intrinsic::riscv_vmfeq_mask;
17704 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17705 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
17706 break;
17707case RISCVVector::BI__builtin_rvv_vmfeq_vv_mu:
17708case RISCVVector::BI__builtin_rvv_vmfeq_vf_mu:
17709 ID = Intrinsic::riscv_vmfeq_mask;
17710 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17711 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
17712 break;
17713case RISCVVector::BI__builtin_rvv_vmfge_vv:
17714case RISCVVector::BI__builtin_rvv_vmfge_vf:
17715 ID = Intrinsic::riscv_vmfge;
17716 DefaultPolicy = 1;
17717 IntrinsicTypes = {Ops[0]->getType(), Ops[1]->getType(), Ops.back()->getType()};
17718 break;
17719case RISCVVector::BI__builtin_rvv_vmfge_vv_ma:
17720case RISCVVector::BI__builtin_rvv_vmfge_vf_ma:
17721 ID = Intrinsic::riscv_vmfge_mask;
17722 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17723 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
17724 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
17725 break;
17726case RISCVVector::BI__builtin_rvv_vmfge_vv_tumu:
17727case RISCVVector::BI__builtin_rvv_vmfge_vf_tumu:
17728 ID = Intrinsic::riscv_vmfge_mask;
17729 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17730 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
17731 break;
17732case RISCVVector::BI__builtin_rvv_vmfge_vv_mu:
17733case RISCVVector::BI__builtin_rvv_vmfge_vf_mu:
17734 ID = Intrinsic::riscv_vmfge_mask;
17735 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17736 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
17737 break;
17738case RISCVVector::BI__builtin_rvv_vmfgt_vv:
17739case RISCVVector::BI__builtin_rvv_vmfgt_vf:
17740 ID = Intrinsic::riscv_vmfgt;
17741 DefaultPolicy = 1;
17742 IntrinsicTypes = {Ops[0]->getType(), Ops[1]->getType(), Ops.back()->getType()};
17743 break;
17744case RISCVVector::BI__builtin_rvv_vmfgt_vv_ma:
17745case RISCVVector::BI__builtin_rvv_vmfgt_vf_ma:
17746 ID = Intrinsic::riscv_vmfgt_mask;
17747 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17748 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
17749 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
17750 break;
17751case RISCVVector::BI__builtin_rvv_vmfgt_vv_tumu:
17752case RISCVVector::BI__builtin_rvv_vmfgt_vf_tumu:
17753 ID = Intrinsic::riscv_vmfgt_mask;
17754 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17755 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
17756 break;
17757case RISCVVector::BI__builtin_rvv_vmfgt_vv_mu:
17758case RISCVVector::BI__builtin_rvv_vmfgt_vf_mu:
17759 ID = Intrinsic::riscv_vmfgt_mask;
17760 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17761 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
17762 break;
17763case RISCVVector::BI__builtin_rvv_vmfle_vv:
17764case RISCVVector::BI__builtin_rvv_vmfle_vf:
17765 ID = Intrinsic::riscv_vmfle;
17766 DefaultPolicy = 1;
17767 IntrinsicTypes = {Ops[0]->getType(), Ops[1]->getType(), Ops.back()->getType()};
17768 break;
17769case RISCVVector::BI__builtin_rvv_vmfle_vv_ma:
17770case RISCVVector::BI__builtin_rvv_vmfle_vf_ma:
17771 ID = Intrinsic::riscv_vmfle_mask;
17772 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17773 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
17774 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
17775 break;
17776case RISCVVector::BI__builtin_rvv_vmfle_vv_tumu:
17777case RISCVVector::BI__builtin_rvv_vmfle_vf_tumu:
17778 ID = Intrinsic::riscv_vmfle_mask;
17779 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17780 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
17781 break;
17782case RISCVVector::BI__builtin_rvv_vmfle_vv_mu:
17783case RISCVVector::BI__builtin_rvv_vmfle_vf_mu:
17784 ID = Intrinsic::riscv_vmfle_mask;
17785 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17786 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
17787 break;
17788case RISCVVector::BI__builtin_rvv_vmflt_vv:
17789case RISCVVector::BI__builtin_rvv_vmflt_vf:
17790 ID = Intrinsic::riscv_vmflt;
17791 DefaultPolicy = 1;
17792 IntrinsicTypes = {Ops[0]->getType(), Ops[1]->getType(), Ops.back()->getType()};
17793 break;
17794case RISCVVector::BI__builtin_rvv_vmflt_vv_ma:
17795case RISCVVector::BI__builtin_rvv_vmflt_vf_ma:
17796 ID = Intrinsic::riscv_vmflt_mask;
17797 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17798 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
17799 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
17800 break;
17801case RISCVVector::BI__builtin_rvv_vmflt_vv_tumu:
17802case RISCVVector::BI__builtin_rvv_vmflt_vf_tumu:
17803 ID = Intrinsic::riscv_vmflt_mask;
17804 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17805 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
17806 break;
17807case RISCVVector::BI__builtin_rvv_vmflt_vv_mu:
17808case RISCVVector::BI__builtin_rvv_vmflt_vf_mu:
17809 ID = Intrinsic::riscv_vmflt_mask;
17810 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17811 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
17812 break;
17813case RISCVVector::BI__builtin_rvv_vmfne_vv:
17814case RISCVVector::BI__builtin_rvv_vmfne_vf:
17815 ID = Intrinsic::riscv_vmfne;
17816 DefaultPolicy = 1;
17817 IntrinsicTypes = {Ops[0]->getType(), Ops[1]->getType(), Ops.back()->getType()};
17818 break;
17819case RISCVVector::BI__builtin_rvv_vmfne_vv_ma:
17820case RISCVVector::BI__builtin_rvv_vmfne_vf_ma:
17821 ID = Intrinsic::riscv_vmfne_mask;
17822 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17823 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
17824 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
17825 break;
17826case RISCVVector::BI__builtin_rvv_vmfne_vv_tumu:
17827case RISCVVector::BI__builtin_rvv_vmfne_vf_tumu:
17828 ID = Intrinsic::riscv_vmfne_mask;
17829 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17830 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
17831 break;
17832case RISCVVector::BI__builtin_rvv_vmfne_vv_mu:
17833case RISCVVector::BI__builtin_rvv_vmfne_vf_mu:
17834 ID = Intrinsic::riscv_vmfne_mask;
17835 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17836 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
17837 break;
17838case RISCVVector::BI__builtin_rvv_vmin_vv_tu:
17839case RISCVVector::BI__builtin_rvv_vmin_vx_tu:
17840 ID = Intrinsic::riscv_vmin;
17841 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
17842 break;
17843case RISCVVector::BI__builtin_rvv_vmin_vv_ta:
17844case RISCVVector::BI__builtin_rvv_vmin_vx_ta:
17845 ID = Intrinsic::riscv_vmin;
17846 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
17847 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
17848 break;
17849case RISCVVector::BI__builtin_rvv_vmin_vv_tuma:
17850case RISCVVector::BI__builtin_rvv_vmin_vx_tuma:
17851 ID = Intrinsic::riscv_vmin_mask;
17852 DefaultPolicy = 2;
17853 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17854 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
17855 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
17856 break;
17857case RISCVVector::BI__builtin_rvv_vmin_vv_tama:
17858case RISCVVector::BI__builtin_rvv_vmin_vx_tama:
17859 ID = Intrinsic::riscv_vmin_mask;
17860 DefaultPolicy = 3;
17861 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17862 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
17863 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
17864 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
17865 break;
17866case RISCVVector::BI__builtin_rvv_vmin_vv_tumu:
17867case RISCVVector::BI__builtin_rvv_vmin_vx_tumu:
17868 ID = Intrinsic::riscv_vmin_mask;
17869 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17870 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
17871 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
17872 break;
17873case RISCVVector::BI__builtin_rvv_vmin_vv_tamu:
17874case RISCVVector::BI__builtin_rvv_vmin_vx_tamu:
17875 ID = Intrinsic::riscv_vmin_mask;
17876 DefaultPolicy = 1;
17877 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17878 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
17879 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
17880 break;
17881case RISCVVector::BI__builtin_rvv_vminu_vv_tu:
17882case RISCVVector::BI__builtin_rvv_vminu_vx_tu:
17883 ID = Intrinsic::riscv_vminu;
17884 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
17885 break;
17886case RISCVVector::BI__builtin_rvv_vminu_vv_ta:
17887case RISCVVector::BI__builtin_rvv_vminu_vx_ta:
17888 ID = Intrinsic::riscv_vminu;
17889 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
17890 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
17891 break;
17892case RISCVVector::BI__builtin_rvv_vminu_vv_tuma:
17893case RISCVVector::BI__builtin_rvv_vminu_vx_tuma:
17894 ID = Intrinsic::riscv_vminu_mask;
17895 DefaultPolicy = 2;
17896 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17897 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
17898 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
17899 break;
17900case RISCVVector::BI__builtin_rvv_vminu_vv_tama:
17901case RISCVVector::BI__builtin_rvv_vminu_vx_tama:
17902 ID = Intrinsic::riscv_vminu_mask;
17903 DefaultPolicy = 3;
17904 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17905 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
17906 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
17907 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
17908 break;
17909case RISCVVector::BI__builtin_rvv_vminu_vv_tumu:
17910case RISCVVector::BI__builtin_rvv_vminu_vx_tumu:
17911 ID = Intrinsic::riscv_vminu_mask;
17912 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17913 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
17914 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
17915 break;
17916case RISCVVector::BI__builtin_rvv_vminu_vv_tamu:
17917case RISCVVector::BI__builtin_rvv_vminu_vx_tamu:
17918 ID = Intrinsic::riscv_vminu_mask;
17919 DefaultPolicy = 1;
17920 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17921 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
17922 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
17923 break;
17924case RISCVVector::BI__builtin_rvv_vmnot_m:
17925 ID = Intrinsic::riscv_vmnand;
17926 DefaultPolicy = 1;
17927IsMasked = false;
17928
17929 {
17930 // op1, vl
17931 IntrinsicTypes = {ResultType,
17932 Ops[1]->getType()};
17933 Ops.insert(Ops.begin() + 1, Ops[0]);
17934 break;
17935 }
17936 break;
17937case RISCVVector::BI__builtin_rvv_vmnand_mm:
17938 ID = Intrinsic::riscv_vmnand;
17939 DefaultPolicy = 1;
17940 IntrinsicTypes = {ResultType, Ops.back()->getType()};
17941 break;
17942case RISCVVector::BI__builtin_rvv_vmnor_mm:
17943 ID = Intrinsic::riscv_vmnor;
17944 DefaultPolicy = 1;
17945 IntrinsicTypes = {ResultType, Ops.back()->getType()};
17946 break;
17947case RISCVVector::BI__builtin_rvv_vmor_mm:
17948 ID = Intrinsic::riscv_vmor;
17949 DefaultPolicy = 1;
17950 IntrinsicTypes = {ResultType, Ops.back()->getType()};
17951 break;
17952case RISCVVector::BI__builtin_rvv_vmorn_mm:
17953 ID = Intrinsic::riscv_vmorn;
17954 DefaultPolicy = 1;
17955 IntrinsicTypes = {ResultType, Ops.back()->getType()};
17956 break;
17957case RISCVVector::BI__builtin_rvv_vmsbc_vv:
17958case RISCVVector::BI__builtin_rvv_vmsbc_vx:
17959 ID = Intrinsic::riscv_vmsbc;
17960 DefaultPolicy = 1;
17961 IntrinsicTypes = {Ops[0]->getType(), Ops[1]->getType(), Ops.back()->getType()};
17962 break;
17963case RISCVVector::BI__builtin_rvv_vmsbc_vvm:
17964case RISCVVector::BI__builtin_rvv_vmsbc_vxm:
17965 ID = Intrinsic::riscv_vmsbc_borrow_in;
17966 DefaultPolicy = 1;
17967 IntrinsicTypes = {Ops[0]->getType(), Ops[1]->getType(), Ops.back()->getType()};
17968 break;
17969case RISCVVector::BI__builtin_rvv_vmsbf_m:
17970 ID = Intrinsic::riscv_vmsbf;
17971 DefaultPolicy = 1;
17972 IntrinsicTypes = {ResultType, Ops.back()->getType()};
17973 break;
17974case RISCVVector::BI__builtin_rvv_vmsbf_m_ma:
17975 ID = Intrinsic::riscv_vmsbf_mask;
17976 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17977 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
17978 IntrinsicTypes = {ResultType, Ops.back()->getType()};
17979 break;
17980case RISCVVector::BI__builtin_rvv_vmsbf_m_tumu:
17981 ID = Intrinsic::riscv_vmsbf_mask;
17982 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17983 IntrinsicTypes = {ResultType, Ops.back()->getType()};
17984 break;
17985case RISCVVector::BI__builtin_rvv_vmsbf_m_mu:
17986 ID = Intrinsic::riscv_vmsbf_mask;
17987 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
17988 IntrinsicTypes = {ResultType, Ops.back()->getType()};
17989 break;
17990case RISCVVector::BI__builtin_rvv_vmseq_vv:
17991case RISCVVector::BI__builtin_rvv_vmseq_vx:
17992 ID = Intrinsic::riscv_vmseq;
17993 DefaultPolicy = 1;
17994 IntrinsicTypes = {Ops[0]->getType(), Ops[1]->getType(), Ops.back()->getType()};
17995 break;
17996case RISCVVector::BI__builtin_rvv_vmseq_vv_ma:
17997case RISCVVector::BI__builtin_rvv_vmseq_vx_ma:
17998 ID = Intrinsic::riscv_vmseq_mask;
17999 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18000 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
18001 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18002 break;
18003case RISCVVector::BI__builtin_rvv_vmseq_vv_tumu:
18004case RISCVVector::BI__builtin_rvv_vmseq_vx_tumu:
18005 ID = Intrinsic::riscv_vmseq_mask;
18006 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18007 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18008 break;
18009case RISCVVector::BI__builtin_rvv_vmseq_vv_mu:
18010case RISCVVector::BI__builtin_rvv_vmseq_vx_mu:
18011 ID = Intrinsic::riscv_vmseq_mask;
18012 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18013 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18014 break;
18015case RISCVVector::BI__builtin_rvv_vmset_m:
18016 ID = Intrinsic::riscv_vmset;
18017 DefaultPolicy = 1;
18018 IntrinsicTypes = {ResultType, Ops.back()->getType()};
18019 break;
18020case RISCVVector::BI__builtin_rvv_vmsge_vv:
18021case RISCVVector::BI__builtin_rvv_vmsge_vx:
18022 ID = Intrinsic::riscv_vmsge;
18023 DefaultPolicy = 1;
18024 IntrinsicTypes = {Ops[0]->getType(), Ops[1]->getType(), Ops.back()->getType()};
18025 break;
18026case RISCVVector::BI__builtin_rvv_vmsge_vv_ma:
18027case RISCVVector::BI__builtin_rvv_vmsge_vx_ma:
18028 ID = Intrinsic::riscv_vmsge_mask;
18029 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18030 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
18031 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18032 break;
18033case RISCVVector::BI__builtin_rvv_vmsge_vv_tumu:
18034case RISCVVector::BI__builtin_rvv_vmsge_vx_tumu:
18035 ID = Intrinsic::riscv_vmsge_mask;
18036 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18037 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18038 break;
18039case RISCVVector::BI__builtin_rvv_vmsge_vv_mu:
18040case RISCVVector::BI__builtin_rvv_vmsge_vx_mu:
18041 ID = Intrinsic::riscv_vmsge_mask;
18042 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18043 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18044 break;
18045case RISCVVector::BI__builtin_rvv_vmsgeu_vv:
18046case RISCVVector::BI__builtin_rvv_vmsgeu_vx:
18047 ID = Intrinsic::riscv_vmsgeu;
18048 DefaultPolicy = 1;
18049 IntrinsicTypes = {Ops[0]->getType(), Ops[1]->getType(), Ops.back()->getType()};
18050 break;
18051case RISCVVector::BI__builtin_rvv_vmsgeu_vv_ma:
18052case RISCVVector::BI__builtin_rvv_vmsgeu_vx_ma:
18053 ID = Intrinsic::riscv_vmsgeu_mask;
18054 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18055 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
18056 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18057 break;
18058case RISCVVector::BI__builtin_rvv_vmsgeu_vv_tumu:
18059case RISCVVector::BI__builtin_rvv_vmsgeu_vx_tumu:
18060 ID = Intrinsic::riscv_vmsgeu_mask;
18061 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18062 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18063 break;
18064case RISCVVector::BI__builtin_rvv_vmsgeu_vv_mu:
18065case RISCVVector::BI__builtin_rvv_vmsgeu_vx_mu:
18066 ID = Intrinsic::riscv_vmsgeu_mask;
18067 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18068 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18069 break;
18070case RISCVVector::BI__builtin_rvv_vmsgt_vv:
18071case RISCVVector::BI__builtin_rvv_vmsgt_vx:
18072 ID = Intrinsic::riscv_vmsgt;
18073 DefaultPolicy = 1;
18074 IntrinsicTypes = {Ops[0]->getType(), Ops[1]->getType(), Ops.back()->getType()};
18075 break;
18076case RISCVVector::BI__builtin_rvv_vmsgt_vv_ma:
18077case RISCVVector::BI__builtin_rvv_vmsgt_vx_ma:
18078 ID = Intrinsic::riscv_vmsgt_mask;
18079 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18080 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
18081 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18082 break;
18083case RISCVVector::BI__builtin_rvv_vmsgt_vv_tumu:
18084case RISCVVector::BI__builtin_rvv_vmsgt_vx_tumu:
18085 ID = Intrinsic::riscv_vmsgt_mask;
18086 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18087 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18088 break;
18089case RISCVVector::BI__builtin_rvv_vmsgt_vv_mu:
18090case RISCVVector::BI__builtin_rvv_vmsgt_vx_mu:
18091 ID = Intrinsic::riscv_vmsgt_mask;
18092 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18093 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18094 break;
18095case RISCVVector::BI__builtin_rvv_vmsgtu_vv:
18096case RISCVVector::BI__builtin_rvv_vmsgtu_vx:
18097 ID = Intrinsic::riscv_vmsgtu;
18098 DefaultPolicy = 1;
18099 IntrinsicTypes = {Ops[0]->getType(), Ops[1]->getType(), Ops.back()->getType()};
18100 break;
18101case RISCVVector::BI__builtin_rvv_vmsgtu_vv_ma:
18102case RISCVVector::BI__builtin_rvv_vmsgtu_vx_ma:
18103 ID = Intrinsic::riscv_vmsgtu_mask;
18104 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18105 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
18106 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18107 break;
18108case RISCVVector::BI__builtin_rvv_vmsgtu_vv_tumu:
18109case RISCVVector::BI__builtin_rvv_vmsgtu_vx_tumu:
18110 ID = Intrinsic::riscv_vmsgtu_mask;
18111 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18112 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18113 break;
18114case RISCVVector::BI__builtin_rvv_vmsgtu_vv_mu:
18115case RISCVVector::BI__builtin_rvv_vmsgtu_vx_mu:
18116 ID = Intrinsic::riscv_vmsgtu_mask;
18117 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18118 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18119 break;
18120case RISCVVector::BI__builtin_rvv_vmsif_m:
18121 ID = Intrinsic::riscv_vmsif;
18122 DefaultPolicy = 1;
18123 IntrinsicTypes = {ResultType, Ops.back()->getType()};
18124 break;
18125case RISCVVector::BI__builtin_rvv_vmsif_m_ma:
18126 ID = Intrinsic::riscv_vmsif_mask;
18127 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18128 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
18129 IntrinsicTypes = {ResultType, Ops.back()->getType()};
18130 break;
18131case RISCVVector::BI__builtin_rvv_vmsif_m_tumu:
18132 ID = Intrinsic::riscv_vmsif_mask;
18133 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18134 IntrinsicTypes = {ResultType, Ops.back()->getType()};
18135 break;
18136case RISCVVector::BI__builtin_rvv_vmsif_m_mu:
18137 ID = Intrinsic::riscv_vmsif_mask;
18138 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18139 IntrinsicTypes = {ResultType, Ops.back()->getType()};
18140 break;
18141case RISCVVector::BI__builtin_rvv_vmsle_vv:
18142case RISCVVector::BI__builtin_rvv_vmsle_vx:
18143 ID = Intrinsic::riscv_vmsle;
18144 DefaultPolicy = 1;
18145 IntrinsicTypes = {Ops[0]->getType(), Ops[1]->getType(), Ops.back()->getType()};
18146 break;
18147case RISCVVector::BI__builtin_rvv_vmsle_vv_ma:
18148case RISCVVector::BI__builtin_rvv_vmsle_vx_ma:
18149 ID = Intrinsic::riscv_vmsle_mask;
18150 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18151 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
18152 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18153 break;
18154case RISCVVector::BI__builtin_rvv_vmsle_vv_tumu:
18155case RISCVVector::BI__builtin_rvv_vmsle_vx_tumu:
18156 ID = Intrinsic::riscv_vmsle_mask;
18157 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18158 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18159 break;
18160case RISCVVector::BI__builtin_rvv_vmsle_vv_mu:
18161case RISCVVector::BI__builtin_rvv_vmsle_vx_mu:
18162 ID = Intrinsic::riscv_vmsle_mask;
18163 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18164 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18165 break;
18166case RISCVVector::BI__builtin_rvv_vmsleu_vv:
18167case RISCVVector::BI__builtin_rvv_vmsleu_vx:
18168 ID = Intrinsic::riscv_vmsleu;
18169 DefaultPolicy = 1;
18170 IntrinsicTypes = {Ops[0]->getType(), Ops[1]->getType(), Ops.back()->getType()};
18171 break;
18172case RISCVVector::BI__builtin_rvv_vmsleu_vv_ma:
18173case RISCVVector::BI__builtin_rvv_vmsleu_vx_ma:
18174 ID = Intrinsic::riscv_vmsleu_mask;
18175 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18176 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
18177 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18178 break;
18179case RISCVVector::BI__builtin_rvv_vmsleu_vv_tumu:
18180case RISCVVector::BI__builtin_rvv_vmsleu_vx_tumu:
18181 ID = Intrinsic::riscv_vmsleu_mask;
18182 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18183 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18184 break;
18185case RISCVVector::BI__builtin_rvv_vmsleu_vv_mu:
18186case RISCVVector::BI__builtin_rvv_vmsleu_vx_mu:
18187 ID = Intrinsic::riscv_vmsleu_mask;
18188 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18189 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18190 break;
18191case RISCVVector::BI__builtin_rvv_vmslt_vv:
18192case RISCVVector::BI__builtin_rvv_vmslt_vx:
18193 ID = Intrinsic::riscv_vmslt;
18194 DefaultPolicy = 1;
18195 IntrinsicTypes = {Ops[0]->getType(), Ops[1]->getType(), Ops.back()->getType()};
18196 break;
18197case RISCVVector::BI__builtin_rvv_vmslt_vv_ma:
18198case RISCVVector::BI__builtin_rvv_vmslt_vx_ma:
18199 ID = Intrinsic::riscv_vmslt_mask;
18200 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18201 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
18202 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18203 break;
18204case RISCVVector::BI__builtin_rvv_vmslt_vv_tumu:
18205case RISCVVector::BI__builtin_rvv_vmslt_vx_tumu:
18206 ID = Intrinsic::riscv_vmslt_mask;
18207 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18208 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18209 break;
18210case RISCVVector::BI__builtin_rvv_vmslt_vv_mu:
18211case RISCVVector::BI__builtin_rvv_vmslt_vx_mu:
18212 ID = Intrinsic::riscv_vmslt_mask;
18213 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18214 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18215 break;
18216case RISCVVector::BI__builtin_rvv_vmsltu_vv:
18217case RISCVVector::BI__builtin_rvv_vmsltu_vx:
18218 ID = Intrinsic::riscv_vmsltu;
18219 DefaultPolicy = 1;
18220 IntrinsicTypes = {Ops[0]->getType(), Ops[1]->getType(), Ops.back()->getType()};
18221 break;
18222case RISCVVector::BI__builtin_rvv_vmsltu_vv_ma:
18223case RISCVVector::BI__builtin_rvv_vmsltu_vx_ma:
18224 ID = Intrinsic::riscv_vmsltu_mask;
18225 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18226 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
18227 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18228 break;
18229case RISCVVector::BI__builtin_rvv_vmsltu_vv_tumu:
18230case RISCVVector::BI__builtin_rvv_vmsltu_vx_tumu:
18231 ID = Intrinsic::riscv_vmsltu_mask;
18232 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18233 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18234 break;
18235case RISCVVector::BI__builtin_rvv_vmsltu_vv_mu:
18236case RISCVVector::BI__builtin_rvv_vmsltu_vx_mu:
18237 ID = Intrinsic::riscv_vmsltu_mask;
18238 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18239 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18240 break;
18241case RISCVVector::BI__builtin_rvv_vmsne_vv:
18242case RISCVVector::BI__builtin_rvv_vmsne_vx:
18243 ID = Intrinsic::riscv_vmsne;
18244 DefaultPolicy = 1;
18245 IntrinsicTypes = {Ops[0]->getType(), Ops[1]->getType(), Ops.back()->getType()};
18246 break;
18247case RISCVVector::BI__builtin_rvv_vmsne_vv_ma:
18248case RISCVVector::BI__builtin_rvv_vmsne_vx_ma:
18249 ID = Intrinsic::riscv_vmsne_mask;
18250 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18251 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
18252 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18253 break;
18254case RISCVVector::BI__builtin_rvv_vmsne_vv_tumu:
18255case RISCVVector::BI__builtin_rvv_vmsne_vx_tumu:
18256 ID = Intrinsic::riscv_vmsne_mask;
18257 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18258 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18259 break;
18260case RISCVVector::BI__builtin_rvv_vmsne_vv_mu:
18261case RISCVVector::BI__builtin_rvv_vmsne_vx_mu:
18262 ID = Intrinsic::riscv_vmsne_mask;
18263 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18264 IntrinsicTypes = {Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18265 break;
18266case RISCVVector::BI__builtin_rvv_vmsof_m:
18267 ID = Intrinsic::riscv_vmsof;
18268 DefaultPolicy = 1;
18269 IntrinsicTypes = {ResultType, Ops.back()->getType()};
18270 break;
18271case RISCVVector::BI__builtin_rvv_vmsof_m_ma:
18272 ID = Intrinsic::riscv_vmsof_mask;
18273 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18274 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
18275 IntrinsicTypes = {ResultType, Ops.back()->getType()};
18276 break;
18277case RISCVVector::BI__builtin_rvv_vmsof_m_tumu:
18278 ID = Intrinsic::riscv_vmsof_mask;
18279 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18280 IntrinsicTypes = {ResultType, Ops.back()->getType()};
18281 break;
18282case RISCVVector::BI__builtin_rvv_vmsof_m_mu:
18283 ID = Intrinsic::riscv_vmsof_mask;
18284 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18285 IntrinsicTypes = {ResultType, Ops.back()->getType()};
18286 break;
18287case RISCVVector::BI__builtin_rvv_vmul_vv_tu:
18288case RISCVVector::BI__builtin_rvv_vmul_vx_tu:
18289 ID = Intrinsic::riscv_vmul;
18290 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
18291 break;
18292case RISCVVector::BI__builtin_rvv_vmul_vv_ta:
18293case RISCVVector::BI__builtin_rvv_vmul_vx_ta:
18294 ID = Intrinsic::riscv_vmul;
18295 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
18296 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
18297 break;
18298case RISCVVector::BI__builtin_rvv_vmul_vv_tuma:
18299case RISCVVector::BI__builtin_rvv_vmul_vx_tuma:
18300 ID = Intrinsic::riscv_vmul_mask;
18301 DefaultPolicy = 2;
18302 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18303 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18304 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
18305 break;
18306case RISCVVector::BI__builtin_rvv_vmul_vv_tama:
18307case RISCVVector::BI__builtin_rvv_vmul_vx_tama:
18308 ID = Intrinsic::riscv_vmul_mask;
18309 DefaultPolicy = 3;
18310 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18311 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18312 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
18313 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
18314 break;
18315case RISCVVector::BI__builtin_rvv_vmul_vv_tumu:
18316case RISCVVector::BI__builtin_rvv_vmul_vx_tumu:
18317 ID = Intrinsic::riscv_vmul_mask;
18318 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18319 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18320 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
18321 break;
18322case RISCVVector::BI__builtin_rvv_vmul_vv_tamu:
18323case RISCVVector::BI__builtin_rvv_vmul_vx_tamu:
18324 ID = Intrinsic::riscv_vmul_mask;
18325 DefaultPolicy = 1;
18326 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18327 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18328 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
18329 break;
18330case RISCVVector::BI__builtin_rvv_vmulh_vv_tu:
18331case RISCVVector::BI__builtin_rvv_vmulh_vx_tu:
18332 ID = Intrinsic::riscv_vmulh;
18333 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
18334 break;
18335case RISCVVector::BI__builtin_rvv_vmulh_vv_ta:
18336case RISCVVector::BI__builtin_rvv_vmulh_vx_ta:
18337 ID = Intrinsic::riscv_vmulh;
18338 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
18339 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
18340 break;
18341case RISCVVector::BI__builtin_rvv_vmulh_vv_tuma:
18342case RISCVVector::BI__builtin_rvv_vmulh_vx_tuma:
18343 ID = Intrinsic::riscv_vmulh_mask;
18344 DefaultPolicy = 2;
18345 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18346 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18347 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
18348 break;
18349case RISCVVector::BI__builtin_rvv_vmulh_vv_tama:
18350case RISCVVector::BI__builtin_rvv_vmulh_vx_tama:
18351 ID = Intrinsic::riscv_vmulh_mask;
18352 DefaultPolicy = 3;
18353 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18354 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18355 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
18356 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
18357 break;
18358case RISCVVector::BI__builtin_rvv_vmulh_vv_tumu:
18359case RISCVVector::BI__builtin_rvv_vmulh_vx_tumu:
18360 ID = Intrinsic::riscv_vmulh_mask;
18361 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18362 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18363 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
18364 break;
18365case RISCVVector::BI__builtin_rvv_vmulh_vv_tamu:
18366case RISCVVector::BI__builtin_rvv_vmulh_vx_tamu:
18367 ID = Intrinsic::riscv_vmulh_mask;
18368 DefaultPolicy = 1;
18369 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18370 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18371 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
18372 break;
18373case RISCVVector::BI__builtin_rvv_vmulhsu_vv_tu:
18374case RISCVVector::BI__builtin_rvv_vmulhsu_vx_tu:
18375 ID = Intrinsic::riscv_vmulhsu;
18376 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
18377 break;
18378case RISCVVector::BI__builtin_rvv_vmulhsu_vv_ta:
18379case RISCVVector::BI__builtin_rvv_vmulhsu_vx_ta:
18380 ID = Intrinsic::riscv_vmulhsu;
18381 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
18382 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
18383 break;
18384case RISCVVector::BI__builtin_rvv_vmulhsu_vv_tuma:
18385case RISCVVector::BI__builtin_rvv_vmulhsu_vx_tuma:
18386 ID = Intrinsic::riscv_vmulhsu_mask;
18387 DefaultPolicy = 2;
18388 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18389 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18390 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
18391 break;
18392case RISCVVector::BI__builtin_rvv_vmulhsu_vv_tama:
18393case RISCVVector::BI__builtin_rvv_vmulhsu_vx_tama:
18394 ID = Intrinsic::riscv_vmulhsu_mask;
18395 DefaultPolicy = 3;
18396 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18397 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18398 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
18399 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
18400 break;
18401case RISCVVector::BI__builtin_rvv_vmulhsu_vv_tumu:
18402case RISCVVector::BI__builtin_rvv_vmulhsu_vx_tumu:
18403 ID = Intrinsic::riscv_vmulhsu_mask;
18404 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18405 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18406 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
18407 break;
18408case RISCVVector::BI__builtin_rvv_vmulhsu_vv_tamu:
18409case RISCVVector::BI__builtin_rvv_vmulhsu_vx_tamu:
18410 ID = Intrinsic::riscv_vmulhsu_mask;
18411 DefaultPolicy = 1;
18412 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18413 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18414 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
18415 break;
18416case RISCVVector::BI__builtin_rvv_vmulhu_vv_tu:
18417case RISCVVector::BI__builtin_rvv_vmulhu_vx_tu:
18418 ID = Intrinsic::riscv_vmulhu;
18419 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
18420 break;
18421case RISCVVector::BI__builtin_rvv_vmulhu_vv_ta:
18422case RISCVVector::BI__builtin_rvv_vmulhu_vx_ta:
18423 ID = Intrinsic::riscv_vmulhu;
18424 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
18425 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
18426 break;
18427case RISCVVector::BI__builtin_rvv_vmulhu_vv_tuma:
18428case RISCVVector::BI__builtin_rvv_vmulhu_vx_tuma:
18429 ID = Intrinsic::riscv_vmulhu_mask;
18430 DefaultPolicy = 2;
18431 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18432 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18433 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
18434 break;
18435case RISCVVector::BI__builtin_rvv_vmulhu_vv_tama:
18436case RISCVVector::BI__builtin_rvv_vmulhu_vx_tama:
18437 ID = Intrinsic::riscv_vmulhu_mask;
18438 DefaultPolicy = 3;
18439 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18440 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18441 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
18442 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
18443 break;
18444case RISCVVector::BI__builtin_rvv_vmulhu_vv_tumu:
18445case RISCVVector::BI__builtin_rvv_vmulhu_vx_tumu:
18446 ID = Intrinsic::riscv_vmulhu_mask;
18447 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18448 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18449 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
18450 break;
18451case RISCVVector::BI__builtin_rvv_vmulhu_vv_tamu:
18452case RISCVVector::BI__builtin_rvv_vmulhu_vx_tamu:
18453 ID = Intrinsic::riscv_vmulhu_mask;
18454 DefaultPolicy = 1;
18455 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18456 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18457 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
18458 break;
18459case RISCVVector::BI__builtin_rvv_vmv_s_x_tu:
18460 ID = Intrinsic::riscv_vmv_s_x;
18461 IntrinsicTypes = {ResultType, Ops.back()->getType()};
18462 break;
18463case RISCVVector::BI__builtin_rvv_vmv_s_x_ta:
18464 ID = Intrinsic::riscv_vmv_s_x;
18465 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
18466 IntrinsicTypes = {ResultType, Ops.back()->getType()};
18467 break;
18468case RISCVVector::BI__builtin_rvv_vmv_v_v_tu:
18469 ID = Intrinsic::riscv_vmv_v_v;
18470 IntrinsicTypes = {ResultType, Ops.back()->getType()};
18471 break;
18472case RISCVVector::BI__builtin_rvv_vmv_v_v_ta:
18473 ID = Intrinsic::riscv_vmv_v_v;
18474 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
18475 IntrinsicTypes = {ResultType, Ops.back()->getType()};
18476 break;
18477case RISCVVector::BI__builtin_rvv_vmv_v_x_tu:
18478 ID = Intrinsic::riscv_vmv_v_x;
18479 IntrinsicTypes = {ResultType, Ops.back()->getType()};
18480 break;
18481case RISCVVector::BI__builtin_rvv_vmv_v_x_ta:
18482 ID = Intrinsic::riscv_vmv_v_x;
18483 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
18484 IntrinsicTypes = {ResultType, Ops.back()->getType()};
18485 break;
18486case RISCVVector::BI__builtin_rvv_vmv_x_s:
18487 ID = Intrinsic::riscv_vmv_x_s;
18488 IntrinsicTypes = {Ops[0]->getType()};
18489 break;
18490case RISCVVector::BI__builtin_rvv_vmxnor_mm:
18491 ID = Intrinsic::riscv_vmxnor;
18492 DefaultPolicy = 1;
18493 IntrinsicTypes = {ResultType, Ops.back()->getType()};
18494 break;
18495case RISCVVector::BI__builtin_rvv_vmxor_mm:
18496 ID = Intrinsic::riscv_vmxor;
18497 DefaultPolicy = 1;
18498 IntrinsicTypes = {ResultType, Ops.back()->getType()};
18499 break;
18500case RISCVVector::BI__builtin_rvv_vnclip_wv_tu:
18501case RISCVVector::BI__builtin_rvv_vnclip_wx_tu:
18502 ID = Intrinsic::riscv_vnclip;
18503 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18504 break;
18505case RISCVVector::BI__builtin_rvv_vnclip_wv_ta:
18506case RISCVVector::BI__builtin_rvv_vnclip_wx_ta:
18507 ID = Intrinsic::riscv_vnclip;
18508 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
18509 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18510 break;
18511case RISCVVector::BI__builtin_rvv_vnclip_wv_tuma:
18512case RISCVVector::BI__builtin_rvv_vnclip_wx_tuma:
18513 ID = Intrinsic::riscv_vnclip_mask;
18514 DefaultPolicy = 2;
18515 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18516 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18517 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18518 break;
18519case RISCVVector::BI__builtin_rvv_vnclip_wv_tama:
18520case RISCVVector::BI__builtin_rvv_vnclip_wx_tama:
18521 ID = Intrinsic::riscv_vnclip_mask;
18522 DefaultPolicy = 3;
18523 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18524 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18525 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
18526 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18527 break;
18528case RISCVVector::BI__builtin_rvv_vnclip_wv_tumu:
18529case RISCVVector::BI__builtin_rvv_vnclip_wx_tumu:
18530 ID = Intrinsic::riscv_vnclip_mask;
18531 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18532 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18533 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18534 break;
18535case RISCVVector::BI__builtin_rvv_vnclip_wv_tamu:
18536case RISCVVector::BI__builtin_rvv_vnclip_wx_tamu:
18537 ID = Intrinsic::riscv_vnclip_mask;
18538 DefaultPolicy = 1;
18539 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18540 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18541 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18542 break;
18543case RISCVVector::BI__builtin_rvv_vnclipu_wv_tu:
18544case RISCVVector::BI__builtin_rvv_vnclipu_wx_tu:
18545 ID = Intrinsic::riscv_vnclipu;
18546 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18547 break;
18548case RISCVVector::BI__builtin_rvv_vnclipu_wv_ta:
18549case RISCVVector::BI__builtin_rvv_vnclipu_wx_ta:
18550 ID = Intrinsic::riscv_vnclipu;
18551 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
18552 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18553 break;
18554case RISCVVector::BI__builtin_rvv_vnclipu_wv_tuma:
18555case RISCVVector::BI__builtin_rvv_vnclipu_wx_tuma:
18556 ID = Intrinsic::riscv_vnclipu_mask;
18557 DefaultPolicy = 2;
18558 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18559 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18560 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18561 break;
18562case RISCVVector::BI__builtin_rvv_vnclipu_wv_tama:
18563case RISCVVector::BI__builtin_rvv_vnclipu_wx_tama:
18564 ID = Intrinsic::riscv_vnclipu_mask;
18565 DefaultPolicy = 3;
18566 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18567 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18568 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
18569 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18570 break;
18571case RISCVVector::BI__builtin_rvv_vnclipu_wv_tumu:
18572case RISCVVector::BI__builtin_rvv_vnclipu_wx_tumu:
18573 ID = Intrinsic::riscv_vnclipu_mask;
18574 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18575 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18576 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18577 break;
18578case RISCVVector::BI__builtin_rvv_vnclipu_wv_tamu:
18579case RISCVVector::BI__builtin_rvv_vnclipu_wx_tamu:
18580 ID = Intrinsic::riscv_vnclipu_mask;
18581 DefaultPolicy = 1;
18582 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18583 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18584 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18585 break;
18586case RISCVVector::BI__builtin_rvv_vnmsac_vv_tu:
18587case RISCVVector::BI__builtin_rvv_vnmsac_vx_tu:
18588 ID = Intrinsic::riscv_vnmsac;
18589 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18590 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
18591 break;
18592case RISCVVector::BI__builtin_rvv_vnmsac_vv_ta:
18593case RISCVVector::BI__builtin_rvv_vnmsac_vx_ta:
18594 ID = Intrinsic::riscv_vnmsac;
18595 DefaultPolicy = 1;
18596 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18597 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
18598 break;
18599case RISCVVector::BI__builtin_rvv_vnmsac_vv_tuma:
18600case RISCVVector::BI__builtin_rvv_vnmsac_vx_tuma:
18601 ID = Intrinsic::riscv_vnmsac_mask;
18602 DefaultPolicy = 2;
18603 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18604 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18605 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
18606 break;
18607case RISCVVector::BI__builtin_rvv_vnmsac_vv_tama:
18608case RISCVVector::BI__builtin_rvv_vnmsac_vx_tama:
18609 ID = Intrinsic::riscv_vnmsac_mask;
18610 DefaultPolicy = 3;
18611 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18612 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18613 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
18614 break;
18615case RISCVVector::BI__builtin_rvv_vnmsac_vv_tumu:
18616case RISCVVector::BI__builtin_rvv_vnmsac_vx_tumu:
18617 ID = Intrinsic::riscv_vnmsac_mask;
18618 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18619 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18620 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
18621 break;
18622case RISCVVector::BI__builtin_rvv_vnmsac_vv_tamu:
18623case RISCVVector::BI__builtin_rvv_vnmsac_vx_tamu:
18624 ID = Intrinsic::riscv_vnmsac_mask;
18625 DefaultPolicy = 1;
18626 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18627 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18628 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
18629 break;
18630case RISCVVector::BI__builtin_rvv_vnmsub_vv_tu:
18631case RISCVVector::BI__builtin_rvv_vnmsub_vx_tu:
18632 ID = Intrinsic::riscv_vnmsub;
18633 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18634 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
18635 break;
18636case RISCVVector::BI__builtin_rvv_vnmsub_vv_ta:
18637case RISCVVector::BI__builtin_rvv_vnmsub_vx_ta:
18638 ID = Intrinsic::riscv_vnmsub;
18639 DefaultPolicy = 1;
18640 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18641 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
18642 break;
18643case RISCVVector::BI__builtin_rvv_vnmsub_vv_tuma:
18644case RISCVVector::BI__builtin_rvv_vnmsub_vx_tuma:
18645 ID = Intrinsic::riscv_vnmsub_mask;
18646 DefaultPolicy = 2;
18647 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18648 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18649 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
18650 break;
18651case RISCVVector::BI__builtin_rvv_vnmsub_vv_tama:
18652case RISCVVector::BI__builtin_rvv_vnmsub_vx_tama:
18653 ID = Intrinsic::riscv_vnmsub_mask;
18654 DefaultPolicy = 3;
18655 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18656 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18657 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
18658 break;
18659case RISCVVector::BI__builtin_rvv_vnmsub_vv_tumu:
18660case RISCVVector::BI__builtin_rvv_vnmsub_vx_tumu:
18661 ID = Intrinsic::riscv_vnmsub_mask;
18662 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18663 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18664 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
18665 break;
18666case RISCVVector::BI__builtin_rvv_vnmsub_vv_tamu:
18667case RISCVVector::BI__builtin_rvv_vnmsub_vx_tamu:
18668 ID = Intrinsic::riscv_vnmsub_mask;
18669 DefaultPolicy = 1;
18670 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18671 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18672 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
18673 break;
18674case RISCVVector::BI__builtin_rvv_vnsra_wv_tu:
18675case RISCVVector::BI__builtin_rvv_vnsra_wx_tu:
18676 ID = Intrinsic::riscv_vnsra;
18677 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18678 break;
18679case RISCVVector::BI__builtin_rvv_vnsra_wv_ta:
18680case RISCVVector::BI__builtin_rvv_vnsra_wx_ta:
18681 ID = Intrinsic::riscv_vnsra;
18682 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
18683 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18684 break;
18685case RISCVVector::BI__builtin_rvv_vnsra_wv_tuma:
18686case RISCVVector::BI__builtin_rvv_vnsra_wx_tuma:
18687 ID = Intrinsic::riscv_vnsra_mask;
18688 DefaultPolicy = 2;
18689 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18690 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18691 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18692 break;
18693case RISCVVector::BI__builtin_rvv_vnsra_wv_tama:
18694case RISCVVector::BI__builtin_rvv_vnsra_wx_tama:
18695 ID = Intrinsic::riscv_vnsra_mask;
18696 DefaultPolicy = 3;
18697 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18698 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18699 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
18700 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18701 break;
18702case RISCVVector::BI__builtin_rvv_vnsra_wv_tumu:
18703case RISCVVector::BI__builtin_rvv_vnsra_wx_tumu:
18704 ID = Intrinsic::riscv_vnsra_mask;
18705 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18706 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18707 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18708 break;
18709case RISCVVector::BI__builtin_rvv_vnsra_wv_tamu:
18710case RISCVVector::BI__builtin_rvv_vnsra_wx_tamu:
18711 ID = Intrinsic::riscv_vnsra_mask;
18712 DefaultPolicy = 1;
18713 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18714 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18715 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18716 break;
18717case RISCVVector::BI__builtin_rvv_vnsrl_wv_tu:
18718case RISCVVector::BI__builtin_rvv_vnsrl_wx_tu:
18719 ID = Intrinsic::riscv_vnsrl;
18720 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18721 break;
18722case RISCVVector::BI__builtin_rvv_vncvt_x_x_w_tu:
18723 ID = Intrinsic::riscv_vnsrl;
18724 DefaultPolicy = 0;
18725IsMasked = false;
18726
18727 {
18728 if (IsMasked) {
18729 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18730 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
18731 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
18732 } else {
18733 if (DefaultPolicy == TAIL_AGNOSTIC)
18734 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
18735 }
18736 Ops.insert(Ops.begin() + 2, llvm::Constant::getNullValue(Ops.back()->getType()));
18737 if (IsMasked) {
18738 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18739 // maskedoff, op1, xlen, mask, vl
18740 IntrinsicTypes = {ResultType,
18741 Ops[1]->getType(),
18742 Ops[4]->getType(),
18743 Ops[4]->getType()};
18744 } else {
18745 // passthru, op1, xlen, vl
18746 IntrinsicTypes = {ResultType,
18747 Ops[1]->getType(),
18748 Ops[3]->getType(),
18749 Ops[3]->getType()};
18750 }
18751 break;
18752 }
18753 break;
18754case RISCVVector::BI__builtin_rvv_vnsrl_wv_ta:
18755case RISCVVector::BI__builtin_rvv_vnsrl_wx_ta:
18756 ID = Intrinsic::riscv_vnsrl;
18757 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
18758 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18759 break;
18760case RISCVVector::BI__builtin_rvv_vncvt_x_x_w_ta:
18761 ID = Intrinsic::riscv_vnsrl;
18762 DefaultPolicy = 1;
18763IsMasked = false;
18764
18765 {
18766 if (IsMasked) {
18767 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18768 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
18769 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
18770 } else {
18771 if (DefaultPolicy == TAIL_AGNOSTIC)
18772 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
18773 }
18774 Ops.insert(Ops.begin() + 2, llvm::Constant::getNullValue(Ops.back()->getType()));
18775 if (IsMasked) {
18776 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18777 // maskedoff, op1, xlen, mask, vl
18778 IntrinsicTypes = {ResultType,
18779 Ops[1]->getType(),
18780 Ops[4]->getType(),
18781 Ops[4]->getType()};
18782 } else {
18783 // passthru, op1, xlen, vl
18784 IntrinsicTypes = {ResultType,
18785 Ops[1]->getType(),
18786 Ops[3]->getType(),
18787 Ops[3]->getType()};
18788 }
18789 break;
18790 }
18791 break;
18792case RISCVVector::BI__builtin_rvv_vnsrl_wv_tuma:
18793case RISCVVector::BI__builtin_rvv_vnsrl_wx_tuma:
18794 ID = Intrinsic::riscv_vnsrl_mask;
18795 DefaultPolicy = 2;
18796 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18797 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18798 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18799 break;
18800case RISCVVector::BI__builtin_rvv_vncvt_x_x_w_tuma:
18801 ID = Intrinsic::riscv_vnsrl_mask;
18802 DefaultPolicy = 2;
18803IsMasked = true;
18804
18805 {
18806 if (IsMasked) {
18807 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18808 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
18809 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
18810 } else {
18811 if (DefaultPolicy == TAIL_AGNOSTIC)
18812 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
18813 }
18814 Ops.insert(Ops.begin() + 2, llvm::Constant::getNullValue(Ops.back()->getType()));
18815 if (IsMasked) {
18816 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18817 // maskedoff, op1, xlen, mask, vl
18818 IntrinsicTypes = {ResultType,
18819 Ops[1]->getType(),
18820 Ops[4]->getType(),
18821 Ops[4]->getType()};
18822 } else {
18823 // passthru, op1, xlen, vl
18824 IntrinsicTypes = {ResultType,
18825 Ops[1]->getType(),
18826 Ops[3]->getType(),
18827 Ops[3]->getType()};
18828 }
18829 break;
18830 }
18831 break;
18832case RISCVVector::BI__builtin_rvv_vnsrl_wv_tama:
18833case RISCVVector::BI__builtin_rvv_vnsrl_wx_tama:
18834 ID = Intrinsic::riscv_vnsrl_mask;
18835 DefaultPolicy = 3;
18836 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18837 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18838 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
18839 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18840 break;
18841case RISCVVector::BI__builtin_rvv_vncvt_x_x_w_tama:
18842 ID = Intrinsic::riscv_vnsrl_mask;
18843 DefaultPolicy = 3;
18844IsMasked = true;
18845
18846 {
18847 if (IsMasked) {
18848 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18849 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
18850 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
18851 } else {
18852 if (DefaultPolicy == TAIL_AGNOSTIC)
18853 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
18854 }
18855 Ops.insert(Ops.begin() + 2, llvm::Constant::getNullValue(Ops.back()->getType()));
18856 if (IsMasked) {
18857 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18858 // maskedoff, op1, xlen, mask, vl
18859 IntrinsicTypes = {ResultType,
18860 Ops[1]->getType(),
18861 Ops[4]->getType(),
18862 Ops[4]->getType()};
18863 } else {
18864 // passthru, op1, xlen, vl
18865 IntrinsicTypes = {ResultType,
18866 Ops[1]->getType(),
18867 Ops[3]->getType(),
18868 Ops[3]->getType()};
18869 }
18870 break;
18871 }
18872 break;
18873case RISCVVector::BI__builtin_rvv_vnsrl_wv_tumu:
18874case RISCVVector::BI__builtin_rvv_vnsrl_wx_tumu:
18875 ID = Intrinsic::riscv_vnsrl_mask;
18876 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18877 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18878 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18879 break;
18880case RISCVVector::BI__builtin_rvv_vncvt_x_x_w_tumu:
18881 ID = Intrinsic::riscv_vnsrl_mask;
18882 DefaultPolicy = 0;
18883IsMasked = true;
18884
18885 {
18886 if (IsMasked) {
18887 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18888 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
18889 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
18890 } else {
18891 if (DefaultPolicy == TAIL_AGNOSTIC)
18892 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
18893 }
18894 Ops.insert(Ops.begin() + 2, llvm::Constant::getNullValue(Ops.back()->getType()));
18895 if (IsMasked) {
18896 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18897 // maskedoff, op1, xlen, mask, vl
18898 IntrinsicTypes = {ResultType,
18899 Ops[1]->getType(),
18900 Ops[4]->getType(),
18901 Ops[4]->getType()};
18902 } else {
18903 // passthru, op1, xlen, vl
18904 IntrinsicTypes = {ResultType,
18905 Ops[1]->getType(),
18906 Ops[3]->getType(),
18907 Ops[3]->getType()};
18908 }
18909 break;
18910 }
18911 break;
18912case RISCVVector::BI__builtin_rvv_vnsrl_wv_tamu:
18913case RISCVVector::BI__builtin_rvv_vnsrl_wx_tamu:
18914 ID = Intrinsic::riscv_vnsrl_mask;
18915 DefaultPolicy = 1;
18916 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18917 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18918 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
18919 break;
18920case RISCVVector::BI__builtin_rvv_vncvt_x_x_w_tamu:
18921 ID = Intrinsic::riscv_vnsrl_mask;
18922 DefaultPolicy = 1;
18923IsMasked = true;
18924
18925 {
18926 if (IsMasked) {
18927 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18928 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
18929 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
18930 } else {
18931 if (DefaultPolicy == TAIL_AGNOSTIC)
18932 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
18933 }
18934 Ops.insert(Ops.begin() + 2, llvm::Constant::getNullValue(Ops.back()->getType()));
18935 if (IsMasked) {
18936 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18937 // maskedoff, op1, xlen, mask, vl
18938 IntrinsicTypes = {ResultType,
18939 Ops[1]->getType(),
18940 Ops[4]->getType(),
18941 Ops[4]->getType()};
18942 } else {
18943 // passthru, op1, xlen, vl
18944 IntrinsicTypes = {ResultType,
18945 Ops[1]->getType(),
18946 Ops[3]->getType(),
18947 Ops[3]->getType()};
18948 }
18949 break;
18950 }
18951 break;
18952case RISCVVector::BI__builtin_rvv_vor_vv_tu:
18953case RISCVVector::BI__builtin_rvv_vor_vx_tu:
18954 ID = Intrinsic::riscv_vor;
18955 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
18956 break;
18957case RISCVVector::BI__builtin_rvv_vor_vv_ta:
18958case RISCVVector::BI__builtin_rvv_vor_vx_ta:
18959 ID = Intrinsic::riscv_vor;
18960 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
18961 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
18962 break;
18963case RISCVVector::BI__builtin_rvv_vor_vv_tuma:
18964case RISCVVector::BI__builtin_rvv_vor_vx_tuma:
18965 ID = Intrinsic::riscv_vor_mask;
18966 DefaultPolicy = 2;
18967 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18968 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18969 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
18970 break;
18971case RISCVVector::BI__builtin_rvv_vor_vv_tama:
18972case RISCVVector::BI__builtin_rvv_vor_vx_tama:
18973 ID = Intrinsic::riscv_vor_mask;
18974 DefaultPolicy = 3;
18975 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18976 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18977 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
18978 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
18979 break;
18980case RISCVVector::BI__builtin_rvv_vor_vv_tumu:
18981case RISCVVector::BI__builtin_rvv_vor_vx_tumu:
18982 ID = Intrinsic::riscv_vor_mask;
18983 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18984 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18985 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
18986 break;
18987case RISCVVector::BI__builtin_rvv_vor_vv_tamu:
18988case RISCVVector::BI__builtin_rvv_vor_vx_tamu:
18989 ID = Intrinsic::riscv_vor_mask;
18990 DefaultPolicy = 1;
18991 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
18992 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
18993 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
18994 break;
18995case RISCVVector::BI__builtin_rvv_vredand_vs_tu:
18996 ID = Intrinsic::riscv_vredand;
18997 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
18998 break;
18999case RISCVVector::BI__builtin_rvv_vredand_vs_ta:
19000 ID = Intrinsic::riscv_vredand;
19001 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
19002 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19003 break;
19004case RISCVVector::BI__builtin_rvv_vredand_vs_tum:
19005 ID = Intrinsic::riscv_vredand_mask;
19006 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19007 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19008 break;
19009case RISCVVector::BI__builtin_rvv_vredand_vs_tam:
19010 ID = Intrinsic::riscv_vredand_mask;
19011 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19012 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
19013 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19014 break;
19015case RISCVVector::BI__builtin_rvv_vredand_vs_tumu:
19016 ID = Intrinsic::riscv_vredand_mask;
19017 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19018 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19019 break;
19020case RISCVVector::BI__builtin_rvv_vredmax_vs_tu:
19021 ID = Intrinsic::riscv_vredmax;
19022 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19023 break;
19024case RISCVVector::BI__builtin_rvv_vredmax_vs_ta:
19025 ID = Intrinsic::riscv_vredmax;
19026 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
19027 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19028 break;
19029case RISCVVector::BI__builtin_rvv_vredmax_vs_tum:
19030 ID = Intrinsic::riscv_vredmax_mask;
19031 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19032 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19033 break;
19034case RISCVVector::BI__builtin_rvv_vredmax_vs_tam:
19035 ID = Intrinsic::riscv_vredmax_mask;
19036 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19037 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
19038 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19039 break;
19040case RISCVVector::BI__builtin_rvv_vredmax_vs_tumu:
19041 ID = Intrinsic::riscv_vredmax_mask;
19042 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19043 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19044 break;
19045case RISCVVector::BI__builtin_rvv_vredmaxu_vs_tu:
19046 ID = Intrinsic::riscv_vredmaxu;
19047 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19048 break;
19049case RISCVVector::BI__builtin_rvv_vredmaxu_vs_ta:
19050 ID = Intrinsic::riscv_vredmaxu;
19051 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
19052 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19053 break;
19054case RISCVVector::BI__builtin_rvv_vredmaxu_vs_tum:
19055 ID = Intrinsic::riscv_vredmaxu_mask;
19056 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19057 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19058 break;
19059case RISCVVector::BI__builtin_rvv_vredmaxu_vs_tam:
19060 ID = Intrinsic::riscv_vredmaxu_mask;
19061 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19062 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
19063 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19064 break;
19065case RISCVVector::BI__builtin_rvv_vredmaxu_vs_tumu:
19066 ID = Intrinsic::riscv_vredmaxu_mask;
19067 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19068 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19069 break;
19070case RISCVVector::BI__builtin_rvv_vredmin_vs_tu:
19071 ID = Intrinsic::riscv_vredmin;
19072 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19073 break;
19074case RISCVVector::BI__builtin_rvv_vredmin_vs_ta:
19075 ID = Intrinsic::riscv_vredmin;
19076 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
19077 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19078 break;
19079case RISCVVector::BI__builtin_rvv_vredmin_vs_tum:
19080 ID = Intrinsic::riscv_vredmin_mask;
19081 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19082 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19083 break;
19084case RISCVVector::BI__builtin_rvv_vredmin_vs_tam:
19085 ID = Intrinsic::riscv_vredmin_mask;
19086 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19087 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
19088 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19089 break;
19090case RISCVVector::BI__builtin_rvv_vredmin_vs_tumu:
19091 ID = Intrinsic::riscv_vredmin_mask;
19092 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19093 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19094 break;
19095case RISCVVector::BI__builtin_rvv_vredminu_vs_tu:
19096 ID = Intrinsic::riscv_vredminu;
19097 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19098 break;
19099case RISCVVector::BI__builtin_rvv_vredminu_vs_ta:
19100 ID = Intrinsic::riscv_vredminu;
19101 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
19102 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19103 break;
19104case RISCVVector::BI__builtin_rvv_vredminu_vs_tum:
19105 ID = Intrinsic::riscv_vredminu_mask;
19106 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19107 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19108 break;
19109case RISCVVector::BI__builtin_rvv_vredminu_vs_tam:
19110 ID = Intrinsic::riscv_vredminu_mask;
19111 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19112 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
19113 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19114 break;
19115case RISCVVector::BI__builtin_rvv_vredminu_vs_tumu:
19116 ID = Intrinsic::riscv_vredminu_mask;
19117 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19118 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19119 break;
19120case RISCVVector::BI__builtin_rvv_vredor_vs_tu:
19121 ID = Intrinsic::riscv_vredor;
19122 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19123 break;
19124case RISCVVector::BI__builtin_rvv_vredor_vs_ta:
19125 ID = Intrinsic::riscv_vredor;
19126 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
19127 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19128 break;
19129case RISCVVector::BI__builtin_rvv_vredor_vs_tum:
19130 ID = Intrinsic::riscv_vredor_mask;
19131 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19132 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19133 break;
19134case RISCVVector::BI__builtin_rvv_vredor_vs_tam:
19135 ID = Intrinsic::riscv_vredor_mask;
19136 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19137 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
19138 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19139 break;
19140case RISCVVector::BI__builtin_rvv_vredor_vs_tumu:
19141 ID = Intrinsic::riscv_vredor_mask;
19142 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19143 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19144 break;
19145case RISCVVector::BI__builtin_rvv_vredsum_vs_tu:
19146 ID = Intrinsic::riscv_vredsum;
19147 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19148 break;
19149case RISCVVector::BI__builtin_rvv_vredsum_vs_ta:
19150 ID = Intrinsic::riscv_vredsum;
19151 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
19152 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19153 break;
19154case RISCVVector::BI__builtin_rvv_vredsum_vs_tum:
19155 ID = Intrinsic::riscv_vredsum_mask;
19156 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19157 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19158 break;
19159case RISCVVector::BI__builtin_rvv_vredsum_vs_tam:
19160 ID = Intrinsic::riscv_vredsum_mask;
19161 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19162 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
19163 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19164 break;
19165case RISCVVector::BI__builtin_rvv_vredsum_vs_tumu:
19166 ID = Intrinsic::riscv_vredsum_mask;
19167 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19168 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19169 break;
19170case RISCVVector::BI__builtin_rvv_vredxor_vs_tu:
19171 ID = Intrinsic::riscv_vredxor;
19172 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19173 break;
19174case RISCVVector::BI__builtin_rvv_vredxor_vs_ta:
19175 ID = Intrinsic::riscv_vredxor;
19176 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
19177 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19178 break;
19179case RISCVVector::BI__builtin_rvv_vredxor_vs_tum:
19180 ID = Intrinsic::riscv_vredxor_mask;
19181 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19182 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19183 break;
19184case RISCVVector::BI__builtin_rvv_vredxor_vs_tam:
19185 ID = Intrinsic::riscv_vredxor_mask;
19186 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19187 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
19188 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19189 break;
19190case RISCVVector::BI__builtin_rvv_vredxor_vs_tumu:
19191 ID = Intrinsic::riscv_vredxor_mask;
19192 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19193 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19194 break;
19195case RISCVVector::BI__builtin_rvv_vrem_vv_tu:
19196case RISCVVector::BI__builtin_rvv_vrem_vx_tu:
19197 ID = Intrinsic::riscv_vrem;
19198 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19199 break;
19200case RISCVVector::BI__builtin_rvv_vrem_vv_ta:
19201case RISCVVector::BI__builtin_rvv_vrem_vx_ta:
19202 ID = Intrinsic::riscv_vrem;
19203 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
19204 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19205 break;
19206case RISCVVector::BI__builtin_rvv_vrem_vv_tuma:
19207case RISCVVector::BI__builtin_rvv_vrem_vx_tuma:
19208 ID = Intrinsic::riscv_vrem_mask;
19209 DefaultPolicy = 2;
19210 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19211 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19212 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19213 break;
19214case RISCVVector::BI__builtin_rvv_vrem_vv_tama:
19215case RISCVVector::BI__builtin_rvv_vrem_vx_tama:
19216 ID = Intrinsic::riscv_vrem_mask;
19217 DefaultPolicy = 3;
19218 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19219 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19220 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
19221 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19222 break;
19223case RISCVVector::BI__builtin_rvv_vrem_vv_tumu:
19224case RISCVVector::BI__builtin_rvv_vrem_vx_tumu:
19225 ID = Intrinsic::riscv_vrem_mask;
19226 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19227 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19228 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19229 break;
19230case RISCVVector::BI__builtin_rvv_vrem_vv_tamu:
19231case RISCVVector::BI__builtin_rvv_vrem_vx_tamu:
19232 ID = Intrinsic::riscv_vrem_mask;
19233 DefaultPolicy = 1;
19234 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19235 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19236 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19237 break;
19238case RISCVVector::BI__builtin_rvv_vremu_vv_tu:
19239case RISCVVector::BI__builtin_rvv_vremu_vx_tu:
19240 ID = Intrinsic::riscv_vremu;
19241 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19242 break;
19243case RISCVVector::BI__builtin_rvv_vremu_vv_ta:
19244case RISCVVector::BI__builtin_rvv_vremu_vx_ta:
19245 ID = Intrinsic::riscv_vremu;
19246 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
19247 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19248 break;
19249case RISCVVector::BI__builtin_rvv_vremu_vv_tuma:
19250case RISCVVector::BI__builtin_rvv_vremu_vx_tuma:
19251 ID = Intrinsic::riscv_vremu_mask;
19252 DefaultPolicy = 2;
19253 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19254 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19255 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19256 break;
19257case RISCVVector::BI__builtin_rvv_vremu_vv_tama:
19258case RISCVVector::BI__builtin_rvv_vremu_vx_tama:
19259 ID = Intrinsic::riscv_vremu_mask;
19260 DefaultPolicy = 3;
19261 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19262 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19263 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
19264 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19265 break;
19266case RISCVVector::BI__builtin_rvv_vremu_vv_tumu:
19267case RISCVVector::BI__builtin_rvv_vremu_vx_tumu:
19268 ID = Intrinsic::riscv_vremu_mask;
19269 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19270 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19271 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19272 break;
19273case RISCVVector::BI__builtin_rvv_vremu_vv_tamu:
19274case RISCVVector::BI__builtin_rvv_vremu_vx_tamu:
19275 ID = Intrinsic::riscv_vremu_mask;
19276 DefaultPolicy = 1;
19277 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19278 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19279 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19280 break;
19281case RISCVVector::BI__builtin_rvv_vrgather_vv_tu:
19282 ID = Intrinsic::riscv_vrgather_vv;
19283 IntrinsicTypes = {ResultType, Ops.back()->getType()};
19284 break;
19285case RISCVVector::BI__builtin_rvv_vrgather_vv_ta:
19286 ID = Intrinsic::riscv_vrgather_vv;
19287 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
19288 IntrinsicTypes = {ResultType, Ops.back()->getType()};
19289 break;
19290case RISCVVector::BI__builtin_rvv_vrgather_vv_tuma:
19291 ID = Intrinsic::riscv_vrgather_vv_mask;
19292 DefaultPolicy = 2;
19293 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19294 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19295 IntrinsicTypes = {ResultType, Ops.back()->getType()};
19296 break;
19297case RISCVVector::BI__builtin_rvv_vrgather_vv_tama:
19298 ID = Intrinsic::riscv_vrgather_vv_mask;
19299 DefaultPolicy = 3;
19300 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19301 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19302 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
19303 IntrinsicTypes = {ResultType, Ops.back()->getType()};
19304 break;
19305case RISCVVector::BI__builtin_rvv_vrgather_vv_tumu:
19306 ID = Intrinsic::riscv_vrgather_vv_mask;
19307 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19308 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19309 IntrinsicTypes = {ResultType, Ops.back()->getType()};
19310 break;
19311case RISCVVector::BI__builtin_rvv_vrgather_vv_tamu:
19312 ID = Intrinsic::riscv_vrgather_vv_mask;
19313 DefaultPolicy = 1;
19314 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19315 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19316 IntrinsicTypes = {ResultType, Ops.back()->getType()};
19317 break;
19318case RISCVVector::BI__builtin_rvv_vrgather_vx_tu:
19319 ID = Intrinsic::riscv_vrgather_vx;
19320 IntrinsicTypes = {ResultType, Ops.back()->getType()};
19321 break;
19322case RISCVVector::BI__builtin_rvv_vrgather_vx_ta:
19323 ID = Intrinsic::riscv_vrgather_vx;
19324 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
19325 IntrinsicTypes = {ResultType, Ops.back()->getType()};
19326 break;
19327case RISCVVector::BI__builtin_rvv_vrgather_vx_tuma:
19328 ID = Intrinsic::riscv_vrgather_vx_mask;
19329 DefaultPolicy = 2;
19330 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19331 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19332 IntrinsicTypes = {ResultType, Ops.back()->getType()};
19333 break;
19334case RISCVVector::BI__builtin_rvv_vrgather_vx_tama:
19335 ID = Intrinsic::riscv_vrgather_vx_mask;
19336 DefaultPolicy = 3;
19337 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19338 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19339 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
19340 IntrinsicTypes = {ResultType, Ops.back()->getType()};
19341 break;
19342case RISCVVector::BI__builtin_rvv_vrgather_vx_tumu:
19343 ID = Intrinsic::riscv_vrgather_vx_mask;
19344 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19345 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19346 IntrinsicTypes = {ResultType, Ops.back()->getType()};
19347 break;
19348case RISCVVector::BI__builtin_rvv_vrgather_vx_tamu:
19349 ID = Intrinsic::riscv_vrgather_vx_mask;
19350 DefaultPolicy = 1;
19351 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19352 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19353 IntrinsicTypes = {ResultType, Ops.back()->getType()};
19354 break;
19355case RISCVVector::BI__builtin_rvv_vrgatherei16_vv_tu:
19356 ID = Intrinsic::riscv_vrgatherei16_vv;
19357 IntrinsicTypes = {ResultType, Ops.back()->getType()};
19358 break;
19359case RISCVVector::BI__builtin_rvv_vrgatherei16_vv_ta:
19360 ID = Intrinsic::riscv_vrgatherei16_vv;
19361 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
19362 IntrinsicTypes = {ResultType, Ops.back()->getType()};
19363 break;
19364case RISCVVector::BI__builtin_rvv_vrgatherei16_vv_tuma:
19365 ID = Intrinsic::riscv_vrgatherei16_vv_mask;
19366 DefaultPolicy = 2;
19367 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19368 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19369 IntrinsicTypes = {ResultType, Ops.back()->getType()};
19370 break;
19371case RISCVVector::BI__builtin_rvv_vrgatherei16_vv_tama:
19372 ID = Intrinsic::riscv_vrgatherei16_vv_mask;
19373 DefaultPolicy = 3;
19374 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19375 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19376 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
19377 IntrinsicTypes = {ResultType, Ops.back()->getType()};
19378 break;
19379case RISCVVector::BI__builtin_rvv_vrgatherei16_vv_tumu:
19380 ID = Intrinsic::riscv_vrgatherei16_vv_mask;
19381 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19382 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19383 IntrinsicTypes = {ResultType, Ops.back()->getType()};
19384 break;
19385case RISCVVector::BI__builtin_rvv_vrgatherei16_vv_tamu:
19386 ID = Intrinsic::riscv_vrgatherei16_vv_mask;
19387 DefaultPolicy = 1;
19388 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19389 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19390 IntrinsicTypes = {ResultType, Ops.back()->getType()};
19391 break;
19392case RISCVVector::BI__builtin_rvv_vrsub_vx_tu:
19393 ID = Intrinsic::riscv_vrsub;
19394 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19395 break;
19396case RISCVVector::BI__builtin_rvv_vneg_v_tu:
19397 ID = Intrinsic::riscv_vrsub;
19398 DefaultPolicy = 0;
19399IsMasked = false;
19400
19401 {
19402 if (IsMasked) {
19403 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19404 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
19405 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
19406 } else {
19407 if (DefaultPolicy == TAIL_AGNOSTIC)
19408 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
19409 }
19410 auto ElemTy = cast<llvm::VectorType>(ResultType)->getElementType();
19411 Ops.insert(Ops.begin() + 2, llvm::Constant::getNullValue(ElemTy));
19412
19413 if (IsMasked) {
19414 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19415 // maskedoff, op1, op2, mask, vl, policy
19416 IntrinsicTypes = {ResultType, ElemTy, Ops[4]->getType()};
19417 } else {
19418 // passthru, op1, op2, vl
19419 IntrinsicTypes = {ResultType, ElemTy, Ops[3]->getType()};
19420 }
19421 break;
19422 }
19423 break;
19424case RISCVVector::BI__builtin_rvv_vrsub_vx_ta:
19425 ID = Intrinsic::riscv_vrsub;
19426 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
19427 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19428 break;
19429case RISCVVector::BI__builtin_rvv_vneg_v_ta:
19430 ID = Intrinsic::riscv_vrsub;
19431 DefaultPolicy = 1;
19432IsMasked = false;
19433
19434 {
19435 if (IsMasked) {
19436 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19437 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
19438 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
19439 } else {
19440 if (DefaultPolicy == TAIL_AGNOSTIC)
19441 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
19442 }
19443 auto ElemTy = cast<llvm::VectorType>(ResultType)->getElementType();
19444 Ops.insert(Ops.begin() + 2, llvm::Constant::getNullValue(ElemTy));
19445
19446 if (IsMasked) {
19447 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19448 // maskedoff, op1, op2, mask, vl, policy
19449 IntrinsicTypes = {ResultType, ElemTy, Ops[4]->getType()};
19450 } else {
19451 // passthru, op1, op2, vl
19452 IntrinsicTypes = {ResultType, ElemTy, Ops[3]->getType()};
19453 }
19454 break;
19455 }
19456 break;
19457case RISCVVector::BI__builtin_rvv_vrsub_vx_tuma:
19458 ID = Intrinsic::riscv_vrsub_mask;
19459 DefaultPolicy = 2;
19460 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19461 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19462 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19463 break;
19464case RISCVVector::BI__builtin_rvv_vneg_v_tuma:
19465 ID = Intrinsic::riscv_vrsub_mask;
19466 DefaultPolicy = 2;
19467IsMasked = true;
19468
19469 {
19470 if (IsMasked) {
19471 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19472 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
19473 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
19474 } else {
19475 if (DefaultPolicy == TAIL_AGNOSTIC)
19476 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
19477 }
19478 auto ElemTy = cast<llvm::VectorType>(ResultType)->getElementType();
19479 Ops.insert(Ops.begin() + 2, llvm::Constant::getNullValue(ElemTy));
19480
19481 if (IsMasked) {
19482 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19483 // maskedoff, op1, op2, mask, vl, policy
19484 IntrinsicTypes = {ResultType, ElemTy, Ops[4]->getType()};
19485 } else {
19486 // passthru, op1, op2, vl
19487 IntrinsicTypes = {ResultType, ElemTy, Ops[3]->getType()};
19488 }
19489 break;
19490 }
19491 break;
19492case RISCVVector::BI__builtin_rvv_vrsub_vx_tama:
19493 ID = Intrinsic::riscv_vrsub_mask;
19494 DefaultPolicy = 3;
19495 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19496 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19497 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
19498 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19499 break;
19500case RISCVVector::BI__builtin_rvv_vneg_v_tama:
19501 ID = Intrinsic::riscv_vrsub_mask;
19502 DefaultPolicy = 3;
19503IsMasked = true;
19504
19505 {
19506 if (IsMasked) {
19507 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19508 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
19509 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
19510 } else {
19511 if (DefaultPolicy == TAIL_AGNOSTIC)
19512 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
19513 }
19514 auto ElemTy = cast<llvm::VectorType>(ResultType)->getElementType();
19515 Ops.insert(Ops.begin() + 2, llvm::Constant::getNullValue(ElemTy));
19516
19517 if (IsMasked) {
19518 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19519 // maskedoff, op1, op2, mask, vl, policy
19520 IntrinsicTypes = {ResultType, ElemTy, Ops[4]->getType()};
19521 } else {
19522 // passthru, op1, op2, vl
19523 IntrinsicTypes = {ResultType, ElemTy, Ops[3]->getType()};
19524 }
19525 break;
19526 }
19527 break;
19528case RISCVVector::BI__builtin_rvv_vrsub_vx_tumu:
19529 ID = Intrinsic::riscv_vrsub_mask;
19530 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19531 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19532 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19533 break;
19534case RISCVVector::BI__builtin_rvv_vneg_v_tumu:
19535 ID = Intrinsic::riscv_vrsub_mask;
19536 DefaultPolicy = 0;
19537IsMasked = true;
19538
19539 {
19540 if (IsMasked) {
19541 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19542 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
19543 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
19544 } else {
19545 if (DefaultPolicy == TAIL_AGNOSTIC)
19546 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
19547 }
19548 auto ElemTy = cast<llvm::VectorType>(ResultType)->getElementType();
19549 Ops.insert(Ops.begin() + 2, llvm::Constant::getNullValue(ElemTy));
19550
19551 if (IsMasked) {
19552 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19553 // maskedoff, op1, op2, mask, vl, policy
19554 IntrinsicTypes = {ResultType, ElemTy, Ops[4]->getType()};
19555 } else {
19556 // passthru, op1, op2, vl
19557 IntrinsicTypes = {ResultType, ElemTy, Ops[3]->getType()};
19558 }
19559 break;
19560 }
19561 break;
19562case RISCVVector::BI__builtin_rvv_vrsub_vx_tamu:
19563 ID = Intrinsic::riscv_vrsub_mask;
19564 DefaultPolicy = 1;
19565 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19566 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19567 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19568 break;
19569case RISCVVector::BI__builtin_rvv_vneg_v_tamu:
19570 ID = Intrinsic::riscv_vrsub_mask;
19571 DefaultPolicy = 1;
19572IsMasked = true;
19573
19574 {
19575 if (IsMasked) {
19576 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19577 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
19578 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
19579 } else {
19580 if (DefaultPolicy == TAIL_AGNOSTIC)
19581 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
19582 }
19583 auto ElemTy = cast<llvm::VectorType>(ResultType)->getElementType();
19584 Ops.insert(Ops.begin() + 2, llvm::Constant::getNullValue(ElemTy));
19585
19586 if (IsMasked) {
19587 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19588 // maskedoff, op1, op2, mask, vl, policy
19589 IntrinsicTypes = {ResultType, ElemTy, Ops[4]->getType()};
19590 } else {
19591 // passthru, op1, op2, vl
19592 IntrinsicTypes = {ResultType, ElemTy, Ops[3]->getType()};
19593 }
19594 break;
19595 }
19596 break;
19597case RISCVVector::BI__builtin_rvv_vsadd_vv_tu:
19598case RISCVVector::BI__builtin_rvv_vsadd_vx_tu:
19599 ID = Intrinsic::riscv_vsadd;
19600 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19601 break;
19602case RISCVVector::BI__builtin_rvv_vsadd_vv_ta:
19603case RISCVVector::BI__builtin_rvv_vsadd_vx_ta:
19604 ID = Intrinsic::riscv_vsadd;
19605 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
19606 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19607 break;
19608case RISCVVector::BI__builtin_rvv_vsadd_vv_tuma:
19609case RISCVVector::BI__builtin_rvv_vsadd_vx_tuma:
19610 ID = Intrinsic::riscv_vsadd_mask;
19611 DefaultPolicy = 2;
19612 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19613 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19614 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19615 break;
19616case RISCVVector::BI__builtin_rvv_vsadd_vv_tama:
19617case RISCVVector::BI__builtin_rvv_vsadd_vx_tama:
19618 ID = Intrinsic::riscv_vsadd_mask;
19619 DefaultPolicy = 3;
19620 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19621 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19622 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
19623 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19624 break;
19625case RISCVVector::BI__builtin_rvv_vsadd_vv_tumu:
19626case RISCVVector::BI__builtin_rvv_vsadd_vx_tumu:
19627 ID = Intrinsic::riscv_vsadd_mask;
19628 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19629 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19630 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19631 break;
19632case RISCVVector::BI__builtin_rvv_vsadd_vv_tamu:
19633case RISCVVector::BI__builtin_rvv_vsadd_vx_tamu:
19634 ID = Intrinsic::riscv_vsadd_mask;
19635 DefaultPolicy = 1;
19636 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19637 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19638 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19639 break;
19640case RISCVVector::BI__builtin_rvv_vsaddu_vv_tu:
19641case RISCVVector::BI__builtin_rvv_vsaddu_vx_tu:
19642 ID = Intrinsic::riscv_vsaddu;
19643 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19644 break;
19645case RISCVVector::BI__builtin_rvv_vsaddu_vv_ta:
19646case RISCVVector::BI__builtin_rvv_vsaddu_vx_ta:
19647 ID = Intrinsic::riscv_vsaddu;
19648 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
19649 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19650 break;
19651case RISCVVector::BI__builtin_rvv_vsaddu_vv_tuma:
19652case RISCVVector::BI__builtin_rvv_vsaddu_vx_tuma:
19653 ID = Intrinsic::riscv_vsaddu_mask;
19654 DefaultPolicy = 2;
19655 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19656 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19657 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19658 break;
19659case RISCVVector::BI__builtin_rvv_vsaddu_vv_tama:
19660case RISCVVector::BI__builtin_rvv_vsaddu_vx_tama:
19661 ID = Intrinsic::riscv_vsaddu_mask;
19662 DefaultPolicy = 3;
19663 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19664 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19665 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
19666 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19667 break;
19668case RISCVVector::BI__builtin_rvv_vsaddu_vv_tumu:
19669case RISCVVector::BI__builtin_rvv_vsaddu_vx_tumu:
19670 ID = Intrinsic::riscv_vsaddu_mask;
19671 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19672 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19673 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19674 break;
19675case RISCVVector::BI__builtin_rvv_vsaddu_vv_tamu:
19676case RISCVVector::BI__builtin_rvv_vsaddu_vx_tamu:
19677 ID = Intrinsic::riscv_vsaddu_mask;
19678 DefaultPolicy = 1;
19679 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19680 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19681 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19682 break;
19683case RISCVVector::BI__builtin_rvv_vsbc_vvm_tu:
19684case RISCVVector::BI__builtin_rvv_vsbc_vxm_tu:
19685 ID = Intrinsic::riscv_vsbc;
19686 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19687 break;
19688case RISCVVector::BI__builtin_rvv_vsbc_vvm_ta:
19689case RISCVVector::BI__builtin_rvv_vsbc_vxm_ta:
19690 ID = Intrinsic::riscv_vsbc;
19691 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
19692 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19693 break;
19694case RISCVVector::BI__builtin_rvv_vse8_v:
19695case RISCVVector::BI__builtin_rvv_vse16_v:
19696case RISCVVector::BI__builtin_rvv_vse32_v:
19697case RISCVVector::BI__builtin_rvv_vse64_v:
19698 ID = Intrinsic::riscv_vse;
19699 DefaultPolicy = 1;
19700IsMasked = false;
19701
19702 if (IsMasked) {
19703 // Builtin: (mask, ptr, value, vl). Intrinsic: (value, ptr, mask, vl)
19704 std::swap(Ops[0], Ops[2]);
19705 } else {
19706 // Builtin: (ptr, value, vl). Intrinsic: (value, ptr, vl)
19707 std::swap(Ops[0], Ops[1]);
19708 }
19709 Ops[1] = Builder.CreateBitCast(Ops[1], Ops[0]->getType()->getPointerTo());
19710 if (IsMasked)
19711 IntrinsicTypes = {Ops[0]->getType(), Ops[3]->getType()};
19712 else
19713 IntrinsicTypes = {Ops[0]->getType(), Ops[2]->getType()};
19714 break;
19715case RISCVVector::BI__builtin_rvv_vse8_v_m:
19716case RISCVVector::BI__builtin_rvv_vse16_v_m:
19717case RISCVVector::BI__builtin_rvv_vse32_v_m:
19718case RISCVVector::BI__builtin_rvv_vse64_v_m:
19719 ID = Intrinsic::riscv_vse_mask;
19720 DefaultPolicy = 0;
19721IsMasked = true;
19722
19723 if (IsMasked) {
19724 // Builtin: (mask, ptr, value, vl). Intrinsic: (value, ptr, mask, vl)
19725 std::swap(Ops[0], Ops[2]);
19726 } else {
19727 // Builtin: (ptr, value, vl). Intrinsic: (value, ptr, vl)
19728 std::swap(Ops[0], Ops[1]);
19729 }
19730 Ops[1] = Builder.CreateBitCast(Ops[1], Ops[0]->getType()->getPointerTo());
19731 if (IsMasked)
19732 IntrinsicTypes = {Ops[0]->getType(), Ops[3]->getType()};
19733 else
19734 IntrinsicTypes = {Ops[0]->getType(), Ops[2]->getType()};
19735 break;
19736case RISCVVector::BI__builtin_rvv_vsetvli:
19737 ID = Intrinsic::riscv_vsetvli;
19738 DefaultPolicy = 1;
19739IsMasked = false;
19740IntrinsicTypes = {ResultType};break;
19741case RISCVVector::BI__builtin_rvv_vsetvlimax:
19742 ID = Intrinsic::riscv_vsetvlimax;
19743 DefaultPolicy = 1;
19744IsMasked = false;
19745IntrinsicTypes = {ResultType};break;
19746case RISCVVector::BI__builtin_rvv_vsext_vf2_tu:
19747case RISCVVector::BI__builtin_rvv_vsext_vf4_tu:
19748case RISCVVector::BI__builtin_rvv_vsext_vf8_tu:
19749 ID = Intrinsic::riscv_vsext;
19750 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19751 break;
19752case RISCVVector::BI__builtin_rvv_vsext_vf2_ta:
19753case RISCVVector::BI__builtin_rvv_vsext_vf4_ta:
19754case RISCVVector::BI__builtin_rvv_vsext_vf8_ta:
19755 ID = Intrinsic::riscv_vsext;
19756 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
19757 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19758 break;
19759case RISCVVector::BI__builtin_rvv_vsext_vf2_tuma:
19760case RISCVVector::BI__builtin_rvv_vsext_vf4_tuma:
19761case RISCVVector::BI__builtin_rvv_vsext_vf8_tuma:
19762 ID = Intrinsic::riscv_vsext_mask;
19763 DefaultPolicy = 2;
19764 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19765 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19766 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19767 break;
19768case RISCVVector::BI__builtin_rvv_vsext_vf2_tama:
19769case RISCVVector::BI__builtin_rvv_vsext_vf4_tama:
19770case RISCVVector::BI__builtin_rvv_vsext_vf8_tama:
19771 ID = Intrinsic::riscv_vsext_mask;
19772 DefaultPolicy = 3;
19773 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19774 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19775 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
19776 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19777 break;
19778case RISCVVector::BI__builtin_rvv_vsext_vf2_tumu:
19779case RISCVVector::BI__builtin_rvv_vsext_vf4_tumu:
19780case RISCVVector::BI__builtin_rvv_vsext_vf8_tumu:
19781 ID = Intrinsic::riscv_vsext_mask;
19782 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19783 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19784 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19785 break;
19786case RISCVVector::BI__builtin_rvv_vsext_vf2_tamu:
19787case RISCVVector::BI__builtin_rvv_vsext_vf4_tamu:
19788case RISCVVector::BI__builtin_rvv_vsext_vf8_tamu:
19789 ID = Intrinsic::riscv_vsext_mask;
19790 DefaultPolicy = 1;
19791 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19792 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19793 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
19794 break;
19795case RISCVVector::BI__builtin_rvv_vslide1down_vx_tu:
19796 ID = Intrinsic::riscv_vslide1down;
19797 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19798 break;
19799case RISCVVector::BI__builtin_rvv_vslide1down_vx_ta:
19800 ID = Intrinsic::riscv_vslide1down;
19801 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
19802 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19803 break;
19804case RISCVVector::BI__builtin_rvv_vslide1down_vx_tuma:
19805 ID = Intrinsic::riscv_vslide1down_mask;
19806 DefaultPolicy = 2;
19807 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19808 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19809 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19810 break;
19811case RISCVVector::BI__builtin_rvv_vslide1down_vx_tama:
19812 ID = Intrinsic::riscv_vslide1down_mask;
19813 DefaultPolicy = 3;
19814 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19815 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19816 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
19817 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19818 break;
19819case RISCVVector::BI__builtin_rvv_vslide1down_vx_tumu:
19820 ID = Intrinsic::riscv_vslide1down_mask;
19821 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19822 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19823 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19824 break;
19825case RISCVVector::BI__builtin_rvv_vslide1down_vx_tamu:
19826 ID = Intrinsic::riscv_vslide1down_mask;
19827 DefaultPolicy = 1;
19828 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19829 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19830 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19831 break;
19832case RISCVVector::BI__builtin_rvv_vslide1up_vx_tu:
19833 ID = Intrinsic::riscv_vslide1up;
19834 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19835 break;
19836case RISCVVector::BI__builtin_rvv_vslide1up_vx_ta:
19837 ID = Intrinsic::riscv_vslide1up;
19838 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
19839 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19840 break;
19841case RISCVVector::BI__builtin_rvv_vslide1up_vx_tuma:
19842 ID = Intrinsic::riscv_vslide1up_mask;
19843 DefaultPolicy = 2;
19844 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19845 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19846 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19847 break;
19848case RISCVVector::BI__builtin_rvv_vslide1up_vx_tama:
19849 ID = Intrinsic::riscv_vslide1up_mask;
19850 DefaultPolicy = 3;
19851 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19852 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19853 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
19854 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19855 break;
19856case RISCVVector::BI__builtin_rvv_vslide1up_vx_tumu:
19857 ID = Intrinsic::riscv_vslide1up_mask;
19858 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19859 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19860 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19861 break;
19862case RISCVVector::BI__builtin_rvv_vslide1up_vx_tamu:
19863 ID = Intrinsic::riscv_vslide1up_mask;
19864 DefaultPolicy = 1;
19865 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19866 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19867 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19868 break;
19869case RISCVVector::BI__builtin_rvv_vslidedown_vx_tu:
19870 ID = Intrinsic::riscv_vslidedown;
19871 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19872 IntrinsicTypes = {ResultType, Ops.back()->getType()};
19873 break;
19874case RISCVVector::BI__builtin_rvv_vslidedown_vx_ta:
19875 ID = Intrinsic::riscv_vslidedown;
19876 DefaultPolicy = 1;
19877 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19878 IntrinsicTypes = {ResultType, Ops.back()->getType()};
19879 break;
19880case RISCVVector::BI__builtin_rvv_vslidedown_vx_tuma:
19881 ID = Intrinsic::riscv_vslidedown_mask;
19882 DefaultPolicy = 2;
19883 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19884 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19885 IntrinsicTypes = {ResultType, Ops.back()->getType()};
19886 break;
19887case RISCVVector::BI__builtin_rvv_vslidedown_vx_tama:
19888 ID = Intrinsic::riscv_vslidedown_mask;
19889 DefaultPolicy = 3;
19890 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19891 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19892 IntrinsicTypes = {ResultType, Ops.back()->getType()};
19893 break;
19894case RISCVVector::BI__builtin_rvv_vslidedown_vx_tumu:
19895 ID = Intrinsic::riscv_vslidedown_mask;
19896 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19897 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19898 IntrinsicTypes = {ResultType, Ops.back()->getType()};
19899 break;
19900case RISCVVector::BI__builtin_rvv_vslidedown_vx_tamu:
19901 ID = Intrinsic::riscv_vslidedown_mask;
19902 DefaultPolicy = 1;
19903 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19904 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19905 IntrinsicTypes = {ResultType, Ops.back()->getType()};
19906 break;
19907case RISCVVector::BI__builtin_rvv_vslideup_vx_tu:
19908 ID = Intrinsic::riscv_vslideup;
19909 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19910 IntrinsicTypes = {ResultType, Ops.back()->getType()};
19911 break;
19912case RISCVVector::BI__builtin_rvv_vslideup_vx_ta:
19913 ID = Intrinsic::riscv_vslideup;
19914 DefaultPolicy = 1;
19915 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19916 IntrinsicTypes = {ResultType, Ops.back()->getType()};
19917 break;
19918case RISCVVector::BI__builtin_rvv_vslideup_vx_tuma:
19919 ID = Intrinsic::riscv_vslideup_mask;
19920 DefaultPolicy = 2;
19921 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19922 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19923 IntrinsicTypes = {ResultType, Ops.back()->getType()};
19924 break;
19925case RISCVVector::BI__builtin_rvv_vslideup_vx_tama:
19926 ID = Intrinsic::riscv_vslideup_mask;
19927 DefaultPolicy = 3;
19928 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19929 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19930 IntrinsicTypes = {ResultType, Ops.back()->getType()};
19931 break;
19932case RISCVVector::BI__builtin_rvv_vslideup_vx_tumu:
19933 ID = Intrinsic::riscv_vslideup_mask;
19934 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19935 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19936 IntrinsicTypes = {ResultType, Ops.back()->getType()};
19937 break;
19938case RISCVVector::BI__builtin_rvv_vslideup_vx_tamu:
19939 ID = Intrinsic::riscv_vslideup_mask;
19940 DefaultPolicy = 1;
19941 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19942 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19943 IntrinsicTypes = {ResultType, Ops.back()->getType()};
19944 break;
19945case RISCVVector::BI__builtin_rvv_vsll_vv_tu:
19946case RISCVVector::BI__builtin_rvv_vsll_vx_tu:
19947 ID = Intrinsic::riscv_vsll;
19948 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19949 break;
19950case RISCVVector::BI__builtin_rvv_vsll_vv_ta:
19951case RISCVVector::BI__builtin_rvv_vsll_vx_ta:
19952 ID = Intrinsic::riscv_vsll;
19953 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
19954 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19955 break;
19956case RISCVVector::BI__builtin_rvv_vsll_vv_tuma:
19957case RISCVVector::BI__builtin_rvv_vsll_vx_tuma:
19958 ID = Intrinsic::riscv_vsll_mask;
19959 DefaultPolicy = 2;
19960 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19961 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19962 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19963 break;
19964case RISCVVector::BI__builtin_rvv_vsll_vv_tama:
19965case RISCVVector::BI__builtin_rvv_vsll_vx_tama:
19966 ID = Intrinsic::riscv_vsll_mask;
19967 DefaultPolicy = 3;
19968 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19969 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19970 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
19971 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19972 break;
19973case RISCVVector::BI__builtin_rvv_vsll_vv_tumu:
19974case RISCVVector::BI__builtin_rvv_vsll_vx_tumu:
19975 ID = Intrinsic::riscv_vsll_mask;
19976 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19977 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19978 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19979 break;
19980case RISCVVector::BI__builtin_rvv_vsll_vv_tamu:
19981case RISCVVector::BI__builtin_rvv_vsll_vx_tamu:
19982 ID = Intrinsic::riscv_vsll_mask;
19983 DefaultPolicy = 1;
19984 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
19985 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
19986 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
19987 break;
19988case RISCVVector::BI__builtin_rvv_vsm_v:
19989 ID = Intrinsic::riscv_vsm;
19990 DefaultPolicy = 1;
19991IsMasked = false;
19992
19993 if (IsMasked) {
19994 // Builtin: (mask, ptr, value, vl). Intrinsic: (value, ptr, mask, vl)
19995 std::swap(Ops[0], Ops[2]);
19996 } else {
19997 // Builtin: (ptr, value, vl). Intrinsic: (value, ptr, vl)
19998 std::swap(Ops[0], Ops[1]);
19999 }
20000 Ops[1] = Builder.CreateBitCast(Ops[1], Ops[0]->getType()->getPointerTo());
20001 if (IsMasked)
20002 IntrinsicTypes = {Ops[0]->getType(), Ops[3]->getType()};
20003 else
20004 IntrinsicTypes = {Ops[0]->getType(), Ops[2]->getType()};
20005 break;
20006case RISCVVector::BI__builtin_rvv_vsmul_vv_tu:
20007case RISCVVector::BI__builtin_rvv_vsmul_vx_tu:
20008 ID = Intrinsic::riscv_vsmul;
20009 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
20010 break;
20011case RISCVVector::BI__builtin_rvv_vsmul_vv_ta:
20012case RISCVVector::BI__builtin_rvv_vsmul_vx_ta:
20013 ID = Intrinsic::riscv_vsmul;
20014 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
20015 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
20016 break;
20017case RISCVVector::BI__builtin_rvv_vsmul_vv_tuma:
20018case RISCVVector::BI__builtin_rvv_vsmul_vx_tuma:
20019 ID = Intrinsic::riscv_vsmul_mask;
20020 DefaultPolicy = 2;
20021 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
20022 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
20023 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
20024 break;
20025case RISCVVector::BI__builtin_rvv_vsmul_vv_tama:
20026case RISCVVector::BI__builtin_rvv_vsmul_vx_tama:
20027 ID = Intrinsic::riscv_vsmul_mask;
20028 DefaultPolicy = 3;
20029 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
20030 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
20031 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
20032 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
20033 break;
20034case RISCVVector::BI__builtin_rvv_vsmul_vv_tumu:
20035case RISCVVector::BI__builtin_rvv_vsmul_vx_tumu:
20036 ID = Intrinsic::riscv_vsmul_mask;
20037 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
20038 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
20039 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
20040 break;
20041case RISCVVector::BI__builtin_rvv_vsmul_vv_tamu:
20042case RISCVVector::BI__builtin_rvv_vsmul_vx_tamu:
20043 ID = Intrinsic::riscv_vsmul_mask;
20044 DefaultPolicy = 1;
20045 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
20046 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
20047 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
20048 break;
20049case RISCVVector::BI__builtin_rvv_vsoxei8_v:
20050case RISCVVector::BI__builtin_rvv_vsoxei16_v:
20051case RISCVVector::BI__builtin_rvv_vsoxei32_v:
20052case RISCVVector::BI__builtin_rvv_vsoxei64_v:
20053 ID = Intrinsic::riscv_vsoxei;
20054 DefaultPolicy = 1;
20055IsMasked = false;
20056
20057 if (IsMasked) {
20058 // Builtin: (mask, ptr, index, value, vl). Intrinsic: (value, ptr, index, mask, vl)
20059 std::swap(Ops[0], Ops[3]);
20060 } else {
20061 // Builtin: (ptr, index, value, vl). Intrinsic: (value, ptr, index, vl)
20062 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.begin() + 3);
20063 }
20064 Ops[1] = Builder.CreateBitCast(Ops[1], Ops[0]->getType()->getPointerTo());
20065 if (IsMasked)
20066 IntrinsicTypes = {Ops[0]->getType(), Ops[2]->getType(), Ops[4]->getType()};
20067 else
20068 IntrinsicTypes = {Ops[0]->getType(), Ops[2]->getType(), Ops[3]->getType()};
20069 break;
20070case RISCVVector::BI__builtin_rvv_vsoxei8_v_m:
20071case RISCVVector::BI__builtin_rvv_vsoxei16_v_m:
20072case RISCVVector::BI__builtin_rvv_vsoxei32_v_m:
20073case RISCVVector::BI__builtin_rvv_vsoxei64_v_m:
20074 ID = Intrinsic::riscv_vsoxei_mask;
20075 DefaultPolicy = 0;
20076IsMasked = true;
20077
20078 if (IsMasked) {
20079 // Builtin: (mask, ptr, index, value, vl). Intrinsic: (value, ptr, index, mask, vl)
20080 std::swap(Ops[0], Ops[3]);
20081 } else {
20082 // Builtin: (ptr, index, value, vl). Intrinsic: (value, ptr, index, vl)
20083 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.begin() + 3);
20084 }
20085 Ops[1] = Builder.CreateBitCast(Ops[1], Ops[0]->getType()->getPointerTo());
20086 if (IsMasked)
20087 IntrinsicTypes = {Ops[0]->getType(), Ops[2]->getType(), Ops[4]->getType()};
20088 else
20089 IntrinsicTypes = {Ops[0]->getType(), Ops[2]->getType(), Ops[3]->getType()};
20090 break;
20091case RISCVVector::BI__builtin_rvv_vsoxseg2ei8_v:
20092case RISCVVector::BI__builtin_rvv_vsoxseg2ei16_v:
20093case RISCVVector::BI__builtin_rvv_vsoxseg2ei32_v:
20094case RISCVVector::BI__builtin_rvv_vsoxseg2ei64_v:
20095 ID = Intrinsic::riscv_vsoxseg2;
20096 NF = 2;
20097 DefaultPolicy = 1;
20098IsMasked = false;
20099
20100 {
20101 if (IsMasked) {
20102 // Builtin: (mask, ptr, index, val0, val1, ..., vl)
20103 // Intrinsic: (val0, val1, ..., ptr, index, mask, vl)
20104 std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
20105 std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
20106 IntrinsicTypes = {Ops[0]->getType(),
20107 Ops[NF + 1]->getType(), Ops[NF + 3]->getType()};
20108 assert(Ops.size() == NF + 4)(static_cast <bool> (Ops.size() == NF + 4) ? void (0) :
__assert_fail ("Ops.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20108, __extension__ __PRETTY_FUNCTION__));
20109 } else {
20110 // Builtin: (ptr, index, val0, val1, ..., vl)
20111 // Intrinsic: (val0, val1, ..., ptr, index, vl)
20112 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
20113 IntrinsicTypes = {Ops[0]->getType(),
20114 Ops[NF + 1]->getType(), Ops[NF + 2]->getType()};
20115 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20115, __extension__ __PRETTY_FUNCTION__));
20116 }
20117 }
20118 break;
20119case RISCVVector::BI__builtin_rvv_vsoxseg2ei8_v_m:
20120case RISCVVector::BI__builtin_rvv_vsoxseg2ei16_v_m:
20121case RISCVVector::BI__builtin_rvv_vsoxseg2ei32_v_m:
20122case RISCVVector::BI__builtin_rvv_vsoxseg2ei64_v_m:
20123 ID = Intrinsic::riscv_vsoxseg2_mask;
20124 NF = 2;
20125 DefaultPolicy = 0;
20126IsMasked = true;
20127
20128 {
20129 if (IsMasked) {
20130 // Builtin: (mask, ptr, index, val0, val1, ..., vl)
20131 // Intrinsic: (val0, val1, ..., ptr, index, mask, vl)
20132 std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
20133 std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
20134 IntrinsicTypes = {Ops[0]->getType(),
20135 Ops[NF + 1]->getType(), Ops[NF + 3]->getType()};
20136 assert(Ops.size() == NF + 4)(static_cast <bool> (Ops.size() == NF + 4) ? void (0) :
__assert_fail ("Ops.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20136, __extension__ __PRETTY_FUNCTION__));
20137 } else {
20138 // Builtin: (ptr, index, val0, val1, ..., vl)
20139 // Intrinsic: (val0, val1, ..., ptr, index, vl)
20140 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
20141 IntrinsicTypes = {Ops[0]->getType(),
20142 Ops[NF + 1]->getType(), Ops[NF + 2]->getType()};
20143 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20143, __extension__ __PRETTY_FUNCTION__));
20144 }
20145 }
20146 break;
20147case RISCVVector::BI__builtin_rvv_vsoxseg3ei8_v:
20148case RISCVVector::BI__builtin_rvv_vsoxseg3ei16_v:
20149case RISCVVector::BI__builtin_rvv_vsoxseg3ei32_v:
20150case RISCVVector::BI__builtin_rvv_vsoxseg3ei64_v:
20151 ID = Intrinsic::riscv_vsoxseg3;
20152 NF = 3;
20153 DefaultPolicy = 1;
20154IsMasked = false;
20155
20156 {
20157 if (IsMasked) {
20158 // Builtin: (mask, ptr, index, val0, val1, ..., vl)
20159 // Intrinsic: (val0, val1, ..., ptr, index, mask, vl)
20160 std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
20161 std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
20162 IntrinsicTypes = {Ops[0]->getType(),
20163 Ops[NF + 1]->getType(), Ops[NF + 3]->getType()};
20164 assert(Ops.size() == NF + 4)(static_cast <bool> (Ops.size() == NF + 4) ? void (0) :
__assert_fail ("Ops.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20164, __extension__ __PRETTY_FUNCTION__));
20165 } else {
20166 // Builtin: (ptr, index, val0, val1, ..., vl)
20167 // Intrinsic: (val0, val1, ..., ptr, index, vl)
20168 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
20169 IntrinsicTypes = {Ops[0]->getType(),
20170 Ops[NF + 1]->getType(), Ops[NF + 2]->getType()};
20171 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20171, __extension__ __PRETTY_FUNCTION__));
20172 }
20173 }
20174 break;
20175case RISCVVector::BI__builtin_rvv_vsoxseg3ei8_v_m:
20176case RISCVVector::BI__builtin_rvv_vsoxseg3ei16_v_m:
20177case RISCVVector::BI__builtin_rvv_vsoxseg3ei32_v_m:
20178case RISCVVector::BI__builtin_rvv_vsoxseg3ei64_v_m:
20179 ID = Intrinsic::riscv_vsoxseg3_mask;
20180 NF = 3;
20181 DefaultPolicy = 0;
20182IsMasked = true;
20183
20184 {
20185 if (IsMasked) {
20186 // Builtin: (mask, ptr, index, val0, val1, ..., vl)
20187 // Intrinsic: (val0, val1, ..., ptr, index, mask, vl)
20188 std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
20189 std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
20190 IntrinsicTypes = {Ops[0]->getType(),
20191 Ops[NF + 1]->getType(), Ops[NF + 3]->getType()};
20192 assert(Ops.size() == NF + 4)(static_cast <bool> (Ops.size() == NF + 4) ? void (0) :
__assert_fail ("Ops.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20192, __extension__ __PRETTY_FUNCTION__));
20193 } else {
20194 // Builtin: (ptr, index, val0, val1, ..., vl)
20195 // Intrinsic: (val0, val1, ..., ptr, index, vl)
20196 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
20197 IntrinsicTypes = {Ops[0]->getType(),
20198 Ops[NF + 1]->getType(), Ops[NF + 2]->getType()};
20199 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20199, __extension__ __PRETTY_FUNCTION__));
20200 }
20201 }
20202 break;
20203case RISCVVector::BI__builtin_rvv_vsoxseg4ei8_v:
20204case RISCVVector::BI__builtin_rvv_vsoxseg4ei16_v:
20205case RISCVVector::BI__builtin_rvv_vsoxseg4ei32_v:
20206case RISCVVector::BI__builtin_rvv_vsoxseg4ei64_v:
20207 ID = Intrinsic::riscv_vsoxseg4;
20208 NF = 4;
20209 DefaultPolicy = 1;
20210IsMasked = false;
20211
20212 {
20213 if (IsMasked) {
20214 // Builtin: (mask, ptr, index, val0, val1, ..., vl)
20215 // Intrinsic: (val0, val1, ..., ptr, index, mask, vl)
20216 std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
20217 std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
20218 IntrinsicTypes = {Ops[0]->getType(),
20219 Ops[NF + 1]->getType(), Ops[NF + 3]->getType()};
20220 assert(Ops.size() == NF + 4)(static_cast <bool> (Ops.size() == NF + 4) ? void (0) :
__assert_fail ("Ops.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20220, __extension__ __PRETTY_FUNCTION__));
20221 } else {
20222 // Builtin: (ptr, index, val0, val1, ..., vl)
20223 // Intrinsic: (val0, val1, ..., ptr, index, vl)
20224 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
20225 IntrinsicTypes = {Ops[0]->getType(),
20226 Ops[NF + 1]->getType(), Ops[NF + 2]->getType()};
20227 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20227, __extension__ __PRETTY_FUNCTION__));
20228 }
20229 }
20230 break;
20231case RISCVVector::BI__builtin_rvv_vsoxseg4ei8_v_m:
20232case RISCVVector::BI__builtin_rvv_vsoxseg4ei16_v_m:
20233case RISCVVector::BI__builtin_rvv_vsoxseg4ei32_v_m:
20234case RISCVVector::BI__builtin_rvv_vsoxseg4ei64_v_m:
20235 ID = Intrinsic::riscv_vsoxseg4_mask;
20236 NF = 4;
20237 DefaultPolicy = 0;
20238IsMasked = true;
20239
20240 {
20241 if (IsMasked) {
20242 // Builtin: (mask, ptr, index, val0, val1, ..., vl)
20243 // Intrinsic: (val0, val1, ..., ptr, index, mask, vl)
20244 std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
20245 std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
20246 IntrinsicTypes = {Ops[0]->getType(),
20247 Ops[NF + 1]->getType(), Ops[NF + 3]->getType()};
20248 assert(Ops.size() == NF + 4)(static_cast <bool> (Ops.size() == NF + 4) ? void (0) :
__assert_fail ("Ops.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20248, __extension__ __PRETTY_FUNCTION__));
20249 } else {
20250 // Builtin: (ptr, index, val0, val1, ..., vl)
20251 // Intrinsic: (val0, val1, ..., ptr, index, vl)
20252 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
20253 IntrinsicTypes = {Ops[0]->getType(),
20254 Ops[NF + 1]->getType(), Ops[NF + 2]->getType()};
20255 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20255, __extension__ __PRETTY_FUNCTION__));
20256 }
20257 }
20258 break;
20259case RISCVVector::BI__builtin_rvv_vsoxseg5ei8_v:
20260case RISCVVector::BI__builtin_rvv_vsoxseg5ei16_v:
20261case RISCVVector::BI__builtin_rvv_vsoxseg5ei32_v:
20262case RISCVVector::BI__builtin_rvv_vsoxseg5ei64_v:
20263 ID = Intrinsic::riscv_vsoxseg5;
20264 NF = 5;
20265 DefaultPolicy = 1;
20266IsMasked = false;
20267
20268 {
20269 if (IsMasked) {
20270 // Builtin: (mask, ptr, index, val0, val1, ..., vl)
20271 // Intrinsic: (val0, val1, ..., ptr, index, mask, vl)
20272 std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
20273 std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
20274 IntrinsicTypes = {Ops[0]->getType(),
20275 Ops[NF + 1]->getType(), Ops[NF + 3]->getType()};
20276 assert(Ops.size() == NF + 4)(static_cast <bool> (Ops.size() == NF + 4) ? void (0) :
__assert_fail ("Ops.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20276, __extension__ __PRETTY_FUNCTION__));
20277 } else {
20278 // Builtin: (ptr, index, val0, val1, ..., vl)
20279 // Intrinsic: (val0, val1, ..., ptr, index, vl)
20280 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
20281 IntrinsicTypes = {Ops[0]->getType(),
20282 Ops[NF + 1]->getType(), Ops[NF + 2]->getType()};
20283 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20283, __extension__ __PRETTY_FUNCTION__));
20284 }
20285 }
20286 break;
20287case RISCVVector::BI__builtin_rvv_vsoxseg5ei8_v_m:
20288case RISCVVector::BI__builtin_rvv_vsoxseg5ei16_v_m:
20289case RISCVVector::BI__builtin_rvv_vsoxseg5ei32_v_m:
20290case RISCVVector::BI__builtin_rvv_vsoxseg5ei64_v_m:
20291 ID = Intrinsic::riscv_vsoxseg5_mask;
20292 NF = 5;
20293 DefaultPolicy = 0;
20294IsMasked = true;
20295
20296 {
20297 if (IsMasked) {
20298 // Builtin: (mask, ptr, index, val0, val1, ..., vl)
20299 // Intrinsic: (val0, val1, ..., ptr, index, mask, vl)
20300 std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
20301 std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
20302 IntrinsicTypes = {Ops[0]->getType(),
20303 Ops[NF + 1]->getType(), Ops[NF + 3]->getType()};
20304 assert(Ops.size() == NF + 4)(static_cast <bool> (Ops.size() == NF + 4) ? void (0) :
__assert_fail ("Ops.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20304, __extension__ __PRETTY_FUNCTION__));
20305 } else {
20306 // Builtin: (ptr, index, val0, val1, ..., vl)
20307 // Intrinsic: (val0, val1, ..., ptr, index, vl)
20308 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
20309 IntrinsicTypes = {Ops[0]->getType(),
20310 Ops[NF + 1]->getType(), Ops[NF + 2]->getType()};
20311 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20311, __extension__ __PRETTY_FUNCTION__));
20312 }
20313 }
20314 break;
20315case RISCVVector::BI__builtin_rvv_vsoxseg6ei8_v:
20316case RISCVVector::BI__builtin_rvv_vsoxseg6ei16_v:
20317case RISCVVector::BI__builtin_rvv_vsoxseg6ei32_v:
20318case RISCVVector::BI__builtin_rvv_vsoxseg6ei64_v:
20319 ID = Intrinsic::riscv_vsoxseg6;
20320 NF = 6;
20321 DefaultPolicy = 1;
20322IsMasked = false;
20323
20324 {
20325 if (IsMasked) {
20326 // Builtin: (mask, ptr, index, val0, val1, ..., vl)
20327 // Intrinsic: (val0, val1, ..., ptr, index, mask, vl)
20328 std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
20329 std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
20330 IntrinsicTypes = {Ops[0]->getType(),
20331 Ops[NF + 1]->getType(), Ops[NF + 3]->getType()};
20332 assert(Ops.size() == NF + 4)(static_cast <bool> (Ops.size() == NF + 4) ? void (0) :
__assert_fail ("Ops.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20332, __extension__ __PRETTY_FUNCTION__));
20333 } else {
20334 // Builtin: (ptr, index, val0, val1, ..., vl)
20335 // Intrinsic: (val0, val1, ..., ptr, index, vl)
20336 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
20337 IntrinsicTypes = {Ops[0]->getType(),
20338 Ops[NF + 1]->getType(), Ops[NF + 2]->getType()};
20339 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20339, __extension__ __PRETTY_FUNCTION__));
20340 }
20341 }
20342 break;
20343case RISCVVector::BI__builtin_rvv_vsoxseg6ei8_v_m:
20344case RISCVVector::BI__builtin_rvv_vsoxseg6ei16_v_m:
20345case RISCVVector::BI__builtin_rvv_vsoxseg6ei32_v_m:
20346case RISCVVector::BI__builtin_rvv_vsoxseg6ei64_v_m:
20347 ID = Intrinsic::riscv_vsoxseg6_mask;
20348 NF = 6;
20349 DefaultPolicy = 0;
20350IsMasked = true;
20351
20352 {
20353 if (IsMasked) {
20354 // Builtin: (mask, ptr, index, val0, val1, ..., vl)
20355 // Intrinsic: (val0, val1, ..., ptr, index, mask, vl)
20356 std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
20357 std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
20358 IntrinsicTypes = {Ops[0]->getType(),
20359 Ops[NF + 1]->getType(), Ops[NF + 3]->getType()};
20360 assert(Ops.size() == NF + 4)(static_cast <bool> (Ops.size() == NF + 4) ? void (0) :
__assert_fail ("Ops.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20360, __extension__ __PRETTY_FUNCTION__));
20361 } else {
20362 // Builtin: (ptr, index, val0, val1, ..., vl)
20363 // Intrinsic: (val0, val1, ..., ptr, index, vl)
20364 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
20365 IntrinsicTypes = {Ops[0]->getType(),
20366 Ops[NF + 1]->getType(), Ops[NF + 2]->getType()};
20367 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20367, __extension__ __PRETTY_FUNCTION__));
20368 }
20369 }
20370 break;
20371case RISCVVector::BI__builtin_rvv_vsoxseg7ei8_v:
20372case RISCVVector::BI__builtin_rvv_vsoxseg7ei16_v:
20373case RISCVVector::BI__builtin_rvv_vsoxseg7ei32_v:
20374case RISCVVector::BI__builtin_rvv_vsoxseg7ei64_v:
20375 ID = Intrinsic::riscv_vsoxseg7;
20376 NF = 7;
20377 DefaultPolicy = 1;
20378IsMasked = false;
20379
20380 {
20381 if (IsMasked) {
20382 // Builtin: (mask, ptr, index, val0, val1, ..., vl)
20383 // Intrinsic: (val0, val1, ..., ptr, index, mask, vl)
20384 std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
20385 std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
20386 IntrinsicTypes = {Ops[0]->getType(),
20387 Ops[NF + 1]->getType(), Ops[NF + 3]->getType()};
20388 assert(Ops.size() == NF + 4)(static_cast <bool> (Ops.size() == NF + 4) ? void (0) :
__assert_fail ("Ops.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20388, __extension__ __PRETTY_FUNCTION__));
20389 } else {
20390 // Builtin: (ptr, index, val0, val1, ..., vl)
20391 // Intrinsic: (val0, val1, ..., ptr, index, vl)
20392 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
20393 IntrinsicTypes = {Ops[0]->getType(),
20394 Ops[NF + 1]->getType(), Ops[NF + 2]->getType()};
20395 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20395, __extension__ __PRETTY_FUNCTION__));
20396 }
20397 }
20398 break;
20399case RISCVVector::BI__builtin_rvv_vsoxseg7ei8_v_m:
20400case RISCVVector::BI__builtin_rvv_vsoxseg7ei16_v_m:
20401case RISCVVector::BI__builtin_rvv_vsoxseg7ei32_v_m:
20402case RISCVVector::BI__builtin_rvv_vsoxseg7ei64_v_m:
20403 ID = Intrinsic::riscv_vsoxseg7_mask;
20404 NF = 7;
20405 DefaultPolicy = 0;
20406IsMasked = true;
20407
20408 {
20409 if (IsMasked) {
20410 // Builtin: (mask, ptr, index, val0, val1, ..., vl)
20411 // Intrinsic: (val0, val1, ..., ptr, index, mask, vl)
20412 std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
20413 std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
20414 IntrinsicTypes = {Ops[0]->getType(),
20415 Ops[NF + 1]->getType(), Ops[NF + 3]->getType()};
20416 assert(Ops.size() == NF + 4)(static_cast <bool> (Ops.size() == NF + 4) ? void (0) :
__assert_fail ("Ops.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20416, __extension__ __PRETTY_FUNCTION__));
20417 } else {
20418 // Builtin: (ptr, index, val0, val1, ..., vl)
20419 // Intrinsic: (val0, val1, ..., ptr, index, vl)
20420 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
20421 IntrinsicTypes = {Ops[0]->getType(),
20422 Ops[NF + 1]->getType(), Ops[NF + 2]->getType()};
20423 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20423, __extension__ __PRETTY_FUNCTION__));
20424 }
20425 }
20426 break;
20427case RISCVVector::BI__builtin_rvv_vsoxseg8ei8_v:
20428case RISCVVector::BI__builtin_rvv_vsoxseg8ei16_v:
20429case RISCVVector::BI__builtin_rvv_vsoxseg8ei32_v:
20430case RISCVVector::BI__builtin_rvv_vsoxseg8ei64_v:
20431 ID = Intrinsic::riscv_vsoxseg8;
20432 NF = 8;
20433 DefaultPolicy = 1;
20434IsMasked = false;
20435
20436 {
20437 if (IsMasked) {
20438 // Builtin: (mask, ptr, index, val0, val1, ..., vl)
20439 // Intrinsic: (val0, val1, ..., ptr, index, mask, vl)
20440 std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
20441 std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
20442 IntrinsicTypes = {Ops[0]->getType(),
20443 Ops[NF + 1]->getType(), Ops[NF + 3]->getType()};
20444 assert(Ops.size() == NF + 4)(static_cast <bool> (Ops.size() == NF + 4) ? void (0) :
__assert_fail ("Ops.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20444, __extension__ __PRETTY_FUNCTION__));
20445 } else {
20446 // Builtin: (ptr, index, val0, val1, ..., vl)
20447 // Intrinsic: (val0, val1, ..., ptr, index, vl)
20448 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
20449 IntrinsicTypes = {Ops[0]->getType(),
20450 Ops[NF + 1]->getType(), Ops[NF + 2]->getType()};
20451 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20451, __extension__ __PRETTY_FUNCTION__));
20452 }
20453 }
20454 break;
20455case RISCVVector::BI__builtin_rvv_vsoxseg8ei8_v_m:
20456case RISCVVector::BI__builtin_rvv_vsoxseg8ei16_v_m:
20457case RISCVVector::BI__builtin_rvv_vsoxseg8ei32_v_m:
20458case RISCVVector::BI__builtin_rvv_vsoxseg8ei64_v_m:
20459 ID = Intrinsic::riscv_vsoxseg8_mask;
20460 NF = 8;
20461 DefaultPolicy = 0;
20462IsMasked = true;
20463
20464 {
20465 if (IsMasked) {
20466 // Builtin: (mask, ptr, index, val0, val1, ..., vl)
20467 // Intrinsic: (val0, val1, ..., ptr, index, mask, vl)
20468 std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
20469 std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
20470 IntrinsicTypes = {Ops[0]->getType(),
20471 Ops[NF + 1]->getType(), Ops[NF + 3]->getType()};
20472 assert(Ops.size() == NF + 4)(static_cast <bool> (Ops.size() == NF + 4) ? void (0) :
__assert_fail ("Ops.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20472, __extension__ __PRETTY_FUNCTION__));
20473 } else {
20474 // Builtin: (ptr, index, val0, val1, ..., vl)
20475 // Intrinsic: (val0, val1, ..., ptr, index, vl)
20476 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
20477 IntrinsicTypes = {Ops[0]->getType(),
20478 Ops[NF + 1]->getType(), Ops[NF + 2]->getType()};
20479 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20479, __extension__ __PRETTY_FUNCTION__));
20480 }
20481 }
20482 break;
20483case RISCVVector::BI__builtin_rvv_vsra_vv_tu:
20484case RISCVVector::BI__builtin_rvv_vsra_vx_tu:
20485 ID = Intrinsic::riscv_vsra;
20486 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
20487 break;
20488case RISCVVector::BI__builtin_rvv_vsra_vv_ta:
20489case RISCVVector::BI__builtin_rvv_vsra_vx_ta:
20490 ID = Intrinsic::riscv_vsra;
20491 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
20492 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
20493 break;
20494case RISCVVector::BI__builtin_rvv_vsra_vv_tuma:
20495case RISCVVector::BI__builtin_rvv_vsra_vx_tuma:
20496 ID = Intrinsic::riscv_vsra_mask;
20497 DefaultPolicy = 2;
20498 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
20499 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
20500 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
20501 break;
20502case RISCVVector::BI__builtin_rvv_vsra_vv_tama:
20503case RISCVVector::BI__builtin_rvv_vsra_vx_tama:
20504 ID = Intrinsic::riscv_vsra_mask;
20505 DefaultPolicy = 3;
20506 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
20507 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
20508 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
20509 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
20510 break;
20511case RISCVVector::BI__builtin_rvv_vsra_vv_tumu:
20512case RISCVVector::BI__builtin_rvv_vsra_vx_tumu:
20513 ID = Intrinsic::riscv_vsra_mask;
20514 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
20515 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
20516 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
20517 break;
20518case RISCVVector::BI__builtin_rvv_vsra_vv_tamu:
20519case RISCVVector::BI__builtin_rvv_vsra_vx_tamu:
20520 ID = Intrinsic::riscv_vsra_mask;
20521 DefaultPolicy = 1;
20522 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
20523 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
20524 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
20525 break;
20526case RISCVVector::BI__builtin_rvv_vsrl_vv_tu:
20527case RISCVVector::BI__builtin_rvv_vsrl_vx_tu:
20528 ID = Intrinsic::riscv_vsrl;
20529 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
20530 break;
20531case RISCVVector::BI__builtin_rvv_vsrl_vv_ta:
20532case RISCVVector::BI__builtin_rvv_vsrl_vx_ta:
20533 ID = Intrinsic::riscv_vsrl;
20534 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
20535 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
20536 break;
20537case RISCVVector::BI__builtin_rvv_vsrl_vv_tuma:
20538case RISCVVector::BI__builtin_rvv_vsrl_vx_tuma:
20539 ID = Intrinsic::riscv_vsrl_mask;
20540 DefaultPolicy = 2;
20541 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
20542 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
20543 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
20544 break;
20545case RISCVVector::BI__builtin_rvv_vsrl_vv_tama:
20546case RISCVVector::BI__builtin_rvv_vsrl_vx_tama:
20547 ID = Intrinsic::riscv_vsrl_mask;
20548 DefaultPolicy = 3;
20549 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
20550 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
20551 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
20552 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
20553 break;
20554case RISCVVector::BI__builtin_rvv_vsrl_vv_tumu:
20555case RISCVVector::BI__builtin_rvv_vsrl_vx_tumu:
20556 ID = Intrinsic::riscv_vsrl_mask;
20557 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
20558 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
20559 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
20560 break;
20561case RISCVVector::BI__builtin_rvv_vsrl_vv_tamu:
20562case RISCVVector::BI__builtin_rvv_vsrl_vx_tamu:
20563 ID = Intrinsic::riscv_vsrl_mask;
20564 DefaultPolicy = 1;
20565 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
20566 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
20567 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
20568 break;
20569case RISCVVector::BI__builtin_rvv_vsse16_v:
20570case RISCVVector::BI__builtin_rvv_vsse32_v:
20571case RISCVVector::BI__builtin_rvv_vsse64_v:
20572case RISCVVector::BI__builtin_rvv_vsse8_v:
20573 ID = Intrinsic::riscv_vsse;
20574 DefaultPolicy = 1;
20575IsMasked = false;
20576
20577 if (IsMasked) {
20578 // Builtin: (mask, ptr, stride, value, vl). Intrinsic: (value, ptr, stride, mask, vl)
20579 std::swap(Ops[0], Ops[3]);
20580 } else {
20581 // Builtin: (ptr, stride, value, vl). Intrinsic: (value, ptr, stride, vl)
20582 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.begin() + 3);
20583 }
20584 Ops[1] = Builder.CreateBitCast(Ops[1], Ops[0]->getType()->getPointerTo());
20585 if (IsMasked)
20586 IntrinsicTypes = {Ops[0]->getType(), Ops[4]->getType()};
20587 else
20588 IntrinsicTypes = {Ops[0]->getType(), Ops[3]->getType()};
20589 break;
20590case RISCVVector::BI__builtin_rvv_vsse16_v_m:
20591case RISCVVector::BI__builtin_rvv_vsse32_v_m:
20592case RISCVVector::BI__builtin_rvv_vsse64_v_m:
20593case RISCVVector::BI__builtin_rvv_vsse8_v_m:
20594 ID = Intrinsic::riscv_vsse_mask;
20595 DefaultPolicy = 0;
20596IsMasked = true;
20597
20598 if (IsMasked) {
20599 // Builtin: (mask, ptr, stride, value, vl). Intrinsic: (value, ptr, stride, mask, vl)
20600 std::swap(Ops[0], Ops[3]);
20601 } else {
20602 // Builtin: (ptr, stride, value, vl). Intrinsic: (value, ptr, stride, vl)
20603 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.begin() + 3);
20604 }
20605 Ops[1] = Builder.CreateBitCast(Ops[1], Ops[0]->getType()->getPointerTo());
20606 if (IsMasked)
20607 IntrinsicTypes = {Ops[0]->getType(), Ops[4]->getType()};
20608 else
20609 IntrinsicTypes = {Ops[0]->getType(), Ops[3]->getType()};
20610 break;
20611case RISCVVector::BI__builtin_rvv_vsseg2e16_v:
20612case RISCVVector::BI__builtin_rvv_vsseg2e32_v:
20613case RISCVVector::BI__builtin_rvv_vsseg2e64_v:
20614case RISCVVector::BI__builtin_rvv_vsseg2e8_v:
20615 ID = Intrinsic::riscv_vsseg2;
20616 NF = 2;
20617 DefaultPolicy = 1;
20618IsMasked = false;
20619
20620 {
20621 if (IsMasked) {
20622 // Builtin: (mask, ptr, val0, val1, ..., vl)
20623 // Intrinsic: (val0, val1, ..., ptr, mask, vl)
20624 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
20625 std::swap(Ops[NF], Ops[NF + 1]);
20626 IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 2]->getType()};
20627 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20627, __extension__ __PRETTY_FUNCTION__));
20628 } else {
20629 // Builtin: (ptr, val0, val1, ..., vl)
20630 // Intrinsic: (val0, val1, ..., ptr, vl)
20631 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
20632 IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 1]->getType()};
20633 assert(Ops.size() == NF + 2)(static_cast <bool> (Ops.size() == NF + 2) ? void (0) :
__assert_fail ("Ops.size() == NF + 2", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20633, __extension__ __PRETTY_FUNCTION__));
20634 }
20635 }
20636 break;
20637case RISCVVector::BI__builtin_rvv_vsseg2e16_v_m:
20638case RISCVVector::BI__builtin_rvv_vsseg2e32_v_m:
20639case RISCVVector::BI__builtin_rvv_vsseg2e64_v_m:
20640case RISCVVector::BI__builtin_rvv_vsseg2e8_v_m:
20641 ID = Intrinsic::riscv_vsseg2_mask;
20642 NF = 2;
20643 DefaultPolicy = 0;
20644IsMasked = true;
20645
20646 {
20647 if (IsMasked) {
20648 // Builtin: (mask, ptr, val0, val1, ..., vl)
20649 // Intrinsic: (val0, val1, ..., ptr, mask, vl)
20650 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
20651 std::swap(Ops[NF], Ops[NF + 1]);
20652 IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 2]->getType()};
20653 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20653, __extension__ __PRETTY_FUNCTION__));
20654 } else {
20655 // Builtin: (ptr, val0, val1, ..., vl)
20656 // Intrinsic: (val0, val1, ..., ptr, vl)
20657 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
20658 IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 1]->getType()};
20659 assert(Ops.size() == NF + 2)(static_cast <bool> (Ops.size() == NF + 2) ? void (0) :
__assert_fail ("Ops.size() == NF + 2", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20659, __extension__ __PRETTY_FUNCTION__));
20660 }
20661 }
20662 break;
20663case RISCVVector::BI__builtin_rvv_vsseg3e8_v:
20664case RISCVVector::BI__builtin_rvv_vsseg3e16_v:
20665case RISCVVector::BI__builtin_rvv_vsseg3e32_v:
20666case RISCVVector::BI__builtin_rvv_vsseg3e64_v:
20667 ID = Intrinsic::riscv_vsseg3;
20668 NF = 3;
20669 DefaultPolicy = 1;
20670IsMasked = false;
20671
20672 {
20673 if (IsMasked) {
20674 // Builtin: (mask, ptr, val0, val1, ..., vl)
20675 // Intrinsic: (val0, val1, ..., ptr, mask, vl)
20676 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
20677 std::swap(Ops[NF], Ops[NF + 1]);
20678 IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 2]->getType()};
20679 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20679, __extension__ __PRETTY_FUNCTION__));
20680 } else {
20681 // Builtin: (ptr, val0, val1, ..., vl)
20682 // Intrinsic: (val0, val1, ..., ptr, vl)
20683 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
20684 IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 1]->getType()};
20685 assert(Ops.size() == NF + 2)(static_cast <bool> (Ops.size() == NF + 2) ? void (0) :
__assert_fail ("Ops.size() == NF + 2", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20685, __extension__ __PRETTY_FUNCTION__));
20686 }
20687 }
20688 break;
20689case RISCVVector::BI__builtin_rvv_vsseg3e8_v_m:
20690case RISCVVector::BI__builtin_rvv_vsseg3e16_v_m:
20691case RISCVVector::BI__builtin_rvv_vsseg3e32_v_m:
20692case RISCVVector::BI__builtin_rvv_vsseg3e64_v_m:
20693 ID = Intrinsic::riscv_vsseg3_mask;
20694 NF = 3;
20695 DefaultPolicy = 0;
20696IsMasked = true;
20697
20698 {
20699 if (IsMasked) {
20700 // Builtin: (mask, ptr, val0, val1, ..., vl)
20701 // Intrinsic: (val0, val1, ..., ptr, mask, vl)
20702 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
20703 std::swap(Ops[NF], Ops[NF + 1]);
20704 IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 2]->getType()};
20705 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20705, __extension__ __PRETTY_FUNCTION__));
20706 } else {
20707 // Builtin: (ptr, val0, val1, ..., vl)
20708 // Intrinsic: (val0, val1, ..., ptr, vl)
20709 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
20710 IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 1]->getType()};
20711 assert(Ops.size() == NF + 2)(static_cast <bool> (Ops.size() == NF + 2) ? void (0) :
__assert_fail ("Ops.size() == NF + 2", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20711, __extension__ __PRETTY_FUNCTION__));
20712 }
20713 }
20714 break;
20715case RISCVVector::BI__builtin_rvv_vsseg4e8_v:
20716case RISCVVector::BI__builtin_rvv_vsseg4e16_v:
20717case RISCVVector::BI__builtin_rvv_vsseg4e32_v:
20718case RISCVVector::BI__builtin_rvv_vsseg4e64_v:
20719 ID = Intrinsic::riscv_vsseg4;
20720 NF = 4;
20721 DefaultPolicy = 1;
20722IsMasked = false;
20723
20724 {
20725 if (IsMasked) {
20726 // Builtin: (mask, ptr, val0, val1, ..., vl)
20727 // Intrinsic: (val0, val1, ..., ptr, mask, vl)
20728 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
20729 std::swap(Ops[NF], Ops[NF + 1]);
20730 IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 2]->getType()};
20731 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20731, __extension__ __PRETTY_FUNCTION__));
20732 } else {
20733 // Builtin: (ptr, val0, val1, ..., vl)
20734 // Intrinsic: (val0, val1, ..., ptr, vl)
20735 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
20736 IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 1]->getType()};
20737 assert(Ops.size() == NF + 2)(static_cast <bool> (Ops.size() == NF + 2) ? void (0) :
__assert_fail ("Ops.size() == NF + 2", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20737, __extension__ __PRETTY_FUNCTION__));
20738 }
20739 }
20740 break;
20741case RISCVVector::BI__builtin_rvv_vsseg4e8_v_m:
20742case RISCVVector::BI__builtin_rvv_vsseg4e16_v_m:
20743case RISCVVector::BI__builtin_rvv_vsseg4e32_v_m:
20744case RISCVVector::BI__builtin_rvv_vsseg4e64_v_m:
20745 ID = Intrinsic::riscv_vsseg4_mask;
20746 NF = 4;
20747 DefaultPolicy = 0;
20748IsMasked = true;
20749
20750 {
20751 if (IsMasked) {
20752 // Builtin: (mask, ptr, val0, val1, ..., vl)
20753 // Intrinsic: (val0, val1, ..., ptr, mask, vl)
20754 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
20755 std::swap(Ops[NF], Ops[NF + 1]);
20756 IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 2]->getType()};
20757 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20757, __extension__ __PRETTY_FUNCTION__));
20758 } else {
20759 // Builtin: (ptr, val0, val1, ..., vl)
20760 // Intrinsic: (val0, val1, ..., ptr, vl)
20761 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
20762 IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 1]->getType()};
20763 assert(Ops.size() == NF + 2)(static_cast <bool> (Ops.size() == NF + 2) ? void (0) :
__assert_fail ("Ops.size() == NF + 2", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20763, __extension__ __PRETTY_FUNCTION__));
20764 }
20765 }
20766 break;
20767case RISCVVector::BI__builtin_rvv_vsseg5e8_v:
20768case RISCVVector::BI__builtin_rvv_vsseg5e16_v:
20769case RISCVVector::BI__builtin_rvv_vsseg5e32_v:
20770case RISCVVector::BI__builtin_rvv_vsseg5e64_v:
20771 ID = Intrinsic::riscv_vsseg5;
20772 NF = 5;
20773 DefaultPolicy = 1;
20774IsMasked = false;
20775
20776 {
20777 if (IsMasked) {
20778 // Builtin: (mask, ptr, val0, val1, ..., vl)
20779 // Intrinsic: (val0, val1, ..., ptr, mask, vl)
20780 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
20781 std::swap(Ops[NF], Ops[NF + 1]);
20782 IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 2]->getType()};
20783 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20783, __extension__ __PRETTY_FUNCTION__));
20784 } else {
20785 // Builtin: (ptr, val0, val1, ..., vl)
20786 // Intrinsic: (val0, val1, ..., ptr, vl)
20787 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
20788 IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 1]->getType()};
20789 assert(Ops.size() == NF + 2)(static_cast <bool> (Ops.size() == NF + 2) ? void (0) :
__assert_fail ("Ops.size() == NF + 2", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20789, __extension__ __PRETTY_FUNCTION__));
20790 }
20791 }
20792 break;
20793case RISCVVector::BI__builtin_rvv_vsseg5e8_v_m:
20794case RISCVVector::BI__builtin_rvv_vsseg5e16_v_m:
20795case RISCVVector::BI__builtin_rvv_vsseg5e32_v_m:
20796case RISCVVector::BI__builtin_rvv_vsseg5e64_v_m:
20797 ID = Intrinsic::riscv_vsseg5_mask;
20798 NF = 5;
20799 DefaultPolicy = 0;
20800IsMasked = true;
20801
20802 {
20803 if (IsMasked) {
20804 // Builtin: (mask, ptr, val0, val1, ..., vl)
20805 // Intrinsic: (val0, val1, ..., ptr, mask, vl)
20806 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
20807 std::swap(Ops[NF], Ops[NF + 1]);
20808 IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 2]->getType()};
20809 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20809, __extension__ __PRETTY_FUNCTION__));
20810 } else {
20811 // Builtin: (ptr, val0, val1, ..., vl)
20812 // Intrinsic: (val0, val1, ..., ptr, vl)
20813 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
20814 IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 1]->getType()};
20815 assert(Ops.size() == NF + 2)(static_cast <bool> (Ops.size() == NF + 2) ? void (0) :
__assert_fail ("Ops.size() == NF + 2", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20815, __extension__ __PRETTY_FUNCTION__));
20816 }
20817 }
20818 break;
20819case RISCVVector::BI__builtin_rvv_vsseg6e8_v:
20820case RISCVVector::BI__builtin_rvv_vsseg6e16_v:
20821case RISCVVector::BI__builtin_rvv_vsseg6e32_v:
20822case RISCVVector::BI__builtin_rvv_vsseg6e64_v:
20823 ID = Intrinsic::riscv_vsseg6;
20824 NF = 6;
20825 DefaultPolicy = 1;
20826IsMasked = false;
20827
20828 {
20829 if (IsMasked) {
20830 // Builtin: (mask, ptr, val0, val1, ..., vl)
20831 // Intrinsic: (val0, val1, ..., ptr, mask, vl)
20832 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
20833 std::swap(Ops[NF], Ops[NF + 1]);
20834 IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 2]->getType()};
20835 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20835, __extension__ __PRETTY_FUNCTION__));
20836 } else {
20837 // Builtin: (ptr, val0, val1, ..., vl)
20838 // Intrinsic: (val0, val1, ..., ptr, vl)
20839 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
20840 IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 1]->getType()};
20841 assert(Ops.size() == NF + 2)(static_cast <bool> (Ops.size() == NF + 2) ? void (0) :
__assert_fail ("Ops.size() == NF + 2", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20841, __extension__ __PRETTY_FUNCTION__));
20842 }
20843 }
20844 break;
20845case RISCVVector::BI__builtin_rvv_vsseg6e8_v_m:
20846case RISCVVector::BI__builtin_rvv_vsseg6e16_v_m:
20847case RISCVVector::BI__builtin_rvv_vsseg6e32_v_m:
20848case RISCVVector::BI__builtin_rvv_vsseg6e64_v_m:
20849 ID = Intrinsic::riscv_vsseg6_mask;
20850 NF = 6;
20851 DefaultPolicy = 0;
20852IsMasked = true;
20853
20854 {
20855 if (IsMasked) {
20856 // Builtin: (mask, ptr, val0, val1, ..., vl)
20857 // Intrinsic: (val0, val1, ..., ptr, mask, vl)
20858 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
20859 std::swap(Ops[NF], Ops[NF + 1]);
20860 IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 2]->getType()};
20861 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20861, __extension__ __PRETTY_FUNCTION__));
20862 } else {
20863 // Builtin: (ptr, val0, val1, ..., vl)
20864 // Intrinsic: (val0, val1, ..., ptr, vl)
20865 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
20866 IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 1]->getType()};
20867 assert(Ops.size() == NF + 2)(static_cast <bool> (Ops.size() == NF + 2) ? void (0) :
__assert_fail ("Ops.size() == NF + 2", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20867, __extension__ __PRETTY_FUNCTION__));
20868 }
20869 }
20870 break;
20871case RISCVVector::BI__builtin_rvv_vsseg7e8_v:
20872case RISCVVector::BI__builtin_rvv_vsseg7e16_v:
20873case RISCVVector::BI__builtin_rvv_vsseg7e32_v:
20874case RISCVVector::BI__builtin_rvv_vsseg7e64_v:
20875 ID = Intrinsic::riscv_vsseg7;
20876 NF = 7;
20877 DefaultPolicy = 1;
20878IsMasked = false;
20879
20880 {
20881 if (IsMasked) {
20882 // Builtin: (mask, ptr, val0, val1, ..., vl)
20883 // Intrinsic: (val0, val1, ..., ptr, mask, vl)
20884 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
20885 std::swap(Ops[NF], Ops[NF + 1]);
20886 IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 2]->getType()};
20887 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20887, __extension__ __PRETTY_FUNCTION__));
20888 } else {
20889 // Builtin: (ptr, val0, val1, ..., vl)
20890 // Intrinsic: (val0, val1, ..., ptr, vl)
20891 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
20892 IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 1]->getType()};
20893 assert(Ops.size() == NF + 2)(static_cast <bool> (Ops.size() == NF + 2) ? void (0) :
__assert_fail ("Ops.size() == NF + 2", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20893, __extension__ __PRETTY_FUNCTION__));
20894 }
20895 }
20896 break;
20897case RISCVVector::BI__builtin_rvv_vsseg7e8_v_m:
20898case RISCVVector::BI__builtin_rvv_vsseg7e16_v_m:
20899case RISCVVector::BI__builtin_rvv_vsseg7e32_v_m:
20900case RISCVVector::BI__builtin_rvv_vsseg7e64_v_m:
20901 ID = Intrinsic::riscv_vsseg7_mask;
20902 NF = 7;
20903 DefaultPolicy = 0;
20904IsMasked = true;
20905
20906 {
20907 if (IsMasked) {
20908 // Builtin: (mask, ptr, val0, val1, ..., vl)
20909 // Intrinsic: (val0, val1, ..., ptr, mask, vl)
20910 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
20911 std::swap(Ops[NF], Ops[NF + 1]);
20912 IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 2]->getType()};
20913 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20913, __extension__ __PRETTY_FUNCTION__));
20914 } else {
20915 // Builtin: (ptr, val0, val1, ..., vl)
20916 // Intrinsic: (val0, val1, ..., ptr, vl)
20917 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
20918 IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 1]->getType()};
20919 assert(Ops.size() == NF + 2)(static_cast <bool> (Ops.size() == NF + 2) ? void (0) :
__assert_fail ("Ops.size() == NF + 2", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20919, __extension__ __PRETTY_FUNCTION__));
20920 }
20921 }
20922 break;
20923case RISCVVector::BI__builtin_rvv_vsseg8e8_v:
20924case RISCVVector::BI__builtin_rvv_vsseg8e16_v:
20925case RISCVVector::BI__builtin_rvv_vsseg8e32_v:
20926case RISCVVector::BI__builtin_rvv_vsseg8e64_v:
20927 ID = Intrinsic::riscv_vsseg8;
20928 NF = 8;
20929 DefaultPolicy = 1;
20930IsMasked = false;
20931
20932 {
20933 if (IsMasked) {
20934 // Builtin: (mask, ptr, val0, val1, ..., vl)
20935 // Intrinsic: (val0, val1, ..., ptr, mask, vl)
20936 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
20937 std::swap(Ops[NF], Ops[NF + 1]);
20938 IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 2]->getType()};
20939 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20939, __extension__ __PRETTY_FUNCTION__));
20940 } else {
20941 // Builtin: (ptr, val0, val1, ..., vl)
20942 // Intrinsic: (val0, val1, ..., ptr, vl)
20943 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
20944 IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 1]->getType()};
20945 assert(Ops.size() == NF + 2)(static_cast <bool> (Ops.size() == NF + 2) ? void (0) :
__assert_fail ("Ops.size() == NF + 2", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20945, __extension__ __PRETTY_FUNCTION__));
20946 }
20947 }
20948 break;
20949case RISCVVector::BI__builtin_rvv_vsseg8e8_v_m:
20950case RISCVVector::BI__builtin_rvv_vsseg8e16_v_m:
20951case RISCVVector::BI__builtin_rvv_vsseg8e32_v_m:
20952case RISCVVector::BI__builtin_rvv_vsseg8e64_v_m:
20953 ID = Intrinsic::riscv_vsseg8_mask;
20954 NF = 8;
20955 DefaultPolicy = 0;
20956IsMasked = true;
20957
20958 {
20959 if (IsMasked) {
20960 // Builtin: (mask, ptr, val0, val1, ..., vl)
20961 // Intrinsic: (val0, val1, ..., ptr, mask, vl)
20962 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
20963 std::swap(Ops[NF], Ops[NF + 1]);
20964 IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 2]->getType()};
20965 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20965, __extension__ __PRETTY_FUNCTION__));
20966 } else {
20967 // Builtin: (ptr, val0, val1, ..., vl)
20968 // Intrinsic: (val0, val1, ..., ptr, vl)
20969 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
20970 IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 1]->getType()};
20971 assert(Ops.size() == NF + 2)(static_cast <bool> (Ops.size() == NF + 2) ? void (0) :
__assert_fail ("Ops.size() == NF + 2", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 20971, __extension__ __PRETTY_FUNCTION__));
20972 }
20973 }
20974 break;
20975case RISCVVector::BI__builtin_rvv_vssra_vv_tu:
20976case RISCVVector::BI__builtin_rvv_vssra_vx_tu:
20977 ID = Intrinsic::riscv_vssra;
20978 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
20979 break;
20980case RISCVVector::BI__builtin_rvv_vssra_vv_ta:
20981case RISCVVector::BI__builtin_rvv_vssra_vx_ta:
20982 ID = Intrinsic::riscv_vssra;
20983 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
20984 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
20985 break;
20986case RISCVVector::BI__builtin_rvv_vssra_vv_tuma:
20987case RISCVVector::BI__builtin_rvv_vssra_vx_tuma:
20988 ID = Intrinsic::riscv_vssra_mask;
20989 DefaultPolicy = 2;
20990 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
20991 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
20992 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
20993 break;
20994case RISCVVector::BI__builtin_rvv_vssra_vv_tama:
20995case RISCVVector::BI__builtin_rvv_vssra_vx_tama:
20996 ID = Intrinsic::riscv_vssra_mask;
20997 DefaultPolicy = 3;
20998 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
20999 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
21000 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
21001 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
21002 break;
21003case RISCVVector::BI__builtin_rvv_vssra_vv_tumu:
21004case RISCVVector::BI__builtin_rvv_vssra_vx_tumu:
21005 ID = Intrinsic::riscv_vssra_mask;
21006 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
21007 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
21008 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
21009 break;
21010case RISCVVector::BI__builtin_rvv_vssra_vv_tamu:
21011case RISCVVector::BI__builtin_rvv_vssra_vx_tamu:
21012 ID = Intrinsic::riscv_vssra_mask;
21013 DefaultPolicy = 1;
21014 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
21015 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
21016 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
21017 break;
21018case RISCVVector::BI__builtin_rvv_vssrl_vv_tu:
21019case RISCVVector::BI__builtin_rvv_vssrl_vx_tu:
21020 ID = Intrinsic::riscv_vssrl;
21021 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
21022 break;
21023case RISCVVector::BI__builtin_rvv_vssrl_vv_ta:
21024case RISCVVector::BI__builtin_rvv_vssrl_vx_ta:
21025 ID = Intrinsic::riscv_vssrl;
21026 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
21027 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
21028 break;
21029case RISCVVector::BI__builtin_rvv_vssrl_vv_tuma:
21030case RISCVVector::BI__builtin_rvv_vssrl_vx_tuma:
21031 ID = Intrinsic::riscv_vssrl_mask;
21032 DefaultPolicy = 2;
21033 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
21034 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
21035 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
21036 break;
21037case RISCVVector::BI__builtin_rvv_vssrl_vv_tama:
21038case RISCVVector::BI__builtin_rvv_vssrl_vx_tama:
21039 ID = Intrinsic::riscv_vssrl_mask;
21040 DefaultPolicy = 3;
21041 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
21042 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
21043 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
21044 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
21045 break;
21046case RISCVVector::BI__builtin_rvv_vssrl_vv_tumu:
21047case RISCVVector::BI__builtin_rvv_vssrl_vx_tumu:
21048 ID = Intrinsic::riscv_vssrl_mask;
21049 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
21050 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
21051 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
21052 break;
21053case RISCVVector::BI__builtin_rvv_vssrl_vv_tamu:
21054case RISCVVector::BI__builtin_rvv_vssrl_vx_tamu:
21055 ID = Intrinsic::riscv_vssrl_mask;
21056 DefaultPolicy = 1;
21057 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
21058 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
21059 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
21060 break;
21061case RISCVVector::BI__builtin_rvv_vssseg2e16_v:
21062case RISCVVector::BI__builtin_rvv_vssseg2e32_v:
21063case RISCVVector::BI__builtin_rvv_vssseg2e64_v:
21064case RISCVVector::BI__builtin_rvv_vssseg2e8_v:
21065 ID = Intrinsic::riscv_vssseg2;
21066 NF = 2;
21067 DefaultPolicy = 1;
21068IsMasked = false;
21069
21070 {
21071 if (IsMasked) {
21072 // Builtin: (mask, ptr, stride, val0, val1, ..., vl).
21073 // Intrinsic: (val0, val1, ..., ptr, stride, mask, vl)
21074 std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
21075 std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
21076 assert(Ops.size() == NF + 4)(static_cast <bool> (Ops.size() == NF + 4) ? void (0) :
__assert_fail ("Ops.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21076, __extension__ __PRETTY_FUNCTION__));
21077 } else {
21078 // Builtin: (ptr, stride, val0, val1, ..., vl).
21079 // Intrinsic: (val0, val1, ..., ptr, stride, vl)
21080 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
21081 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21081, __extension__ __PRETTY_FUNCTION__));
21082 }
21083 IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 1]->getType()};
21084 }
21085 break;
21086case RISCVVector::BI__builtin_rvv_vssseg2e16_v_m:
21087case RISCVVector::BI__builtin_rvv_vssseg2e32_v_m:
21088case RISCVVector::BI__builtin_rvv_vssseg2e64_v_m:
21089case RISCVVector::BI__builtin_rvv_vssseg2e8_v_m:
21090 ID = Intrinsic::riscv_vssseg2_mask;
21091 NF = 2;
21092 DefaultPolicy = 0;
21093IsMasked = true;
21094
21095 {
21096 if (IsMasked) {
21097 // Builtin: (mask, ptr, stride, val0, val1, ..., vl).
21098 // Intrinsic: (val0, val1, ..., ptr, stride, mask, vl)
21099 std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
21100 std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
21101 assert(Ops.size() == NF + 4)(static_cast <bool> (Ops.size() == NF + 4) ? void (0) :
__assert_fail ("Ops.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21101, __extension__ __PRETTY_FUNCTION__));
21102 } else {
21103 // Builtin: (ptr, stride, val0, val1, ..., vl).
21104 // Intrinsic: (val0, val1, ..., ptr, stride, vl)
21105 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
21106 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21106, __extension__ __PRETTY_FUNCTION__));
21107 }
21108 IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 1]->getType()};
21109 }
21110 break;
21111case RISCVVector::BI__builtin_rvv_vssseg3e8_v:
21112case RISCVVector::BI__builtin_rvv_vssseg3e16_v:
21113case RISCVVector::BI__builtin_rvv_vssseg3e32_v:
21114case RISCVVector::BI__builtin_rvv_vssseg3e64_v:
21115 ID = Intrinsic::riscv_vssseg3;
21116 NF = 3;
21117 DefaultPolicy = 1;
21118IsMasked = false;
21119
21120 {
21121 if (IsMasked) {
21122 // Builtin: (mask, ptr, stride, val0, val1, ..., vl).
21123 // Intrinsic: (val0, val1, ..., ptr, stride, mask, vl)
21124 std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
21125 std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
21126 assert(Ops.size() == NF + 4)(static_cast <bool> (Ops.size() == NF + 4) ? void (0) :
__assert_fail ("Ops.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21126, __extension__ __PRETTY_FUNCTION__));
21127 } else {
21128 // Builtin: (ptr, stride, val0, val1, ..., vl).
21129 // Intrinsic: (val0, val1, ..., ptr, stride, vl)
21130 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
21131 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21131, __extension__ __PRETTY_FUNCTION__));
21132 }
21133 IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 1]->getType()};
21134 }
21135 break;
21136case RISCVVector::BI__builtin_rvv_vssseg3e8_v_m:
21137case RISCVVector::BI__builtin_rvv_vssseg3e16_v_m:
21138case RISCVVector::BI__builtin_rvv_vssseg3e32_v_m:
21139case RISCVVector::BI__builtin_rvv_vssseg3e64_v_m:
21140 ID = Intrinsic::riscv_vssseg3_mask;
21141 NF = 3;
21142 DefaultPolicy = 0;
21143IsMasked = true;
21144
21145 {
21146 if (IsMasked) {
21147 // Builtin: (mask, ptr, stride, val0, val1, ..., vl).
21148 // Intrinsic: (val0, val1, ..., ptr, stride, mask, vl)
21149 std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
21150 std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
21151 assert(Ops.size() == NF + 4)(static_cast <bool> (Ops.size() == NF + 4) ? void (0) :
__assert_fail ("Ops.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21151, __extension__ __PRETTY_FUNCTION__));
21152 } else {
21153 // Builtin: (ptr, stride, val0, val1, ..., vl).
21154 // Intrinsic: (val0, val1, ..., ptr, stride, vl)
21155 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
21156 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21156, __extension__ __PRETTY_FUNCTION__));
21157 }
21158 IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 1]->getType()};
21159 }
21160 break;
21161case RISCVVector::BI__builtin_rvv_vssseg4e8_v:
21162case RISCVVector::BI__builtin_rvv_vssseg4e16_v:
21163case RISCVVector::BI__builtin_rvv_vssseg4e32_v:
21164case RISCVVector::BI__builtin_rvv_vssseg4e64_v:
21165 ID = Intrinsic::riscv_vssseg4;
21166 NF = 4;
21167 DefaultPolicy = 1;
21168IsMasked = false;
21169
21170 {
21171 if (IsMasked) {
21172 // Builtin: (mask, ptr, stride, val0, val1, ..., vl).
21173 // Intrinsic: (val0, val1, ..., ptr, stride, mask, vl)
21174 std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
21175 std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
21176 assert(Ops.size() == NF + 4)(static_cast <bool> (Ops.size() == NF + 4) ? void (0) :
__assert_fail ("Ops.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21176, __extension__ __PRETTY_FUNCTION__));
21177 } else {
21178 // Builtin: (ptr, stride, val0, val1, ..., vl).
21179 // Intrinsic: (val0, val1, ..., ptr, stride, vl)
21180 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
21181 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21181, __extension__ __PRETTY_FUNCTION__));
21182 }
21183 IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 1]->getType()};
21184 }
21185 break;
21186case RISCVVector::BI__builtin_rvv_vssseg4e8_v_m:
21187case RISCVVector::BI__builtin_rvv_vssseg4e16_v_m:
21188case RISCVVector::BI__builtin_rvv_vssseg4e32_v_m:
21189case RISCVVector::BI__builtin_rvv_vssseg4e64_v_m:
21190 ID = Intrinsic::riscv_vssseg4_mask;
21191 NF = 4;
21192 DefaultPolicy = 0;
21193IsMasked = true;
21194
21195 {
21196 if (IsMasked) {
21197 // Builtin: (mask, ptr, stride, val0, val1, ..., vl).
21198 // Intrinsic: (val0, val1, ..., ptr, stride, mask, vl)
21199 std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
21200 std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
21201 assert(Ops.size() == NF + 4)(static_cast <bool> (Ops.size() == NF + 4) ? void (0) :
__assert_fail ("Ops.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21201, __extension__ __PRETTY_FUNCTION__));
21202 } else {
21203 // Builtin: (ptr, stride, val0, val1, ..., vl).
21204 // Intrinsic: (val0, val1, ..., ptr, stride, vl)
21205 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
21206 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21206, __extension__ __PRETTY_FUNCTION__));
21207 }
21208 IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 1]->getType()};
21209 }
21210 break;
21211case RISCVVector::BI__builtin_rvv_vssseg5e8_v:
21212case RISCVVector::BI__builtin_rvv_vssseg5e16_v:
21213case RISCVVector::BI__builtin_rvv_vssseg5e32_v:
21214case RISCVVector::BI__builtin_rvv_vssseg5e64_v:
21215 ID = Intrinsic::riscv_vssseg5;
21216 NF = 5;
21217 DefaultPolicy = 1;
21218IsMasked = false;
21219
21220 {
21221 if (IsMasked) {
21222 // Builtin: (mask, ptr, stride, val0, val1, ..., vl).
21223 // Intrinsic: (val0, val1, ..., ptr, stride, mask, vl)
21224 std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
21225 std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
21226 assert(Ops.size() == NF + 4)(static_cast <bool> (Ops.size() == NF + 4) ? void (0) :
__assert_fail ("Ops.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21226, __extension__ __PRETTY_FUNCTION__));
21227 } else {
21228 // Builtin: (ptr, stride, val0, val1, ..., vl).
21229 // Intrinsic: (val0, val1, ..., ptr, stride, vl)
21230 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
21231 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21231, __extension__ __PRETTY_FUNCTION__));
21232 }
21233 IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 1]->getType()};
21234 }
21235 break;
21236case RISCVVector::BI__builtin_rvv_vssseg5e8_v_m:
21237case RISCVVector::BI__builtin_rvv_vssseg5e16_v_m:
21238case RISCVVector::BI__builtin_rvv_vssseg5e32_v_m:
21239case RISCVVector::BI__builtin_rvv_vssseg5e64_v_m:
21240 ID = Intrinsic::riscv_vssseg5_mask;
21241 NF = 5;
21242 DefaultPolicy = 0;
21243IsMasked = true;
21244
21245 {
21246 if (IsMasked) {
21247 // Builtin: (mask, ptr, stride, val0, val1, ..., vl).
21248 // Intrinsic: (val0, val1, ..., ptr, stride, mask, vl)
21249 std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
21250 std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
21251 assert(Ops.size() == NF + 4)(static_cast <bool> (Ops.size() == NF + 4) ? void (0) :
__assert_fail ("Ops.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21251, __extension__ __PRETTY_FUNCTION__));
21252 } else {
21253 // Builtin: (ptr, stride, val0, val1, ..., vl).
21254 // Intrinsic: (val0, val1, ..., ptr, stride, vl)
21255 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
21256 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21256, __extension__ __PRETTY_FUNCTION__));
21257 }
21258 IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 1]->getType()};
21259 }
21260 break;
21261case RISCVVector::BI__builtin_rvv_vssseg6e8_v:
21262case RISCVVector::BI__builtin_rvv_vssseg6e16_v:
21263case RISCVVector::BI__builtin_rvv_vssseg6e32_v:
21264case RISCVVector::BI__builtin_rvv_vssseg6e64_v:
21265 ID = Intrinsic::riscv_vssseg6;
21266 NF = 6;
21267 DefaultPolicy = 1;
21268IsMasked = false;
21269
21270 {
21271 if (IsMasked) {
21272 // Builtin: (mask, ptr, stride, val0, val1, ..., vl).
21273 // Intrinsic: (val0, val1, ..., ptr, stride, mask, vl)
21274 std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
21275 std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
21276 assert(Ops.size() == NF + 4)(static_cast <bool> (Ops.size() == NF + 4) ? void (0) :
__assert_fail ("Ops.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21276, __extension__ __PRETTY_FUNCTION__));
21277 } else {
21278 // Builtin: (ptr, stride, val0, val1, ..., vl).
21279 // Intrinsic: (val0, val1, ..., ptr, stride, vl)
21280 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
21281 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21281, __extension__ __PRETTY_FUNCTION__));
21282 }
21283 IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 1]->getType()};
21284 }
21285 break;
21286case RISCVVector::BI__builtin_rvv_vssseg6e8_v_m:
21287case RISCVVector::BI__builtin_rvv_vssseg6e16_v_m:
21288case RISCVVector::BI__builtin_rvv_vssseg6e32_v_m:
21289case RISCVVector::BI__builtin_rvv_vssseg6e64_v_m:
21290 ID = Intrinsic::riscv_vssseg6_mask;
21291 NF = 6;
21292 DefaultPolicy = 0;
21293IsMasked = true;
21294
21295 {
21296 if (IsMasked) {
21297 // Builtin: (mask, ptr, stride, val0, val1, ..., vl).
21298 // Intrinsic: (val0, val1, ..., ptr, stride, mask, vl)
21299 std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
21300 std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
21301 assert(Ops.size() == NF + 4)(static_cast <bool> (Ops.size() == NF + 4) ? void (0) :
__assert_fail ("Ops.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21301, __extension__ __PRETTY_FUNCTION__));
21302 } else {
21303 // Builtin: (ptr, stride, val0, val1, ..., vl).
21304 // Intrinsic: (val0, val1, ..., ptr, stride, vl)
21305 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
21306 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21306, __extension__ __PRETTY_FUNCTION__));
21307 }
21308 IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 1]->getType()};
21309 }
21310 break;
21311case RISCVVector::BI__builtin_rvv_vssseg7e8_v:
21312case RISCVVector::BI__builtin_rvv_vssseg7e16_v:
21313case RISCVVector::BI__builtin_rvv_vssseg7e32_v:
21314case RISCVVector::BI__builtin_rvv_vssseg7e64_v:
21315 ID = Intrinsic::riscv_vssseg7;
21316 NF = 7;
21317 DefaultPolicy = 1;
21318IsMasked = false;
21319
21320 {
21321 if (IsMasked) {
21322 // Builtin: (mask, ptr, stride, val0, val1, ..., vl).
21323 // Intrinsic: (val0, val1, ..., ptr, stride, mask, vl)
21324 std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
21325 std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
21326 assert(Ops.size() == NF + 4)(static_cast <bool> (Ops.size() == NF + 4) ? void (0) :
__assert_fail ("Ops.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21326, __extension__ __PRETTY_FUNCTION__));
21327 } else {
21328 // Builtin: (ptr, stride, val0, val1, ..., vl).
21329 // Intrinsic: (val0, val1, ..., ptr, stride, vl)
21330 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
21331 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21331, __extension__ __PRETTY_FUNCTION__));
21332 }
21333 IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 1]->getType()};
21334 }
21335 break;
21336case RISCVVector::BI__builtin_rvv_vssseg7e8_v_m:
21337case RISCVVector::BI__builtin_rvv_vssseg7e16_v_m:
21338case RISCVVector::BI__builtin_rvv_vssseg7e32_v_m:
21339case RISCVVector::BI__builtin_rvv_vssseg7e64_v_m:
21340 ID = Intrinsic::riscv_vssseg7_mask;
21341 NF = 7;
21342 DefaultPolicy = 0;
21343IsMasked = true;
21344
21345 {
21346 if (IsMasked) {
21347 // Builtin: (mask, ptr, stride, val0, val1, ..., vl).
21348 // Intrinsic: (val0, val1, ..., ptr, stride, mask, vl)
21349 std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
21350 std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
21351 assert(Ops.size() == NF + 4)(static_cast <bool> (Ops.size() == NF + 4) ? void (0) :
__assert_fail ("Ops.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21351, __extension__ __PRETTY_FUNCTION__));
21352 } else {
21353 // Builtin: (ptr, stride, val0, val1, ..., vl).
21354 // Intrinsic: (val0, val1, ..., ptr, stride, vl)
21355 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
21356 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21356, __extension__ __PRETTY_FUNCTION__));
21357 }
21358 IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 1]->getType()};
21359 }
21360 break;
21361case RISCVVector::BI__builtin_rvv_vssseg8e8_v:
21362case RISCVVector::BI__builtin_rvv_vssseg8e16_v:
21363case RISCVVector::BI__builtin_rvv_vssseg8e32_v:
21364case RISCVVector::BI__builtin_rvv_vssseg8e64_v:
21365 ID = Intrinsic::riscv_vssseg8;
21366 NF = 8;
21367 DefaultPolicy = 1;
21368IsMasked = false;
21369
21370 {
21371 if (IsMasked) {
21372 // Builtin: (mask, ptr, stride, val0, val1, ..., vl).
21373 // Intrinsic: (val0, val1, ..., ptr, stride, mask, vl)
21374 std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
21375 std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
21376 assert(Ops.size() == NF + 4)(static_cast <bool> (Ops.size() == NF + 4) ? void (0) :
__assert_fail ("Ops.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21376, __extension__ __PRETTY_FUNCTION__));
21377 } else {
21378 // Builtin: (ptr, stride, val0, val1, ..., vl).
21379 // Intrinsic: (val0, val1, ..., ptr, stride, vl)
21380 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
21381 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21381, __extension__ __PRETTY_FUNCTION__));
21382 }
21383 IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 1]->getType()};
21384 }
21385 break;
21386case RISCVVector::BI__builtin_rvv_vssseg8e8_v_m:
21387case RISCVVector::BI__builtin_rvv_vssseg8e16_v_m:
21388case RISCVVector::BI__builtin_rvv_vssseg8e32_v_m:
21389case RISCVVector::BI__builtin_rvv_vssseg8e64_v_m:
21390 ID = Intrinsic::riscv_vssseg8_mask;
21391 NF = 8;
21392 DefaultPolicy = 0;
21393IsMasked = true;
21394
21395 {
21396 if (IsMasked) {
21397 // Builtin: (mask, ptr, stride, val0, val1, ..., vl).
21398 // Intrinsic: (val0, val1, ..., ptr, stride, mask, vl)
21399 std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
21400 std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
21401 assert(Ops.size() == NF + 4)(static_cast <bool> (Ops.size() == NF + 4) ? void (0) :
__assert_fail ("Ops.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21401, __extension__ __PRETTY_FUNCTION__));
21402 } else {
21403 // Builtin: (ptr, stride, val0, val1, ..., vl).
21404 // Intrinsic: (val0, val1, ..., ptr, stride, vl)
21405 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
21406 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21406, __extension__ __PRETTY_FUNCTION__));
21407 }
21408 IntrinsicTypes = {Ops[0]->getType(), Ops[NF + 1]->getType()};
21409 }
21410 break;
21411case RISCVVector::BI__builtin_rvv_vssub_vv_tu:
21412case RISCVVector::BI__builtin_rvv_vssub_vx_tu:
21413 ID = Intrinsic::riscv_vssub;
21414 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
21415 break;
21416case RISCVVector::BI__builtin_rvv_vssub_vv_ta:
21417case RISCVVector::BI__builtin_rvv_vssub_vx_ta:
21418 ID = Intrinsic::riscv_vssub;
21419 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
21420 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
21421 break;
21422case RISCVVector::BI__builtin_rvv_vssub_vv_tuma:
21423case RISCVVector::BI__builtin_rvv_vssub_vx_tuma:
21424 ID = Intrinsic::riscv_vssub_mask;
21425 DefaultPolicy = 2;
21426 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
21427 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
21428 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
21429 break;
21430case RISCVVector::BI__builtin_rvv_vssub_vv_tama:
21431case RISCVVector::BI__builtin_rvv_vssub_vx_tama:
21432 ID = Intrinsic::riscv_vssub_mask;
21433 DefaultPolicy = 3;
21434 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
21435 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
21436 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
21437 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
21438 break;
21439case RISCVVector::BI__builtin_rvv_vssub_vv_tumu:
21440case RISCVVector::BI__builtin_rvv_vssub_vx_tumu:
21441 ID = Intrinsic::riscv_vssub_mask;
21442 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
21443 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
21444 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
21445 break;
21446case RISCVVector::BI__builtin_rvv_vssub_vv_tamu:
21447case RISCVVector::BI__builtin_rvv_vssub_vx_tamu:
21448 ID = Intrinsic::riscv_vssub_mask;
21449 DefaultPolicy = 1;
21450 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
21451 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
21452 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
21453 break;
21454case RISCVVector::BI__builtin_rvv_vssubu_vv_tu:
21455case RISCVVector::BI__builtin_rvv_vssubu_vx_tu:
21456 ID = Intrinsic::riscv_vssubu;
21457 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
21458 break;
21459case RISCVVector::BI__builtin_rvv_vssubu_vv_ta:
21460case RISCVVector::BI__builtin_rvv_vssubu_vx_ta:
21461 ID = Intrinsic::riscv_vssubu;
21462 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
21463 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
21464 break;
21465case RISCVVector::BI__builtin_rvv_vssubu_vv_tuma:
21466case RISCVVector::BI__builtin_rvv_vssubu_vx_tuma:
21467 ID = Intrinsic::riscv_vssubu_mask;
21468 DefaultPolicy = 2;
21469 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
21470 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
21471 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
21472 break;
21473case RISCVVector::BI__builtin_rvv_vssubu_vv_tama:
21474case RISCVVector::BI__builtin_rvv_vssubu_vx_tama:
21475 ID = Intrinsic::riscv_vssubu_mask;
21476 DefaultPolicy = 3;
21477 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
21478 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
21479 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
21480 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
21481 break;
21482case RISCVVector::BI__builtin_rvv_vssubu_vv_tumu:
21483case RISCVVector::BI__builtin_rvv_vssubu_vx_tumu:
21484 ID = Intrinsic::riscv_vssubu_mask;
21485 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
21486 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
21487 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
21488 break;
21489case RISCVVector::BI__builtin_rvv_vssubu_vv_tamu:
21490case RISCVVector::BI__builtin_rvv_vssubu_vx_tamu:
21491 ID = Intrinsic::riscv_vssubu_mask;
21492 DefaultPolicy = 1;
21493 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
21494 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
21495 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
21496 break;
21497case RISCVVector::BI__builtin_rvv_vsub_vv_tu:
21498case RISCVVector::BI__builtin_rvv_vsub_vx_tu:
21499 ID = Intrinsic::riscv_vsub;
21500 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
21501 break;
21502case RISCVVector::BI__builtin_rvv_vsub_vv_ta:
21503case RISCVVector::BI__builtin_rvv_vsub_vx_ta:
21504 ID = Intrinsic::riscv_vsub;
21505 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
21506 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
21507 break;
21508case RISCVVector::BI__builtin_rvv_vsub_vv_tuma:
21509case RISCVVector::BI__builtin_rvv_vsub_vx_tuma:
21510 ID = Intrinsic::riscv_vsub_mask;
21511 DefaultPolicy = 2;
21512 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
21513 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
21514 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
21515 break;
21516case RISCVVector::BI__builtin_rvv_vsub_vv_tama:
21517case RISCVVector::BI__builtin_rvv_vsub_vx_tama:
21518 ID = Intrinsic::riscv_vsub_mask;
21519 DefaultPolicy = 3;
21520 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
21521 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
21522 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
21523 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
21524 break;
21525case RISCVVector::BI__builtin_rvv_vsub_vv_tumu:
21526case RISCVVector::BI__builtin_rvv_vsub_vx_tumu:
21527 ID = Intrinsic::riscv_vsub_mask;
21528 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
21529 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
21530 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
21531 break;
21532case RISCVVector::BI__builtin_rvv_vsub_vv_tamu:
21533case RISCVVector::BI__builtin_rvv_vsub_vx_tamu:
21534 ID = Intrinsic::riscv_vsub_mask;
21535 DefaultPolicy = 1;
21536 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
21537 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
21538 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
21539 break;
21540case RISCVVector::BI__builtin_rvv_vsuxei16_v:
21541case RISCVVector::BI__builtin_rvv_vsuxei32_v:
21542case RISCVVector::BI__builtin_rvv_vsuxei8_v:
21543case RISCVVector::BI__builtin_rvv_vsuxei64_v:
21544 ID = Intrinsic::riscv_vsuxei;
21545 DefaultPolicy = 1;
21546IsMasked = false;
21547
21548 if (IsMasked) {
21549 // Builtin: (mask, ptr, index, value, vl). Intrinsic: (value, ptr, index, mask, vl)
21550 std::swap(Ops[0], Ops[3]);
21551 } else {
21552 // Builtin: (ptr, index, value, vl). Intrinsic: (value, ptr, index, vl)
21553 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.begin() + 3);
21554 }
21555 Ops[1] = Builder.CreateBitCast(Ops[1], Ops[0]->getType()->getPointerTo());
21556 if (IsMasked)
21557 IntrinsicTypes = {Ops[0]->getType(), Ops[2]->getType(), Ops[4]->getType()};
21558 else
21559 IntrinsicTypes = {Ops[0]->getType(), Ops[2]->getType(), Ops[3]->getType()};
21560 break;
21561case RISCVVector::BI__builtin_rvv_vsuxei16_v_m:
21562case RISCVVector::BI__builtin_rvv_vsuxei32_v_m:
21563case RISCVVector::BI__builtin_rvv_vsuxei8_v_m:
21564case RISCVVector::BI__builtin_rvv_vsuxei64_v_m:
21565 ID = Intrinsic::riscv_vsuxei_mask;
21566 DefaultPolicy = 0;
21567IsMasked = true;
21568
21569 if (IsMasked) {
21570 // Builtin: (mask, ptr, index, value, vl). Intrinsic: (value, ptr, index, mask, vl)
21571 std::swap(Ops[0], Ops[3]);
21572 } else {
21573 // Builtin: (ptr, index, value, vl). Intrinsic: (value, ptr, index, vl)
21574 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.begin() + 3);
21575 }
21576 Ops[1] = Builder.CreateBitCast(Ops[1], Ops[0]->getType()->getPointerTo());
21577 if (IsMasked)
21578 IntrinsicTypes = {Ops[0]->getType(), Ops[2]->getType(), Ops[4]->getType()};
21579 else
21580 IntrinsicTypes = {Ops[0]->getType(), Ops[2]->getType(), Ops[3]->getType()};
21581 break;
21582case RISCVVector::BI__builtin_rvv_vsuxseg2ei16_v:
21583case RISCVVector::BI__builtin_rvv_vsuxseg2ei32_v:
21584case RISCVVector::BI__builtin_rvv_vsuxseg2ei64_v:
21585case RISCVVector::BI__builtin_rvv_vsuxseg2ei8_v:
21586 ID = Intrinsic::riscv_vsuxseg2;
21587 NF = 2;
21588 DefaultPolicy = 1;
21589IsMasked = false;
21590
21591 {
21592 if (IsMasked) {
21593 // Builtin: (mask, ptr, index, val0, val1, ..., vl)
21594 // Intrinsic: (val0, val1, ..., ptr, index, mask, vl)
21595 std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
21596 std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
21597 IntrinsicTypes = {Ops[0]->getType(),
21598 Ops[NF + 1]->getType(), Ops[NF + 3]->getType()};
21599 assert(Ops.size() == NF + 4)(static_cast <bool> (Ops.size() == NF + 4) ? void (0) :
__assert_fail ("Ops.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21599, __extension__ __PRETTY_FUNCTION__));
21600 } else {
21601 // Builtin: (ptr, index, val0, val1, ..., vl)
21602 // Intrinsic: (val0, val1, ..., ptr, index, vl)
21603 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
21604 IntrinsicTypes = {Ops[0]->getType(),
21605 Ops[NF + 1]->getType(), Ops[NF + 2]->getType()};
21606 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21606, __extension__ __PRETTY_FUNCTION__));
21607 }
21608 }
21609 break;
21610case RISCVVector::BI__builtin_rvv_vsuxseg2ei16_v_m:
21611case RISCVVector::BI__builtin_rvv_vsuxseg2ei32_v_m:
21612case RISCVVector::BI__builtin_rvv_vsuxseg2ei64_v_m:
21613case RISCVVector::BI__builtin_rvv_vsuxseg2ei8_v_m:
21614 ID = Intrinsic::riscv_vsuxseg2_mask;
21615 NF = 2;
21616 DefaultPolicy = 0;
21617IsMasked = true;
21618
21619 {
21620 if (IsMasked) {
21621 // Builtin: (mask, ptr, index, val0, val1, ..., vl)
21622 // Intrinsic: (val0, val1, ..., ptr, index, mask, vl)
21623 std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
21624 std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
21625 IntrinsicTypes = {Ops[0]->getType(),
21626 Ops[NF + 1]->getType(), Ops[NF + 3]->getType()};
21627 assert(Ops.size() == NF + 4)(static_cast <bool> (Ops.size() == NF + 4) ? void (0) :
__assert_fail ("Ops.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21627, __extension__ __PRETTY_FUNCTION__));
21628 } else {
21629 // Builtin: (ptr, index, val0, val1, ..., vl)
21630 // Intrinsic: (val0, val1, ..., ptr, index, vl)
21631 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
21632 IntrinsicTypes = {Ops[0]->getType(),
21633 Ops[NF + 1]->getType(), Ops[NF + 2]->getType()};
21634 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21634, __extension__ __PRETTY_FUNCTION__));
21635 }
21636 }
21637 break;
21638case RISCVVector::BI__builtin_rvv_vsuxseg3ei8_v:
21639case RISCVVector::BI__builtin_rvv_vsuxseg3ei16_v:
21640case RISCVVector::BI__builtin_rvv_vsuxseg3ei32_v:
21641case RISCVVector::BI__builtin_rvv_vsuxseg3ei64_v:
21642 ID = Intrinsic::riscv_vsuxseg3;
21643 NF = 3;
21644 DefaultPolicy = 1;
21645IsMasked = false;
21646
21647 {
21648 if (IsMasked) {
21649 // Builtin: (mask, ptr, index, val0, val1, ..., vl)
21650 // Intrinsic: (val0, val1, ..., ptr, index, mask, vl)
21651 std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
21652 std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
21653 IntrinsicTypes = {Ops[0]->getType(),
21654 Ops[NF + 1]->getType(), Ops[NF + 3]->getType()};
21655 assert(Ops.size() == NF + 4)(static_cast <bool> (Ops.size() == NF + 4) ? void (0) :
__assert_fail ("Ops.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21655, __extension__ __PRETTY_FUNCTION__));
21656 } else {
21657 // Builtin: (ptr, index, val0, val1, ..., vl)
21658 // Intrinsic: (val0, val1, ..., ptr, index, vl)
21659 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
21660 IntrinsicTypes = {Ops[0]->getType(),
21661 Ops[NF + 1]->getType(), Ops[NF + 2]->getType()};
21662 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21662, __extension__ __PRETTY_FUNCTION__));
21663 }
21664 }
21665 break;
21666case RISCVVector::BI__builtin_rvv_vsuxseg3ei8_v_m:
21667case RISCVVector::BI__builtin_rvv_vsuxseg3ei16_v_m:
21668case RISCVVector::BI__builtin_rvv_vsuxseg3ei32_v_m:
21669case RISCVVector::BI__builtin_rvv_vsuxseg3ei64_v_m:
21670 ID = Intrinsic::riscv_vsuxseg3_mask;
21671 NF = 3;
21672 DefaultPolicy = 0;
21673IsMasked = true;
21674
21675 {
21676 if (IsMasked) {
21677 // Builtin: (mask, ptr, index, val0, val1, ..., vl)
21678 // Intrinsic: (val0, val1, ..., ptr, index, mask, vl)
21679 std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
21680 std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
21681 IntrinsicTypes = {Ops[0]->getType(),
21682 Ops[NF + 1]->getType(), Ops[NF + 3]->getType()};
21683 assert(Ops.size() == NF + 4)(static_cast <bool> (Ops.size() == NF + 4) ? void (0) :
__assert_fail ("Ops.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21683, __extension__ __PRETTY_FUNCTION__));
21684 } else {
21685 // Builtin: (ptr, index, val0, val1, ..., vl)
21686 // Intrinsic: (val0, val1, ..., ptr, index, vl)
21687 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
21688 IntrinsicTypes = {Ops[0]->getType(),
21689 Ops[NF + 1]->getType(), Ops[NF + 2]->getType()};
21690 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21690, __extension__ __PRETTY_FUNCTION__));
21691 }
21692 }
21693 break;
21694case RISCVVector::BI__builtin_rvv_vsuxseg4ei8_v:
21695case RISCVVector::BI__builtin_rvv_vsuxseg4ei16_v:
21696case RISCVVector::BI__builtin_rvv_vsuxseg4ei32_v:
21697case RISCVVector::BI__builtin_rvv_vsuxseg4ei64_v:
21698 ID = Intrinsic::riscv_vsuxseg4;
21699 NF = 4;
21700 DefaultPolicy = 1;
21701IsMasked = false;
21702
21703 {
21704 if (IsMasked) {
21705 // Builtin: (mask, ptr, index, val0, val1, ..., vl)
21706 // Intrinsic: (val0, val1, ..., ptr, index, mask, vl)
21707 std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
21708 std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
21709 IntrinsicTypes = {Ops[0]->getType(),
21710 Ops[NF + 1]->getType(), Ops[NF + 3]->getType()};
21711 assert(Ops.size() == NF + 4)(static_cast <bool> (Ops.size() == NF + 4) ? void (0) :
__assert_fail ("Ops.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21711, __extension__ __PRETTY_FUNCTION__));
21712 } else {
21713 // Builtin: (ptr, index, val0, val1, ..., vl)
21714 // Intrinsic: (val0, val1, ..., ptr, index, vl)
21715 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
21716 IntrinsicTypes = {Ops[0]->getType(),
21717 Ops[NF + 1]->getType(), Ops[NF + 2]->getType()};
21718 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21718, __extension__ __PRETTY_FUNCTION__));
21719 }
21720 }
21721 break;
21722case RISCVVector::BI__builtin_rvv_vsuxseg4ei8_v_m:
21723case RISCVVector::BI__builtin_rvv_vsuxseg4ei16_v_m:
21724case RISCVVector::BI__builtin_rvv_vsuxseg4ei32_v_m:
21725case RISCVVector::BI__builtin_rvv_vsuxseg4ei64_v_m:
21726 ID = Intrinsic::riscv_vsuxseg4_mask;
21727 NF = 4;
21728 DefaultPolicy = 0;
21729IsMasked = true;
21730
21731 {
21732 if (IsMasked) {
21733 // Builtin: (mask, ptr, index, val0, val1, ..., vl)
21734 // Intrinsic: (val0, val1, ..., ptr, index, mask, vl)
21735 std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
21736 std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
21737 IntrinsicTypes = {Ops[0]->getType(),
21738 Ops[NF + 1]->getType(), Ops[NF + 3]->getType()};
21739 assert(Ops.size() == NF + 4)(static_cast <bool> (Ops.size() == NF + 4) ? void (0) :
__assert_fail ("Ops.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21739, __extension__ __PRETTY_FUNCTION__));
21740 } else {
21741 // Builtin: (ptr, index, val0, val1, ..., vl)
21742 // Intrinsic: (val0, val1, ..., ptr, index, vl)
21743 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
21744 IntrinsicTypes = {Ops[0]->getType(),
21745 Ops[NF + 1]->getType(), Ops[NF + 2]->getType()};
21746 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21746, __extension__ __PRETTY_FUNCTION__));
21747 }
21748 }
21749 break;
21750case RISCVVector::BI__builtin_rvv_vsuxseg5ei8_v:
21751case RISCVVector::BI__builtin_rvv_vsuxseg5ei16_v:
21752case RISCVVector::BI__builtin_rvv_vsuxseg5ei32_v:
21753case RISCVVector::BI__builtin_rvv_vsuxseg5ei64_v:
21754 ID = Intrinsic::riscv_vsuxseg5;
21755 NF = 5;
21756 DefaultPolicy = 1;
21757IsMasked = false;
21758
21759 {
21760 if (IsMasked) {
21761 // Builtin: (mask, ptr, index, val0, val1, ..., vl)
21762 // Intrinsic: (val0, val1, ..., ptr, index, mask, vl)
21763 std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
21764 std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
21765 IntrinsicTypes = {Ops[0]->getType(),
21766 Ops[NF + 1]->getType(), Ops[NF + 3]->getType()};
21767 assert(Ops.size() == NF + 4)(static_cast <bool> (Ops.size() == NF + 4) ? void (0) :
__assert_fail ("Ops.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21767, __extension__ __PRETTY_FUNCTION__));
21768 } else {
21769 // Builtin: (ptr, index, val0, val1, ..., vl)
21770 // Intrinsic: (val0, val1, ..., ptr, index, vl)
21771 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
21772 IntrinsicTypes = {Ops[0]->getType(),
21773 Ops[NF + 1]->getType(), Ops[NF + 2]->getType()};
21774 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21774, __extension__ __PRETTY_FUNCTION__));
21775 }
21776 }
21777 break;
21778case RISCVVector::BI__builtin_rvv_vsuxseg5ei8_v_m:
21779case RISCVVector::BI__builtin_rvv_vsuxseg5ei16_v_m:
21780case RISCVVector::BI__builtin_rvv_vsuxseg5ei32_v_m:
21781case RISCVVector::BI__builtin_rvv_vsuxseg5ei64_v_m:
21782 ID = Intrinsic::riscv_vsuxseg5_mask;
21783 NF = 5;
21784 DefaultPolicy = 0;
21785IsMasked = true;
21786
21787 {
21788 if (IsMasked) {
21789 // Builtin: (mask, ptr, index, val0, val1, ..., vl)
21790 // Intrinsic: (val0, val1, ..., ptr, index, mask, vl)
21791 std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
21792 std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
21793 IntrinsicTypes = {Ops[0]->getType(),
21794 Ops[NF + 1]->getType(), Ops[NF + 3]->getType()};
21795 assert(Ops.size() == NF + 4)(static_cast <bool> (Ops.size() == NF + 4) ? void (0) :
__assert_fail ("Ops.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21795, __extension__ __PRETTY_FUNCTION__));
21796 } else {
21797 // Builtin: (ptr, index, val0, val1, ..., vl)
21798 // Intrinsic: (val0, val1, ..., ptr, index, vl)
21799 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
21800 IntrinsicTypes = {Ops[0]->getType(),
21801 Ops[NF + 1]->getType(), Ops[NF + 2]->getType()};
21802 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21802, __extension__ __PRETTY_FUNCTION__));
21803 }
21804 }
21805 break;
21806case RISCVVector::BI__builtin_rvv_vsuxseg6ei8_v:
21807case RISCVVector::BI__builtin_rvv_vsuxseg6ei16_v:
21808case RISCVVector::BI__builtin_rvv_vsuxseg6ei32_v:
21809case RISCVVector::BI__builtin_rvv_vsuxseg6ei64_v:
21810 ID = Intrinsic::riscv_vsuxseg6;
21811 NF = 6;
21812 DefaultPolicy = 1;
21813IsMasked = false;
21814
21815 {
21816 if (IsMasked) {
21817 // Builtin: (mask, ptr, index, val0, val1, ..., vl)
21818 // Intrinsic: (val0, val1, ..., ptr, index, mask, vl)
21819 std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
21820 std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
21821 IntrinsicTypes = {Ops[0]->getType(),
21822 Ops[NF + 1]->getType(), Ops[NF + 3]->getType()};
21823 assert(Ops.size() == NF + 4)(static_cast <bool> (Ops.size() == NF + 4) ? void (0) :
__assert_fail ("Ops.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21823, __extension__ __PRETTY_FUNCTION__));
21824 } else {
21825 // Builtin: (ptr, index, val0, val1, ..., vl)
21826 // Intrinsic: (val0, val1, ..., ptr, index, vl)
21827 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
21828 IntrinsicTypes = {Ops[0]->getType(),
21829 Ops[NF + 1]->getType(), Ops[NF + 2]->getType()};
21830 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21830, __extension__ __PRETTY_FUNCTION__));
21831 }
21832 }
21833 break;
21834case RISCVVector::BI__builtin_rvv_vsuxseg6ei8_v_m:
21835case RISCVVector::BI__builtin_rvv_vsuxseg6ei16_v_m:
21836case RISCVVector::BI__builtin_rvv_vsuxseg6ei32_v_m:
21837case RISCVVector::BI__builtin_rvv_vsuxseg6ei64_v_m:
21838 ID = Intrinsic::riscv_vsuxseg6_mask;
21839 NF = 6;
21840 DefaultPolicy = 0;
21841IsMasked = true;
21842
21843 {
21844 if (IsMasked) {
21845 // Builtin: (mask, ptr, index, val0, val1, ..., vl)
21846 // Intrinsic: (val0, val1, ..., ptr, index, mask, vl)
21847 std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
21848 std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
21849 IntrinsicTypes = {Ops[0]->getType(),
21850 Ops[NF + 1]->getType(), Ops[NF + 3]->getType()};
21851 assert(Ops.size() == NF + 4)(static_cast <bool> (Ops.size() == NF + 4) ? void (0) :
__assert_fail ("Ops.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21851, __extension__ __PRETTY_FUNCTION__));
21852 } else {
21853 // Builtin: (ptr, index, val0, val1, ..., vl)
21854 // Intrinsic: (val0, val1, ..., ptr, index, vl)
21855 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
21856 IntrinsicTypes = {Ops[0]->getType(),
21857 Ops[NF + 1]->getType(), Ops[NF + 2]->getType()};
21858 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21858, __extension__ __PRETTY_FUNCTION__));
21859 }
21860 }
21861 break;
21862case RISCVVector::BI__builtin_rvv_vsuxseg7ei8_v:
21863case RISCVVector::BI__builtin_rvv_vsuxseg7ei16_v:
21864case RISCVVector::BI__builtin_rvv_vsuxseg7ei32_v:
21865case RISCVVector::BI__builtin_rvv_vsuxseg7ei64_v:
21866 ID = Intrinsic::riscv_vsuxseg7;
21867 NF = 7;
21868 DefaultPolicy = 1;
21869IsMasked = false;
21870
21871 {
21872 if (IsMasked) {
21873 // Builtin: (mask, ptr, index, val0, val1, ..., vl)
21874 // Intrinsic: (val0, val1, ..., ptr, index, mask, vl)
21875 std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
21876 std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
21877 IntrinsicTypes = {Ops[0]->getType(),
21878 Ops[NF + 1]->getType(), Ops[NF + 3]->getType()};
21879 assert(Ops.size() == NF + 4)(static_cast <bool> (Ops.size() == NF + 4) ? void (0) :
__assert_fail ("Ops.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21879, __extension__ __PRETTY_FUNCTION__));
21880 } else {
21881 // Builtin: (ptr, index, val0, val1, ..., vl)
21882 // Intrinsic: (val0, val1, ..., ptr, index, vl)
21883 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
21884 IntrinsicTypes = {Ops[0]->getType(),
21885 Ops[NF + 1]->getType(), Ops[NF + 2]->getType()};
21886 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21886, __extension__ __PRETTY_FUNCTION__));
21887 }
21888 }
21889 break;
21890case RISCVVector::BI__builtin_rvv_vsuxseg7ei8_v_m:
21891case RISCVVector::BI__builtin_rvv_vsuxseg7ei16_v_m:
21892case RISCVVector::BI__builtin_rvv_vsuxseg7ei32_v_m:
21893case RISCVVector::BI__builtin_rvv_vsuxseg7ei64_v_m:
21894 ID = Intrinsic::riscv_vsuxseg7_mask;
21895 NF = 7;
21896 DefaultPolicy = 0;
21897IsMasked = true;
21898
21899 {
21900 if (IsMasked) {
21901 // Builtin: (mask, ptr, index, val0, val1, ..., vl)
21902 // Intrinsic: (val0, val1, ..., ptr, index, mask, vl)
21903 std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
21904 std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
21905 IntrinsicTypes = {Ops[0]->getType(),
21906 Ops[NF + 1]->getType(), Ops[NF + 3]->getType()};
21907 assert(Ops.size() == NF + 4)(static_cast <bool> (Ops.size() == NF + 4) ? void (0) :
__assert_fail ("Ops.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21907, __extension__ __PRETTY_FUNCTION__));
21908 } else {
21909 // Builtin: (ptr, index, val0, val1, ..., vl)
21910 // Intrinsic: (val0, val1, ..., ptr, index, vl)
21911 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
21912 IntrinsicTypes = {Ops[0]->getType(),
21913 Ops[NF + 1]->getType(), Ops[NF + 2]->getType()};
21914 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21914, __extension__ __PRETTY_FUNCTION__));
21915 }
21916 }
21917 break;
21918case RISCVVector::BI__builtin_rvv_vsuxseg8ei8_v:
21919case RISCVVector::BI__builtin_rvv_vsuxseg8ei16_v:
21920case RISCVVector::BI__builtin_rvv_vsuxseg8ei32_v:
21921case RISCVVector::BI__builtin_rvv_vsuxseg8ei64_v:
21922 ID = Intrinsic::riscv_vsuxseg8;
21923 NF = 8;
21924 DefaultPolicy = 1;
21925IsMasked = false;
21926
21927 {
21928 if (IsMasked) {
21929 // Builtin: (mask, ptr, index, val0, val1, ..., vl)
21930 // Intrinsic: (val0, val1, ..., ptr, index, mask, vl)
21931 std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
21932 std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
21933 IntrinsicTypes = {Ops[0]->getType(),
21934 Ops[NF + 1]->getType(), Ops[NF + 3]->getType()};
21935 assert(Ops.size() == NF + 4)(static_cast <bool> (Ops.size() == NF + 4) ? void (0) :
__assert_fail ("Ops.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21935, __extension__ __PRETTY_FUNCTION__));
21936 } else {
21937 // Builtin: (ptr, index, val0, val1, ..., vl)
21938 // Intrinsic: (val0, val1, ..., ptr, index, vl)
21939 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
21940 IntrinsicTypes = {Ops[0]->getType(),
21941 Ops[NF + 1]->getType(), Ops[NF + 2]->getType()};
21942 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21942, __extension__ __PRETTY_FUNCTION__));
21943 }
21944 }
21945 break;
21946case RISCVVector::BI__builtin_rvv_vsuxseg8ei8_v_m:
21947case RISCVVector::BI__builtin_rvv_vsuxseg8ei16_v_m:
21948case RISCVVector::BI__builtin_rvv_vsuxseg8ei32_v_m:
21949case RISCVVector::BI__builtin_rvv_vsuxseg8ei64_v_m:
21950 ID = Intrinsic::riscv_vsuxseg8_mask;
21951 NF = 8;
21952 DefaultPolicy = 0;
21953IsMasked = true;
21954
21955 {
21956 if (IsMasked) {
21957 // Builtin: (mask, ptr, index, val0, val1, ..., vl)
21958 // Intrinsic: (val0, val1, ..., ptr, index, mask, vl)
21959 std::rotate(Ops.begin(), Ops.begin() + 3, Ops.end() - 1);
21960 std::rotate(Ops.begin() + NF, Ops.begin() + NF + 1, Ops.begin() + NF + 3);
21961 IntrinsicTypes = {Ops[0]->getType(),
21962 Ops[NF + 1]->getType(), Ops[NF + 3]->getType()};
21963 assert(Ops.size() == NF + 4)(static_cast <bool> (Ops.size() == NF + 4) ? void (0) :
__assert_fail ("Ops.size() == NF + 4", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21963, __extension__ __PRETTY_FUNCTION__));
21964 } else {
21965 // Builtin: (ptr, index, val0, val1, ..., vl)
21966 // Intrinsic: (val0, val1, ..., ptr, index, vl)
21967 std::rotate(Ops.begin(), Ops.begin() + 2, Ops.end() - 1);
21968 IntrinsicTypes = {Ops[0]->getType(),
21969 Ops[NF + 1]->getType(), Ops[NF + 2]->getType()};
21970 assert(Ops.size() == NF + 3)(static_cast <bool> (Ops.size() == NF + 3) ? void (0) :
__assert_fail ("Ops.size() == NF + 3", "tools/clang/include/clang/Basic/riscv_vector_builtin_cg.inc"
, 21970, __extension__ __PRETTY_FUNCTION__));
21971 }
21972 }
21973 break;
21974case RISCVVector::BI__builtin_rvv_vwadd_vv_tu:
21975case RISCVVector::BI__builtin_rvv_vwadd_vx_tu:
21976 ID = Intrinsic::riscv_vwadd;
21977 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
21978 break;
21979case RISCVVector::BI__builtin_rvv_vwcvt_x_x_v_tu:
21980 ID = Intrinsic::riscv_vwadd;
21981 DefaultPolicy = 0;
21982IsMasked = false;
21983
21984 {
21985 if (IsMasked) {
21986 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
21987 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
21988 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
21989 } else {
21990 if (DefaultPolicy == TAIL_AGNOSTIC)
21991 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
21992 }
21993 auto ElemTy = cast<llvm::VectorType>(ResultType)->getElementType();
21994 Ops.insert(Ops.begin() + 2, llvm::Constant::getNullValue(ElemTy));
21995 if (IsMasked) {
21996 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
21997 // maskedoff, op1, op2, mask, vl, policy
21998 IntrinsicTypes = {ResultType,
21999 Ops[1]->getType(),
22000 ElemTy,
22001 Ops[4]->getType()};
22002 } else {
22003 // passtru, op1, op2, vl
22004 IntrinsicTypes = {ResultType,
22005 Ops[1]->getType(),
22006 ElemTy,
22007 Ops[3]->getType()};
22008 }
22009 break;
22010 }
22011 break;
22012case RISCVVector::BI__builtin_rvv_vwadd_vv_ta:
22013case RISCVVector::BI__builtin_rvv_vwadd_vx_ta:
22014 ID = Intrinsic::riscv_vwadd;
22015 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
22016 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22017 break;
22018case RISCVVector::BI__builtin_rvv_vwcvt_x_x_v_ta:
22019 ID = Intrinsic::riscv_vwadd;
22020 DefaultPolicy = 1;
22021IsMasked = false;
22022
22023 {
22024 if (IsMasked) {
22025 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22026 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
22027 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
22028 } else {
22029 if (DefaultPolicy == TAIL_AGNOSTIC)
22030 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
22031 }
22032 auto ElemTy = cast<llvm::VectorType>(ResultType)->getElementType();
22033 Ops.insert(Ops.begin() + 2, llvm::Constant::getNullValue(ElemTy));
22034 if (IsMasked) {
22035 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22036 // maskedoff, op1, op2, mask, vl, policy
22037 IntrinsicTypes = {ResultType,
22038 Ops[1]->getType(),
22039 ElemTy,
22040 Ops[4]->getType()};
22041 } else {
22042 // passtru, op1, op2, vl
22043 IntrinsicTypes = {ResultType,
22044 Ops[1]->getType(),
22045 ElemTy,
22046 Ops[3]->getType()};
22047 }
22048 break;
22049 }
22050 break;
22051case RISCVVector::BI__builtin_rvv_vwadd_vv_tuma:
22052case RISCVVector::BI__builtin_rvv_vwadd_vx_tuma:
22053 ID = Intrinsic::riscv_vwadd_mask;
22054 DefaultPolicy = 2;
22055 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22056 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22057 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22058 break;
22059case RISCVVector::BI__builtin_rvv_vwcvt_x_x_v_tuma:
22060 ID = Intrinsic::riscv_vwadd_mask;
22061 DefaultPolicy = 2;
22062IsMasked = true;
22063
22064 {
22065 if (IsMasked) {
22066 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22067 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
22068 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
22069 } else {
22070 if (DefaultPolicy == TAIL_AGNOSTIC)
22071 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
22072 }
22073 auto ElemTy = cast<llvm::VectorType>(ResultType)->getElementType();
22074 Ops.insert(Ops.begin() + 2, llvm::Constant::getNullValue(ElemTy));
22075 if (IsMasked) {
22076 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22077 // maskedoff, op1, op2, mask, vl, policy
22078 IntrinsicTypes = {ResultType,
22079 Ops[1]->getType(),
22080 ElemTy,
22081 Ops[4]->getType()};
22082 } else {
22083 // passtru, op1, op2, vl
22084 IntrinsicTypes = {ResultType,
22085 Ops[1]->getType(),
22086 ElemTy,
22087 Ops[3]->getType()};
22088 }
22089 break;
22090 }
22091 break;
22092case RISCVVector::BI__builtin_rvv_vwadd_vv_tama:
22093case RISCVVector::BI__builtin_rvv_vwadd_vx_tama:
22094 ID = Intrinsic::riscv_vwadd_mask;
22095 DefaultPolicy = 3;
22096 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22097 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22098 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
22099 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22100 break;
22101case RISCVVector::BI__builtin_rvv_vwcvt_x_x_v_tama:
22102 ID = Intrinsic::riscv_vwadd_mask;
22103 DefaultPolicy = 3;
22104IsMasked = true;
22105
22106 {
22107 if (IsMasked) {
22108 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22109 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
22110 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
22111 } else {
22112 if (DefaultPolicy == TAIL_AGNOSTIC)
22113 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
22114 }
22115 auto ElemTy = cast<llvm::VectorType>(ResultType)->getElementType();
22116 Ops.insert(Ops.begin() + 2, llvm::Constant::getNullValue(ElemTy));
22117 if (IsMasked) {
22118 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22119 // maskedoff, op1, op2, mask, vl, policy
22120 IntrinsicTypes = {ResultType,
22121 Ops[1]->getType(),
22122 ElemTy,
22123 Ops[4]->getType()};
22124 } else {
22125 // passtru, op1, op2, vl
22126 IntrinsicTypes = {ResultType,
22127 Ops[1]->getType(),
22128 ElemTy,
22129 Ops[3]->getType()};
22130 }
22131 break;
22132 }
22133 break;
22134case RISCVVector::BI__builtin_rvv_vwadd_vv_tumu:
22135case RISCVVector::BI__builtin_rvv_vwadd_vx_tumu:
22136 ID = Intrinsic::riscv_vwadd_mask;
22137 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22138 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22139 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22140 break;
22141case RISCVVector::BI__builtin_rvv_vwcvt_x_x_v_tumu:
22142 ID = Intrinsic::riscv_vwadd_mask;
22143 DefaultPolicy = 0;
22144IsMasked = true;
22145
22146 {
22147 if (IsMasked) {
22148 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22149 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
22150 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
22151 } else {
22152 if (DefaultPolicy == TAIL_AGNOSTIC)
22153 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
22154 }
22155 auto ElemTy = cast<llvm::VectorType>(ResultType)->getElementType();
22156 Ops.insert(Ops.begin() + 2, llvm::Constant::getNullValue(ElemTy));
22157 if (IsMasked) {
22158 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22159 // maskedoff, op1, op2, mask, vl, policy
22160 IntrinsicTypes = {ResultType,
22161 Ops[1]->getType(),
22162 ElemTy,
22163 Ops[4]->getType()};
22164 } else {
22165 // passtru, op1, op2, vl
22166 IntrinsicTypes = {ResultType,
22167 Ops[1]->getType(),
22168 ElemTy,
22169 Ops[3]->getType()};
22170 }
22171 break;
22172 }
22173 break;
22174case RISCVVector::BI__builtin_rvv_vwadd_vv_tamu:
22175case RISCVVector::BI__builtin_rvv_vwadd_vx_tamu:
22176 ID = Intrinsic::riscv_vwadd_mask;
22177 DefaultPolicy = 1;
22178 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22179 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22180 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22181 break;
22182case RISCVVector::BI__builtin_rvv_vwcvt_x_x_v_tamu:
22183 ID = Intrinsic::riscv_vwadd_mask;
22184 DefaultPolicy = 1;
22185IsMasked = true;
22186
22187 {
22188 if (IsMasked) {
22189 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22190 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
22191 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
22192 } else {
22193 if (DefaultPolicy == TAIL_AGNOSTIC)
22194 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
22195 }
22196 auto ElemTy = cast<llvm::VectorType>(ResultType)->getElementType();
22197 Ops.insert(Ops.begin() + 2, llvm::Constant::getNullValue(ElemTy));
22198 if (IsMasked) {
22199 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22200 // maskedoff, op1, op2, mask, vl, policy
22201 IntrinsicTypes = {ResultType,
22202 Ops[1]->getType(),
22203 ElemTy,
22204 Ops[4]->getType()};
22205 } else {
22206 // passtru, op1, op2, vl
22207 IntrinsicTypes = {ResultType,
22208 Ops[1]->getType(),
22209 ElemTy,
22210 Ops[3]->getType()};
22211 }
22212 break;
22213 }
22214 break;
22215case RISCVVector::BI__builtin_rvv_vwadd_wv_tu:
22216case RISCVVector::BI__builtin_rvv_vwadd_wx_tu:
22217 ID = Intrinsic::riscv_vwadd_w;
22218 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
22219 break;
22220case RISCVVector::BI__builtin_rvv_vwadd_wv_ta:
22221case RISCVVector::BI__builtin_rvv_vwadd_wx_ta:
22222 ID = Intrinsic::riscv_vwadd_w;
22223 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
22224 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
22225 break;
22226case RISCVVector::BI__builtin_rvv_vwadd_wv_tuma:
22227case RISCVVector::BI__builtin_rvv_vwadd_wx_tuma:
22228 ID = Intrinsic::riscv_vwadd_w_mask;
22229 DefaultPolicy = 2;
22230 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22231 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22232 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
22233 break;
22234case RISCVVector::BI__builtin_rvv_vwadd_wv_tama:
22235case RISCVVector::BI__builtin_rvv_vwadd_wx_tama:
22236 ID = Intrinsic::riscv_vwadd_w_mask;
22237 DefaultPolicy = 3;
22238 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22239 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22240 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
22241 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
22242 break;
22243case RISCVVector::BI__builtin_rvv_vwadd_wv_tumu:
22244case RISCVVector::BI__builtin_rvv_vwadd_wx_tumu:
22245 ID = Intrinsic::riscv_vwadd_w_mask;
22246 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22247 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22248 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
22249 break;
22250case RISCVVector::BI__builtin_rvv_vwadd_wv_tamu:
22251case RISCVVector::BI__builtin_rvv_vwadd_wx_tamu:
22252 ID = Intrinsic::riscv_vwadd_w_mask;
22253 DefaultPolicy = 1;
22254 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22255 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22256 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
22257 break;
22258case RISCVVector::BI__builtin_rvv_vwaddu_vv_tu:
22259case RISCVVector::BI__builtin_rvv_vwaddu_vx_tu:
22260 ID = Intrinsic::riscv_vwaddu;
22261 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22262 break;
22263case RISCVVector::BI__builtin_rvv_vwcvtu_x_x_v_tu:
22264 ID = Intrinsic::riscv_vwaddu;
22265 DefaultPolicy = 0;
22266IsMasked = false;
22267
22268 {
22269 if (IsMasked) {
22270 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22271 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
22272 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
22273 } else {
22274 if (DefaultPolicy == TAIL_AGNOSTIC)
22275 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
22276 }
22277 auto ElemTy = cast<llvm::VectorType>(ResultType)->getElementType();
22278 Ops.insert(Ops.begin() + 2, llvm::Constant::getNullValue(ElemTy));
22279 if (IsMasked) {
22280 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22281 // maskedoff, op1, op2, mask, vl, policy
22282 IntrinsicTypes = {ResultType,
22283 Ops[1]->getType(),
22284 ElemTy,
22285 Ops[4]->getType()};
22286 } else {
22287 // passtru, op1, op2, vl
22288 IntrinsicTypes = {ResultType,
22289 Ops[1]->getType(),
22290 ElemTy,
22291 Ops[3]->getType()};
22292 }
22293 break;
22294 }
22295 break;
22296case RISCVVector::BI__builtin_rvv_vwaddu_vv_ta:
22297case RISCVVector::BI__builtin_rvv_vwaddu_vx_ta:
22298 ID = Intrinsic::riscv_vwaddu;
22299 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
22300 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22301 break;
22302case RISCVVector::BI__builtin_rvv_vwcvtu_x_x_v_ta:
22303 ID = Intrinsic::riscv_vwaddu;
22304 DefaultPolicy = 1;
22305IsMasked = false;
22306
22307 {
22308 if (IsMasked) {
22309 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22310 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
22311 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
22312 } else {
22313 if (DefaultPolicy == TAIL_AGNOSTIC)
22314 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
22315 }
22316 auto ElemTy = cast<llvm::VectorType>(ResultType)->getElementType();
22317 Ops.insert(Ops.begin() + 2, llvm::Constant::getNullValue(ElemTy));
22318 if (IsMasked) {
22319 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22320 // maskedoff, op1, op2, mask, vl, policy
22321 IntrinsicTypes = {ResultType,
22322 Ops[1]->getType(),
22323 ElemTy,
22324 Ops[4]->getType()};
22325 } else {
22326 // passtru, op1, op2, vl
22327 IntrinsicTypes = {ResultType,
22328 Ops[1]->getType(),
22329 ElemTy,
22330 Ops[3]->getType()};
22331 }
22332 break;
22333 }
22334 break;
22335case RISCVVector::BI__builtin_rvv_vwaddu_vv_tuma:
22336case RISCVVector::BI__builtin_rvv_vwaddu_vx_tuma:
22337 ID = Intrinsic::riscv_vwaddu_mask;
22338 DefaultPolicy = 2;
22339 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22340 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22341 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22342 break;
22343case RISCVVector::BI__builtin_rvv_vwcvtu_x_x_v_tuma:
22344 ID = Intrinsic::riscv_vwaddu_mask;
22345 DefaultPolicy = 2;
22346IsMasked = true;
22347
22348 {
22349 if (IsMasked) {
22350 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22351 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
22352 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
22353 } else {
22354 if (DefaultPolicy == TAIL_AGNOSTIC)
22355 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
22356 }
22357 auto ElemTy = cast<llvm::VectorType>(ResultType)->getElementType();
22358 Ops.insert(Ops.begin() + 2, llvm::Constant::getNullValue(ElemTy));
22359 if (IsMasked) {
22360 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22361 // maskedoff, op1, op2, mask, vl, policy
22362 IntrinsicTypes = {ResultType,
22363 Ops[1]->getType(),
22364 ElemTy,
22365 Ops[4]->getType()};
22366 } else {
22367 // passtru, op1, op2, vl
22368 IntrinsicTypes = {ResultType,
22369 Ops[1]->getType(),
22370 ElemTy,
22371 Ops[3]->getType()};
22372 }
22373 break;
22374 }
22375 break;
22376case RISCVVector::BI__builtin_rvv_vwaddu_vv_tama:
22377case RISCVVector::BI__builtin_rvv_vwaddu_vx_tama:
22378 ID = Intrinsic::riscv_vwaddu_mask;
22379 DefaultPolicy = 3;
22380 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22381 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22382 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
22383 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22384 break;
22385case RISCVVector::BI__builtin_rvv_vwcvtu_x_x_v_tama:
22386 ID = Intrinsic::riscv_vwaddu_mask;
22387 DefaultPolicy = 3;
22388IsMasked = true;
22389
22390 {
22391 if (IsMasked) {
22392 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22393 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
22394 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
22395 } else {
22396 if (DefaultPolicy == TAIL_AGNOSTIC)
22397 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
22398 }
22399 auto ElemTy = cast<llvm::VectorType>(ResultType)->getElementType();
22400 Ops.insert(Ops.begin() + 2, llvm::Constant::getNullValue(ElemTy));
22401 if (IsMasked) {
22402 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22403 // maskedoff, op1, op2, mask, vl, policy
22404 IntrinsicTypes = {ResultType,
22405 Ops[1]->getType(),
22406 ElemTy,
22407 Ops[4]->getType()};
22408 } else {
22409 // passtru, op1, op2, vl
22410 IntrinsicTypes = {ResultType,
22411 Ops[1]->getType(),
22412 ElemTy,
22413 Ops[3]->getType()};
22414 }
22415 break;
22416 }
22417 break;
22418case RISCVVector::BI__builtin_rvv_vwaddu_vv_tumu:
22419case RISCVVector::BI__builtin_rvv_vwaddu_vx_tumu:
22420 ID = Intrinsic::riscv_vwaddu_mask;
22421 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22422 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22423 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22424 break;
22425case RISCVVector::BI__builtin_rvv_vwcvtu_x_x_v_tumu:
22426 ID = Intrinsic::riscv_vwaddu_mask;
22427 DefaultPolicy = 0;
22428IsMasked = true;
22429
22430 {
22431 if (IsMasked) {
22432 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22433 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
22434 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
22435 } else {
22436 if (DefaultPolicy == TAIL_AGNOSTIC)
22437 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
22438 }
22439 auto ElemTy = cast<llvm::VectorType>(ResultType)->getElementType();
22440 Ops.insert(Ops.begin() + 2, llvm::Constant::getNullValue(ElemTy));
22441 if (IsMasked) {
22442 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22443 // maskedoff, op1, op2, mask, vl, policy
22444 IntrinsicTypes = {ResultType,
22445 Ops[1]->getType(),
22446 ElemTy,
22447 Ops[4]->getType()};
22448 } else {
22449 // passtru, op1, op2, vl
22450 IntrinsicTypes = {ResultType,
22451 Ops[1]->getType(),
22452 ElemTy,
22453 Ops[3]->getType()};
22454 }
22455 break;
22456 }
22457 break;
22458case RISCVVector::BI__builtin_rvv_vwaddu_vv_tamu:
22459case RISCVVector::BI__builtin_rvv_vwaddu_vx_tamu:
22460 ID = Intrinsic::riscv_vwaddu_mask;
22461 DefaultPolicy = 1;
22462 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22463 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22464 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22465 break;
22466case RISCVVector::BI__builtin_rvv_vwcvtu_x_x_v_tamu:
22467 ID = Intrinsic::riscv_vwaddu_mask;
22468 DefaultPolicy = 1;
22469IsMasked = true;
22470
22471 {
22472 if (IsMasked) {
22473 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22474 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
22475 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
22476 } else {
22477 if (DefaultPolicy == TAIL_AGNOSTIC)
22478 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
22479 }
22480 auto ElemTy = cast<llvm::VectorType>(ResultType)->getElementType();
22481 Ops.insert(Ops.begin() + 2, llvm::Constant::getNullValue(ElemTy));
22482 if (IsMasked) {
22483 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22484 // maskedoff, op1, op2, mask, vl, policy
22485 IntrinsicTypes = {ResultType,
22486 Ops[1]->getType(),
22487 ElemTy,
22488 Ops[4]->getType()};
22489 } else {
22490 // passtru, op1, op2, vl
22491 IntrinsicTypes = {ResultType,
22492 Ops[1]->getType(),
22493 ElemTy,
22494 Ops[3]->getType()};
22495 }
22496 break;
22497 }
22498 break;
22499case RISCVVector::BI__builtin_rvv_vwaddu_wx_tu:
22500case RISCVVector::BI__builtin_rvv_vwaddu_wv_tu:
22501 ID = Intrinsic::riscv_vwaddu_w;
22502 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
22503 break;
22504case RISCVVector::BI__builtin_rvv_vwaddu_wx_ta:
22505case RISCVVector::BI__builtin_rvv_vwaddu_wv_ta:
22506 ID = Intrinsic::riscv_vwaddu_w;
22507 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
22508 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
22509 break;
22510case RISCVVector::BI__builtin_rvv_vwaddu_wx_tuma:
22511case RISCVVector::BI__builtin_rvv_vwaddu_wv_tuma:
22512 ID = Intrinsic::riscv_vwaddu_w_mask;
22513 DefaultPolicy = 2;
22514 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22515 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22516 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
22517 break;
22518case RISCVVector::BI__builtin_rvv_vwaddu_wx_tama:
22519case RISCVVector::BI__builtin_rvv_vwaddu_wv_tama:
22520 ID = Intrinsic::riscv_vwaddu_w_mask;
22521 DefaultPolicy = 3;
22522 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22523 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22524 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
22525 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
22526 break;
22527case RISCVVector::BI__builtin_rvv_vwaddu_wx_tumu:
22528case RISCVVector::BI__builtin_rvv_vwaddu_wv_tumu:
22529 ID = Intrinsic::riscv_vwaddu_w_mask;
22530 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22531 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22532 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
22533 break;
22534case RISCVVector::BI__builtin_rvv_vwaddu_wx_tamu:
22535case RISCVVector::BI__builtin_rvv_vwaddu_wv_tamu:
22536 ID = Intrinsic::riscv_vwaddu_w_mask;
22537 DefaultPolicy = 1;
22538 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22539 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22540 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
22541 break;
22542case RISCVVector::BI__builtin_rvv_vwmacc_vv_tu:
22543case RISCVVector::BI__builtin_rvv_vwmacc_vx_tu:
22544 ID = Intrinsic::riscv_vwmacc;
22545 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22546 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22547 break;
22548case RISCVVector::BI__builtin_rvv_vwmacc_vv_ta:
22549case RISCVVector::BI__builtin_rvv_vwmacc_vx_ta:
22550 ID = Intrinsic::riscv_vwmacc;
22551 DefaultPolicy = 1;
22552 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22553 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22554 break;
22555case RISCVVector::BI__builtin_rvv_vwmacc_vv_tuma:
22556case RISCVVector::BI__builtin_rvv_vwmacc_vx_tuma:
22557 ID = Intrinsic::riscv_vwmacc_mask;
22558 DefaultPolicy = 2;
22559 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22560 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22561 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22562 break;
22563case RISCVVector::BI__builtin_rvv_vwmacc_vv_tama:
22564case RISCVVector::BI__builtin_rvv_vwmacc_vx_tama:
22565 ID = Intrinsic::riscv_vwmacc_mask;
22566 DefaultPolicy = 3;
22567 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22568 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22569 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22570 break;
22571case RISCVVector::BI__builtin_rvv_vwmacc_vv_tumu:
22572case RISCVVector::BI__builtin_rvv_vwmacc_vx_tumu:
22573 ID = Intrinsic::riscv_vwmacc_mask;
22574 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22575 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22576 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22577 break;
22578case RISCVVector::BI__builtin_rvv_vwmacc_vv_tamu:
22579case RISCVVector::BI__builtin_rvv_vwmacc_vx_tamu:
22580 ID = Intrinsic::riscv_vwmacc_mask;
22581 DefaultPolicy = 1;
22582 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22583 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22584 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22585 break;
22586case RISCVVector::BI__builtin_rvv_vwmaccsu_vv_tu:
22587case RISCVVector::BI__builtin_rvv_vwmaccsu_vx_tu:
22588 ID = Intrinsic::riscv_vwmaccsu;
22589 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22590 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22591 break;
22592case RISCVVector::BI__builtin_rvv_vwmaccsu_vv_ta:
22593case RISCVVector::BI__builtin_rvv_vwmaccsu_vx_ta:
22594 ID = Intrinsic::riscv_vwmaccsu;
22595 DefaultPolicy = 1;
22596 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22597 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22598 break;
22599case RISCVVector::BI__builtin_rvv_vwmaccsu_vv_tuma:
22600case RISCVVector::BI__builtin_rvv_vwmaccsu_vx_tuma:
22601 ID = Intrinsic::riscv_vwmaccsu_mask;
22602 DefaultPolicy = 2;
22603 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22604 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22605 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22606 break;
22607case RISCVVector::BI__builtin_rvv_vwmaccsu_vv_tama:
22608case RISCVVector::BI__builtin_rvv_vwmaccsu_vx_tama:
22609 ID = Intrinsic::riscv_vwmaccsu_mask;
22610 DefaultPolicy = 3;
22611 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22612 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22613 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22614 break;
22615case RISCVVector::BI__builtin_rvv_vwmaccsu_vv_tumu:
22616case RISCVVector::BI__builtin_rvv_vwmaccsu_vx_tumu:
22617 ID = Intrinsic::riscv_vwmaccsu_mask;
22618 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22619 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22620 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22621 break;
22622case RISCVVector::BI__builtin_rvv_vwmaccsu_vv_tamu:
22623case RISCVVector::BI__builtin_rvv_vwmaccsu_vx_tamu:
22624 ID = Intrinsic::riscv_vwmaccsu_mask;
22625 DefaultPolicy = 1;
22626 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22627 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22628 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22629 break;
22630case RISCVVector::BI__builtin_rvv_vwmaccu_vv_tu:
22631case RISCVVector::BI__builtin_rvv_vwmaccu_vx_tu:
22632 ID = Intrinsic::riscv_vwmaccu;
22633 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22634 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22635 break;
22636case RISCVVector::BI__builtin_rvv_vwmaccu_vv_ta:
22637case RISCVVector::BI__builtin_rvv_vwmaccu_vx_ta:
22638 ID = Intrinsic::riscv_vwmaccu;
22639 DefaultPolicy = 1;
22640 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22641 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22642 break;
22643case RISCVVector::BI__builtin_rvv_vwmaccu_vv_tuma:
22644case RISCVVector::BI__builtin_rvv_vwmaccu_vx_tuma:
22645 ID = Intrinsic::riscv_vwmaccu_mask;
22646 DefaultPolicy = 2;
22647 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22648 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22649 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22650 break;
22651case RISCVVector::BI__builtin_rvv_vwmaccu_vv_tama:
22652case RISCVVector::BI__builtin_rvv_vwmaccu_vx_tama:
22653 ID = Intrinsic::riscv_vwmaccu_mask;
22654 DefaultPolicy = 3;
22655 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22656 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22657 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22658 break;
22659case RISCVVector::BI__builtin_rvv_vwmaccu_vv_tumu:
22660case RISCVVector::BI__builtin_rvv_vwmaccu_vx_tumu:
22661 ID = Intrinsic::riscv_vwmaccu_mask;
22662 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22663 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22664 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22665 break;
22666case RISCVVector::BI__builtin_rvv_vwmaccu_vv_tamu:
22667case RISCVVector::BI__builtin_rvv_vwmaccu_vx_tamu:
22668 ID = Intrinsic::riscv_vwmaccu_mask;
22669 DefaultPolicy = 1;
22670 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22671 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22672 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22673 break;
22674case RISCVVector::BI__builtin_rvv_vwmaccus_vx_tu:
22675 ID = Intrinsic::riscv_vwmaccus;
22676 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22677 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22678 break;
22679case RISCVVector::BI__builtin_rvv_vwmaccus_vx_ta:
22680 ID = Intrinsic::riscv_vwmaccus;
22681 DefaultPolicy = 1;
22682 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22683 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22684 break;
22685case RISCVVector::BI__builtin_rvv_vwmaccus_vx_tuma:
22686 ID = Intrinsic::riscv_vwmaccus_mask;
22687 DefaultPolicy = 2;
22688 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22689 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22690 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22691 break;
22692case RISCVVector::BI__builtin_rvv_vwmaccus_vx_tama:
22693 ID = Intrinsic::riscv_vwmaccus_mask;
22694 DefaultPolicy = 3;
22695 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22696 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22697 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22698 break;
22699case RISCVVector::BI__builtin_rvv_vwmaccus_vx_tumu:
22700 ID = Intrinsic::riscv_vwmaccus_mask;
22701 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22702 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22703 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22704 break;
22705case RISCVVector::BI__builtin_rvv_vwmaccus_vx_tamu:
22706 ID = Intrinsic::riscv_vwmaccus_mask;
22707 DefaultPolicy = 1;
22708 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22709 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22710 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22711 break;
22712case RISCVVector::BI__builtin_rvv_vwmul_vv_tu:
22713case RISCVVector::BI__builtin_rvv_vwmul_vx_tu:
22714 ID = Intrinsic::riscv_vwmul;
22715 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22716 break;
22717case RISCVVector::BI__builtin_rvv_vwmul_vv_ta:
22718case RISCVVector::BI__builtin_rvv_vwmul_vx_ta:
22719 ID = Intrinsic::riscv_vwmul;
22720 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
22721 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22722 break;
22723case RISCVVector::BI__builtin_rvv_vwmul_vv_tuma:
22724case RISCVVector::BI__builtin_rvv_vwmul_vx_tuma:
22725 ID = Intrinsic::riscv_vwmul_mask;
22726 DefaultPolicy = 2;
22727 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22728 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22729 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22730 break;
22731case RISCVVector::BI__builtin_rvv_vwmul_vv_tama:
22732case RISCVVector::BI__builtin_rvv_vwmul_vx_tama:
22733 ID = Intrinsic::riscv_vwmul_mask;
22734 DefaultPolicy = 3;
22735 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22736 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22737 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
22738 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22739 break;
22740case RISCVVector::BI__builtin_rvv_vwmul_vv_tumu:
22741case RISCVVector::BI__builtin_rvv_vwmul_vx_tumu:
22742 ID = Intrinsic::riscv_vwmul_mask;
22743 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22744 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22745 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22746 break;
22747case RISCVVector::BI__builtin_rvv_vwmul_vv_tamu:
22748case RISCVVector::BI__builtin_rvv_vwmul_vx_tamu:
22749 ID = Intrinsic::riscv_vwmul_mask;
22750 DefaultPolicy = 1;
22751 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22752 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22753 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22754 break;
22755case RISCVVector::BI__builtin_rvv_vwmulsu_vv_tu:
22756case RISCVVector::BI__builtin_rvv_vwmulsu_vx_tu:
22757 ID = Intrinsic::riscv_vwmulsu;
22758 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22759 break;
22760case RISCVVector::BI__builtin_rvv_vwmulsu_vv_ta:
22761case RISCVVector::BI__builtin_rvv_vwmulsu_vx_ta:
22762 ID = Intrinsic::riscv_vwmulsu;
22763 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
22764 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22765 break;
22766case RISCVVector::BI__builtin_rvv_vwmulsu_vv_tuma:
22767case RISCVVector::BI__builtin_rvv_vwmulsu_vx_tuma:
22768 ID = Intrinsic::riscv_vwmulsu_mask;
22769 DefaultPolicy = 2;
22770 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22771 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22772 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22773 break;
22774case RISCVVector::BI__builtin_rvv_vwmulsu_vv_tama:
22775case RISCVVector::BI__builtin_rvv_vwmulsu_vx_tama:
22776 ID = Intrinsic::riscv_vwmulsu_mask;
22777 DefaultPolicy = 3;
22778 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22779 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22780 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
22781 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22782 break;
22783case RISCVVector::BI__builtin_rvv_vwmulsu_vv_tumu:
22784case RISCVVector::BI__builtin_rvv_vwmulsu_vx_tumu:
22785 ID = Intrinsic::riscv_vwmulsu_mask;
22786 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22787 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22788 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22789 break;
22790case RISCVVector::BI__builtin_rvv_vwmulsu_vv_tamu:
22791case RISCVVector::BI__builtin_rvv_vwmulsu_vx_tamu:
22792 ID = Intrinsic::riscv_vwmulsu_mask;
22793 DefaultPolicy = 1;
22794 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22795 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22796 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22797 break;
22798case RISCVVector::BI__builtin_rvv_vwmulu_vv_tu:
22799case RISCVVector::BI__builtin_rvv_vwmulu_vx_tu:
22800 ID = Intrinsic::riscv_vwmulu;
22801 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22802 break;
22803case RISCVVector::BI__builtin_rvv_vwmulu_vv_ta:
22804case RISCVVector::BI__builtin_rvv_vwmulu_vx_ta:
22805 ID = Intrinsic::riscv_vwmulu;
22806 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
22807 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22808 break;
22809case RISCVVector::BI__builtin_rvv_vwmulu_vv_tuma:
22810case RISCVVector::BI__builtin_rvv_vwmulu_vx_tuma:
22811 ID = Intrinsic::riscv_vwmulu_mask;
22812 DefaultPolicy = 2;
22813 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22814 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22815 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22816 break;
22817case RISCVVector::BI__builtin_rvv_vwmulu_vv_tama:
22818case RISCVVector::BI__builtin_rvv_vwmulu_vx_tama:
22819 ID = Intrinsic::riscv_vwmulu_mask;
22820 DefaultPolicy = 3;
22821 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22822 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22823 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
22824 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22825 break;
22826case RISCVVector::BI__builtin_rvv_vwmulu_vv_tumu:
22827case RISCVVector::BI__builtin_rvv_vwmulu_vx_tumu:
22828 ID = Intrinsic::riscv_vwmulu_mask;
22829 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22830 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22831 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22832 break;
22833case RISCVVector::BI__builtin_rvv_vwmulu_vv_tamu:
22834case RISCVVector::BI__builtin_rvv_vwmulu_vx_tamu:
22835 ID = Intrinsic::riscv_vwmulu_mask;
22836 DefaultPolicy = 1;
22837 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22838 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22839 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22840 break;
22841case RISCVVector::BI__builtin_rvv_vwredsum_vs_tu:
22842 ID = Intrinsic::riscv_vwredsum;
22843 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
22844 break;
22845case RISCVVector::BI__builtin_rvv_vwredsum_vs_ta:
22846 ID = Intrinsic::riscv_vwredsum;
22847 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
22848 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
22849 break;
22850case RISCVVector::BI__builtin_rvv_vwredsum_vs_tum:
22851 ID = Intrinsic::riscv_vwredsum_mask;
22852 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22853 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
22854 break;
22855case RISCVVector::BI__builtin_rvv_vwredsum_vs_tam:
22856 ID = Intrinsic::riscv_vwredsum_mask;
22857 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22858 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
22859 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
22860 break;
22861case RISCVVector::BI__builtin_rvv_vwredsum_vs_tumu:
22862 ID = Intrinsic::riscv_vwredsum_mask;
22863 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22864 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
22865 break;
22866case RISCVVector::BI__builtin_rvv_vwredsumu_vs_tu:
22867 ID = Intrinsic::riscv_vwredsumu;
22868 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
22869 break;
22870case RISCVVector::BI__builtin_rvv_vwredsumu_vs_ta:
22871 ID = Intrinsic::riscv_vwredsumu;
22872 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
22873 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
22874 break;
22875case RISCVVector::BI__builtin_rvv_vwredsumu_vs_tum:
22876 ID = Intrinsic::riscv_vwredsumu_mask;
22877 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22878 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
22879 break;
22880case RISCVVector::BI__builtin_rvv_vwredsumu_vs_tam:
22881 ID = Intrinsic::riscv_vwredsumu_mask;
22882 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22883 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
22884 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
22885 break;
22886case RISCVVector::BI__builtin_rvv_vwredsumu_vs_tumu:
22887 ID = Intrinsic::riscv_vwredsumu_mask;
22888 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22889 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
22890 break;
22891case RISCVVector::BI__builtin_rvv_vwsub_vv_tu:
22892case RISCVVector::BI__builtin_rvv_vwsub_vx_tu:
22893 ID = Intrinsic::riscv_vwsub;
22894 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22895 break;
22896case RISCVVector::BI__builtin_rvv_vwsub_vv_ta:
22897case RISCVVector::BI__builtin_rvv_vwsub_vx_ta:
22898 ID = Intrinsic::riscv_vwsub;
22899 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
22900 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22901 break;
22902case RISCVVector::BI__builtin_rvv_vwsub_vv_tuma:
22903case RISCVVector::BI__builtin_rvv_vwsub_vx_tuma:
22904 ID = Intrinsic::riscv_vwsub_mask;
22905 DefaultPolicy = 2;
22906 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22907 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22908 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22909 break;
22910case RISCVVector::BI__builtin_rvv_vwsub_vv_tama:
22911case RISCVVector::BI__builtin_rvv_vwsub_vx_tama:
22912 ID = Intrinsic::riscv_vwsub_mask;
22913 DefaultPolicy = 3;
22914 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22915 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22916 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
22917 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22918 break;
22919case RISCVVector::BI__builtin_rvv_vwsub_vv_tumu:
22920case RISCVVector::BI__builtin_rvv_vwsub_vx_tumu:
22921 ID = Intrinsic::riscv_vwsub_mask;
22922 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22923 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22924 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22925 break;
22926case RISCVVector::BI__builtin_rvv_vwsub_vv_tamu:
22927case RISCVVector::BI__builtin_rvv_vwsub_vx_tamu:
22928 ID = Intrinsic::riscv_vwsub_mask;
22929 DefaultPolicy = 1;
22930 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22931 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22932 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22933 break;
22934case RISCVVector::BI__builtin_rvv_vwsub_wv_tu:
22935case RISCVVector::BI__builtin_rvv_vwsub_wx_tu:
22936 ID = Intrinsic::riscv_vwsub_w;
22937 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
22938 break;
22939case RISCVVector::BI__builtin_rvv_vwsub_wv_ta:
22940case RISCVVector::BI__builtin_rvv_vwsub_wx_ta:
22941 ID = Intrinsic::riscv_vwsub_w;
22942 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
22943 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
22944 break;
22945case RISCVVector::BI__builtin_rvv_vwsub_wv_tuma:
22946case RISCVVector::BI__builtin_rvv_vwsub_wx_tuma:
22947 ID = Intrinsic::riscv_vwsub_w_mask;
22948 DefaultPolicy = 2;
22949 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22950 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22951 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
22952 break;
22953case RISCVVector::BI__builtin_rvv_vwsub_wv_tama:
22954case RISCVVector::BI__builtin_rvv_vwsub_wx_tama:
22955 ID = Intrinsic::riscv_vwsub_w_mask;
22956 DefaultPolicy = 3;
22957 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22958 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22959 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
22960 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
22961 break;
22962case RISCVVector::BI__builtin_rvv_vwsub_wv_tumu:
22963case RISCVVector::BI__builtin_rvv_vwsub_wx_tumu:
22964 ID = Intrinsic::riscv_vwsub_w_mask;
22965 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22966 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22967 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
22968 break;
22969case RISCVVector::BI__builtin_rvv_vwsub_wv_tamu:
22970case RISCVVector::BI__builtin_rvv_vwsub_wx_tamu:
22971 ID = Intrinsic::riscv_vwsub_w_mask;
22972 DefaultPolicy = 1;
22973 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22974 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22975 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
22976 break;
22977case RISCVVector::BI__builtin_rvv_vwsubu_vv_tu:
22978case RISCVVector::BI__builtin_rvv_vwsubu_vx_tu:
22979 ID = Intrinsic::riscv_vwsubu;
22980 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22981 break;
22982case RISCVVector::BI__builtin_rvv_vwsubu_vv_ta:
22983case RISCVVector::BI__builtin_rvv_vwsubu_vx_ta:
22984 ID = Intrinsic::riscv_vwsubu;
22985 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
22986 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22987 break;
22988case RISCVVector::BI__builtin_rvv_vwsubu_vv_tuma:
22989case RISCVVector::BI__builtin_rvv_vwsubu_vx_tuma:
22990 ID = Intrinsic::riscv_vwsubu_mask;
22991 DefaultPolicy = 2;
22992 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
22993 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
22994 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
22995 break;
22996case RISCVVector::BI__builtin_rvv_vwsubu_vv_tama:
22997case RISCVVector::BI__builtin_rvv_vwsubu_vx_tama:
22998 ID = Intrinsic::riscv_vwsubu_mask;
22999 DefaultPolicy = 3;
23000 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
23001 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
23002 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
23003 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
23004 break;
23005case RISCVVector::BI__builtin_rvv_vwsubu_vv_tumu:
23006case RISCVVector::BI__builtin_rvv_vwsubu_vx_tumu:
23007 ID = Intrinsic::riscv_vwsubu_mask;
23008 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
23009 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
23010 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
23011 break;
23012case RISCVVector::BI__builtin_rvv_vwsubu_vv_tamu:
23013case RISCVVector::BI__builtin_rvv_vwsubu_vx_tamu:
23014 ID = Intrinsic::riscv_vwsubu_mask;
23015 DefaultPolicy = 1;
23016 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
23017 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
23018 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops[2]->getType(), Ops.back()->getType()};
23019 break;
23020case RISCVVector::BI__builtin_rvv_vwsubu_wv_tu:
23021case RISCVVector::BI__builtin_rvv_vwsubu_wx_tu:
23022 ID = Intrinsic::riscv_vwsubu_w;
23023 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
23024 break;
23025case RISCVVector::BI__builtin_rvv_vwsubu_wv_ta:
23026case RISCVVector::BI__builtin_rvv_vwsubu_wx_ta:
23027 ID = Intrinsic::riscv_vwsubu_w;
23028 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
23029 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
23030 break;
23031case RISCVVector::BI__builtin_rvv_vwsubu_wv_tuma:
23032case RISCVVector::BI__builtin_rvv_vwsubu_wx_tuma:
23033 ID = Intrinsic::riscv_vwsubu_w_mask;
23034 DefaultPolicy = 2;
23035 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
23036 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
23037 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
23038 break;
23039case RISCVVector::BI__builtin_rvv_vwsubu_wv_tama:
23040case RISCVVector::BI__builtin_rvv_vwsubu_wx_tama:
23041 ID = Intrinsic::riscv_vwsubu_w_mask;
23042 DefaultPolicy = 3;
23043 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
23044 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
23045 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
23046 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
23047 break;
23048case RISCVVector::BI__builtin_rvv_vwsubu_wv_tumu:
23049case RISCVVector::BI__builtin_rvv_vwsubu_wx_tumu:
23050 ID = Intrinsic::riscv_vwsubu_w_mask;
23051 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
23052 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
23053 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
23054 break;
23055case RISCVVector::BI__builtin_rvv_vwsubu_wv_tamu:
23056case RISCVVector::BI__builtin_rvv_vwsubu_wx_tamu:
23057 ID = Intrinsic::riscv_vwsubu_w_mask;
23058 DefaultPolicy = 1;
23059 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
23060 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
23061 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
23062 break;
23063case RISCVVector::BI__builtin_rvv_vxor_vv_tu:
23064case RISCVVector::BI__builtin_rvv_vxor_vx_tu:
23065 ID = Intrinsic::riscv_vxor;
23066 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
23067 break;
23068case RISCVVector::BI__builtin_rvv_vnot_v_tu:
23069 ID = Intrinsic::riscv_vxor;
23070 DefaultPolicy = 0;
23071IsMasked = false;
23072
23073 {
23074 if (IsMasked) {
23075 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
23076 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
23077 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
23078 } else {
23079 if (DefaultPolicy == TAIL_AGNOSTIC)
23080 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
23081 }
23082 auto ElemTy = cast<llvm::VectorType>(ResultType)->getElementType();
23083 Ops.insert(Ops.begin() + 2,
23084 llvm::Constant::getAllOnesValue(ElemTy));
23085 if (IsMasked) {
23086 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
23087 // maskedoff, op1, po2, mask, vl, policy
23088 IntrinsicTypes = {ResultType,
23089 ElemTy,
23090 Ops[4]->getType()};
23091 } else {
23092 // passthru, op1, op2, vl
23093 IntrinsicTypes = {ResultType,
23094 ElemTy,
23095 Ops[3]->getType()};
23096 }
23097 break;
23098 }
23099 break;
23100case RISCVVector::BI__builtin_rvv_vxor_vv_ta:
23101case RISCVVector::BI__builtin_rvv_vxor_vx_ta:
23102 ID = Intrinsic::riscv_vxor;
23103 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
23104 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
23105 break;
23106case RISCVVector::BI__builtin_rvv_vnot_v_ta:
23107 ID = Intrinsic::riscv_vxor;
23108 DefaultPolicy = 1;
23109IsMasked = false;
23110
23111 {
23112 if (IsMasked) {
23113 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
23114 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
23115 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
23116 } else {
23117 if (DefaultPolicy == TAIL_AGNOSTIC)
23118 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
23119 }
23120 auto ElemTy = cast<llvm::VectorType>(ResultType)->getElementType();
23121 Ops.insert(Ops.begin() + 2,
23122 llvm::Constant::getAllOnesValue(ElemTy));
23123 if (IsMasked) {
23124 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
23125 // maskedoff, op1, po2, mask, vl, policy
23126 IntrinsicTypes = {ResultType,
23127 ElemTy,
23128 Ops[4]->getType()};
23129 } else {
23130 // passthru, op1, op2, vl
23131 IntrinsicTypes = {ResultType,
23132 ElemTy,
23133 Ops[3]->getType()};
23134 }
23135 break;
23136 }
23137 break;
23138case RISCVVector::BI__builtin_rvv_vxor_vv_tuma:
23139case RISCVVector::BI__builtin_rvv_vxor_vx_tuma:
23140 ID = Intrinsic::riscv_vxor_mask;
23141 DefaultPolicy = 2;
23142 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
23143 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
23144 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
23145 break;
23146case RISCVVector::BI__builtin_rvv_vnot_v_tuma:
23147 ID = Intrinsic::riscv_vxor_mask;
23148 DefaultPolicy = 2;
23149IsMasked = true;
23150
23151 {
23152 if (IsMasked) {
23153 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
23154 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
23155 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
23156 } else {
23157 if (DefaultPolicy == TAIL_AGNOSTIC)
23158 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
23159 }
23160 auto ElemTy = cast<llvm::VectorType>(ResultType)->getElementType();
23161 Ops.insert(Ops.begin() + 2,
23162 llvm::Constant::getAllOnesValue(ElemTy));
23163 if (IsMasked) {
23164 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
23165 // maskedoff, op1, po2, mask, vl, policy
23166 IntrinsicTypes = {ResultType,
23167 ElemTy,
23168 Ops[4]->getType()};
23169 } else {
23170 // passthru, op1, op2, vl
23171 IntrinsicTypes = {ResultType,
23172 ElemTy,
23173 Ops[3]->getType()};
23174 }
23175 break;
23176 }
23177 break;
23178case RISCVVector::BI__builtin_rvv_vxor_vv_tama:
23179case RISCVVector::BI__builtin_rvv_vxor_vx_tama:
23180 ID = Intrinsic::riscv_vxor_mask;
23181 DefaultPolicy = 3;
23182 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
23183 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
23184 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
23185 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
23186 break;
23187case RISCVVector::BI__builtin_rvv_vnot_v_tama:
23188 ID = Intrinsic::riscv_vxor_mask;
23189 DefaultPolicy = 3;
23190IsMasked = true;
23191
23192 {
23193 if (IsMasked) {
23194 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
23195 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
23196 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
23197 } else {
23198 if (DefaultPolicy == TAIL_AGNOSTIC)
23199 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
23200 }
23201 auto ElemTy = cast<llvm::VectorType>(ResultType)->getElementType();
23202 Ops.insert(Ops.begin() + 2,
23203 llvm::Constant::getAllOnesValue(ElemTy));
23204 if (IsMasked) {
23205 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
23206 // maskedoff, op1, po2, mask, vl, policy
23207 IntrinsicTypes = {ResultType,
23208 ElemTy,
23209 Ops[4]->getType()};
23210 } else {
23211 // passthru, op1, op2, vl
23212 IntrinsicTypes = {ResultType,
23213 ElemTy,
23214 Ops[3]->getType()};
23215 }
23216 break;
23217 }
23218 break;
23219case RISCVVector::BI__builtin_rvv_vxor_vv_tumu:
23220case RISCVVector::BI__builtin_rvv_vxor_vx_tumu:
23221 ID = Intrinsic::riscv_vxor_mask;
23222 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
23223 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
23224 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
23225 break;
23226case RISCVVector::BI__builtin_rvv_vnot_v_tumu:
23227 ID = Intrinsic::riscv_vxor_mask;
23228 DefaultPolicy = 0;
23229IsMasked = true;
23230
23231 {
23232 if (IsMasked) {
23233 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
23234 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
23235 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
23236 } else {
23237 if (DefaultPolicy == TAIL_AGNOSTIC)
23238 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
23239 }
23240 auto ElemTy = cast<llvm::VectorType>(ResultType)->getElementType();
23241 Ops.insert(Ops.begin() + 2,
23242 llvm::Constant::getAllOnesValue(ElemTy));
23243 if (IsMasked) {
23244 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
23245 // maskedoff, op1, po2, mask, vl, policy
23246 IntrinsicTypes = {ResultType,
23247 ElemTy,
23248 Ops[4]->getType()};
23249 } else {
23250 // passthru, op1, op2, vl
23251 IntrinsicTypes = {ResultType,
23252 ElemTy,
23253 Ops[3]->getType()};
23254 }
23255 break;
23256 }
23257 break;
23258case RISCVVector::BI__builtin_rvv_vxor_vv_tamu:
23259case RISCVVector::BI__builtin_rvv_vxor_vx_tamu:
23260 ID = Intrinsic::riscv_vxor_mask;
23261 DefaultPolicy = 1;
23262 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
23263 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
23264 IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
23265 break;
23266case RISCVVector::BI__builtin_rvv_vnot_v_tamu:
23267 ID = Intrinsic::riscv_vxor_mask;
23268 DefaultPolicy = 1;
23269IsMasked = true;
23270
23271 {
23272 if (IsMasked) {
23273 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
23274 if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
23275 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
23276 } else {
23277 if (DefaultPolicy == TAIL_AGNOSTIC)
23278 Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
23279 }
23280 auto ElemTy = cast<llvm::VectorType>(ResultType)->getElementType();
23281 Ops.insert(Ops.begin() + 2,
23282 llvm::Constant::getAllOnesValue(ElemTy));
23283 if (IsMasked) {
23284 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
23285 // maskedoff, op1, po2, mask, vl, policy
23286 IntrinsicTypes = {ResultType,
23287 ElemTy,
23288 Ops[4]->getType()};
23289 } else {
23290 // passthru, op1, op2, vl
23291 IntrinsicTypes = {ResultType,
23292 ElemTy,
23293 Ops[3]->getType()};
23294 }
23295 break;
23296 }
23297 break;
23298case RISCVVector::BI__builtin_rvv_vzext_vf2_tu:
23299case RISCVVector::BI__builtin_rvv_vzext_vf4_tu:
23300case RISCVVector::BI__builtin_rvv_vzext_vf8_tu:
23301 ID = Intrinsic::riscv_vzext;
23302 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
23303 break;
23304case RISCVVector::BI__builtin_rvv_vzext_vf2_ta:
23305case RISCVVector::BI__builtin_rvv_vzext_vf4_ta:
23306case RISCVVector::BI__builtin_rvv_vzext_vf8_ta:
23307 ID = Intrinsic::riscv_vzext;
23308 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
23309 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
23310 break;
23311case RISCVVector::BI__builtin_rvv_vzext_vf2_tuma:
23312case RISCVVector::BI__builtin_rvv_vzext_vf4_tuma:
23313case RISCVVector::BI__builtin_rvv_vzext_vf8_tuma:
23314 ID = Intrinsic::riscv_vzext_mask;
23315 DefaultPolicy = 2;
23316 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
23317 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
23318 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
23319 break;
23320case RISCVVector::BI__builtin_rvv_vzext_vf2_tama:
23321case RISCVVector::BI__builtin_rvv_vzext_vf4_tama:
23322case RISCVVector::BI__builtin_rvv_vzext_vf8_tama:
23323 ID = Intrinsic::riscv_vzext_mask;
23324 DefaultPolicy = 3;
23325 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
23326 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
23327 Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));
23328 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
23329 break;
23330case RISCVVector::BI__builtin_rvv_vzext_vf2_tumu:
23331case RISCVVector::BI__builtin_rvv_vzext_vf4_tumu:
23332case RISCVVector::BI__builtin_rvv_vzext_vf8_tumu:
23333 ID = Intrinsic::riscv_vzext_mask;
23334 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
23335 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
23336 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
23337 break;
23338case RISCVVector::BI__builtin_rvv_vzext_vf2_tamu:
23339case RISCVVector::BI__builtin_rvv_vzext_vf4_tamu:
23340case RISCVVector::BI__builtin_rvv_vzext_vf8_tamu:
23341 ID = Intrinsic::riscv_vzext_mask;
23342 DefaultPolicy = 1;
23343 std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
23344 Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
23345 IntrinsicTypes = {ResultType, Ops[1]->getType(), Ops.back()->getType()};
23346 break;
23347