clang 23.0.0git
RISCVVIntrinsicUtils.cpp
Go to the documentation of this file.
1//===- RISCVVIntrinsicUtils.cpp - RISC-V Vector Intrinsic Utils -*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "clang/Support/RISCVVIntrinsicUtils.h"
10#include "llvm/ADT/ArrayRef.h"
11#include "llvm/ADT/StringExtras.h"
12#include "llvm/ADT/Twine.h"
13#include "llvm/Support/ErrorHandling.h"
14#include "llvm/Support/raw_ostream.h"
15#include <optional>
16
17using namespace llvm;
18
19namespace clang {
20namespace RISCV {
21
22const PrototypeDescriptor PrototypeDescriptor::Mask = PrototypeDescriptor(
23 BaseTypeModifier::Vector, VectorTypeModifier::MaskVector);
24const PrototypeDescriptor PrototypeDescriptor::VL =
25 PrototypeDescriptor(BaseTypeModifier::SizeT);
26const PrototypeDescriptor PrototypeDescriptor::Vector =
27 PrototypeDescriptor(BaseTypeModifier::Vector);
28
29//===----------------------------------------------------------------------===//
30// Type implementation
31//===----------------------------------------------------------------------===//
32
33LMULType::LMULType(int NewLog2LMUL) {
34 // Check Log2LMUL is -3, -2, -1, 0, 1, 2, 3
35 assert(NewLog2LMUL <= 3 && NewLog2LMUL >= -3 && "Bad LMUL number!");
36 Log2LMUL = NewLog2LMUL;
37}
38
39std::string LMULType::str() const {
40 if (Log2LMUL < 0)
41 return "mf" + utostr(1ULL << (-Log2LMUL));
42 return "m" + utostr(1ULL << Log2LMUL);
43}
44
45VScaleVal LMULType::getScale(unsigned ElementBitwidth) const {
46 int Log2ScaleResult = 0;
47 switch (ElementBitwidth) {
48 default:
49 break;
50 case 8:
51 Log2ScaleResult = Log2LMUL + 3;
52 break;
53 case 16:
54 Log2ScaleResult = Log2LMUL + 2;
55 break;
56 case 32:
57 Log2ScaleResult = Log2LMUL + 1;
58 break;
59 case 64:
60 Log2ScaleResult = Log2LMUL;
61 break;
62 }
63 // Illegal vscale result would be less than 1
64 if (Log2ScaleResult < 0)
65 return std::nullopt;
66 return 1 << Log2ScaleResult;
67}
68
69void LMULType::MulLog2LMUL(int log2LMUL) { Log2LMUL += log2LMUL; }
70
71RVVType::RVVType(BasicType BT, int Log2LMUL,
72 const PrototypeDescriptor &prototype)
73 : BT(BT), LMUL(LMULType(Log2LMUL)) {
74 applyBasicType();
75 applyModifier(prototype);
76 Valid = verifyType();
77 if (Valid) {
78 initBuiltinStr();
79 initTypeStr();
80 if (isVector()) {
81 initClangBuiltinStr();
82 }
83 }
84}
85
86// clang-format off
87// boolean type are encoded the ratio of n (SEW/LMUL)
88// SEW/LMUL | 1 | 2 | 4 | 8 | 16 | 32 | 64
89// c type | vbool64_t | vbool32_t | vbool16_t | vbool8_t | vbool4_t | vbool2_t | vbool1_t
90// IR type | nxv1i1 | nxv2i1 | nxv4i1 | nxv8i1 | nxv16i1 | nxv32i1 | nxv64i1
91
92// type\lmul | 1/8 | 1/4 | 1/2 | 1 | 2 | 4 | 8
93// -------- |------ | -------- | ------- | ------- | -------- | -------- | --------
94// i64 | N/A | N/A | N/A | nxv1i64 | nxv2i64 | nxv4i64 | nxv8i64
95// i32 | N/A | N/A | nxv1i32 | nxv2i32 | nxv4i32 | nxv8i32 | nxv16i32
96// i16 | N/A | nxv1i16 | nxv2i16 | nxv4i16 | nxv8i16 | nxv16i16 | nxv32i16
97// i8 | nxv1i8 | nxv2i8 | nxv4i8 | nxv8i8 | nxv16i8 | nxv32i8 | nxv64i8
98// double | N/A | N/A | N/A | nxv1f64 | nxv2f64 | nxv4f64 | nxv8f64
99// float | N/A | N/A | nxv1f32 | nxv2f32 | nxv4f32 | nxv8f32 | nxv16f32
100// half | N/A | nxv1f16 | nxv2f16 | nxv4f16 | nxv8f16 | nxv16f16 | nxv32f16
101// bfloat16 | N/A | nxv1bf16 | nxv2bf16| nxv4bf16| nxv8bf16 | nxv16bf16| nxv32bf16
102// clang-format on
103
104bool RVVType::verifyType() const {
105 if (ScalarType == Invalid)
106 return false;
107 if (isScalar())
108 return true;
109 if (!Scale)
110 return false;
111 if (isFloat() && ElementBitwidth == 8)
112 return false;
113 if (isBFloat() && ElementBitwidth != 16)
114 return false;
115 if (IsTuple && (NF == 1 || NF > 8))
116 return false;
117 if (IsTuple && (1 << std::max(0, LMUL.Log2LMUL)) * NF > 8)
118 return false;
119 unsigned V = *Scale;
120 switch (ElementBitwidth) {
121 case 1:
122 case 8:
123 // Check Scale is 1,2,4,8,16,32,64
124 return (V <= 64 && isPowerOf2_32(V));
125 case 16:
126 // Check Scale is 1,2,4,8,16,32
127 return (V <= 32 && isPowerOf2_32(V));
128 case 32:
129 // Check Scale is 1,2,4,8,16
130 return (V <= 16 && isPowerOf2_32(V));
131 case 64:
132 // Check Scale is 1,2,4,8
133 return (V <= 8 && isPowerOf2_32(V));
134 }
135 return false;
136}
137
138void RVVType::initBuiltinStr() {
139 assert(isValid() && "RVVType is invalid");
140 switch (ScalarType) {
141 case ScalarTypeKind::Void:
142 BuiltinStr = "v";
143 return;
144 case ScalarTypeKind::Size_t:
145 BuiltinStr = "z";
146 if (IsImmediate)
147 BuiltinStr = "I" + BuiltinStr;
148 if (IsPointer)
149 BuiltinStr += "*";
150 return;
151 case ScalarTypeKind::Ptrdiff_t:
152 BuiltinStr = "Y";
153 return;
154 case ScalarTypeKind::UnsignedLong:
155 BuiltinStr = "ULi";
156 return;
157 case ScalarTypeKind::SignedLong:
158 BuiltinStr = "Li";
159 return;
160 case ScalarTypeKind::Boolean:
161 assert(ElementBitwidth == 1);
162 BuiltinStr += "b";
163 break;
164 case ScalarTypeKind::SignedInteger:
165 case ScalarTypeKind::UnsignedInteger:
166 switch (ElementBitwidth) {
167 case 8:
168 BuiltinStr += "c";
169 break;
170 case 16:
171 BuiltinStr += "s";
172 break;
173 case 32:
174 BuiltinStr += "i";
175 break;
176 case 64:
177 BuiltinStr += "Wi";
178 break;
179 default:
180 llvm_unreachable("Unhandled ElementBitwidth!");
181 }
182 if (isSignedInteger())
183 BuiltinStr = "S" + BuiltinStr;
184 else
185 BuiltinStr = "U" + BuiltinStr;
186 break;
187 case ScalarTypeKind::Float:
188 switch (ElementBitwidth) {
189 case 16:
190 BuiltinStr += "x";
191 break;
192 case 32:
193 BuiltinStr += "f";
194 break;
195 case 64:
196 BuiltinStr += "d";
197 break;
198 default:
199 llvm_unreachable("Unhandled ElementBitwidth!");
200 }
201 break;
202 case ScalarTypeKind::BFloat:
203 BuiltinStr += "y";
204 break;
205 case ScalarTypeKind::FloatE4M3:
206 BuiltinStr += "a";
207 break;
208 case ScalarTypeKind::FloatE5M2:
209 BuiltinStr += "b";
210 break;
211 default:
212 llvm_unreachable("ScalarType is invalid!");
213 }
214 if (IsImmediate)
215 BuiltinStr = "I" + BuiltinStr;
216 if (isScalar()) {
217 if (IsConstant)
218 BuiltinStr += "C";
219 if (IsPointer)
220 BuiltinStr += "*";
221 return;
222 }
223 BuiltinStr = "q" + utostr(*Scale) + BuiltinStr;
224 // Pointer to vector types. Defined for segment load intrinsics.
225 // segment load intrinsics have pointer type arguments to store the loaded
226 // vector values.
227 if (IsPointer)
228 BuiltinStr += "*";
229
230 if (IsTuple)
231 BuiltinStr = "T" + utostr(NF) + BuiltinStr;
232}
233
234void RVVType::initClangBuiltinStr() {
235 assert(isValid() && "RVVType is invalid");
236 assert(isVector() && "Handle Vector type only");
237
238 ClangBuiltinStr = "__rvv_";
239 switch (ScalarType) {
240 case ScalarTypeKind::Boolean:
241 ClangBuiltinStr += "bool" + utostr(64 / *Scale) + "_t";
242 return;
243 case ScalarTypeKind::Float:
244 ClangBuiltinStr += "float";
245 break;
246 case ScalarTypeKind::BFloat:
247 ClangBuiltinStr += "bfloat";
248 break;
249 case ScalarTypeKind::SignedInteger:
250 ClangBuiltinStr += "int";
251 break;
252 case ScalarTypeKind::UnsignedInteger:
253 ClangBuiltinStr += "uint";
254 break;
255 case ScalarTypeKind::FloatE4M3:
256 ClangBuiltinStr += "float8e4m3" + LMUL.str() + "_t";
257 return;
258 case ScalarTypeKind::FloatE5M2:
259 ClangBuiltinStr += "float8e5m2" + LMUL.str() + "_t";
260 return;
261 default:
262 llvm_unreachable("ScalarTypeKind is invalid");
263 }
264 ClangBuiltinStr += utostr(ElementBitwidth) + LMUL.str() +
265 (IsTuple ? "x" + utostr(NF) : "") + "_t";
266}
267
268void RVVType::initTypeStr() {
269 assert(isValid() && "RVVType is invalid");
270
271 if (IsConstant)
272 Str += "const ";
273
274 auto getTypeString = [&](StringRef TypeStr) {
275 if (isScalar())
276 return Twine(TypeStr + Twine(ElementBitwidth) + "_t").str();
277 return Twine("v" + TypeStr + Twine(ElementBitwidth) + LMUL.str() +
278 (IsTuple ? "x" + utostr(NF) : "") + "_t")
279 .str();
280 };
281
282 switch (ScalarType) {
283 case ScalarTypeKind::Void:
284 Str = "void";
285 return;
286 case ScalarTypeKind::Size_t:
287 Str = "size_t";
288 if (IsPointer)
289 Str += " *";
290 return;
291 case ScalarTypeKind::Ptrdiff_t:
292 Str = "ptrdiff_t";
293 return;
294 case ScalarTypeKind::UnsignedLong:
295 Str = "unsigned long";
296 return;
297 case ScalarTypeKind::SignedLong:
298 Str = "long";
299 return;
300 case ScalarTypeKind::Boolean:
301 if (isScalar())
302 Str += "bool";
303 else
304 // Vector bool is special case, the formulate is
305 // `vbool<N>_t = MVT::nxv<64/N>i1` ex. vbool16_t = MVT::4i1
306 Str += "vbool" + utostr(64 / *Scale) + "_t";
307 break;
308 case ScalarTypeKind::Float:
309 if (isScalar()) {
310 if (ElementBitwidth == 64)
311 Str += "double";
312 else if (ElementBitwidth == 32)
313 Str += "float";
314 else if (ElementBitwidth == 16)
315 Str += "_Float16";
316 else
317 llvm_unreachable("Unhandled floating type.");
318 } else
319 Str += getTypeString("float");
320 break;
321 case ScalarTypeKind::BFloat:
322 if (isScalar()) {
323 if (ElementBitwidth == 16)
324 Str += "__bf16";
325 else
326 llvm_unreachable("Unhandled floating type.");
327 } else
328 Str += getTypeString("bfloat");
329 break;
330 case ScalarTypeKind::SignedInteger:
331 Str += getTypeString("int");
332 break;
333 case ScalarTypeKind::UnsignedInteger:
334 Str += getTypeString("uint");
335 break;
336 case ScalarTypeKind::FloatE4M3:
337 Str += "vfloat8e4m3" + LMUL.str() + "_t";
338 break;
339 case ScalarTypeKind::FloatE5M2:
340 Str += "vfloat8e5m2" + LMUL.str() + "_t";
341 break;
342 default:
343 llvm_unreachable("ScalarType is invalid!");
344 }
345 if (IsPointer)
346 Str += " *";
347}
348
349void RVVType::initShortStr() {
350 switch (ScalarType) {
351 case ScalarTypeKind::Boolean:
352 assert(isVector());
353 ShortStr = "b" + utostr(64 / *Scale);
354 return;
355 case ScalarTypeKind::Float:
356 ShortStr = "f" + utostr(ElementBitwidth);
357 break;
358 case ScalarTypeKind::BFloat:
359 ShortStr = "bf" + utostr(ElementBitwidth);
360 break;
361 case ScalarTypeKind::SignedInteger:
362 ShortStr = "i" + utostr(ElementBitwidth);
363 break;
364 case ScalarTypeKind::UnsignedInteger:
365 ShortStr = "u" + utostr(ElementBitwidth);
366 break;
367 case ScalarTypeKind::FloatE4M3:
368 ShortStr = "f8e4m3";
369 break;
370 case ScalarTypeKind::FloatE5M2:
371 ShortStr = "f8e5m2";
372 break;
373 default:
374 llvm_unreachable("Unhandled case!");
375 }
376 if (isVector())
377 ShortStr += LMUL.str();
378 if (isTuple())
379 ShortStr += "x" + utostr(NF);
380}
381
382static VectorTypeModifier getTupleVTM(unsigned NF) {
383 assert(2 <= NF && NF <= 8 && "2 <= NF <= 8");
384 return static_cast<VectorTypeModifier>(
385 static_cast<uint8_t>(VectorTypeModifier::Tuple2) + (NF - 2));
386}
387
388void RVVType::applyBasicType() {
389 switch (BT) {
390 case BasicType::Int8:
391 ElementBitwidth = 8;
392 ScalarType = ScalarTypeKind::SignedInteger;
393 break;
394 case BasicType::Int16:
395 ElementBitwidth = 16;
396 ScalarType = ScalarTypeKind::SignedInteger;
397 break;
398 case BasicType::Int32:
399 ElementBitwidth = 32;
400 ScalarType = ScalarTypeKind::SignedInteger;
401 break;
402 case BasicType::Int64:
403 ElementBitwidth = 64;
404 ScalarType = ScalarTypeKind::SignedInteger;
405 break;
406 case BasicType::Float16:
407 ElementBitwidth = 16;
408 ScalarType = ScalarTypeKind::Float;
409 break;
410 case BasicType::Float32:
411 ElementBitwidth = 32;
412 ScalarType = ScalarTypeKind::Float;
413 break;
414 case BasicType::Float64:
415 ElementBitwidth = 64;
416 ScalarType = ScalarTypeKind::Float;
417 break;
418 case BasicType::BFloat16:
419 ElementBitwidth = 16;
420 ScalarType = ScalarTypeKind::BFloat;
421 break;
422 case BasicType::F8E4M3:
423 ElementBitwidth = 8;
424 ScalarType = ScalarTypeKind::FloatE4M3;
425 break;
426 case BasicType::F8E5M2:
427 ElementBitwidth = 8;
428 ScalarType = ScalarTypeKind::FloatE5M2;
429 break;
430 default:
431 llvm_unreachable("Unhandled type code!");
432 }
433 assert(ElementBitwidth != 0 && "Bad element bitwidth!");
434}
435
436std::optional<PrototypeDescriptor>
437PrototypeDescriptor::parsePrototypeDescriptor(
438 llvm::StringRef PrototypeDescriptorStr) {
439 PrototypeDescriptor PD;
440 BaseTypeModifier PT = BaseTypeModifier::Invalid;
441 VectorTypeModifier VTM = VectorTypeModifier::NoModifier;
442
443 if (PrototypeDescriptorStr.empty())
444 return PD;
445
446 // Handle base type modifier
447 auto PType = PrototypeDescriptorStr.back();
448 switch (PType) {
449 case 'e':
450 PT = BaseTypeModifier::Scalar;
451 break;
452 case 'v':
453 PT = BaseTypeModifier::Vector;
454 break;
455 case 'w':
456 PT = BaseTypeModifier::Vector;
457 VTM = VectorTypeModifier::Widening2XVector;
458 break;
459 case 'd':
460 PT = BaseTypeModifier::Vector;
461 VTM = VectorTypeModifier::DoubleLMULVector;
462 break;
463 case 'q':
464 PT = BaseTypeModifier::Vector;
465 VTM = VectorTypeModifier::Widening4XVector;
466 break;
467 case 'o':
468 PT = BaseTypeModifier::Vector;
469 VTM = VectorTypeModifier::Widening8XVector;
470 break;
471 case 'm':
472 PT = BaseTypeModifier::Vector;
473 VTM = VectorTypeModifier::MaskVector;
474 break;
475 case '0':
476 PT = BaseTypeModifier::Void;
477 break;
478 case 'z':
479 PT = BaseTypeModifier::SizeT;
480 break;
481 case 't':
482 PT = BaseTypeModifier::Ptrdiff;
483 break;
484 case 'u':
485 PT = BaseTypeModifier::UnsignedLong;
486 break;
487 case 'l':
488 PT = BaseTypeModifier::SignedLong;
489 break;
490 case 'f':
491 PT = BaseTypeModifier::Float32;
492 break;
493 default:
494 llvm_unreachable("Illegal primitive type transformers!");
495 }
496 PD.PT = PT;
497 PrototypeDescriptorStr = PrototypeDescriptorStr.drop_back();
498
499 // Compute the vector type transformers, it can only appear one time.
500 if (PrototypeDescriptorStr.starts_with("(")) {
501 assert(VTM == VectorTypeModifier::NoModifier &&
502 "VectorTypeModifier should only have one modifier");
503 size_t Idx = PrototypeDescriptorStr.find(')');
504 assert(Idx != StringRef::npos);
505 StringRef ComplexType = PrototypeDescriptorStr.slice(1, Idx);
506 PrototypeDescriptorStr = PrototypeDescriptorStr.drop_front(Idx + 1);
507 assert(!PrototypeDescriptorStr.contains('(') &&
508 "Only allow one vector type modifier");
509
510 auto ComplexTT = ComplexType.split(":");
511 if (ComplexTT.first == "Log2EEW") {
512 uint32_t Log2EEW;
513 if (ComplexTT.second.getAsInteger(10, Log2EEW)) {
514 llvm_unreachable("Invalid Log2EEW value!");
515 return std::nullopt;
516 }
517 switch (Log2EEW) {
518 case 3:
519 VTM = VectorTypeModifier::Log2EEW3;
520 break;
521 case 4:
522 VTM = VectorTypeModifier::Log2EEW4;
523 break;
524 case 5:
525 VTM = VectorTypeModifier::Log2EEW5;
526 break;
527 case 6:
528 VTM = VectorTypeModifier::Log2EEW6;
529 break;
530 default:
531 llvm_unreachable("Invalid Log2EEW value, should be [3-6]");
532 return std::nullopt;
533 }
534 } else if (ComplexTT.first == "FixedSEW") {
535 uint32_t NewSEW;
536 if (ComplexTT.second.getAsInteger(10, NewSEW)) {
537 llvm_unreachable("Invalid FixedSEW value!");
538 return std::nullopt;
539 }
540 switch (NewSEW) {
541 case 8:
542 VTM = VectorTypeModifier::FixedSEW8;
543 break;
544 case 16:
545 VTM = VectorTypeModifier::FixedSEW16;
546 break;
547 case 32:
548 VTM = VectorTypeModifier::FixedSEW32;
549 break;
550 case 64:
551 VTM = VectorTypeModifier::FixedSEW64;
552 break;
553 default:
554 llvm_unreachable("Invalid FixedSEW value, should be 8, 16, 32 or 64");
555 return std::nullopt;
556 }
557 } else if (ComplexTT.first == "LFixedLog2LMUL") {
558 int32_t Log2LMUL;
559 if (ComplexTT.second.getAsInteger(10, Log2LMUL)) {
560 llvm_unreachable("Invalid LFixedLog2LMUL value!");
561 return std::nullopt;
562 }
563 switch (Log2LMUL) {
564 case -3:
565 VTM = VectorTypeModifier::LFixedLog2LMULN3;
566 break;
567 case -2:
568 VTM = VectorTypeModifier::LFixedLog2LMULN2;
569 break;
570 case -1:
571 VTM = VectorTypeModifier::LFixedLog2LMULN1;
572 break;
573 case 0:
574 VTM = VectorTypeModifier::LFixedLog2LMUL0;
575 break;
576 case 1:
577 VTM = VectorTypeModifier::LFixedLog2LMUL1;
578 break;
579 case 2:
580 VTM = VectorTypeModifier::LFixedLog2LMUL2;
581 break;
582 case 3:
583 VTM = VectorTypeModifier::LFixedLog2LMUL3;
584 break;
585 default:
586 llvm_unreachable("Invalid LFixedLog2LMUL value, should be [-3, 3]");
587 return std::nullopt;
588 }
589 } else if (ComplexTT.first == "SFixedLog2LMUL") {
590 int32_t Log2LMUL;
591 if (ComplexTT.second.getAsInteger(10, Log2LMUL)) {
592 llvm_unreachable("Invalid SFixedLog2LMUL value!");
593 return std::nullopt;
594 }
595 switch (Log2LMUL) {
596 case -3:
597 VTM = VectorTypeModifier::SFixedLog2LMULN3;
598 break;
599 case -2:
600 VTM = VectorTypeModifier::SFixedLog2LMULN2;
601 break;
602 case -1:
603 VTM = VectorTypeModifier::SFixedLog2LMULN1;
604 break;
605 case 0:
606 VTM = VectorTypeModifier::SFixedLog2LMUL0;
607 break;
608 case 1:
609 VTM = VectorTypeModifier::SFixedLog2LMUL1;
610 break;
611 case 2:
612 VTM = VectorTypeModifier::SFixedLog2LMUL2;
613 break;
614 case 3:
615 VTM = VectorTypeModifier::SFixedLog2LMUL3;
616 break;
617 default:
618 llvm_unreachable("Invalid LFixedLog2LMUL value, should be [-3, 3]");
619 return std::nullopt;
620 }
621
622 } else if (ComplexTT.first == "SEFixedLog2LMUL") {
623 int32_t Log2LMUL;
624 if (ComplexTT.second.getAsInteger(10, Log2LMUL)) {
625 llvm_unreachable("Invalid SEFixedLog2LMUL value!");
626 return std::nullopt;
627 }
628 switch (Log2LMUL) {
629 case -3:
630 VTM = VectorTypeModifier::SEFixedLog2LMULN3;
631 break;
632 case -2:
633 VTM = VectorTypeModifier::SEFixedLog2LMULN2;
634 break;
635 case -1:
636 VTM = VectorTypeModifier::SEFixedLog2LMULN1;
637 break;
638 case 0:
639 VTM = VectorTypeModifier::SEFixedLog2LMUL0;
640 break;
641 case 1:
642 VTM = VectorTypeModifier::SEFixedLog2LMUL1;
643 break;
644 case 2:
645 VTM = VectorTypeModifier::SEFixedLog2LMUL2;
646 break;
647 case 3:
648 VTM = VectorTypeModifier::SEFixedLog2LMUL3;
649 break;
650 default:
651 llvm_unreachable("Invalid LFixedLog2LMUL value, should be [-3, 3]");
652 return std::nullopt;
653 }
654 } else if (ComplexTT.first == "Tuple") {
655 unsigned NF = 0;
656 if (ComplexTT.second.getAsInteger(10, NF)) {
657 llvm_unreachable("Invalid NF value!");
658 return std::nullopt;
659 }
660 VTM = getTupleVTM(NF);
661 } else {
662 llvm_unreachable("Illegal complex type transformers!");
663 }
664 }
665 PD.VTM = VTM;
666
667 // Compute the remain type transformers
668 TypeModifier TM = TypeModifier::NoModifier;
669 for (char I : PrototypeDescriptorStr) {
670 switch (I) {
671 case 'P':
672 if ((TM & TypeModifier::Const) == TypeModifier::Const)
673 llvm_unreachable("'P' transformer cannot be used after 'C'");
674 if ((TM & TypeModifier::Pointer) == TypeModifier::Pointer)
675 llvm_unreachable("'P' transformer cannot be used twice");
676 TM |= TypeModifier::Pointer;
677 break;
678 case 'C':
679 TM |= TypeModifier::Const;
680 break;
681 case 'K':
682 TM |= TypeModifier::Immediate;
683 break;
684 case 'U':
685 TM |= TypeModifier::UnsignedInteger;
686 break;
687 case 'I':
688 TM |= TypeModifier::SignedInteger;
689 break;
690 case 'F':
691 TM |= TypeModifier::Float;
692 break;
693 case 'Y':
694 TM |= TypeModifier::BFloat;
695 break;
696 case 'S':
697 TM |= TypeModifier::LMUL1;
698 break;
699 default:
700 llvm_unreachable("Illegal non-primitive type transformer!");
701 }
702 }
703 PD.TM = TM;
704
705 return PD;
706}
707
708void RVVType::applyModifier(const PrototypeDescriptor &Transformer) {
709 // Handle primitive type transformer
710 switch (static_cast<BaseTypeModifier>(Transformer.PT)) {
711 case BaseTypeModifier::Scalar:
712 Scale = 0;
713 break;
714 case BaseTypeModifier::Vector:
715 Scale = LMUL.getScale(ElementBitwidth);
716 break;
717 case BaseTypeModifier::Void:
718 ScalarType = ScalarTypeKind::Void;
719 break;
720 case BaseTypeModifier::SizeT:
721 ScalarType = ScalarTypeKind::Size_t;
722 break;
723 case BaseTypeModifier::Ptrdiff:
724 ScalarType = ScalarTypeKind::Ptrdiff_t;
725 break;
726 case BaseTypeModifier::UnsignedLong:
727 ScalarType = ScalarTypeKind::UnsignedLong;
728 break;
729 case BaseTypeModifier::SignedLong:
730 ScalarType = ScalarTypeKind::SignedLong;
731 break;
732 case BaseTypeModifier::Float32:
733 ElementBitwidth = 32;
734 ScalarType = ScalarTypeKind::Float;
735 break;
736 case BaseTypeModifier::Invalid:
737 ScalarType = ScalarTypeKind::Invalid;
738 return;
739 }
740
741 switch (static_cast<VectorTypeModifier>(Transformer.VTM)) {
742 case VectorTypeModifier::Widening2XVector:
743 ElementBitwidth *= 2;
744 LMUL.MulLog2LMUL(1);
745 Scale = LMUL.getScale(ElementBitwidth);
746 if (ScalarType == ScalarTypeKind::BFloat)
747 ScalarType = ScalarTypeKind::Float;
748 if (ScalarType == ScalarTypeKind::FloatE4M3 ||
749 ScalarType == ScalarTypeKind::FloatE5M2)
750 ScalarType = ScalarTypeKind::BFloat;
751 break;
752 case VectorTypeModifier::DoubleLMULVector:
753 LMUL.MulLog2LMUL(1);
754 Scale = LMUL.getScale(ElementBitwidth);
755 break;
756 case VectorTypeModifier::Widening4XVector:
757 ElementBitwidth *= 4;
758 LMUL.MulLog2LMUL(2);
759 Scale = LMUL.getScale(ElementBitwidth);
760 if (ScalarType == ScalarTypeKind::FloatE4M3 ||
761 ScalarType == ScalarTypeKind::FloatE5M2)
762 ScalarType = ScalarTypeKind::Float;
763 break;
764 case VectorTypeModifier::Widening8XVector:
765 ElementBitwidth *= 8;
766 LMUL.MulLog2LMUL(3);
767 Scale = LMUL.getScale(ElementBitwidth);
768 break;
769 case VectorTypeModifier::MaskVector:
770 ScalarType = ScalarTypeKind::Boolean;
771 Scale = LMUL.getScale(ElementBitwidth);
772 ElementBitwidth = 1;
773 break;
774 case VectorTypeModifier::Log2EEW3:
775 applyLog2EEW(3);
776 break;
777 case VectorTypeModifier::Log2EEW4:
778 applyLog2EEW(4);
779 break;
780 case VectorTypeModifier::Log2EEW5:
781 applyLog2EEW(5);
782 break;
783 case VectorTypeModifier::Log2EEW6:
784 applyLog2EEW(6);
785 break;
786 case VectorTypeModifier::FixedSEW8:
787 applyFixedSEW(8);
788 break;
789 case VectorTypeModifier::FixedSEW16:
790 applyFixedSEW(16);
791 break;
792 case VectorTypeModifier::FixedSEW32:
793 applyFixedSEW(32);
794 break;
795 case VectorTypeModifier::FixedSEW64:
796 applyFixedSEW(64);
797 break;
798 case VectorTypeModifier::LFixedLog2LMULN3:
799 applyFixedLog2LMUL(-3, FixedLMULType::LargerThan);
800 break;
801 case VectorTypeModifier::LFixedLog2LMULN2:
802 applyFixedLog2LMUL(-2, FixedLMULType::LargerThan);
803 break;
804 case VectorTypeModifier::LFixedLog2LMULN1:
805 applyFixedLog2LMUL(-1, FixedLMULType::LargerThan);
806 break;
807 case VectorTypeModifier::LFixedLog2LMUL0:
808 applyFixedLog2LMUL(0, FixedLMULType::LargerThan);
809 break;
810 case VectorTypeModifier::LFixedLog2LMUL1:
811 applyFixedLog2LMUL(1, FixedLMULType::LargerThan);
812 break;
813 case VectorTypeModifier::LFixedLog2LMUL2:
814 applyFixedLog2LMUL(2, FixedLMULType::LargerThan);
815 break;
816 case VectorTypeModifier::LFixedLog2LMUL3:
817 applyFixedLog2LMUL(3, FixedLMULType::LargerThan);
818 break;
819 case VectorTypeModifier::SFixedLog2LMULN3:
820 applyFixedLog2LMUL(-3, FixedLMULType::SmallerThan);
821 break;
822 case VectorTypeModifier::SFixedLog2LMULN2:
823 applyFixedLog2LMUL(-2, FixedLMULType::SmallerThan);
824 break;
825 case VectorTypeModifier::SFixedLog2LMULN1:
826 applyFixedLog2LMUL(-1, FixedLMULType::SmallerThan);
827 break;
828 case VectorTypeModifier::SFixedLog2LMUL0:
829 applyFixedLog2LMUL(0, FixedLMULType::SmallerThan);
830 break;
831 case VectorTypeModifier::SFixedLog2LMUL1:
832 applyFixedLog2LMUL(1, FixedLMULType::SmallerThan);
833 break;
834 case VectorTypeModifier::SFixedLog2LMUL2:
835 applyFixedLog2LMUL(2, FixedLMULType::SmallerThan);
836 break;
837 case VectorTypeModifier::SFixedLog2LMUL3:
838 applyFixedLog2LMUL(3, FixedLMULType::SmallerThan);
839 break;
840 case VectorTypeModifier::SEFixedLog2LMULN3:
841 applyFixedLog2LMUL(-3, FixedLMULType::SmallerOrEqual);
842 break;
843 case VectorTypeModifier::SEFixedLog2LMULN2:
844 applyFixedLog2LMUL(-2, FixedLMULType::SmallerOrEqual);
845 break;
846 case VectorTypeModifier::SEFixedLog2LMULN1:
847 applyFixedLog2LMUL(-1, FixedLMULType::SmallerOrEqual);
848 break;
849 case VectorTypeModifier::SEFixedLog2LMUL0:
850 applyFixedLog2LMUL(0, FixedLMULType::SmallerOrEqual);
851 break;
852 case VectorTypeModifier::SEFixedLog2LMUL1:
853 applyFixedLog2LMUL(1, FixedLMULType::SmallerOrEqual);
854 break;
855 case VectorTypeModifier::SEFixedLog2LMUL2:
856 applyFixedLog2LMUL(2, FixedLMULType::SmallerOrEqual);
857 break;
858 case VectorTypeModifier::SEFixedLog2LMUL3:
859 applyFixedLog2LMUL(3, FixedLMULType::SmallerOrEqual);
860 break;
861 case VectorTypeModifier::Tuple2:
862 case VectorTypeModifier::Tuple3:
863 case VectorTypeModifier::Tuple4:
864 case VectorTypeModifier::Tuple5:
865 case VectorTypeModifier::Tuple6:
866 case VectorTypeModifier::Tuple7:
867 case VectorTypeModifier::Tuple8: {
868 IsTuple = true;
869 NF = 2 + static_cast<uint8_t>(Transformer.VTM) -
870 static_cast<uint8_t>(VectorTypeModifier::Tuple2);
871 break;
872 }
873 case VectorTypeModifier::NoModifier:
874 break;
875 }
876
877 // Early return if the current type modifier is already invalid.
878 if (ScalarType == Invalid)
879 return;
880
881 for (unsigned TypeModifierMaskShift = 0;
882 TypeModifierMaskShift <= static_cast<unsigned>(TypeModifier::MaxOffset);
883 ++TypeModifierMaskShift) {
884 unsigned TypeModifierMask = 1 << TypeModifierMaskShift;
885 if ((static_cast<unsigned>(Transformer.TM) & TypeModifierMask) !=
886 TypeModifierMask)
887 continue;
888 switch (static_cast<TypeModifier>(TypeModifierMask)) {
889 case TypeModifier::Pointer:
890 IsPointer = true;
891 break;
892 case TypeModifier::Const:
893 IsConstant = true;
894 break;
895 case TypeModifier::Immediate:
896 IsImmediate = true;
897 IsConstant = true;
898 break;
899 case TypeModifier::UnsignedInteger:
900 ScalarType = ScalarTypeKind::UnsignedInteger;
901 break;
902 case TypeModifier::SignedInteger:
903 ScalarType = ScalarTypeKind::SignedInteger;
904 break;
905 case TypeModifier::Float:
906 ScalarType = ScalarTypeKind::Float;
907 break;
908 case TypeModifier::BFloat:
909 ScalarType = ScalarTypeKind::BFloat;
910 break;
911 case TypeModifier::LMUL1:
912 LMUL = LMULType(0);
913 // Update ElementBitwidth need to update Scale too.
914 Scale = LMUL.getScale(ElementBitwidth);
915 break;
916 default:
917 llvm_unreachable("Unknown type modifier mask!");
918 }
919 }
920}
921
922void RVVType::applyLog2EEW(unsigned Log2EEW) {
923 // update new elmul = (eew/sew) * lmul
924 LMUL.MulLog2LMUL(Log2EEW - Log2_32(ElementBitwidth));
925 // update new eew
926 ElementBitwidth = 1 << Log2EEW;
927 ScalarType = ScalarTypeKind::SignedInteger;
928 Scale = LMUL.getScale(ElementBitwidth);
929}
930
931void RVVType::applyFixedSEW(unsigned NewSEW) {
932 // Set invalid type if src and dst SEW are same.
933 if (ElementBitwidth == NewSEW) {
934 ScalarType = ScalarTypeKind::Invalid;
935 return;
936 }
937 // Update new SEW
938 ElementBitwidth = NewSEW;
939 Scale = LMUL.getScale(ElementBitwidth);
940}
941
942void RVVType::applyFixedLog2LMUL(int Log2LMUL, enum FixedLMULType Type) {
943 switch (Type) {
944 case FixedLMULType::LargerThan:
945 if (Log2LMUL <= LMUL.Log2LMUL) {
946 ScalarType = ScalarTypeKind::Invalid;
947 return;
948 }
949 break;
950 case FixedLMULType::SmallerThan:
951 if (Log2LMUL >= LMUL.Log2LMUL) {
952 ScalarType = ScalarTypeKind::Invalid;
953 return;
954 }
955 break;
956 case FixedLMULType::SmallerOrEqual:
957 if (Log2LMUL > LMUL.Log2LMUL) {
958 ScalarType = ScalarTypeKind::Invalid;
959 return;
960 }
961 break;
962 }
963
964 // Update new LMUL
965 LMUL = LMULType(Log2LMUL);
966 Scale = LMUL.getScale(ElementBitwidth);
967}
968
969std::optional<RVVTypes>
970RVVTypeCache::computeTypes(BasicType BT, int Log2LMUL, unsigned NF,
971 ArrayRef<PrototypeDescriptor> Prototype) {
972 RVVTypes Types;
973 for (const PrototypeDescriptor &Proto : Prototype) {
974 auto T = computeType(BT, Log2LMUL, Proto);
975 if (!T)
976 return std::nullopt;
977 // Record legal type index
978 Types.push_back(*T);
979 }
980 return Types;
981}
982
983// Compute the hash value of RVVType, used for cache the result of computeType.
984static uint64_t computeRVVTypeHashValue(BasicType BT, int Log2LMUL,
985 PrototypeDescriptor Proto) {
986 // Layout of hash value:
987 // 0 8 24 32 40 48
988 // | Log2LMUL + 3 | BT | Proto.PT | Proto.TM | Proto.VTM |
989 assert(Log2LMUL >= -3 && Log2LMUL <= 3);
990 return (Log2LMUL + 3) | (static_cast<uint64_t>(BT) & 0xffff) << 8 |
991 (static_cast<uint64_t>(Proto.PT) << 24) |
992 (static_cast<uint64_t>(Proto.TM) << 32) |
993 (static_cast<uint64_t>(Proto.VTM) << 40);
994}
995
996std::optional<RVVTypePtr> RVVTypeCache::computeType(BasicType BT, int Log2LMUL,
997 PrototypeDescriptor Proto) {
998 uint64_t Idx = computeRVVTypeHashValue(BT, Log2LMUL, Proto);
999 // Search first
1000 auto It = LegalTypes.find(Idx);
1001 if (It != LegalTypes.end())
1002 return &(It->second);
1003
1004 if (IllegalTypes.count(Idx))
1005 return std::nullopt;
1006
1007 // Compute type and record the result.
1008 RVVType T(BT, Log2LMUL, Proto);
1009 if (T.isValid()) {
1010 // Record legal type index and value.
1011 std::pair<std::unordered_map<uint64_t, RVVType>::iterator, bool>
1012 InsertResult = LegalTypes.insert({Idx, T});
1013 return &(InsertResult.first->second);
1014 }
1015 // Record illegal type index.
1016 IllegalTypes.insert(Idx);
1017 return std::nullopt;
1018}
1019
1020//===----------------------------------------------------------------------===//
1021// RVVIntrinsic implementation
1022//===----------------------------------------------------------------------===//
1023RVVIntrinsic::RVVIntrinsic(StringRef NewName, StringRef Suffix,
1024 StringRef NewOverloadedName,
1025 StringRef OverloadedSuffix, StringRef IRName,
1026 bool IsMasked, bool HasMaskedOffOperand, bool HasVL,
1027 PolicyScheme Scheme, bool SupportOverloading,
1028 bool HasBuiltinAlias, StringRef ManualCodegen,
1029 const RVVTypes &OutInTypes,
1030 const std::vector<int64_t> &NewIntrinsicTypes,
1031 unsigned NF, Policy NewPolicyAttrs,
1032 bool HasFRMRoundModeOp, unsigned TWiden, bool AltFmt)
1033 : IRName(IRName), IsMasked(IsMasked),
1034 HasMaskedOffOperand(HasMaskedOffOperand), HasVL(HasVL), Scheme(Scheme),
1035 SupportOverloading(SupportOverloading), HasBuiltinAlias(HasBuiltinAlias),
1036 ManualCodegen(ManualCodegen.str()), NF(NF), PolicyAttrs(NewPolicyAttrs),
1037 TWiden(TWiden) {
1038
1039 // Init BuiltinName, Name and OverloadedName
1040 BuiltinName = NewName.str();
1041 Name = BuiltinName;
1042 if (NewOverloadedName.empty())
1043 OverloadedName = NewName.split("_").first.str();
1044 else
1045 OverloadedName = NewOverloadedName.str();
1046 if (!Suffix.empty())
1047 Name += "_" + Suffix.str();
1048 if (!OverloadedSuffix.empty())
1049 OverloadedName += "_" + OverloadedSuffix.str();
1050
1051 updateNamesAndPolicy(IsMasked, hasPolicy(), Name, BuiltinName, OverloadedName,
1052 PolicyAttrs, HasFRMRoundModeOp, AltFmt);
1053
1054 // Init OutputType and InputTypes
1055 OutputType = OutInTypes[0];
1056 InputTypes.assign(OutInTypes.begin() + 1, OutInTypes.end());
1057
1058 // IntrinsicTypes is unmasked TA version index. Need to update it
1059 // if there is merge operand (It is always in first operand).
1060 IntrinsicTypes = NewIntrinsicTypes;
1061 if ((IsMasked && hasMaskedOffOperand()) ||
1062 (!IsMasked && hasPassthruOperand())) {
1063 for (auto &I : IntrinsicTypes) {
1064 if (I >= 0)
1065 I += 1;
1066 }
1067 }
1068}
1069
1070std::string RVVIntrinsic::getBuiltinTypeStr() const {
1071 std::string S;
1072 S += OutputType->getBuiltinStr();
1073 for (const auto &T : InputTypes) {
1074 S += T->getBuiltinStr();
1075 }
1076 return S;
1077}
1078
1079std::string RVVIntrinsic::getSuffixStr(
1080 RVVTypeCache &TypeCache, BasicType Type, int Log2LMUL,
1081 llvm::ArrayRef<PrototypeDescriptor> PrototypeDescriptors) {
1082 SmallVector<std::string> SuffixStrs;
1083 for (auto PD : PrototypeDescriptors) {
1084 auto T = TypeCache.computeType(Type, Log2LMUL, PD);
1085 SuffixStrs.push_back((*T)->getShortStr());
1086 }
1087 return join(SuffixStrs, "_");
1088}
1089
1090llvm::SmallVector<PrototypeDescriptor> RVVIntrinsic::computeBuiltinTypes(
1091 llvm::ArrayRef<PrototypeDescriptor> Prototype, bool IsMasked,
1092 bool HasMaskedOffOperand, bool HasVL, unsigned NF,
1093 PolicyScheme DefaultScheme, Policy PolicyAttrs, bool IsTuple) {
1094 SmallVector<PrototypeDescriptor> NewPrototype(Prototype);
1095 bool HasPassthruOp = DefaultScheme == PolicyScheme::HasPassthruOperand;
1096 if (IsMasked) {
1097 // If HasMaskedOffOperand, insert result type as first input operand if
1098 // need.
1099 if (HasMaskedOffOperand && !PolicyAttrs.isTAMAPolicy()) {
1100 if (NF == 1) {
1101 NewPrototype.insert(NewPrototype.begin() + 1, NewPrototype[0]);
1102 } else if (NF > 1) {
1103 if (IsTuple) {
1104 PrototypeDescriptor BasePtrOperand = Prototype[1];
1105 PrototypeDescriptor MaskoffType =
1106 PrototypeDescriptor(BaseTypeModifier::Vector, getTupleVTM(NF),
1107 BasePtrOperand.TM & ~TypeModifier::Pointer);
1108 NewPrototype.insert(NewPrototype.begin() + 1, MaskoffType);
1109 } else {
1110 // Convert
1111 // (void, op0 address, op1 address, ...)
1112 // to
1113 // (void, op0 address, op1 address, ..., maskedoff0, maskedoff1, ...)
1114 PrototypeDescriptor MaskoffType = NewPrototype[1];
1115 MaskoffType.TM &= ~TypeModifier::Pointer;
1116 NewPrototype.insert(NewPrototype.begin() + NF + 1, NF, MaskoffType);
1117 }
1118 }
1119 }
1120 if (HasMaskedOffOperand && NF > 1) {
1121 // Convert
1122 // (void, op0 address, op1 address, ..., maskedoff0, maskedoff1, ...)
1123 // to
1124 // (void, op0 address, op1 address, ..., mask, maskedoff0, maskedoff1,
1125 // ...)
1126 if (IsTuple)
1127 NewPrototype.insert(NewPrototype.begin() + 1,
1128 PrototypeDescriptor::Mask);
1129 else
1130 NewPrototype.insert(NewPrototype.begin() + NF + 1,
1131 PrototypeDescriptor::Mask);
1132 } else {
1133 // If IsMasked, insert PrototypeDescriptor:Mask as first input operand.
1134 NewPrototype.insert(NewPrototype.begin() + 1, PrototypeDescriptor::Mask);
1135 }
1136 } else {
1137 if (NF == 1) {
1138 if (PolicyAttrs.isTUPolicy() && HasPassthruOp)
1139 NewPrototype.insert(NewPrototype.begin(), NewPrototype[0]);
1140 } else if (PolicyAttrs.isTUPolicy() && HasPassthruOp) {
1141 if (IsTuple) {
1142 PrototypeDescriptor BasePtrOperand = Prototype[0];
1143 PrototypeDescriptor MaskoffType =
1144 PrototypeDescriptor(BaseTypeModifier::Vector, getTupleVTM(NF),
1145 BasePtrOperand.TM & ~TypeModifier::Pointer);
1146 NewPrototype.insert(NewPrototype.begin(), MaskoffType);
1147 } else {
1148 // NF > 1 cases for segment load operations.
1149 // Convert
1150 // (void, op0 address, op1 address, ...)
1151 // to
1152 // (void, op0 address, op1 address, maskedoff0, maskedoff1, ...)
1153 PrototypeDescriptor MaskoffType = Prototype[1];
1154 MaskoffType.TM &= ~TypeModifier::Pointer;
1155 NewPrototype.insert(NewPrototype.begin() + NF + 1, NF, MaskoffType);
1156 }
1157 }
1158 }
1159
1160 // If HasVL, append PrototypeDescriptor:VL to last operand
1161 if (HasVL)
1162 NewPrototype.push_back(PrototypeDescriptor::VL);
1163
1164 return NewPrototype;
1165}
1166
1170
1171llvm::SmallVector<Policy>
1172RVVIntrinsic::getSupportedMaskedPolicies(bool HasTailPolicy,
1173 bool HasMaskPolicy) {
1174 if (HasTailPolicy && HasMaskPolicy)
1175 return {Policy(Policy::PolicyType::Undisturbed,
1176 Policy::PolicyType::Agnostic), // TUM
1177 Policy(Policy::PolicyType::Undisturbed,
1178 Policy::PolicyType::Undisturbed), // TUMU
1179 Policy(Policy::PolicyType::Agnostic,
1180 Policy::PolicyType::Undisturbed)}; // MU
1181 if (HasTailPolicy && !HasMaskPolicy)
1182 return {Policy(Policy::PolicyType::Undisturbed,
1183 Policy::PolicyType::Agnostic)}; // TU
1184 if (!HasTailPolicy && HasMaskPolicy)
1185 return {Policy(Policy::PolicyType::Agnostic,
1186 Policy::PolicyType::Undisturbed)}; // MU
1187 llvm_unreachable("An RVV instruction should not be without both tail policy "
1188 "and mask policy");
1189}
1190
1191void RVVIntrinsic::updateNamesAndPolicy(bool IsMasked, bool HasPolicy,
1192 std::string &Name,
1193 std::string &BuiltinName,
1194 std::string &OverloadedName,
1195 Policy &PolicyAttrs,
1196 bool HasFRMRoundModeOp, bool AltFmt) {
1197
1198 auto appendPolicySuffix = [&](const std::string &suffix) {
1199 Name += suffix;
1200 BuiltinName += suffix;
1201 OverloadedName += suffix;
1202 };
1203
1204 if (HasFRMRoundModeOp) {
1205 Name += "_rm";
1206 BuiltinName += "_rm";
1207 }
1208
1209 if (AltFmt)
1210 BuiltinName += "_alt";
1211
1212 if (IsMasked) {
1213 if (PolicyAttrs.isTUMUPolicy())
1214 appendPolicySuffix("_tumu");
1215 else if (PolicyAttrs.isTUMAPolicy())
1216 appendPolicySuffix("_tum");
1217 else if (PolicyAttrs.isTAMUPolicy())
1218 appendPolicySuffix("_mu");
1219 else if (PolicyAttrs.isTAMAPolicy()) {
1220 Name += "_m";
1221 BuiltinName += "_m";
1222 } else
1223 llvm_unreachable("Unhandled policy condition");
1224 } else {
1225 if (PolicyAttrs.isTUPolicy())
1226 appendPolicySuffix("_tu");
1227 else if (PolicyAttrs.isTAPolicy()) // no suffix needed
1228 return;
1229 else
1230 llvm_unreachable("Unhandled policy condition");
1231 }
1232}
1233
1234SmallVector<PrototypeDescriptor> parsePrototypes(StringRef Prototypes) {
1235 SmallVector<PrototypeDescriptor> PrototypeDescriptors;
1236 const StringRef Primaries("evwdqom0ztulf");
1237 while (!Prototypes.empty()) {
1238 size_t Idx = 0;
1239 // Skip over complex prototype because it could contain primitive type
1240 // character.
1241 if (Prototypes[0] == '(')
1242 Idx = Prototypes.find_first_of(')');
1243 Idx = Prototypes.find_first_of(Primaries, Idx);
1244 assert(Idx != StringRef::npos);
1245 auto PD = PrototypeDescriptor::parsePrototypeDescriptor(
1246 Prototypes.slice(0, Idx + 1));
1247 if (!PD)
1248 llvm_unreachable("Error during parsing prototype.");
1249 PrototypeDescriptors.push_back(*PD);
1250 Prototypes = Prototypes.drop_front(Idx + 1);
1251 }
1252 return PrototypeDescriptors;
1253}
1254
1255#define STRINGIFY(NAME) \
1256 case NAME: \
1257 OS << #NAME; \
1258 break;
1259
1260llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, enum PolicyScheme PS) {
1261 switch (PS) {
1262 STRINGIFY(SchemeNone)
1263 STRINGIFY(HasPassthruOperand)
1264 STRINGIFY(HasPolicyOperand)
1265 }
1266 return OS;
1267}
1268
1269#undef STRINGIFY
1270
1271raw_ostream &operator<<(raw_ostream &OS, const RVVIntrinsicRecord &Record) {
1272 OS << "{";
1273 OS << "/*Name=*/\"" << Record.Name << "\", ";
1274 if (Record.OverloadedName == nullptr ||
1275 StringRef(Record.OverloadedName).empty())
1276 OS << "/*OverloadedName=*/nullptr, ";
1277 else
1278 OS << "/*OverloadedName=*/\"" << Record.OverloadedName << "\", ";
1279 OS << "/*RequiredExtensions=*/\"" << Record.RequiredExtensions << "\", ";
1280 OS << "/*PrototypeIndex=*/" << Record.PrototypeIndex << ", ";
1281 OS << "/*SuffixIndex=*/" << Record.SuffixIndex << ", ";
1282 OS << "/*OverloadedSuffixIndex=*/" << Record.OverloadedSuffixIndex << ", ";
1283 OS << "/*PrototypeLength=*/" << (int)Record.PrototypeLength << ", ";
1284 OS << "/*SuffixLength=*/" << (int)Record.SuffixLength << ", ";
1285 OS << "/*OverloadedSuffixSize=*/" << (int)Record.OverloadedSuffixSize << ", ";
1286 OS << "/*TypeRangeMask=*/" << (int)Record.TypeRangeMask << ", ";
1287 OS << "/*Log2LMULMask=*/" << (int)Record.Log2LMULMask << ", ";
1288 OS << "/*NF=*/" << (int)Record.NF << ", ";
1289 OS << "/*HasMasked=*/" << (int)Record.HasMasked << ", ";
1290 OS << "/*HasVL=*/" << (int)Record.HasVL << ", ";
1291 OS << "/*HasMaskedOffOperand=*/" << (int)Record.HasMaskedOffOperand << ", ";
1292 OS << "/*HasTailPolicy=*/" << (int)Record.HasTailPolicy << ", ";
1293 OS << "/*HasMaskPolicy=*/" << (int)Record.HasMaskPolicy << ", ";
1294 OS << "/*HasFRMRoundModeOp=*/" << (int)Record.HasFRMRoundModeOp << ", ";
1295 OS << "/*AltFmt=*/" << (int)Record.AltFmt << ",";
1296 OS << "/*IsTuple=*/" << (int)Record.IsTuple << ", ";
1297 OS << "/*UnMaskedPolicyScheme=*/" << (PolicyScheme)Record.UnMaskedPolicyScheme
1298 << ", ";
1299 OS << "/*MaskedPolicyScheme=*/" << (PolicyScheme)Record.MaskedPolicyScheme
1300 << ", ";
1301 OS << "},\n";
1302 return OS;
1303}
1304
1305} // end namespace RISCV
1306} // end namespace clang
V
#define V(N, I)
Definition ASTContext.h:3718
getTypeString
static bool getTypeString(SmallStringEnc &Enc, const Decl *D, const CodeGen::CodeGenModule &CGM, TypeStringCache &TSC)
The XCore ABI includes a type information section that communicates symbol type information to the li...
Definition XCore.cpp:630
Record
llvm::MachO::Record Record
Definition MachO.h:31
STRINGIFY
#define STRINGIFY(NAME)
Definition RISCVVIntrinsicUtils.cpp:1255
isVector
static bool isVector(QualType QT, QualType ElementType)
This helper function returns true if QT is a vector type that has element type ElementType.
Definition SemaExpr.cpp:9630
clang::ComplexType
Complex values, per C99 6.2.5p11.
Definition TypeBase.h:3337
clang::RISCV::RVVIntrinsic::getSupportedMaskedPolicies
static llvm::SmallVector< Policy > getSupportedMaskedPolicies(bool HasTailPolicy, bool HasMaskPolicy)
Definition RISCVVIntrinsicUtils.cpp:1172
clang::RISCV::RVVIntrinsic::computeBuiltinTypes
static llvm::SmallVector< PrototypeDescriptor > computeBuiltinTypes(llvm::ArrayRef< PrototypeDescriptor > Prototype, bool IsMasked, bool HasMaskedOffOperand, bool HasVL, unsigned NF, PolicyScheme DefaultScheme, Policy PolicyAttrs, bool IsTuple)
Definition RISCVVIntrinsicUtils.cpp:1090
clang::RISCV::RVVIntrinsic::getSuffixStr
static std::string getSuffixStr(RVVTypeCache &TypeCache, BasicType Type, int Log2LMUL, llvm::ArrayRef< PrototypeDescriptor > PrototypeDescriptors)
Definition RISCVVIntrinsicUtils.cpp:1079
clang::RISCV::RVVIntrinsic::RVVIntrinsic
RVVIntrinsic(llvm::StringRef Name, llvm::StringRef Suffix, llvm::StringRef OverloadedName, llvm::StringRef OverloadedSuffix, llvm::StringRef IRName, bool IsMasked, bool HasMaskedOffOperand, bool HasVL, PolicyScheme Scheme, bool SupportOverloading, bool HasBuiltinAlias, llvm::StringRef ManualCodegen, const RVVTypes &Types, const std::vector< int64_t > &IntrinsicTypes, unsigned NF, Policy PolicyAttrs, bool HasFRMRoundModeOp, unsigned TWiden, bool AltFmt)
Definition RISCVVIntrinsicUtils.cpp:1023
clang::RISCV::RVVIntrinsic::updateNamesAndPolicy
static void updateNamesAndPolicy(bool IsMasked, bool HasPolicy, std::string &Name, std::string &BuiltinName, std::string &OverloadedName, Policy &PolicyAttrs, bool HasFRMRoundModeOp, bool AltFmt)
Definition RISCVVIntrinsicUtils.cpp:1191
clang::RISCV::RVVIntrinsic::getSupportedUnMaskedPolicies
static llvm::SmallVector< Policy > getSupportedUnMaskedPolicies()
Definition RISCVVIntrinsicUtils.cpp:1167
clang::RISCV::RVVTypeCache::computeType
std::optional< RVVTypePtr > computeType(BasicType BT, int Log2LMUL, PrototypeDescriptor Proto)
Definition RISCVVIntrinsicUtils.cpp:996
clang::RISCV::RVVTypeCache::computeTypes
std::optional< RVVTypes > computeTypes(BasicType BT, int Log2LMUL, unsigned NF, llvm::ArrayRef< PrototypeDescriptor > Prototype)
Compute output and input types by applying different config (basic type and LMUL with type transforme...
Definition RISCVVIntrinsicUtils.cpp:970
clang::Type
The base class of the type hierarchy.
Definition TypeBase.h:1875
clang::RISCV
RISCV builtins.
Definition TargetBuiltins.h:220
clang::RISCV::VScaleVal
std::optional< unsigned > VScaleVal
Definition RISCVVIntrinsicUtils.h:30
clang::RISCV::operator<<
llvm::raw_ostream & operator<<(llvm::raw_ostream &OS, enum PolicyScheme PS)
Definition RISCVVIntrinsicUtils.cpp:1260
clang::RISCV::parsePrototypes
llvm::SmallVector< PrototypeDescriptor > parsePrototypes(llvm::StringRef Prototypes)
clang::RISCV::RVVTypes
std::vector< RVVTypePtr > RVVTypes
Definition RISCVVIntrinsicUtils.h:253
clang::RISCV::computeRVVTypeHashValue
static uint64_t computeRVVTypeHashValue(BasicType BT, int Log2LMUL, PrototypeDescriptor Proto)
Definition RISCVVIntrinsicUtils.cpp:984
clang::RISCV::getTupleVTM
static VectorTypeModifier getTupleVTM(unsigned NF)
Definition RISCVVIntrinsicUtils.cpp:382
clang
The JSON file list parser is used to communicate input to InstallAPI.
Definition CalledOnceCheck.h:17
clang::if
if(T->getSizeExpr()) TRY_TO(TraverseStmt(const_cast< Expr * >(T -> getSizeExpr())))
clang::NameClassificationKind::Type
@ Type
The name was classified as a type.
Definition Sema.h:564
llvm
Diagnostic wrappers for TextAPI types for error reporting.
Definition Dominators.h:30
clang::RISCV::LMULType::getScale
std::optional< unsigned > getScale(unsigned ElementBitwidth) const
Definition RISCVVIntrinsicUtils.cpp:45
clang::RISCV::PrototypeDescriptor::parsePrototypeDescriptor
static std::optional< PrototypeDescriptor > parsePrototypeDescriptor(llvm::StringRef PrototypeStr)
Definition RISCVVIntrinsicUtils.cpp:437
clang::RISCV::PrototypeDescriptor::VL
static const PrototypeDescriptor VL
Definition RISCVVIntrinsicUtils.h:198
clang::RISCV::PrototypeDescriptor::PrototypeDescriptor
constexpr PrototypeDescriptor()=default
clang::RISCV::PrototypeDescriptor::Mask
static const PrototypeDescriptor Mask
Definition RISCVVIntrinsicUtils.h:196
clang::RISCV::PrototypeDescriptor::Vector
static const PrototypeDescriptor Vector
Definition RISCVVIntrinsicUtils.h:197
Generated on for clang by doxygen 1.14.0