1 //===- VTEmitter.cpp - Generate properties from ValueTypes.td -------------===//
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 "llvm/ADT/StringRef.h"
10 #include "llvm/Support/raw_ostream.h"
11 #include "llvm/TableGen/Record.h"
12 #include "llvm/TableGen/TableGenBackend.h"
13 #include <array>
14 #include <cassert>
15 #include <map>
16 using namespace llvm;
17
18 namespace {
19
20 class VTEmitter {
21 private:
22 RecordKeeper &Records;
23
24 public:
VTEmitter(RecordKeeper & R)25 VTEmitter(RecordKeeper &R) : Records(R) {}
26
27 void run(raw_ostream &OS);
28 };
29
30 } // End anonymous namespace.
31
VTtoGetLLVMTyString(raw_ostream & OS,const Record * VT)32 static void VTtoGetLLVMTyString(raw_ostream &OS, const Record *VT) {
33 bool IsVector = VT->getValueAsBit("isVector");
34 if (IsVector)
35 OS << (VT->getValueAsBit("isScalable") ? "Scalable" : "Fixed")
36 << "VectorType::get(";
37
38 auto OutputVT = IsVector ? VT->getValueAsDef("ElementType") : VT;
39 int64_t OutputVTSize = OutputVT->getValueAsInt("Size");
40
41 if (OutputVT->getValueAsBit("isFP")) {
42 StringRef FloatTy;
43 auto OutputVTName = OutputVT->getValueAsString("LLVMName");
44 switch (OutputVTSize) {
45 default:
46 llvm_unreachable("Unhandled case");
47 case 16:
48 FloatTy = (OutputVTName == "bf16") ? "BFloatTy" : "HalfTy";
49 break;
50 case 32:
51 FloatTy = "FloatTy";
52 break;
53 case 64:
54 FloatTy = "DoubleTy";
55 break;
56 case 80:
57 FloatTy = "X86_FP80Ty";
58 break;
59 case 128:
60 FloatTy = (OutputVTName == "ppcf128") ? "PPC_FP128Ty" : "FP128Ty";
61 break;
62 }
63 OS << "Type::get" << FloatTy << "(Context)";
64 } else if (OutputVT->getValueAsBit("isInteger")) {
65 // We only have Type::getInt1Ty, Int8, Int16, Int32, Int64, and Int128
66 if ((isPowerOf2_64(OutputVTSize) && OutputVTSize >= 8 &&
67 OutputVTSize <= 128) ||
68 OutputVTSize == 1)
69 OS << "Type::getInt" << OutputVTSize << "Ty(Context)";
70 else
71 OS << "Type::getIntNTy(Context, " << OutputVTSize << ")";
72 } else
73 llvm_unreachable("Unhandled case");
74
75 if (IsVector)
76 OS << ", " << VT->getValueAsInt("nElem") << ")";
77 }
78
run(raw_ostream & OS)79 void VTEmitter::run(raw_ostream &OS) {
80 emitSourceFileHeader("ValueTypes Source Fragment", OS, Records);
81
82 std::array<const Record *, 256> VTsByNumber = {};
83 auto ValueTypes = Records.getAllDerivedDefinitions("ValueType");
84 for (auto *VT : ValueTypes) {
85 auto Number = VT->getValueAsInt("Value");
86 assert(0 <= Number && Number < (int)VTsByNumber.size() &&
87 "ValueType should be uint8_t");
88 assert(!VTsByNumber[Number] && "Duplicate ValueType");
89 VTsByNumber[Number] = VT;
90 }
91
92 struct VTRange {
93 StringRef First;
94 StringRef Last;
95 bool Closed;
96 };
97
98 std::map<StringRef, VTRange> VTRanges;
99
100 auto UpdateVTRange = [&VTRanges](const char *Key, StringRef Name,
101 bool Valid) {
102 if (Valid) {
103 if (!VTRanges.count(Key))
104 VTRanges[Key].First = Name;
105 assert(!VTRanges[Key].Closed && "Gap detected!");
106 VTRanges[Key].Last = Name;
107 } else if (VTRanges.count(Key)) {
108 VTRanges[Key].Closed = true;
109 }
110 };
111
112 OS << "#ifdef GET_VT_ATTR // (Ty, n, sz, Any, Int, FP, Vec, Sc)\n";
113 for (const auto *VT : VTsByNumber) {
114 if (!VT)
115 continue;
116 auto Name = VT->getValueAsString("LLVMName");
117 auto Value = VT->getValueAsInt("Value");
118 bool IsInteger = VT->getValueAsBit("isInteger");
119 bool IsFP = VT->getValueAsBit("isFP");
120 bool IsVector = VT->getValueAsBit("isVector");
121 bool IsScalable = VT->getValueAsBit("isScalable");
122 bool IsNormalValueType = VT->getValueAsBit("isNormalValueType");
123 int64_t NElem = IsVector ? VT->getValueAsInt("nElem") : 0;
124 StringRef EltName = IsVector ? VT->getValueAsDef("ElementType")->getName()
125 : "INVALID_SIMPLE_VALUE_TYPE";
126
127 UpdateVTRange("INTEGER_FIXEDLEN_VECTOR_VALUETYPE", Name,
128 IsInteger && IsVector && !IsScalable);
129 UpdateVTRange("INTEGER_SCALABLE_VECTOR_VALUETYPE", Name,
130 IsInteger && IsScalable);
131 UpdateVTRange("FP_FIXEDLEN_VECTOR_VALUETYPE", Name,
132 IsFP && IsVector && !IsScalable);
133 UpdateVTRange("FP_SCALABLE_VECTOR_VALUETYPE", Name, IsFP && IsScalable);
134 UpdateVTRange("FIXEDLEN_VECTOR_VALUETYPE", Name, IsVector && !IsScalable);
135 UpdateVTRange("SCALABLE_VECTOR_VALUETYPE", Name, IsScalable);
136 UpdateVTRange("VECTOR_VALUETYPE", Name, IsVector);
137 UpdateVTRange("INTEGER_VALUETYPE", Name, IsInteger && !IsVector);
138 UpdateVTRange("FP_VALUETYPE", Name, IsFP && !IsVector);
139 UpdateVTRange("VALUETYPE", Name, IsNormalValueType);
140
141 // clang-format off
142 OS << " GET_VT_ATTR("
143 << Name << ", "
144 << Value << ", "
145 << VT->getValueAsInt("Size") << ", "
146 << VT->getValueAsBit("isOverloaded") << ", "
147 << (IsInteger ? Name[0] == 'i' ? 3 : 1 : 0) << ", "
148 << (IsFP ? Name[0] == 'f' ? 3 : 1 : 0) << ", "
149 << IsVector << ", "
150 << IsScalable << ", "
151 << NElem << ", "
152 << EltName << ")\n";
153 // clang-format on
154 }
155 OS << "#endif\n\n";
156
157 OS << "#ifdef GET_VT_RANGES\n";
158 for (const auto &KV : VTRanges) {
159 assert(KV.second.Closed);
160 OS << " FIRST_" << KV.first << " = " << KV.second.First << ",\n"
161 << " LAST_" << KV.first << " = " << KV.second.Last << ",\n";
162 }
163 OS << "#endif\n\n";
164
165 OS << "#ifdef GET_VT_VECATTR // (Ty, Sc, nElem, ElTy)\n";
166 for (const auto *VT : VTsByNumber) {
167 if (!VT || !VT->getValueAsBit("isVector"))
168 continue;
169 const auto *ElTy = VT->getValueAsDef("ElementType");
170 assert(ElTy);
171 // clang-format off
172 OS << " GET_VT_VECATTR("
173 << VT->getValueAsString("LLVMName") << ", "
174 << VT->getValueAsBit("isScalable") << ", "
175 << VT->getValueAsInt("nElem") << ", "
176 << ElTy->getName() << ")\n";
177 // clang-format on
178 }
179 OS << "#endif\n\n";
180
181 OS << "#ifdef GET_VT_EVT\n";
182 for (const auto *VT : VTsByNumber) {
183 if (!VT)
184 continue;
185 bool IsInteger = VT->getValueAsBit("isInteger");
186 bool IsVector = VT->getValueAsBit("isVector");
187 bool IsFP = VT->getValueAsBit("isFP");
188
189 if (!IsInteger && !IsVector && !IsFP)
190 continue;
191
192 OS << " GET_VT_EVT(" << VT->getValueAsString("LLVMName") << ", ";
193 VTtoGetLLVMTyString(OS, VT);
194 OS << ")\n";
195 }
196 OS << "#endif\n\n";
197 }
198
199 static TableGen::Emitter::OptClass<VTEmitter> X("gen-vt", "Generate ValueType");
200