Debian Codegraph @

visa/iga/IGALibrary/Frontend/IRToString.cpp

raw
1 /*========================== begin_copyright_notice ============================
2
3 Copyright (C) 2020-2021 Intel Corporation
4
5 SPDX-License-Identifier: MIT
6
7 ============================= end_copyright_notice ===========================*/
8
9 #include <ostream>
10 #include <sstream>
11 #include <string>
12
13 #include "../strings.hpp"
14 #include "IRToString.hpp"
15
16 using namespace iga;
17
18 std::string iga::ToSymbol(Platform x) {
19 switch (x) {
20 MAKE_CASE(Platform, INVALID);
21 MAKE_CASE(Platform, GEN6);
22 MAKE_CASE(Platform, GEN7);
23 MAKE_CASE(Platform, GEN7P5);
24 MAKE_CASE(Platform, GEN8);
25 MAKE_CASE(Platform, GEN8LP);
26 MAKE_CASE(Platform, GEN9);
27 MAKE_CASE(Platform, GEN9LP);
28 MAKE_CASE(Platform, GEN9P5);
29 MAKE_CASE(Platform, GEN10);
30 MAKE_CASE(Platform, GEN11);
31 MAKE_CASE(Platform, XE);
32 MAKE_CASE(Platform, XE_HP);
33 MAKE_CASE(Platform, XE_HPG);
34 MAKE_CASE(Platform, XE_HPC);
35 MAKE_CASE(Platform, XE2);
36 MAKE_CASE(Platform, XE3);
37 MAKE_CASE(Platform, XE3P_XPC);
38 MAKE_CASE(Platform, FUTURE);
39 MAKE_DEFAULT_CASE(Platform);
40 }
41 }
42
43 std::string iga::ToSyntax(MathFC sf) {
44 switch (sf) {
45 case MathFC::COS:
46 return "cos";
47 case MathFC::EXP:
48 return "exp";
49 case MathFC::FDIV:
50 return "fdiv";
51 case MathFC::IDIV:
52 return "idiv";
53 case MathFC::IQOT:
54 return "iqot";
55 case MathFC::IREM:
56 return "irem";
57 case MathFC::INV:
58 return "inv";
59 case MathFC::INVM:
60 return "invm";
61 case MathFC::LOG:
62 return "log";
63 case MathFC::POW:
64 return "pow";
65 case MathFC::RSQT:
66 return "rsqt";
67 case MathFC::RSQTM:
68 return "rsqtm";
69 case MathFC::SIN:
70 return "sin";
71 case MathFC::SQT:
72 return "sqt";
73 case MathFC::TANH:
74 return "tanh";
75 case MathFC::SIGM:
76 return "sigm";
77 default:
78 return fmtHex(static_cast<uint32_t>(sf)) + "?";
79 }
80 }
81 template <> MathFC iga::FromSyntax<MathFC>(const std::string& syn) {
82 for (auto sf : ALL_MathFCs) {
83 if (syn == ToSyntax(sf))
84 return sf;
85 }
86 return MathFC::INVALID;
87 }
88
89 std::string iga::ToSyntax(SFID sfid) {
90 switch (sfid) {
91 case SFID::CRE:
92 return "cre";
93 case SFID::DC0:
94 return "dc0";
95 case SFID::DC1:
96 return "dc1";
97 case SFID::DC2:
98 return "dc2";
99 case SFID::DCRO:
100 return "dcro";
101 case SFID::GTWY:
102 return "gtwy";
103 case SFID::NULL_:
104 return "null";
105 case SFID::RC:
106 return "rc";
107 case SFID::PIXI:
108 return "pixi";
109 case SFID::SMPL:
110 return "smpl";
111 case SFID::TS:
112 return "ts";
113 case SFID::URB:
114 return "urb";
115 case SFID::VME:
116 return "vme";
117 case SFID::BTD:
118 return "btd";
119 case SFID::RTA:
120 return "rta";
121 case SFID::SLM:
122 return "slm";
123 case SFID::TGM:
124 return "tgm";
125 case SFID::UGM:
126 return "ugm";
127 case SFID::UGML:
128 return "ugml";
129 default:
130 std::stringstream ss;
131 ss << "SFID::0x" << std::hex << static_cast<int>(sfid) << "?";
132 return ss.str();
133 }
134 }
135 template <> SFID iga::FromSyntax<SFID>(const std::string& syn) {
136 for (SFID sf : ALL_SFIDS) {
137 if (syn == ToSyntax(sf))
138 return sf;
139 }
140 return SFID::INVALID;
141 }
142
143
144 std::string iga::ToSyntax(SyncFC sfc) {
145 switch (sfc) {
146 case SyncFC::NOP:
147 return "nop";
148 case SyncFC::ALLRD:
149 return "allrd";
150 case SyncFC::ALLWR:
151 return "allwr";
152 case SyncFC::FLUSH:
153 return "flush";
154 case SyncFC::FENCE:
155 return "fence";
156 case SyncFC::BAR:
157 return "bar";
158 case SyncFC::HOST:
159 return "host";
160 default:
161 return fmtHex(static_cast<uint32_t>(sfc)) + "?";
162 }
163 }
164 template <> SyncFC iga::FromSyntax<SyncFC>(const std::string& syn) {
165 for (auto sf : ALL_SyncFCs) {
166 if (syn == ToSyntax(sf))
167 return sf;
168 }
169 return SyncFC::INVALID;
170 }
171
172 std::string iga::ToSyntax(DpasFC sfc) {
173 switch (sfc) {
174 case DpasFC::F_1X1:
175 return "1x1";
176 case DpasFC::F_1X2:
177 return "1x2";
178 case DpasFC::F_1X3:
179 return "1x3";
180 case DpasFC::F_1X4:
181 return "1x4";
182 case DpasFC::F_1X5:
183 return "1x5";
184 case DpasFC::F_1X6:
185 return "1x6";
186 case DpasFC::F_1X7:
187 return "1x7";
188 case DpasFC::F_1X8:
189 return "1x8";
190 //
191 case DpasFC::F_2X1:
192 return "2x1";
193 case DpasFC::F_2X2:
194 return "2x2";
195 case DpasFC::F_2X3:
196 return "2x3";
197 case DpasFC::F_2X4:
198 return "2x4";
199 case DpasFC::F_2X5:
200 return "2x5";
201 case DpasFC::F_2X6:
202 return "2x6";
203 case DpasFC::F_2X7:
204 return "2x7";
205 case DpasFC::F_2X8:
206 return "2x8";
207 //
208 case DpasFC::F_4X1:
209 return "4x1";
210 case DpasFC::F_4X2:
211 return "4x2";
212 case DpasFC::F_4X3:
213 return "4x3";
214 case DpasFC::F_4X4:
215 return "4x4";
216 case DpasFC::F_4X5:
217 return "4x5";
218 case DpasFC::F_4X6:
219 return "4x6";
220 case DpasFC::F_4X7:
221 return "4x7";
222 case DpasFC::F_4X8:
223 return "4x8";
224 //
225 case DpasFC::F_8X1:
226 return "8x1";
227 case DpasFC::F_8X2:
228 return "8x2";
229 case DpasFC::F_8X3:
230 return "8x3";
231 case DpasFC::F_8X4:
232 return "8x4";
233 case DpasFC::F_8X5:
234 return "8x5";
235 case DpasFC::F_8X6:
236 return "8x6";
237 case DpasFC::F_8X7:
238 return "8x7";
239 case DpasFC::F_8X8:
240 return "8x8";
241 //
242 default:
243 return fmtHex(static_cast<uint32_t>(sfc)) + "?";
244 }
245 }
246 template <> DpasFC iga::FromSyntax<DpasFC>(const std::string& syn) {
247 for (auto sf : ALL_DpasFCs) {
248 if (syn == ToSyntax(sf))
249 return sf;
250 }
251 return DpasFC::INVALID;
252 }
253 std::string iga::ToSyntax(ShuffleFC op) {
254 switch (op) {
255 case ShuffleFC::UP:
256 return "up";
257 case ShuffleFC::UPZ:
258 return "upz";
259 case ShuffleFC::DN:
260 return "dn";
261 case ShuffleFC::DNZ:
262 return "dnx";
263 case ShuffleFC::XOR:
264 return "xor";
265 case ShuffleFC::IDX:
266 return "idx";
267 case ShuffleFC::IDX4:
268 return "idx4";
269 default:
270 return fmtHex(static_cast<uint32_t>(op)) + "?";
271 }
272 }
273
274 template <> ShuffleFC iga::FromSyntax<ShuffleFC>(const std::string& symbol) {
275 for (auto op : ALL_ShuffleFC) {
276 if (symbol == ToSyntax(op)) {
277 return op;
278 }
279 }
280 return ShuffleFC::INVALID;
281 }
282
283 std::string iga::ToSyntax(LfsrFC op) {
284 switch (op) {
285 case LfsrFC::LFSR_b32:
286 return "b32";
287 case LfsrFC::LFSR_b16v2:
288 return "b16v2";
289 case LfsrFC::LFSR_b8v4:
290 return "b8v4";
291 default:
292 return fmtHex(static_cast<uint32_t>(op)) + "?";
293 }
294 }
295
296 template <> LfsrFC iga::FromSyntax<LfsrFC>(const std::string& str) {
297 for (auto op : ALL_LfsrFC) {
298 if (str == ToSyntax(op)) {
299 return op;
300 }
301 }
302 return LfsrFC::INVALID;
303 }
304
305 // dnscl src/dst type and mode strings
306 std::string iga::ToSyntax(ConvSrcDataType op) {
307 switch (op) {
308 case ConvSrcDataType::HF:
309 return "hf";
310 case ConvSrcDataType::BF:
311 return "bf";
312 default:
313 return fmtHex(static_cast<uint32_t>(op)) + "?";
314 }
315 }
316
317 template <> ConvSrcDataType iga::FromSyntax<ConvSrcDataType>(const std::string& str) {
318 for (auto op : ALL_ConvSrcDataType) {
319 if (str == ToSyntax(op)) {
320 return op;
321 }
322 }
323 return ConvSrcDataType::INVALID;
324 }
325
326 std::string iga::ToSyntax(ConvDstDataType op) {
327 switch (op) {
328 case ConvDstDataType::E2M1:
329 return "e2m1";
330 case ConvDstDataType::INT4:
331 return "int4";
332 default:
333 return fmtHex(static_cast<uint32_t>(op)) + "?";
334 }
335 }
336
337 template <> ConvDstDataType iga::FromSyntax<ConvDstDataType>(const std::string& str) {
338 for (auto op : ALL_ConvDstDataType) {
339 if (str == ToSyntax(op)) {
340 return op;
341 }
342 }
343 return ConvDstDataType::INVALID;
344 }
345
346 std::string iga::ToSyntax(DnsclMode op) {
347 switch (op) {
348 case DnsclMode::MODE0:
349 return "mode0";
350 case DnsclMode::MODE1:
351 return "mode1";
352 case DnsclMode::MODE2:
353 return "mode2";
354 case DnsclMode::MODE3:
355 return "mode3";
356 default:
357 return fmtHex(static_cast<uint32_t>(op)) + "?";
358 }
359 }
360
361 template <> DnsclMode iga::FromSyntax<DnsclMode>(const std::string& str) {
362 for (auto op : ALL_DnsclMode) {
363 if (str == ToSyntax(op)) {
364 return op;
365 }
366 }
367 return DnsclMode::INVALID;
368 }
369
370 std::string iga::ToSyntax(RoundingMode op) {
371 switch (op) {
372 case RoundingMode::SRAND:
373 return "srnd";
374 case RoundingMode::RNE:
375 return "rne";
376 default:
377 return fmtHex(static_cast<uint32_t>(op)) + "?";
378 }
379 }
380
381 template <> RoundingMode iga::FromSyntax<RoundingMode>(const std::string& str) {
382 for (auto op : ALL_RoundingMode) {
383 if (str == ToSyntax(op)) {
384 return op;
385 }
386 }
387 return RoundingMode::INVALID;
388 }
389
390 std::string iga::ToSyntax(DnsclFC dfc) {
391 // DnsclFC syntax:
392 // <ConvSrcDataType>to<ConvDstDataType>.<DnsclMode>.<RoundingMode>
393 return ToSyntax(dfc.convSrcTy) + "to" + ToSyntax(dfc.convDstTy) + "." +
394 ToSyntax(dfc.dnsclMode) + "." + ToSyntax(dfc.roundingMode);
395 }