/home/arjun/llvm-project/build/tools/mlir/include/mlir/Dialect/StandardOps/IR/OpsEnums.cpp.inc

Source (jump to first uncovered line)
/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|*                                                                            *|
|* Enum Utility Definitions                                                   *|
|*                                                                            *|
|* Automatically generated file, do not edit!                                 *|
|*                                                                            *|
\*===----------------------------------------------------------------------===*/

namespace mlir {
llvm::StringRef stringifyAtomicRMWKind(AtomicRMWKind val) {
  switch (val) {
    case AtomicRMWKind::addf: return "addf";
    case AtomicRMWKind::addi: return "addi";
    case AtomicRMWKind::assign: return "assign";
    case AtomicRMWKind::maxf: return "maxf";
    case AtomicRMWKind::maxs: return "maxs";
    case AtomicRMWKind::maxu: return "maxu";
    case AtomicRMWKind::minf: return "minf";
    case AtomicRMWKind::mins: return "mins";
    case AtomicRMWKind::minu: return "minu";
    case AtomicRMWKind::mulf: return "mulf";
    case AtomicRMWKind::muli: return "muli";
  }
  return "";
}

llvm::Optional<AtomicRMWKind> symbolizeAtomicRMWKind(llvm::StringRef str) {
  return llvm::StringSwitch<llvm::Optional<AtomicRMWKind>>(str)
      .Case("addf", AtomicRMWKind::addf)
      .Case("addi", AtomicRMWKind::addi)
      .Case("assign", AtomicRMWKind::assign)
      .Case("maxf", AtomicRMWKind::maxf)
      .Case("maxs", AtomicRMWKind::maxs)
      .Case("maxu", AtomicRMWKind::maxu)
      .Case("minf", AtomicRMWKind::minf)
      .Case("mins", AtomicRMWKind::mins)
      .Case("minu", AtomicRMWKind::minu)
      .Case("mulf", AtomicRMWKind::mulf)
      .Case("muli", AtomicRMWKind::muli)
      .Default(llvm::None);
}
llvm::Optional<AtomicRMWKind> symbolizeAtomicRMWKind(uint64_t value) {
  switch (value) {
  case 0: return AtomicRMWKind::addf;
  case 1: return AtomicRMWKind::addi;
  case 2: return AtomicRMWKind::assign;
  case 3: return AtomicRMWKind::maxf;
  case 4: return AtomicRMWKind::maxs;
  case 5: return AtomicRMWKind::maxu;
  case 6: return AtomicRMWKind::minf;
  case 7: return AtomicRMWKind::mins;
  case 8: return AtomicRMWKind::minu;
  case 9: return AtomicRMWKind::mulf;
  case 10: return AtomicRMWKind::muli;
  default: return llvm::None;
  }
}

} // namespace mlir

namespace mlir {
llvm::StringRef stringifyCmpFPredicate(CmpFPredicate val) {
  switch (val) {
    case CmpFPredicate::AlwaysFalse: return "false";
    case CmpFPredicate::OEQ: return "oeq";
    case CmpFPredicate::OGT: return "ogt";
    case CmpFPredicate::OGE: return "oge";
    case CmpFPredicate::OLT: return "olt";
    case CmpFPredicate::OLE: return "ole";
    case CmpFPredicate::ONE: return "one";
    case CmpFPredicate::ORD: return "ord";
    case CmpFPredicate::UEQ: return "ueq";
    case CmpFPredicate::UGT: return "ugt";
    case CmpFPredicate::UGE: return "uge";
    case CmpFPredicate::ULT: return "ult";
    case CmpFPredicate::ULE: return "ule";
    case CmpFPredicate::UNE: return "une";
    case CmpFPredicate::UNO: return "uno";
    case CmpFPredicate::AlwaysTrue: return "true";
  }
  return "";
}

llvm::Optional<CmpFPredicate> symbolizeCmpFPredicate(llvm::StringRef str) {
  return llvm::StringSwitch<llvm::Optional<CmpFPredicate>>(str)
      .Case("false", CmpFPredicate::AlwaysFalse)
      .Case("oeq", CmpFPredicate::OEQ)
      .Case("ogt", CmpFPredicate::OGT)
      .Case("oge", CmpFPredicate::OGE)
      .Case("olt", CmpFPredicate::OLT)
      .Case("ole", CmpFPredicate::OLE)
      .Case("one", CmpFPredicate::ONE)
      .Case("ord", CmpFPredicate::ORD)
      .Case("ueq", CmpFPredicate::UEQ)
      .Case("ugt", CmpFPredicate::UGT)
      .Case("uge", CmpFPredicate::UGE)
      .Case("ult", CmpFPredicate::ULT)
      .Case("ule", CmpFPredicate::ULE)
      .Case("une", CmpFPredicate::UNE)
      .Case("uno", CmpFPredicate::UNO)
      .Case("true", CmpFPredicate::AlwaysTrue)
      .Default(llvm::None);
}
llvm::Optional<CmpFPredicate> symbolizeCmpFPredicate(uint64_t value) {
  switch (value) {
  case 0: return CmpFPredicate::AlwaysFalse;
  case 1: return CmpFPredicate::OEQ;
  case 2: return CmpFPredicate::OGT;
  case 3: return CmpFPredicate::OGE;
  case 4: return CmpFPredicate::OLT;
  case 5: return CmpFPredicate::OLE;
  case 6: return CmpFPredicate::ONE;
  case 7: return CmpFPredicate::ORD;
  case 8: return CmpFPredicate::UEQ;
  case 9: return CmpFPredicate::UGT;
  case 10: return CmpFPredicate::UGE;
  case 11: return CmpFPredicate::ULT;
  case 12: return CmpFPredicate::ULE;
  case 13: return CmpFPredicate::UNE;
  case 14: return CmpFPredicate::UNO;
  case 15: return CmpFPredicate::AlwaysTrue;
  default: return llvm::None;
  }
}

} // namespace mlir

namespace mlir {
llvm::StringRef stringifyCmpIPredicate(CmpIPredicate val) {
  switch (val) {
    case CmpIPredicate::eq: return "eq";
    case CmpIPredicate::ne: return "ne";
    case CmpIPredicate::slt: return "slt";
    case CmpIPredicate::sle: return "sle";
    case CmpIPredicate::sgt: return "sgt";
    case CmpIPredicate::sge: return "sge";
    case CmpIPredicate::ult: return "ult";
    case CmpIPredicate::ule: return "ule";
    case CmpIPredicate::ugt: return "ugt";
    case CmpIPredicate::uge: return "uge";
  }
  return "";
}

llvm::Optional<CmpIPredicate> symbolizeCmpIPredicate(llvm::StringRef str) {
  return llvm::StringSwitch<llvm::Optional<CmpIPredicate>>(str)
      .Case("eq", CmpIPredicate::eq)
      .Case("ne", CmpIPredicate::ne)
      .Case("slt", CmpIPredicate::slt)
      .Case("sle", CmpIPredicate::sle)
      .Case("sgt", CmpIPredicate::sgt)
      .Case("sge", CmpIPredicate::sge)
      .Case("ult", CmpIPredicate::ult)
      .Case("ule", CmpIPredicate::ule)
      .Case("ugt", CmpIPredicate::ugt)
      .Case("uge", CmpIPredicate::uge)
      .Default(llvm::None);
}
llvm::Optional<CmpIPredicate> symbolizeCmpIPredicate(uint64_t value) {
  switch (value) {
  case 0: return CmpIPredicate::eq;
  case 1: return CmpIPredicate::ne;
  case 2: return CmpIPredicate::slt;
  case 3: return CmpIPredicate::sle;
  case 4: return CmpIPredicate::sgt;
  case 5: return CmpIPredicate::sge;
  case 6: return CmpIPredicate::ult;
  case 7: return CmpIPredicate::ule;
  case 8: return CmpIPredicate::ugt;
  case 9: return CmpIPredicate::uge;
  default: return llvm::None;
  }
}

} // namespace mlir


Line	Count	Source (jump to first uncovered line)
1		/===- TableGen'erated file -------------------------------------- C++ --===\
2		\|* *\|
3		\|* Enum Utility Definitions *\|
4		\|* *\|
5		\|* Automatically generated file, do not edit! *\|
6		\|* *\|
7		\===----------------------------------------------------------------------===/
8
9		namespace mlir {
10	0	llvm::StringRef stringifyAtomicRMWKind(AtomicRMWKind val) {
11	0	switch (val) {
12	0	case AtomicRMWKind::addf: return "addf";
13	0	case AtomicRMWKind::addi: return "addi";
14	0	case AtomicRMWKind::assign: return "assign";
15	0	case AtomicRMWKind::maxf: return "maxf";
16	0	case AtomicRMWKind::maxs: return "maxs";
17	0	case AtomicRMWKind::maxu: return "maxu";
18	0	case AtomicRMWKind::minf: return "minf";
19	0	case AtomicRMWKind::mins: return "mins";
20	0	case AtomicRMWKind::minu: return "minu";
21	0	case AtomicRMWKind::mulf: return "mulf";
22	0	case AtomicRMWKind::muli: return "muli";
23	0	}
24	0	return "";
25	0	}
26
27	0	llvm::Optional<AtomicRMWKind> symbolizeAtomicRMWKind(llvm::StringRef str) {
28	0	return llvm::StringSwitch<llvm::Optional<AtomicRMWKind>>(str)
29	0	.Case("addf", AtomicRMWKind::addf)
30	0	.Case("addi", AtomicRMWKind::addi)
31	0	.Case("assign", AtomicRMWKind::assign)
32	0	.Case("maxf", AtomicRMWKind::maxf)
33	0	.Case("maxs", AtomicRMWKind::maxs)
34	0	.Case("maxu", AtomicRMWKind::maxu)
35	0	.Case("minf", AtomicRMWKind::minf)
36	0	.Case("mins", AtomicRMWKind::mins)
37	0	.Case("minu", AtomicRMWKind::minu)
38	0	.Case("mulf", AtomicRMWKind::mulf)
39	0	.Case("muli", AtomicRMWKind::muli)
40	0	.Default(llvm::None);
41	0	}
42		llvm::Optional<AtomicRMWKind> symbolizeAtomicRMWKind(uint64_t value) {
43		switch (value) {
44		case 0: return AtomicRMWKind::addf;
45		case 1: return AtomicRMWKind::addi;
46		case 2: return AtomicRMWKind::assign;
47		case 3: return AtomicRMWKind::maxf;
48		case 4: return AtomicRMWKind::maxs;
49		case 5: return AtomicRMWKind::maxu;
50		case 6: return AtomicRMWKind::minf;
51		case 7: return AtomicRMWKind::mins;
52		case 8: return AtomicRMWKind::minu;
53		case 9: return AtomicRMWKind::mulf;
54		case 10: return AtomicRMWKind::muli;
55		default: return llvm::None;
56		}
57		}
58
59		} // namespace mlir
60
61		namespace mlir {
62	0	llvm::StringRef stringifyCmpFPredicate(CmpFPredicate val) {
63	0	switch (val) {
64	0	case CmpFPredicate::AlwaysFalse: return "false";
65	0	case CmpFPredicate::OEQ: return "oeq";
66	0	case CmpFPredicate::OGT: return "ogt";
67	0	case CmpFPredicate::OGE: return "oge";
68	0	case CmpFPredicate::OLT: return "olt";
69	0	case CmpFPredicate::OLE: return "ole";
70	0	case CmpFPredicate::ONE: return "one";
71	0	case CmpFPredicate::ORD: return "ord";
72	0	case CmpFPredicate::UEQ: return "ueq";
73	0	case CmpFPredicate::UGT: return "ugt";
74	0	case CmpFPredicate::UGE: return "uge";
75	0	case CmpFPredicate::ULT: return "ult";
76	0	case CmpFPredicate::ULE: return "ule";
77	0	case CmpFPredicate::UNE: return "une";
78	0	case CmpFPredicate::UNO: return "uno";
79	0	case CmpFPredicate::AlwaysTrue: return "true";
80	0	}
81	0	return "";
82	0	}
83
84	0	llvm::Optional<CmpFPredicate> symbolizeCmpFPredicate(llvm::StringRef str) {
85	0	return llvm::StringSwitch<llvm::Optional<CmpFPredicate>>(str)
86	0	.Case("false", CmpFPredicate::AlwaysFalse)
87	0	.Case("oeq", CmpFPredicate::OEQ)
88	0	.Case("ogt", CmpFPredicate::OGT)
89	0	.Case("oge", CmpFPredicate::OGE)
90	0	.Case("olt", CmpFPredicate::OLT)
91	0	.Case("ole", CmpFPredicate::OLE)
92	0	.Case("one", CmpFPredicate::ONE)
93	0	.Case("ord", CmpFPredicate::ORD)
94	0	.Case("ueq", CmpFPredicate::UEQ)
95	0	.Case("ugt", CmpFPredicate::UGT)
96	0	.Case("uge", CmpFPredicate::UGE)
97	0	.Case("ult", CmpFPredicate::ULT)
98	0	.Case("ule", CmpFPredicate::ULE)
99	0	.Case("une", CmpFPredicate::UNE)
100	0	.Case("uno", CmpFPredicate::UNO)
101	0	.Case("true", CmpFPredicate::AlwaysTrue)
102	0	.Default(llvm::None);
103	0	}
104		llvm::Optional<CmpFPredicate> symbolizeCmpFPredicate(uint64_t value) {
105		switch (value) {
106		case 0: return CmpFPredicate::AlwaysFalse;
107		case 1: return CmpFPredicate::OEQ;
108		case 2: return CmpFPredicate::OGT;
109		case 3: return CmpFPredicate::OGE;
110		case 4: return CmpFPredicate::OLT;
111		case 5: return CmpFPredicate::OLE;
112		case 6: return CmpFPredicate::ONE;
113		case 7: return CmpFPredicate::ORD;
114		case 8: return CmpFPredicate::UEQ;
115		case 9: return CmpFPredicate::UGT;
116		case 10: return CmpFPredicate::UGE;
117		case 11: return CmpFPredicate::ULT;
118		case 12: return CmpFPredicate::ULE;
119		case 13: return CmpFPredicate::UNE;
120		case 14: return CmpFPredicate::UNO;
121		case 15: return CmpFPredicate::AlwaysTrue;
122		default: return llvm::None;
123		}
124		}
125
126		} // namespace mlir
127
128		namespace mlir {
129	0	llvm::StringRef stringifyCmpIPredicate(CmpIPredicate val) {
130	0	switch (val) {
131	0	case CmpIPredicate::eq: return "eq";
132	0	case CmpIPredicate::ne: return "ne";
133	0	case CmpIPredicate::slt: return "slt";
134	0	case CmpIPredicate::sle: return "sle";
135	0	case CmpIPredicate::sgt: return "sgt";
136	0	case CmpIPredicate::sge: return "sge";
137	0	case CmpIPredicate::ult: return "ult";
138	0	case CmpIPredicate::ule: return "ule";
139	0	case CmpIPredicate::ugt: return "ugt";
140	0	case CmpIPredicate::uge: return "uge";
141	0	}
142	0	return "";
143	0	}
144
145	0	llvm::Optional<CmpIPredicate> symbolizeCmpIPredicate(llvm::StringRef str) {
146	0	return llvm::StringSwitch<llvm::Optional<CmpIPredicate>>(str)
147	0	.Case("eq", CmpIPredicate::eq)
148	0	.Case("ne", CmpIPredicate::ne)
149	0	.Case("slt", CmpIPredicate::slt)
150	0	.Case("sle", CmpIPredicate::sle)
151	0	.Case("sgt", CmpIPredicate::sgt)
152	0	.Case("sge", CmpIPredicate::sge)
153	0	.Case("ult", CmpIPredicate::ult)
154	0	.Case("ule", CmpIPredicate::ule)
155	0	.Case("ugt", CmpIPredicate::ugt)
156	0	.Case("uge", CmpIPredicate::uge)
157	0	.Default(llvm::None);
158	0	}
159		llvm::Optional<CmpIPredicate> symbolizeCmpIPredicate(uint64_t value) {
160		switch (value) {
161		case 0: return CmpIPredicate::eq;
162		case 1: return CmpIPredicate::ne;
163		case 2: return CmpIPredicate::slt;
164		case 3: return CmpIPredicate::sle;
165		case 4: return CmpIPredicate::sgt;
166		case 5: return CmpIPredicate::sge;
167		case 6: return CmpIPredicate::ult;
168		case 7: return CmpIPredicate::ule;
169		case 8: return CmpIPredicate::ugt;
170		case 9: return CmpIPredicate::uge;
171		default: return llvm::None;
172		}
173		}
174
175		} // namespace mlir
176

Coverage Report

Created: 2020-06-26 05:44