Debian Codegraph @

visa/iga/IGALibrary/Frontend/IRToString.hpp

raw
1 /*========================== begin_copyright_notice ============================
2
3 Copyright (C) 2017-2021 Intel Corporation
4
5 SPDX-License-Identifier: MIT
6
7 ============================= end_copyright_notice ===========================*/
8
9 #ifndef _IGA_FRONTEND_IRTOSTRING_HPP
10 #define _IGA_FRONTEND_IRTOSTRING_HPP
11
12 #include "../IR/Types.hpp"
13 #include "../api/iga_bxml_enums.hpp"
14 #include "../strings.hpp"
15
16 #include <ostream>
17 #include <sstream>
18 #include <string>
19
20 namespace iga {
21
22 static inline std::string MakeErrorString(const char *pfx, int t) {
23 std::stringstream ss;
24 ss << pfx << "::" << fmtHex((uint32_t)t, 8) << "?";
25 return ss.str();
26 }
27
28 #define MAKE_CASE(C, S) \
29 case C::S: \
30 return #C "::" #S
31 #define MAKE_DEFAULT_CASE(C) \
32 default: \
33 return MakeErrorString(#C, (int)x)
34
35 // e.g. "Platform::GEN11"
36 std::string ToSymbol(Platform x);
37
38 static inline std::string ToSymbol(PredCtrl x) {
39 switch (x) {
40 MAKE_CASE(PredCtrl, NONE);
41 MAKE_CASE(PredCtrl, SEQ);
42 MAKE_CASE(PredCtrl, ANYV);
43 MAKE_CASE(PredCtrl, ALLV);
44 MAKE_CASE(PredCtrl, ANY2H);
45 MAKE_CASE(PredCtrl, ALL2H);
46 MAKE_CASE(PredCtrl, ANY4H);
47 MAKE_CASE(PredCtrl, ALL4H);
48 MAKE_CASE(PredCtrl, ANY8H);
49 MAKE_CASE(PredCtrl, ALL8H);
50 MAKE_CASE(PredCtrl, ANY16H);
51 MAKE_CASE(PredCtrl, ALL16H);
52 MAKE_CASE(PredCtrl, ANY32H);
53 MAKE_CASE(PredCtrl, ALL32H);
54 MAKE_CASE(PredCtrl, ANY);
55 MAKE_CASE(PredCtrl, ALL);
56 MAKE_DEFAULT_CASE(PredCtrl);
57 }
58 }
59
60 static inline std::string ToSymbol(Op op) {
61 std::stringstream ss;
62 ss << "Op::0x" << std::hex << std::uppercase << (int)op;
63 return ss.str();
64 }
65
66 static inline std::string ToSymbol(bool x) { return x ? "true" : "false"; }
67
68 static inline std::string ToSymbol(BranchCntrl x) {
69 switch (x) {
70 MAKE_CASE(BranchCntrl, ON);
71 MAKE_CASE(BranchCntrl, OFF);
72 MAKE_DEFAULT_CASE(BranchCntrl);
73 }
74 }
75
76 static inline std::string ToSymbol(ExecSize x) {
77 switch (x) {
78 MAKE_CASE(ExecSize, SIMD1);
79 MAKE_CASE(ExecSize, SIMD2);
80 MAKE_CASE(ExecSize, SIMD4);
81 MAKE_CASE(ExecSize, SIMD8);
82 MAKE_CASE(ExecSize, SIMD16);
83 MAKE_CASE(ExecSize, SIMD32);
84 MAKE_DEFAULT_CASE(ExecSize);
85 }
86 }
87
88 static inline std::string ToSymbol(ChannelOffset x) {
89 switch (x) {
90 MAKE_CASE(ChannelOffset, M0);
91 MAKE_CASE(ChannelOffset, M4);
92 MAKE_CASE(ChannelOffset, M8);
93 MAKE_CASE(ChannelOffset, M12);
94 MAKE_CASE(ChannelOffset, M16);
95 MAKE_CASE(ChannelOffset, M20);
96 MAKE_CASE(ChannelOffset, M24);
97 MAKE_CASE(ChannelOffset, M28);
98 MAKE_DEFAULT_CASE(ChannelOffset);
99 }
100 }
101
102 static inline std::string ToSymbol(MaskCtrl x) {
103 switch (x) {
104 MAKE_CASE(MaskCtrl, NORMAL);
105 MAKE_CASE(MaskCtrl, NOMASK);
106 MAKE_DEFAULT_CASE(MaskCtrl);
107 }
108 }
109
110 static inline std::string ToSymbol(SrcModifier x) {
111 switch (x) {
112 MAKE_CASE(SrcModifier, NONE);
113 MAKE_CASE(SrcModifier, ABS);
114 MAKE_CASE(SrcModifier, NEG);
115 MAKE_CASE(SrcModifier, NEG_ABS);
116 MAKE_DEFAULT_CASE(SrcModifier);
117 }
118 }
119
120 static inline std::string ToSymbol(DstModifier x) {
121 switch (x) {
122 MAKE_CASE(DstModifier, NONE);
123 MAKE_CASE(DstModifier, SAT);
124 MAKE_DEFAULT_CASE(DstModifier);
125 }
126 }
127
128 static inline std::string ToSymbol(RegName x) {
129 switch (x) {
130 MAKE_CASE(RegName, INVALID);
131 MAKE_CASE(RegName, ARF_NULL);
132 MAKE_CASE(RegName, ARF_A);
133 MAKE_CASE(RegName, ARF_ACC);
134 MAKE_CASE(RegName, ARF_MME);
135 MAKE_CASE(RegName, ARF_F);
136 MAKE_CASE(RegName, ARF_CE);
137 MAKE_CASE(RegName, ARF_MSG);
138 MAKE_CASE(RegName, ARF_SP);
139 MAKE_CASE(RegName, ARF_SR);
140 MAKE_CASE(RegName, ARF_CR);
141 MAKE_CASE(RegName, ARF_N);
142 MAKE_CASE(RegName, ARF_IP);
143 MAKE_CASE(RegName, ARF_TDR);
144 MAKE_CASE(RegName, ARF_TM);
145 MAKE_CASE(RegName, ARF_FC);
146 MAKE_CASE(RegName, ARF_DBG);
147 MAKE_CASE(RegName, GRF_R);
148 MAKE_DEFAULT_CASE(RegName);
149 }
150 }
151
152 static inline std::string ToSymbol(MathMacroExt x) {
153 switch (x) {
154 MAKE_CASE(MathMacroExt, INVALID);
155 MAKE_CASE(MathMacroExt, MME0);
156 MAKE_CASE(MathMacroExt, MME1);
157 MAKE_CASE(MathMacroExt, MME2);
158 MAKE_CASE(MathMacroExt, MME3);
159 MAKE_CASE(MathMacroExt, MME4);
160 MAKE_CASE(MathMacroExt, MME5);
161 MAKE_CASE(MathMacroExt, MME6);
162 MAKE_CASE(MathMacroExt, MME7);
163 MAKE_CASE(MathMacroExt, NOMME);
164 MAKE_DEFAULT_CASE(MathMacroExt);
165 }
166 }
167
168 static inline std::string ToSymbol(Type x) {
169 switch (x) {
170 MAKE_CASE(Type, INVALID);
171
172 MAKE_CASE(Type, UB);
173 MAKE_CASE(Type, B);
174 MAKE_CASE(Type, UW);
175 MAKE_CASE(Type, W);
176 MAKE_CASE(Type, UD);
177 MAKE_CASE(Type, D);
178 MAKE_CASE(Type, UQ);
179 MAKE_CASE(Type, Q);
180
181 MAKE_CASE(Type, HF);
182 MAKE_CASE(Type, F);
183 MAKE_CASE(Type, DF);
184 MAKE_CASE(Type, NF);
185
186 MAKE_CASE(Type, UV);
187 MAKE_CASE(Type, V);
188 MAKE_CASE(Type, VF);
189
190 MAKE_CASE(Type, U1);
191 MAKE_CASE(Type, U2);
192 MAKE_CASE(Type, U4);
193 MAKE_CASE(Type, S2);
194 MAKE_CASE(Type, S4);
195 MAKE_CASE(Type, BF);
196
197 MAKE_CASE(Type, BF8);
198 MAKE_CASE(Type, HF8);
199 MAKE_CASE(Type, QF);
200 MAKE_CASE(Type, TF32);
201 MAKE_DEFAULT_CASE(Type);
202 }
203 }
204
205 static inline std::string ToSymbol(FlagModifier x) {
206 switch (x) {
207 MAKE_CASE(FlagModifier, NONE);
208 MAKE_CASE(FlagModifier, EQ);
209 MAKE_CASE(FlagModifier, NE);
210 MAKE_CASE(FlagModifier, GT);
211 MAKE_CASE(FlagModifier, GE);
212 MAKE_CASE(FlagModifier, LT);
213 MAKE_CASE(FlagModifier, LE);
214 MAKE_CASE(FlagModifier, OV);
215 MAKE_CASE(FlagModifier, UN);
216 MAKE_CASE(FlagModifier, EO);
217 MAKE_DEFAULT_CASE(FlagModifier);
218 }
219 }
220
221 static inline std::string ToSymbol(Region x) {
222 if (x == Region::INVALID)
223 return "Region::INVALID";
224 else if (x == Region::SRC010)
225 return "Region::SRC010";
226 else if (x == Region::SRC110)
227 return "Region::SRC110";
228 else if (x == Region::SRC221)
229 return "Region::SRC221";
230 else if (x == Region::SRC441)
231 return "Region::SRC441";
232 else if (x == Region::SRC881)
233 return "Region::SRC881";
234 else if (x == Region::SRCFF1)
235 return "Region::SRCFF1";
236 else if (x == Region::DST1)
237 return "Region::DST1";
238 else if (x == Region::SRC0X0)
239 return "Region::SRC0X0";
240 else if (x == Region::SRC1X0)
241 return "Region::SRC1X0";
242 else if (x == Region::SRC2X1)
243 return "Region::SRC2X1";
244 else if (x == Region::SRC4X1)
245 return "Region::SRC4X1";
246 else if (x == Region::SRC8X1)
247 return "Region::SRC8X1";
248 else if (x == Region::SRCXX0)
249 return "Region::SRCXX0";
250 else if (x == Region::SRCXX1)
251 return "Region::SRCXX1";
252 else if (x == Region::SRCXX2)
253 return "Region::SRCXX2";
254 else {
255 std::stringstream ss;
256 ss << "{";
257 switch (x.getVt()) {
258 case Region::Vert::VT_0:
259 ss << "Region::Vert::VT_0";
260 break;
261 case Region::Vert::VT_1:
262 ss << "Region::Vert::VT_1";
263 break;
264 case Region::Vert::VT_2:
265 ss << "Region::Vert::VT_2";
266 break;
267 case Region::Vert::VT_4:
268 ss << "Region::Vert::VT_4";
269 break;
270 case Region::Vert::VT_8:
271 ss << "Region::Vert::VT_8";
272 break;
273 case Region::Vert::VT_16:
274 ss << "Region::Vert::VT_16";
275 break;
276 case Region::Vert::VT_32:
277 ss << "Region::Vert::VT_32";
278 break;
279 case Region::Vert::VT_VxH:
280 ss << "Region::Vert::VT_VxH";
281 break;
282 case Region::Vert::VT_INVALID:
283 ss << "Region::Vert::VT_INVALID";
284 default:
285 ss << x.v << "?";
286 break;
287 }
288 ss << ",";
289
290 switch (x.getWi()) {
291 case Region::Width::WI_1:
292 ss << "Region::Width::WI_1";
293 break;
294 case Region::Width::WI_2:
295 ss << "Region::Width::WI_2";
296 break;
297 case Region::Width::WI_4:
298 ss << "Region::Width::WI_4";
299 break;
300 case Region::Width::WI_8:
301 ss << "Region::Width::WI_8";
302 break;
303 case Region::Width::WI_16:
304 ss << "Region::Width::WI_16";
305 break;
306 case Region::Width::WI_INVALID:
307 ss << "Region::Width::WI_INVALID";
308 break;
309 default:
310 ss << x.v << "?";
311 break;
312 }
313 ss << ",";
314
315 switch (x.getHz()) {
316 case Region::Horz::HZ_0:
317 ss << "Region::Horz::HZ_0";
318 break;
319 case Region::Horz::HZ_1:
320 ss << "Region::Horz::HZ_1";
321 break;
322 case Region::Horz::HZ_2:
323 ss << "Region::Horz::HZ_2";
324 break;
325 case Region::Horz::HZ_4:
326 ss << "Region::Horz::HZ_4";
327 break;
328 case Region::Horz::HZ_INVALID:
329 ss << "Region::Horz::HZ_INVALID";
330 break;
331 default:
332 ss << x.v << "?";
333 break;
334 }
335 ss << "}";
336 return ss.str();
337 }
338 }
339
340 static inline std::string ToSymbol(InstOpt x) {
341 switch (x) {
342 MAKE_CASE(InstOpt, ACCWREN);
343 MAKE_CASE(InstOpt, ATOMIC);
344 MAKE_CASE(InstOpt, BREAKPOINT);
345 MAKE_CASE(InstOpt, COMPACTED);
346 MAKE_CASE(InstOpt, EOT);
347 MAKE_CASE(InstOpt, NODDCHK);
348 MAKE_CASE(InstOpt, NODDCLR);
349 MAKE_CASE(InstOpt, NOPREEMPT);
350 MAKE_CASE(InstOpt, NOSRCDEPSET);
351 MAKE_CASE(InstOpt, SWITCH);
352 MAKE_CASE(InstOpt, SERIALIZE);
353 MAKE_DEFAULT_CASE(InstOpt);
354 }
355 }
356
357 static inline std::string ToSymbol(const RegRef &x) {
358 if (x == REGREF_INVALID) {
359 return "RegRef::INVALID";
360 } else {
361 std::stringstream ss;
362 ss << "{";
363 ss << x.regNum;
364 ss << ",";
365 ss << x.subRegNum;
366 ss << "}";
367 return ss.str();
368 }
369 }
370
371 static inline std::string ToSymbol(const SendDesc &x) {
372 std::stringstream ss;
373 ss << "{";
374 ss << (x.isImm() ? "IMM" : "REG32A");
375 ss << ",";
376 if (x.isImm()) {
377 ss << ToSymbol(x.reg);
378 } else {
379 fmtHex(ss, x.imm);
380 }
381 ss << "}";
382 return ss.str();
383 }
384
385 static inline std::string ToSymbol(CacheOpt x) {
386
387 switch (x) {
388 MAKE_CASE(CacheOpt, INVALID);
389 MAKE_CASE(CacheOpt, DEFAULT);
390 MAKE_CASE(CacheOpt, READINVALIDATE);
391 MAKE_CASE(CacheOpt, CACHED);
392 MAKE_CASE(CacheOpt, UNCACHED);
393 MAKE_CASE(CacheOpt, STREAMING);
394 MAKE_CASE(CacheOpt, WRITEBACK);
395 MAKE_CASE(CacheOpt, WRITETHROUGH);
396 MAKE_CASE(CacheOpt, CONSTCACHED);
397 MAKE_DEFAULT_CASE(CacheOpt);
398 }
399 }
400
401 static inline std::string ToSyntax(Type ot) {
402 switch (ot) {
403 case Type::UV:
404 return ":uv";
405 case Type::UB:
406 return ":ub";
407 case Type::UW:
408 return ":uw";
409 case Type::UD:
410 return ":ud";
411 case Type::UQ:
412 return ":uq";
413
414 case Type::V:
415 return ":v";
416 case Type::B:
417 return ":b";
418 case Type::W:
419 return ":w";
420 case Type::D:
421 return ":d";
422 case Type::Q:
423 return ":q";
424
425 case Type::VF:
426 return ":vf";
427 case Type::F:
428 return ":f";
429 case Type::NF:
430 return ":nf";
431 case Type::HF:
432 return ":hf";
433 case Type::DF:
434 return ":df";
435
436 case Type::U1:
437 return ":u1";
438 case Type::U2:
439 return ":u2";
440 case Type::U4:
441 return ":u4";
442 case Type::S2:
443 return ":s2";
444 case Type::S4:
445 return ":s4";
446 case Type::BF:
447 return ":bf";
448 case Type::QF:
449 return ":qf";
450 case Type::BF8:
451 return ":bf8";
452 case Type::HF8:
453 return ":hf8";
454 case Type::TF32:
455 return ":tf32";
456
457 case Type::INVALID:
458 return ":Type::INVALID";
459 case Type::E2M1:
460 return ":e2m1";
461 default:
462 return MakeErrorString("Type", (int)ot);
463 }
464 }
465
466 static inline std::string ToSyntax(MaskCtrl mc) {
467 return mc == MaskCtrl::NOMASK ? "W" : "";
468 }
469
470 static inline std::string ToSyntax(PredCtrl pc) {
471 switch (pc) {
472 case PredCtrl::NONE:
473 return "";
474 case PredCtrl::SEQ:
475 return "";
476 case PredCtrl::ANYV:
477 return ".anyv";
478 case PredCtrl::ALLV:
479 return ".allv";
480 case PredCtrl::ANY2H:
481 return ".any2h";
482 case PredCtrl::ALL2H:
483 return ".all2h";
484 case PredCtrl::ANY4H:
485 return ".any4h";
486 case PredCtrl::ALL4H:
487 return ".all4h";
488 case PredCtrl::ANY8H:
489 return ".any8h";
490 case PredCtrl::ALL8H:
491 return ".all8h";
492 case PredCtrl::ANY16H:
493 return ".any16h";
494 case PredCtrl::ALL16H:
495 return ".all16h";
496 case PredCtrl::ANY32H:
497 return ".any32h";
498 case PredCtrl::ALL32H:
499 return ".all32h";
500 case PredCtrl::ANY:
501 return ".any";
502 case PredCtrl::ALL:
503 return ".all";
504 default:
505 return MakeErrorString("PredCtrl", (int)pc);
506 }
507 }
508
509 static inline std::string ToSyntax(const Predication &pred) {
510 std::stringstream ss;
511 ss << (pred.inverse ? "~" : "");
512 ss << ToSyntax(pred.function);
513 return ss.str();
514 }
515
516 static inline std::string ToSyntax(ExecSize es) {
517 switch (es) {
518 case ExecSize::SIMD1:
519 return "1";
520 case ExecSize::SIMD2:
521 return "2";
522 case ExecSize::SIMD4:
523 return "4";
524 case ExecSize::SIMD8:
525 return "8";
526 case ExecSize::SIMD16:
527 return "16";
528 case ExecSize::SIMD32:
529 return "32";
530 default:
531 return MakeErrorString("ExecSize", (int)es);
532 }
533 }
534
535 static inline std::string ToSyntax(ChannelOffset es) {
536 switch (es) {
537 case ChannelOffset::M0:
538 return "M0";
539 case ChannelOffset::M4:
540 return "M4";
541 case ChannelOffset::M8:
542 return "M8";
543 case ChannelOffset::M12:
544 return "M12";
545 case ChannelOffset::M16:
546 return "M16";
547 case ChannelOffset::M20:
548 return "M20";
549 case ChannelOffset::M24:
550 return "M24";
551 case ChannelOffset::M28:
552 return "M28";
553 default:
554 return MakeErrorString("ChannelOffset", (int)es);
555 }
556 }
557
558 static inline std::string ToSyntax(FlagModifier fm) {
559 switch (fm) {
560 case FlagModifier::NONE:
561 return ""; // 0
562 case FlagModifier::EQ:
563 return "eq";
564 case FlagModifier::NE:
565 return "ne";
566 case FlagModifier::LT:
567 return "lt";
568 case FlagModifier::LE:
569 return "le";
570 case FlagModifier::GE:
571 return "ge";
572 case FlagModifier::GT:
573 return "gt";
574 case FlagModifier::OV:
575 return "ov"; // 8
576 case FlagModifier::UN:
577 return "un";
578 case FlagModifier::EO:
579 return "eo";
580 default:
581 return MakeErrorString("FlagModifier", (int)fm);
582 }
583 }
584
585 static inline bool IsBitwise(Op op) {
586 switch (op) {
587 case Op::AND:
588 case Op::OR:
589 case Op::XOR:
590 case Op::NOT:
591 case Op::BFN:
592 // what about these?
593 // case Op::CBIT:
594 // case Op::LZD:
595 return true;
596 default:
597 return false;
598 }
599 }
600
601 static inline std::string ToSyntax(BranchCntrl bc) {
602 switch (bc) {
603 case BranchCntrl::OFF:
604 return "";
605 case BranchCntrl::ON:
606 return ".b";
607 default:
608 return MakeErrorString("BranchCntrl", (int)bc);
609 }
610 }
611
612 static inline std::string ToSyntax(Op op, SrcModifier sm) {
613 switch (sm) {
614 case SrcModifier::NONE:
615 return "";
616 case SrcModifier::ABS:
617 return "(abs)";
618 case SrcModifier::NEG:
619 return IsBitwise(op) ? "~" : "-";
620 case SrcModifier::NEG_ABS:
621 return "-(abs)";
622 default:
623 return MakeErrorString("SrcModifier", (int)sm);
624 }
625 }
626
627 static inline std::string ToSyntax(RegName regName) {
628 switch (regName) {
629 case RegName::ARF_NULL:
630 return "null"; // null
631 case RegName::ARF_A:
632 return "a";
633 case RegName::ARF_ACC:
634 return "acc";
635 case RegName::ARF_MME:
636 return "mme";
637 case RegName::ARF_F:
638 return "f";
639 case RegName::ARF_CE:
640 return "ce";
641 case RegName::ARF_MSG:
642 return "msg";
643 case RegName::ARF_SP:
644 return "sp";
645 case RegName::ARF_SR:
646 return "sr";
647 case RegName::ARF_CR:
648 return "cr";
649 case RegName::ARF_N:
650 return "n";
651 case RegName::ARF_IP:
652 return "ip";
653 case RegName::ARF_TDR:
654 return "tdr";
655 case RegName::ARF_TM:
656 return "tm";
657 case RegName::ARF_FC:
658 return "fc";
659 case RegName::ARF_DBG:
660 return "dbg";
661 case RegName::ARF_S:
662 return "s";
663 case RegName::GRF_R:
664 return "r";
665 default:
666 return MakeErrorString("RegName", (int)regName);
667 }
668 }
669
670 static inline std::string ToSyntax(MathMacroExt MathMacroReg) {
671 switch (MathMacroReg) {
672 case MathMacroExt::MME0:
673 return ".mme0";
674 case MathMacroExt::MME1:
675 return ".mme1";
676 case MathMacroExt::MME2:
677 return ".mme2";
678 case MathMacroExt::MME3:
679 return ".mme3";
680 case MathMacroExt::MME4:
681 return ".mme4";
682 case MathMacroExt::MME5:
683 return ".mme5";
684 case MathMacroExt::MME6:
685 return ".mme6";
686 case MathMacroExt::MME7:
687 return ".mme7";
688 case MathMacroExt::NOMME:
689 return ".nomme";
690 case MathMacroExt::INVALID:
691 return "MathMacroExt::INVALID";
692 default:
693 return MakeErrorString("MathMacroExt", (int)MathMacroReg);
694 }
695 }
696
697 static inline std::string ToSyntax(const Region &rgn) {
698 std::stringstream ss;
699
700 if (rgn.getVt() != Region::Vert::VT_INVALID &&
701 rgn.getWi() != Region::Width::WI_INVALID &&
702 rgn.getHz() != Region::Horz::HZ_INVALID) {
703 if (rgn.getVt() == Region::Vert::VT_VxH) {
704 ss << "<" << (int)rgn.w << "," << (int)rgn.h << ">";
705 } else {
706 ss << "<" << (int)rgn.v << ";" << (int)rgn.w << "," << (int)rgn.h << ">";
707 }
708 } else if (rgn.getVt() != Region::Vert::VT_INVALID &&
709 rgn.getWi() == Region::Width::WI_INVALID &&
710 rgn.getHz() != Region::Horz::HZ_INVALID) {
711 ss << "<" << (int)rgn.v << ";" << (int)rgn.h << ">";
712 } else if (rgn.getVt() == Region::Vert::VT_INVALID &&
713 rgn.getWi() == Region::Width::WI_INVALID &&
714 rgn.getHz() != Region::Horz::HZ_INVALID) {
715 ss << "<" << (int)rgn.h << ">";
716 } else if (rgn == Region::INVALID) {
717 ss << "Region::INVALID";
718 } else {
719 ss << "<0x" << std::hex << (int)rgn.bits << "?>";
720 }
721 return ss.str();
722 }
723
724 static inline std::string ToSyntax(const InstOpt &i) {
725 switch (i) {
726 case InstOpt::ACCWREN:
727 return "AccWrEn";
728 case InstOpt::ATOMIC:
729 return "Atomic";
730 case InstOpt::BREAKPOINT:
731 return "Breakpoint";
732 case InstOpt::COMPACTED:
733 return "Compacted";
734 case InstOpt::EOT:
735 return "EOT";
736 case InstOpt::NOCOMPACT:
737 return "NoCompact";
738 case InstOpt::NODDCHK:
739 return "NoDDChk";
740 case InstOpt::NODDCLR:
741 return "NoDDClr";
742 case InstOpt::NOPREEMPT:
743 return "NoPreempt";
744 case InstOpt::NOSRCDEPSET:
745 return "NoSrcDepSet";
746 case InstOpt::SWITCH:
747 return "Switch";
748 case InstOpt::SERIALIZE:
749 return "Serialize";
750 case InstOpt::EXBSO:
751 return "ExBSO";
752 case InstOpt::CPS:
753 return "CPS";
754 case InstOpt::FWD:
755 return "Fwd";
756 default:
757 return MakeErrorString("InstOpt", (int)i);
758 }
759 }
760
761 static inline void ToSyntaxNoBraces(std::ostream &os,
762 const InstOptSet &instOpts) {
763 static const InstOpt ALL_INST_OPTS[]{InstOpt::ACCWREN,
764 InstOpt::ATOMIC,
765 InstOpt::BREAKPOINT,
766 InstOpt::COMPACTED,
767 InstOpt::EOT,
768 InstOpt::NOCOMPACT,
769 InstOpt::NODDCHK,
770 InstOpt::NODDCLR,
771 InstOpt::NOPREEMPT,
772 InstOpt::NOSRCDEPSET,
773 InstOpt::SWITCH,
774 InstOpt::SERIALIZE,
775 InstOpt::EXBSO,
776 InstOpt::CPS,
777 InstOpt::FWD
778 };
779
780 bool first = true;
781 for (size_t i = 0; i < sizeof(ALL_INST_OPTS) / sizeof(ALL_INST_OPTS[0]);
782 i++) {
783 if (instOpts.contains(ALL_INST_OPTS[i])) {
784 if (first) {
785 first = false;
786 } else {
787 os << ",";
788 }
789 os << ToSyntax(ALL_INST_OPTS[i]);
790 }
791 }
792 }
793
794 static inline std::string ToSyntax(const InstOptSet &instOpts) {
795 std::stringstream ss;
796
797 ss << "{";
798 ToSyntaxNoBraces(ss, instOpts);
799 ss << "}";
800
801 return ss.str();
802 }
803
804 /////////////////////////////////////////////////////
805 // manually defined enumerations from BXML
806 template <typename T> T FromSyntax(const std::string& str);
807
808 std::string ToSyntax(MathFC sfc);
809 template <> MathFC FromSyntax<MathFC>(const std::string& str);
810
811 std::string ToSyntax(SFID sfid);
812 template <> SFID FromSyntax<SFID>(const std::string& str);
813
814 std::string ToSyntax(SyncFC sfc);
815 template <> SyncFC FromSyntax<SyncFC>(const std::string& str);
816
817 std::string ToSyntax(DpasFC sfc);
818 template <> DpasFC FromSyntax<DpasFC>(const std::string& str);
819 std::string ToSyntax(ShuffleFC op);
820 template <> ShuffleFC FromSyntax<ShuffleFC>(const std::string& str);
821
822 std::string ToSyntax(LfsrFC op);
823 template <> LfsrFC FromSyntax<LfsrFC>(const std::string& str);
824
825 std::string ToSyntax(ConvSrcDataType op);
826 template <> ConvSrcDataType FromSyntax<ConvSrcDataType>(const std::string& str);
827
828 std::string ToSyntax(ConvDstDataType op);
829 template <> ConvDstDataType FromSyntax<ConvDstDataType>(const std::string& str);
830
831 std::string ToSyntax(DnsclMode op);
832 template <> DnsclMode FromSyntax<DnsclMode>(const std::string& str);
833
834 std::string ToSyntax(RoundingMode op);
835 template <> RoundingMode FromSyntax<RoundingMode>(const std::string& str);
836
837 std::string ToSyntax(DnsclFC dfc);
838
839 } // namespace iga
840
841 #endif // _IGA_FRONTEND_IRTOSTRING_HPP