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 case ScalarTypeKind::FloatE4M3:
254 case ScalarTypeKind::FloatE5M2:
255 ClangBuiltinStr += "uint";
256 break;
257 default:
258 llvm_unreachable("ScalarTypeKind is invalid");
259 }
260 ClangBuiltinStr += utostr(ElementBitwidth) + LMUL.str() +
261 (IsTuple ? "x" + utostr(NF) : "") + "_t";
262}
263
264void RVVType::initTypeStr() {
265 assert(isValid() && "RVVType is invalid");
266
267 if (IsConstant)
268 Str += "const ";
269
270 auto getTypeString = [&](StringRef TypeStr) {
271 if (isScalar())
272 return Twine(TypeStr + Twine(ElementBitwidth) + "_t").str();
273 return Twine("v" + TypeStr + Twine(ElementBitwidth) + LMUL.str() +
274 (IsTuple ? "x" + utostr(NF) : "") + "_t")
275 .str();
276 };
277
278 switch (ScalarType) {
279 case ScalarTypeKind::Void:
280 Str = "void";
281 return;
282 case ScalarTypeKind::Size_t:
283 Str = "size_t";
284 if (IsPointer)
285 Str += " *";
286 return;
287 case ScalarTypeKind::Ptrdiff_t:
288 Str = "ptrdiff_t";
289 return;
290 case ScalarTypeKind::UnsignedLong:
291 Str = "unsigned long";
292 return;
293 case ScalarTypeKind::SignedLong:
294 Str = "long";
295 return;
296 case ScalarTypeKind::Boolean:
297 if (isScalar())
298 Str += "bool";
299 else
300 // Vector bool is special case, the formulate is
301 // `vbool<N>_t = MVT::nxv<64/N>i1` ex. vbool16_t = MVT::4i1
302 Str += "vbool" + utostr(64 / *Scale) + "_t";
303 break;
304 case ScalarTypeKind::Float:
305 if (isScalar()) {
306 if (ElementBitwidth == 64)
307 Str += "double";
308 else if (ElementBitwidth == 32)
309 Str += "float";
310 else if (ElementBitwidth == 16)
311 Str += "_Float16";
312 else
313 llvm_unreachable("Unhandled floating type.");
314 } else
315 Str += getTypeString("float");
316 break;
317 case ScalarTypeKind::BFloat:
318 if (isScalar()) {
319 if (ElementBitwidth == 16)
320 Str += "__bf16";
321 else
322 llvm_unreachable("Unhandled floating type.");
323 } else
324 Str += getTypeString("bfloat");
325 break;
326 case ScalarTypeKind::SignedInteger:
327 Str += getTypeString("int");
328 break;
329 case ScalarTypeKind::UnsignedInteger:
330 case ScalarTypeKind::FloatE4M3:
331 case ScalarTypeKind::FloatE5M2:
332 Str += getTypeString("uint");
333 break;
334 default:
335 llvm_unreachable("ScalarType is invalid!");
336 }
337 if (IsPointer)
338 Str += " *";
339}
340
341void RVVType::initShortStr() {
342 switch (ScalarType) {
343 case ScalarTypeKind::Boolean:
344 assert(isVector());
345 ShortStr = "b" + utostr(64 / *Scale);
346 return;
347 case ScalarTypeKind::Float:
348 ShortStr = "f" + utostr(ElementBitwidth);
349 break;
350 case ScalarTypeKind::BFloat:
351 ShortStr = "bf" + utostr(ElementBitwidth);
352 break;
353 case ScalarTypeKind::SignedInteger:
354 ShortStr = "i" + utostr(ElementBitwidth);
355 break;
356 case ScalarTypeKind::UnsignedInteger:
357 ShortStr = "u" + utostr(ElementBitwidth);
358 break;
359 case ScalarTypeKind::FloatE4M3:
360 ShortStr = "f8e4m3";
361 break;
362 case ScalarTypeKind::FloatE5M2:
363 ShortStr = "f8e5m2";
364 break;
365 default:
366 llvm_unreachable("Unhandled case!");
367 }
368 if (isVector())
369 ShortStr += LMUL.str();
370 if (isTuple())
371 ShortStr += "x" + utostr(NF);
372}
373
374static VectorTypeModifier getTupleVTM(unsigned NF) {
375 assert(2 <= NF && NF <= 8 && "2 <= NF <= 8");
376 return static_cast<VectorTypeModifier>(
377 static_cast<uint8_t>(VectorTypeModifier::Tuple2) + (NF - 2));
378}
379
380void RVVType::applyBasicType() {
381 switch (BT) {
382 case BasicType::Int8:
383 ElementBitwidth = 8;
384 ScalarType = ScalarTypeKind::SignedInteger;
385 break;
386 case BasicType::Int16:
387 ElementBitwidth = 16;
388 ScalarType = ScalarTypeKind::SignedInteger;
389 break;
390 case BasicType::Int32:
391 ElementBitwidth = 32;
392 ScalarType = ScalarTypeKind::SignedInteger;
393 break;
394 case BasicType::Int64:
395 ElementBitwidth = 64;
396 ScalarType = ScalarTypeKind::SignedInteger;
397 break;
398 case BasicType::Float16:
399 ElementBitwidth = 16;
400 ScalarType = ScalarTypeKind::Float;
401 break;
402 case BasicType::Float32:
403 ElementBitwidth = 32;
404 ScalarType = ScalarTypeKind::Float;
405 break;
406 case BasicType::Float64:
407 ElementBitwidth = 64;
408 ScalarType = ScalarTypeKind::Float;
409 break;
410 case BasicType::BFloat16:
411 ElementBitwidth = 16;
412 ScalarType = ScalarTypeKind::BFloat;
413 break;
414 case BasicType::F8E4M3:
415 ElementBitwidth = 8;
416 ScalarType = ScalarTypeKind::FloatE4M3;
417 break;
418 case BasicType::F8E5M2:
419 ElementBitwidth = 8;
420 ScalarType = ScalarTypeKind::FloatE5M2;
421 break;
422 default:
423 llvm_unreachable("Unhandled type code!");
424 }
425 assert(ElementBitwidth != 0 && "Bad element bitwidth!");
426}
427
428std::optional<PrototypeDescriptor>
429PrototypeDescriptor::parsePrototypeDescriptor(
430 llvm::StringRef PrototypeDescriptorStr) {
431 PrototypeDescriptor PD;
432 BaseTypeModifier PT = BaseTypeModifier::Invalid;
433 VectorTypeModifier VTM = VectorTypeModifier::NoModifier;
434
435 if (PrototypeDescriptorStr.empty())
436 return PD;
437
438 // Handle base type modifier
439 auto PType = PrototypeDescriptorStr.back();
440 switch (PType) {
441 case 'e':
442 PT = BaseTypeModifier::Scalar;
443 break;
444 case 'v':
445 PT = BaseTypeModifier::Vector;
446 break;
447 case 'w':
448 PT = BaseTypeModifier::Vector;
449 VTM = VectorTypeModifier::Widening2XVector;
450 break;
451 case 'd':
452 PT = BaseTypeModifier::Vector;
453 VTM = VectorTypeModifier::DoubleLMULVector;
454 break;
455 case 'q':
456 PT = BaseTypeModifier::Vector;
457 VTM = VectorTypeModifier::Widening4XVector;
458 break;
459 case 'o':
460 PT = BaseTypeModifier::Vector;
461 VTM = VectorTypeModifier::Widening8XVector;
462 break;
463 case 'm':
464 PT = BaseTypeModifier::Vector;
465 VTM = VectorTypeModifier::MaskVector;
466 break;
467 case '0':
468 PT = BaseTypeModifier::Void;
469 break;
470 case 'z':
471 PT = BaseTypeModifier::SizeT;
472 break;
473 case 't':
474 PT = BaseTypeModifier::Ptrdiff;
475 break;
476 case 'u':
477 PT = BaseTypeModifier::UnsignedLong;
478 break;
479 case 'l':
480 PT = BaseTypeModifier::SignedLong;
481 break;
482 case 'f':
483 PT = BaseTypeModifier::Float32;
484 break;
485 default:
486 llvm_unreachable("Illegal primitive type transformers!");
487 }
488 PD.PT = PT;
489 PrototypeDescriptorStr = PrototypeDescriptorStr.drop_back();
490
491 // Compute the vector type transformers, it can only appear one time.
492 if (PrototypeDescriptorStr.starts_with("(")) {
493 assert(VTM == VectorTypeModifier::NoModifier &&
494 "VectorTypeModifier should only have one modifier");
495 size_t Idx = PrototypeDescriptorStr.find(')');
496 assert(Idx != StringRef::npos);
497 StringRef ComplexType = PrototypeDescriptorStr.slice(1, Idx);
498 PrototypeDescriptorStr = PrototypeDescriptorStr.drop_front(Idx + 1);
499 assert(!PrototypeDescriptorStr.contains('(') &&
500 "Only allow one vector type modifier");
501
502 auto ComplexTT = ComplexType.split(":");
503 if (ComplexTT.first == "Log2EEW") {
504 uint32_t Log2EEW;
505 if (ComplexTT.second.getAsInteger(10, Log2EEW)) {
506 llvm_unreachable("Invalid Log2EEW value!");
507 return std::nullopt;
508 }
509 switch (Log2EEW) {
510 case 3:
511 VTM = VectorTypeModifier::Log2EEW3;
512 break;
513 case 4:
514 VTM = VectorTypeModifier::Log2EEW4;
515 break;
516 case 5:
517 VTM = VectorTypeModifier::Log2EEW5;
518 break;
519 case 6:
520 VTM = VectorTypeModifier::Log2EEW6;
521 break;
522 default:
523 llvm_unreachable("Invalid Log2EEW value, should be [3-6]");
524 return std::nullopt;
525 }
526 } else if (ComplexTT.first == "FixedSEW") {
527 uint32_t NewSEW;
528 if (ComplexTT.second.getAsInteger(10, NewSEW)) {
529 llvm_unreachable("Invalid FixedSEW value!");
530 return std::nullopt;
531 }
532 switch (NewSEW) {
533 case 8:
534 VTM = VectorTypeModifier::FixedSEW8;
535 break;
536 case 16:
537 VTM = VectorTypeModifier::FixedSEW16;
538 break;
539 case 32:
540 VTM = VectorTypeModifier::FixedSEW32;
541 break;
542 case 64:
543 VTM = VectorTypeModifier::FixedSEW64;
544 break;
545 default:
546 llvm_unreachable("Invalid FixedSEW value, should be 8, 16, 32 or 64");
547 return std::nullopt;
548 }
549 } else if (ComplexTT.first == "LFixedLog2LMUL") {
550 int32_t Log2LMUL;
551 if (ComplexTT.second.getAsInteger(10, Log2LMUL)) {
552 llvm_unreachable("Invalid LFixedLog2LMUL value!");
553 return std::nullopt;
554 }
555 switch (Log2LMUL) {
556 case -3:
557 VTM = VectorTypeModifier::LFixedLog2LMULN3;
558 break;
559 case -2:
560 VTM = VectorTypeModifier::LFixedLog2LMULN2;
561 break;
562 case -1:
563 VTM = VectorTypeModifier::LFixedLog2LMULN1;
564 break;
565 case 0:
566 VTM = VectorTypeModifier::LFixedLog2LMUL0;
567 break;
568 case 1:
569 VTM = VectorTypeModifier::LFixedLog2LMUL1;
570 break;
571 case 2:
572 VTM = VectorTypeModifier::LFixedLog2LMUL2;
573 break;
574 case 3:
575 VTM = VectorTypeModifier::LFixedLog2LMUL3;
576 break;
577 default:
578 llvm_unreachable("Invalid LFixedLog2LMUL value, should be [-3, 3]");
579 return std::nullopt;
580 }
581 } else if (ComplexTT.first == "SFixedLog2LMUL") {
582 int32_t Log2LMUL;
583 if (ComplexTT.second.getAsInteger(10, Log2LMUL)) {
584 llvm_unreachable("Invalid SFixedLog2LMUL value!");
585 return std::nullopt;
586 }
587 switch (Log2LMUL) {
588 case -3:
589 VTM = VectorTypeModifier::SFixedLog2LMULN3;
590 break;
591 case -2:
592 VTM = VectorTypeModifier::SFixedLog2LMULN2;
593 break;
594 case -1:
595 VTM = VectorTypeModifier::SFixedLog2LMULN1;
596 break;
597 case 0:
598 VTM = VectorTypeModifier::SFixedLog2LMUL0;
599 break;
600 case 1:
601 VTM = VectorTypeModifier::SFixedLog2LMUL1;
602 break;
603 case 2:
604 VTM = VectorTypeModifier::SFixedLog2LMUL2;
605 break;
606 case 3:
607 VTM = VectorTypeModifier::SFixedLog2LMUL3;
608 break;
609 default:
610 llvm_unreachable("Invalid LFixedLog2LMUL value, should be [-3, 3]");
611 return std::nullopt;
612 }
613
614 } else if (ComplexTT.first == "SEFixedLog2LMUL") {
615 int32_t Log2LMUL;
616 if (ComplexTT.second.getAsInteger(10, Log2LMUL)) {
617 llvm_unreachable("Invalid SEFixedLog2LMUL value!");
618 return std::nullopt;
619 }
620 switch (Log2LMUL) {
621 case -3:
622 VTM = VectorTypeModifier::SEFixedLog2LMULN3;
623 break;
624 case -2:
625 VTM = VectorTypeModifier::SEFixedLog2LMULN2;
626 break;
627 case -1:
628 VTM = VectorTypeModifier::SEFixedLog2LMULN1;
629 break;
630 case 0:
631 VTM = VectorTypeModifier::SEFixedLog2LMUL0;
632 break;
633 case 1:
634 VTM = VectorTypeModifier::SEFixedLog2LMUL1;
635 break;
636 case 2:
637 VTM = VectorTypeModifier::SEFixedLog2LMUL2;
638 break;
639 case 3:
640 VTM = VectorTypeModifier::SEFixedLog2LMUL3;
641 break;
642 default:
643 llvm_unreachable("Invalid LFixedLog2LMUL value, should be [-3, 3]");
644 return std::nullopt;
645 }
646 } else if (ComplexTT.first == "Tuple") {
647 unsigned NF = 0;
648 if (ComplexTT.second.getAsInteger(10, NF)) {
649 llvm_unreachable("Invalid NF value!");
650 return std::nullopt;
651 }
652 VTM = getTupleVTM(NF);
653 } else {
654 llvm_unreachable("Illegal complex type transformers!");
655 }
656 }
657 PD.VTM = VTM;
658
659 // Compute the remain type transformers
660 TypeModifier TM = TypeModifier::NoModifier;
661 for (char I : PrototypeDescriptorStr) {
662 switch (I) {
663 case 'P':
664 if ((TM & TypeModifier::Const) == TypeModifier::Const)
665 llvm_unreachable("'P' transformer cannot be used after 'C'");
666 if ((TM & TypeModifier::Pointer) == TypeModifier::Pointer)
667 llvm_unreachable("'P' transformer cannot be used twice");
668 TM |= TypeModifier::Pointer;
669 break;
670 case 'C':
671 TM |= TypeModifier::Const;
672 break;
673 case 'K':
674 TM |= TypeModifier::Immediate;
675 break;
676 case 'U':
677 TM |= TypeModifier::UnsignedInteger;
678 break;
679 case 'I':
680 TM |= TypeModifier::SignedInteger;
681 break;
682 case 'F':
683 TM |= TypeModifier::Float;
684 break;
685 case 'Y':
686 TM |= TypeModifier::BFloat;
687 break;
688 case 'S':
689 TM |= TypeModifier::LMUL1;
690 break;
691 default:
692 llvm_unreachable("Illegal non-primitive type transformer!");
693 }
694 }
695 PD.TM = TM;
696
697 return PD;
698}
699
700void RVVType::applyModifier(const PrototypeDescriptor &Transformer) {
701 // Handle primitive type transformer
702 switch (static_cast<BaseTypeModifier>(Transformer.PT)) {
703 case BaseTypeModifier::Scalar:
704 Scale = 0;
705 break;
706 case BaseTypeModifier::Vector:
707 Scale = LMUL.getScale(ElementBitwidth);
708 break;
709 case BaseTypeModifier::Void:
710 ScalarType = ScalarTypeKind::Void;
711 break;
712 case BaseTypeModifier::SizeT:
713 ScalarType = ScalarTypeKind::Size_t;
714 break;
715 case BaseTypeModifier::Ptrdiff:
716 ScalarType = ScalarTypeKind::Ptrdiff_t;
717 break;
718 case BaseTypeModifier::UnsignedLong:
719 ScalarType = ScalarTypeKind::UnsignedLong;
720 break;
721 case BaseTypeModifier::SignedLong:
722 ScalarType = ScalarTypeKind::SignedLong;
723 break;
724 case BaseTypeModifier::Float32:
725 ElementBitwidth = 32;
726 ScalarType = ScalarTypeKind::Float;
727 break;
728 case BaseTypeModifier::Invalid:
729 ScalarType = ScalarTypeKind::Invalid;
730 return;
731 }
732
733 switch (static_cast<VectorTypeModifier>(Transformer.VTM)) {
734 case VectorTypeModifier::Widening2XVector:
735 ElementBitwidth *= 2;
736 LMUL.MulLog2LMUL(1);
737 Scale = LMUL.getScale(ElementBitwidth);
738 if (ScalarType == ScalarTypeKind::BFloat)
739 ScalarType = ScalarTypeKind::Float;
740 if (ScalarType == ScalarTypeKind::FloatE4M3 ||
741 ScalarType == ScalarTypeKind::FloatE5M2)
742 ScalarType = ScalarTypeKind::BFloat;
743 break;
744 case VectorTypeModifier::DoubleLMULVector:
745 LMUL.MulLog2LMUL(1);
746 Scale = LMUL.getScale(ElementBitwidth);
747 break;
748 case VectorTypeModifier::Widening4XVector:
749 ElementBitwidth *= 4;
750 LMUL.MulLog2LMUL(2);
751 Scale = LMUL.getScale(ElementBitwidth);
752 if (ScalarType == ScalarTypeKind::FloatE4M3 ||
753 ScalarType == ScalarTypeKind::FloatE5M2)
754 ScalarType = ScalarTypeKind::Float;
755 break;
756 case VectorTypeModifier::Widening8XVector:
757 ElementBitwidth *= 8;
758 LMUL.MulLog2LMUL(3);
759 Scale = LMUL.getScale(ElementBitwidth);
760 break;
761 case VectorTypeModifier::MaskVector:
762 ScalarType = ScalarTypeKind::Boolean;
763 Scale = LMUL.getScale(ElementBitwidth);
764 ElementBitwidth = 1;
765 break;
766 case VectorTypeModifier::Log2EEW3:
767 applyLog2EEW(3);
768 break;
769 case VectorTypeModifier::Log2EEW4:
770 applyLog2EEW(4);
771 break;
772 case VectorTypeModifier::Log2EEW5:
773 applyLog2EEW(5);
774 break;
775 case VectorTypeModifier::Log2EEW6:
776 applyLog2EEW(6);
777 break;
778 case VectorTypeModifier::FixedSEW8:
779 applyFixedSEW(8);
780 break;
781 case VectorTypeModifier::FixedSEW16:
782 applyFixedSEW(16);
783 break;
784 case VectorTypeModifier::FixedSEW32:
785 applyFixedSEW(32);
786 break;
787 case VectorTypeModifier::FixedSEW64:
788 applyFixedSEW(64);
789 break;
790 case VectorTypeModifier::LFixedLog2LMULN3:
791 applyFixedLog2LMUL(-3, FixedLMULType::LargerThan);
792 break;
793 case VectorTypeModifier::LFixedLog2LMULN2:
794 applyFixedLog2LMUL(-2, FixedLMULType::LargerThan);
795 break;
796 case VectorTypeModifier::LFixedLog2LMULN1:
797 applyFixedLog2LMUL(-1, FixedLMULType::LargerThan);
798 break;
799 case VectorTypeModifier::LFixedLog2LMUL0:
800 applyFixedLog2LMUL(0, FixedLMULType::LargerThan);
801 break;
802 case VectorTypeModifier::LFixedLog2LMUL1:
803 applyFixedLog2LMUL(1, FixedLMULType::LargerThan);
804 break;
805 case VectorTypeModifier::LFixedLog2LMUL2:
806 applyFixedLog2LMUL(2, FixedLMULType::LargerThan);
807 break;
808 case VectorTypeModifier::LFixedLog2LMUL3:
809 applyFixedLog2LMUL(3, FixedLMULType::LargerThan);
810 break;
811 case VectorTypeModifier::SFixedLog2LMULN3:
812 applyFixedLog2LMUL(-3, FixedLMULType::SmallerThan);
813 break;
814 case VectorTypeModifier::SFixedLog2LMULN2:
815 applyFixedLog2LMUL(-2, FixedLMULType::SmallerThan);
816 break;
817 case VectorTypeModifier::SFixedLog2LMULN1:
818 applyFixedLog2LMUL(-1, FixedLMULType::SmallerThan);
819 break;
820 case VectorTypeModifier::SFixedLog2LMUL0:
821 applyFixedLog2LMUL(0, FixedLMULType::SmallerThan);
822 break;
823 case VectorTypeModifier::SFixedLog2LMUL1:
824 applyFixedLog2LMUL(1, FixedLMULType::SmallerThan);
825 break;
826 case VectorTypeModifier::SFixedLog2LMUL2:
827 applyFixedLog2LMUL(2, FixedLMULType::SmallerThan);
828 break;
829 case VectorTypeModifier::SFixedLog2LMUL3:
830 applyFixedLog2LMUL(3, FixedLMULType::SmallerThan);
831 break;
832 case VectorTypeModifier::SEFixedLog2LMULN3:
833 applyFixedLog2LMUL(-3, FixedLMULType::SmallerOrEqual);
834 break;
835 case VectorTypeModifier::SEFixedLog2LMULN2:
836 applyFixedLog2LMUL(-2, FixedLMULType::SmallerOrEqual);
837 break;
838 case VectorTypeModifier::SEFixedLog2LMULN1:
839 applyFixedLog2LMUL(-1, FixedLMULType::SmallerOrEqual);
840 break;
841 case VectorTypeModifier::SEFixedLog2LMUL0:
842 applyFixedLog2LMUL(0, FixedLMULType::SmallerOrEqual);
843 break;
844 case VectorTypeModifier::SEFixedLog2LMUL1:
845 applyFixedLog2LMUL(1, FixedLMULType::SmallerOrEqual);
846 break;
847 case VectorTypeModifier::SEFixedLog2LMUL2:
848 applyFixedLog2LMUL(2, FixedLMULType::SmallerOrEqual);
849 break;
850 case VectorTypeModifier::SEFixedLog2LMUL3:
851 applyFixedLog2LMUL(3, FixedLMULType::SmallerOrEqual);
852 break;
853 case VectorTypeModifier::Tuple2:
854 case VectorTypeModifier::Tuple3:
855 case VectorTypeModifier::Tuple4:
856 case VectorTypeModifier::Tuple5:
857 case VectorTypeModifier::Tuple6:
858 case VectorTypeModifier::Tuple7:
859 case VectorTypeModifier::Tuple8: {
860 IsTuple = true;
861 NF = 2 + static_cast<uint8_t>(Transformer.VTM) -
862 static_cast<uint8_t>(VectorTypeModifier::Tuple2);
863 break;
864 }
865 case VectorTypeModifier::NoModifier:
866 break;
867 }
868
869 // Early return if the current type modifier is already invalid.
870 if (ScalarType == Invalid)
871 return;
872
873 for (unsigned TypeModifierMaskShift = 0;
874 TypeModifierMaskShift <= static_cast<unsigned>(TypeModifier::MaxOffset);
875 ++TypeModifierMaskShift) {
876 unsigned TypeModifierMask = 1 << TypeModifierMaskShift;
877 if ((static_cast<unsigned>(Transformer.TM) & TypeModifierMask) !=
878 TypeModifierMask)
879 continue;
880 switch (static_cast<TypeModifier>(TypeModifierMask)) {
881 case TypeModifier::Pointer:
882 IsPointer = true;
883 break;
884 case TypeModifier::Const:
885 IsConstant = true;
886 break;
887 case TypeModifier::Immediate:
888 IsImmediate = true;
889 IsConstant = true;
890 break;
891 case TypeModifier::UnsignedInteger:
892 ScalarType = ScalarTypeKind::UnsignedInteger;
893 break;
894 case TypeModifier::SignedInteger:
895 ScalarType = ScalarTypeKind::SignedInteger;
896 break;
897 case TypeModifier::Float:
898 ScalarType = ScalarTypeKind::Float;
899 break;
900 case TypeModifier::BFloat:
901 ScalarType = ScalarTypeKind::BFloat;
902 break;
903 case TypeModifier::LMUL1:
904 LMUL = LMULType(0);
905 // Update ElementBitwidth need to update Scale too.
906 Scale = LMUL.getScale(ElementBitwidth);
907 break;
908 default:
909 llvm_unreachable("Unknown type modifier mask!");
910 }
911 }
912}
913
914void RVVType::applyLog2EEW(unsigned Log2EEW) {
915 // update new elmul = (eew/sew) * lmul
916 LMUL.MulLog2LMUL(Log2EEW - Log2_32(ElementBitwidth));
917 // update new eew
918 ElementBitwidth = 1 << Log2EEW;
919 ScalarType = ScalarTypeKind::SignedInteger;
920 Scale = LMUL.getScale(ElementBitwidth);
921}
922
923void RVVType::applyFixedSEW(unsigned NewSEW) {
924 // Set invalid type if src and dst SEW are same.
925 if (ElementBitwidth == NewSEW) {
926 ScalarType = ScalarTypeKind::Invalid;
927 return;
928 }
929 // Update new SEW
930 ElementBitwidth = NewSEW;
931 Scale = LMUL.getScale(ElementBitwidth);
932}
933
934void RVVType::applyFixedLog2LMUL(int Log2LMUL, enum FixedLMULType Type) {
935 switch (Type) {
936 case FixedLMULType::LargerThan:
937 if (Log2LMUL <= LMUL.Log2LMUL) {
938 ScalarType = ScalarTypeKind::Invalid;
939 return;
940 }
941 break;
942 case FixedLMULType::SmallerThan:
943 if (Log2LMUL >= LMUL.Log2LMUL) {
944 ScalarType = ScalarTypeKind::Invalid;
945 return;
946 }
947 break;
948 case FixedLMULType::SmallerOrEqual:
949 if (Log2LMUL > LMUL.Log2LMUL) {
950 ScalarType = ScalarTypeKind::Invalid;
951 return;
952 }
953 break;
954 }
955
956 // Update new LMUL
957 LMUL = LMULType(Log2LMUL);
958 Scale = LMUL.getScale(ElementBitwidth);
959}
960
961std::optional<RVVTypes>
962RVVTypeCache::computeTypes(BasicType BT, int Log2LMUL, unsigned NF,
963 ArrayRef<PrototypeDescriptor> Prototype) {
964 RVVTypes Types;
965 for (const PrototypeDescriptor &Proto : Prototype) {
966 auto T = computeType(BT, Log2LMUL, Proto);
967 if (!T)
968 return std::nullopt;
969 // Record legal type index
970 Types.push_back(*T);
971 }
972 return Types;
973}
974
975// Compute the hash value of RVVType, used for cache the result of computeType.
976static uint64_t computeRVVTypeHashValue(BasicType BT, int Log2LMUL,
977 PrototypeDescriptor Proto) {
978 // Layout of hash value:
979 // 0 8 24 32 40 48
980 // | Log2LMUL + 3 | BT | Proto.PT | Proto.TM | Proto.VTM |
981 assert(Log2LMUL >= -3 && Log2LMUL <= 3);
982 return (Log2LMUL + 3) | (static_cast<uint64_t>(BT) & 0xffff) << 8 |
983 (static_cast<uint64_t>(Proto.PT) << 24) |
984 (static_cast<uint64_t>(Proto.TM) << 32) |
985 (static_cast<uint64_t>(Proto.VTM) << 40);
986}
987
988std::optional<RVVTypePtr> RVVTypeCache::computeType(BasicType BT, int Log2LMUL,
989 PrototypeDescriptor Proto) {
990 uint64_t Idx = computeRVVTypeHashValue(BT, Log2LMUL, Proto);
991 // Search first
992 auto It = LegalTypes.find(Idx);
993 if (It != LegalTypes.end())
994 return &(It->second);
995
996 if (IllegalTypes.count(Idx))
997 return std::nullopt;
998
999 // Compute type and record the result.
1000 RVVType T(BT, Log2LMUL, Proto);
1001 if (T.isValid()) {
1002 // Record legal type index and value.
1003 std::pair<std::unordered_map<uint64_t, RVVType>::iterator, bool>
1004 InsertResult = LegalTypes.insert({Idx, T});
1005 return &(InsertResult.first->second);
1006 }
1007 // Record illegal type index.
1008 IllegalTypes.insert(Idx);
1009 return std::nullopt;
1010}
1011
1012//===----------------------------------------------------------------------===//
1013// RVVIntrinsic implementation
1014//===----------------------------------------------------------------------===//
1015RVVIntrinsic::RVVIntrinsic(StringRef NewName, StringRef Suffix,
1016 StringRef NewOverloadedName,
1017 StringRef OverloadedSuffix, StringRef IRName,
1018 bool IsMasked, bool HasMaskedOffOperand, bool HasVL,
1019 PolicyScheme Scheme, bool SupportOverloading,
1020 bool HasBuiltinAlias, StringRef ManualCodegen,
1021 const RVVTypes &OutInTypes,
1022 const std::vector<int64_t> &NewIntrinsicTypes,
1023 unsigned NF, Policy NewPolicyAttrs,
1024 bool HasFRMRoundModeOp, unsigned TWiden, bool AltFmt)
1025 : IRName(IRName), IsMasked(IsMasked),
1026 HasMaskedOffOperand(HasMaskedOffOperand), HasVL(HasVL), Scheme(Scheme),
1027 SupportOverloading(SupportOverloading), HasBuiltinAlias(HasBuiltinAlias),
1028 ManualCodegen(ManualCodegen.str()), NF(NF), PolicyAttrs(NewPolicyAttrs),
1029 TWiden(TWiden) {
1030
1031 // Init BuiltinName, Name and OverloadedName
1032 BuiltinName = NewName.str();
1033 Name = BuiltinName;
1034 if (NewOverloadedName.empty())
1035 OverloadedName = NewName.split("_").first.str();
1036 else
1037 OverloadedName = NewOverloadedName.str();
1038 if (!Suffix.empty())
1039 Name += "_" + Suffix.str();
1040 if (!OverloadedSuffix.empty())
1041 OverloadedName += "_" + OverloadedSuffix.str();
1042
1043 updateNamesAndPolicy(IsMasked, hasPolicy(), Name, BuiltinName, OverloadedName,
1044 PolicyAttrs, HasFRMRoundModeOp, AltFmt);
1045
1046 // Init OutputType and InputTypes
1047 OutputType = OutInTypes[0];
1048 InputTypes.assign(OutInTypes.begin() + 1, OutInTypes.end());
1049
1050 // IntrinsicTypes is unmasked TA version index. Need to update it
1051 // if there is merge operand (It is always in first operand).
1052 IntrinsicTypes = NewIntrinsicTypes;
1053 if ((IsMasked && hasMaskedOffOperand()) ||
1054 (!IsMasked && hasPassthruOperand())) {
1055 for (auto &I : IntrinsicTypes) {
1056 if (I >= 0)
1057 I += 1;
1058 }
1059 }
1060}
1061
1062std::string RVVIntrinsic::getBuiltinTypeStr() const {
1063 std::string S;
1064 S += OutputType->getBuiltinStr();
1065 for (const auto &T : InputTypes) {
1066 S += T->getBuiltinStr();
1067 }
1068 return S;
1069}
1070
1071std::string RVVIntrinsic::getSuffixStr(
1072 RVVTypeCache &TypeCache, BasicType Type, int Log2LMUL,
1073 llvm::ArrayRef<PrototypeDescriptor> PrototypeDescriptors) {
1074 SmallVector<std::string> SuffixStrs;
1075 for (auto PD : PrototypeDescriptors) {
1076 auto T = TypeCache.computeType(Type, Log2LMUL, PD);
1077 SuffixStrs.push_back((*T)->getShortStr());
1078 }
1079 return join(SuffixStrs, "_");
1080}
1081
1082llvm::SmallVector<PrototypeDescriptor> RVVIntrinsic::computeBuiltinTypes(
1083 llvm::ArrayRef<PrototypeDescriptor> Prototype, bool IsMasked,
1084 bool HasMaskedOffOperand, bool HasVL, unsigned NF,
1085 PolicyScheme DefaultScheme, Policy PolicyAttrs, bool IsTuple) {
1086 SmallVector<PrototypeDescriptor> NewPrototype(Prototype);
1087 bool HasPassthruOp = DefaultScheme == PolicyScheme::HasPassthruOperand;
1088 if (IsMasked) {
1089 // If HasMaskedOffOperand, insert result type as first input operand if
1090 // need.
1091 if (HasMaskedOffOperand && !PolicyAttrs.isTAMAPolicy()) {
1092 if (NF == 1) {
1093 NewPrototype.insert(NewPrototype.begin() + 1, NewPrototype[0]);
1094 } else if (NF > 1) {
1095 if (IsTuple) {
1096 PrototypeDescriptor BasePtrOperand = Prototype[1];
1097 PrototypeDescriptor MaskoffType =
1098 PrototypeDescriptor(BaseTypeModifier::Vector, getTupleVTM(NF),
1099 BasePtrOperand.TM & ~TypeModifier::Pointer);
1100 NewPrototype.insert(NewPrototype.begin() + 1, MaskoffType);
1101 } else {
1102 // Convert
1103 // (void, op0 address, op1 address, ...)
1104 // to
1105 // (void, op0 address, op1 address, ..., maskedoff0, maskedoff1, ...)
1106 PrototypeDescriptor MaskoffType = NewPrototype[1];
1107 MaskoffType.TM &= ~TypeModifier::Pointer;
1108 NewPrototype.insert(NewPrototype.begin() + NF + 1, NF, MaskoffType);
1109 }
1110 }
1111 }
1112 if (HasMaskedOffOperand && NF > 1) {
1113 // Convert
1114 // (void, op0 address, op1 address, ..., maskedoff0, maskedoff1, ...)
1115 // to
1116 // (void, op0 address, op1 address, ..., mask, maskedoff0, maskedoff1,
1117 // ...)
1118 if (IsTuple)
1119 NewPrototype.insert(NewPrototype.begin() + 1,
1120 PrototypeDescriptor::Mask);
1121 else
1122 NewPrototype.insert(NewPrototype.begin() + NF + 1,
1123 PrototypeDescriptor::Mask);
1124 } else {
1125 // If IsMasked, insert PrototypeDescriptor:Mask as first input operand.
1126 NewPrototype.insert(NewPrototype.begin() + 1, PrototypeDescriptor::Mask);
1127 }
1128 } else {
1129 if (NF == 1) {
1130 if (PolicyAttrs.isTUPolicy() && HasPassthruOp)
1131 NewPrototype.insert(NewPrototype.begin(), NewPrototype[0]);
1132 } else if (PolicyAttrs.isTUPolicy() && HasPassthruOp) {
1133 if (IsTuple) {
1134 PrototypeDescriptor BasePtrOperand = Prototype[0];
1135 PrototypeDescriptor MaskoffType =
1136 PrototypeDescriptor(BaseTypeModifier::Vector, getTupleVTM(NF),
1137 BasePtrOperand.TM & ~TypeModifier::Pointer);
1138 NewPrototype.insert(NewPrototype.begin(), MaskoffType);
1139 } else {
1140 // NF > 1 cases for segment load operations.
1141 // Convert
1142 // (void, op0 address, op1 address, ...)
1143 // to
1144 // (void, op0 address, op1 address, maskedoff0, maskedoff1, ...)
1145 PrototypeDescriptor MaskoffType = Prototype[1];
1146 MaskoffType.TM &= ~TypeModifier::Pointer;
1147 NewPrototype.insert(NewPrototype.begin() + NF + 1, NF, MaskoffType);
1148 }
1149 }
1150 }
1151
1152 // If HasVL, append PrototypeDescriptor:VL to last operand
1153 if (HasVL)
1154 NewPrototype.push_back(PrototypeDescriptor::VL);
1155
1156 return NewPrototype;
1157}
1158
1162
1163llvm::SmallVector<Policy>
1164RVVIntrinsic::getSupportedMaskedPolicies(bool HasTailPolicy,
1165 bool HasMaskPolicy) {
1166 if (HasTailPolicy && HasMaskPolicy)
1167 return {Policy(Policy::PolicyType::Undisturbed,
1168 Policy::PolicyType::Agnostic), // TUM
1169 Policy(Policy::PolicyType::Undisturbed,
1170 Policy::PolicyType::Undisturbed), // TUMU
1171 Policy(Policy::PolicyType::Agnostic,
1172 Policy::PolicyType::Undisturbed)}; // MU
1173 if (HasTailPolicy && !HasMaskPolicy)
1174 return {Policy(Policy::PolicyType::Undisturbed,
1175 Policy::PolicyType::Agnostic)}; // TU
1176 if (!HasTailPolicy && HasMaskPolicy)
1177 return {Policy(Policy::PolicyType::Agnostic,
1178 Policy::PolicyType::Undisturbed)}; // MU
1179 llvm_unreachable("An RVV instruction should not be without both tail policy "
1180 "and mask policy");
1181}
1182
1183void RVVIntrinsic::updateNamesAndPolicy(bool IsMasked, bool HasPolicy,
1184 std::string &Name,
1185 std::string &BuiltinName,
1186 std::string &OverloadedName,
1187 Policy &PolicyAttrs,
1188 bool HasFRMRoundModeOp, bool AltFmt) {
1189
1190 auto appendPolicySuffix = [&](const std::string &suffix) {
1191 Name += suffix;
1192 BuiltinName += suffix;
1193 OverloadedName += suffix;
1194 };
1195
1196 if (HasFRMRoundModeOp) {
1197 Name += "_rm";
1198 BuiltinName += "_rm";
1199 }
1200
1201 if (AltFmt)
1202 BuiltinName += "_alt";
1203
1204 if (IsMasked) {
1205 if (PolicyAttrs.isTUMUPolicy())
1206 appendPolicySuffix("_tumu");
1207 else if (PolicyAttrs.isTUMAPolicy())
1208 appendPolicySuffix("_tum");
1209 else if (PolicyAttrs.isTAMUPolicy())
1210 appendPolicySuffix("_mu");
1211 else if (PolicyAttrs.isTAMAPolicy()) {
1212 Name += "_m";
1213 BuiltinName += "_m";
1214 } else
1215 llvm_unreachable("Unhandled policy condition");
1216 } else {
1217 if (PolicyAttrs.isTUPolicy())
1218 appendPolicySuffix("_tu");
1219 else if (PolicyAttrs.isTAPolicy()) // no suffix needed
1220 return;
1221 else
1222 llvm_unreachable("Unhandled policy condition");
1223 }
1224}
1225
1226SmallVector<PrototypeDescriptor> parsePrototypes(StringRef Prototypes) {
1227 SmallVector<PrototypeDescriptor> PrototypeDescriptors;
1228 const StringRef Primaries("evwdqom0ztulf");
1229 while (!Prototypes.empty()) {
1230 size_t Idx = 0;
1231 // Skip over complex prototype because it could contain primitive type
1232 // character.
1233 if (Prototypes[0] == '(')
1234 Idx = Prototypes.find_first_of(')');
1235 Idx = Prototypes.find_first_of(Primaries, Idx);
1236 assert(Idx != StringRef::npos);
1237 auto PD = PrototypeDescriptor::parsePrototypeDescriptor(
1238 Prototypes.slice(0, Idx + 1));
1239 if (!PD)
1240 llvm_unreachable("Error during parsing prototype.");
1241 PrototypeDescriptors.push_back(*PD);
1242 Prototypes = Prototypes.drop_front(Idx + 1);
1243 }
1244 return PrototypeDescriptors;
1245}
1246
1247#define STRINGIFY(NAME) \
1248 case NAME: \
1249 OS << #NAME; \
1250 break;
1251
1252llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, enum PolicyScheme PS) {
1253 switch (PS) {
1254 STRINGIFY(SchemeNone)
1255 STRINGIFY(HasPassthruOperand)
1256 STRINGIFY(HasPolicyOperand)
1257 }
1258 return OS;
1259}
1260
1261#undef STRINGIFY
1262
1263raw_ostream &operator<<(raw_ostream &OS, const RVVIntrinsicRecord &Record) {
1264 OS << "{";
1265 OS << "/*Name=*/\"" << Record.Name << "\", ";
1266 if (Record.OverloadedName == nullptr ||
1267 StringRef(Record.OverloadedName).empty())
1268 OS << "/*OverloadedName=*/nullptr, ";
1269 else
1270 OS << "/*OverloadedName=*/\"" << Record.OverloadedName << "\", ";
1271 OS << "/*RequiredExtensions=*/\"" << Record.RequiredExtensions << "\", ";
1272 OS << "/*PrototypeIndex=*/" << Record.PrototypeIndex << ", ";
1273 OS << "/*SuffixIndex=*/" << Record.SuffixIndex << ", ";
1274 OS << "/*OverloadedSuffixIndex=*/" << Record.OverloadedSuffixIndex << ", ";
1275 OS << "/*PrototypeLength=*/" << (int)Record.PrototypeLength << ", ";
1276 OS << "/*SuffixLength=*/" << (int)Record.SuffixLength << ", ";
1277 OS << "/*OverloadedSuffixSize=*/" << (int)Record.OverloadedSuffixSize << ", ";
1278 OS << "/*TypeRangeMask=*/" << (int)Record.TypeRangeMask << ", ";
1279 OS << "/*Log2LMULMask=*/" << (int)Record.Log2LMULMask << ", ";
1280 OS << "/*NF=*/" << (int)Record.NF << ", ";
1281 OS << "/*HasMasked=*/" << (int)Record.HasMasked << ", ";
1282 OS << "/*HasVL=*/" << (int)Record.HasVL << ", ";
1283 OS << "/*HasMaskedOffOperand=*/" << (int)Record.HasMaskedOffOperand << ", ";
1284 OS << "/*HasTailPolicy=*/" << (int)Record.HasTailPolicy << ", ";
1285 OS << "/*HasMaskPolicy=*/" << (int)Record.HasMaskPolicy << ", ";
1286 OS << "/*HasFRMRoundModeOp=*/" << (int)Record.HasFRMRoundModeOp << ", ";
1287 OS << "/*AltFmt=*/" << (int)Record.AltFmt << ",";
1288 OS << "/*IsTuple=*/" << (int)Record.IsTuple << ", ";
1289 OS << "/*UnMaskedPolicyScheme=*/" << (PolicyScheme)Record.UnMaskedPolicyScheme
1290 << ", ";
1291 OS << "/*MaskedPolicyScheme=*/" << (PolicyScheme)Record.MaskedPolicyScheme
1292 << ", ";
1293 OS << "},\n";
1294 return OS;
1295}
1296
1297} // end namespace RISCV
1298} // end namespace clang
V
#define V(N, I)
Definition ASTContext.h:3719
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:1247
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:9612
clang::ComplexType
Complex values, per C99 6.2.5p11.
Definition TypeBase.h:3330
clang::RISCV::RVVIntrinsic::getSupportedMaskedPolicies
static llvm::SmallVector< Policy > getSupportedMaskedPolicies(bool HasTailPolicy, bool HasMaskPolicy)
Definition RISCVVIntrinsicUtils.cpp:1164
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:1082
clang::RISCV::RVVIntrinsic::getSuffixStr
static std::string getSuffixStr(RVVTypeCache &TypeCache, BasicType Type, int Log2LMUL, llvm::ArrayRef< PrototypeDescriptor > PrototypeDescriptors)
Definition RISCVVIntrinsicUtils.cpp:1071
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:1015
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:1183
clang::RISCV::RVVIntrinsic::getSupportedUnMaskedPolicies
static llvm::SmallVector< Policy > getSupportedUnMaskedPolicies()
Definition RISCVVIntrinsicUtils.cpp:1159
clang::RISCV::RVVTypeCache::computeType
std::optional< RVVTypePtr > computeType(BasicType BT, int Log2LMUL, PrototypeDescriptor Proto)
Definition RISCVVIntrinsicUtils.cpp:988
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:962
clang::Type
The base class of the type hierarchy.
Definition TypeBase.h:1871
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:1252
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:976
clang::RISCV::getTupleVTM
static VectorTypeModifier getTupleVTM(unsigned NF)
Definition RISCVVIntrinsicUtils.cpp:374
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:429
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