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

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

namespace mlir {
// allowed 64-bit signless integer cases: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
enum class AtomicRMWKind : uint64_t {
  addf = 0,
  addi = 1,
  assign = 2,
  maxf = 3,
  maxs = 4,
  maxu = 5,
  minf = 6,
  mins = 7,
  minu = 8,
  mulf = 9,
  muli = 10,
};

llvm::Optional<AtomicRMWKind> symbolizeAtomicRMWKind(uint64_t);
llvm::StringRef stringifyAtomicRMWKind(AtomicRMWKind);
llvm::Optional<AtomicRMWKind> symbolizeAtomicRMWKind(llvm::StringRef);
inline constexpr unsigned getMaxEnumValForAtomicRMWKind() {
  return 10;
}


inline llvm::StringRef stringifyEnum(AtomicRMWKind enumValue) {
  return stringifyAtomicRMWKind(enumValue);
}

template <typename EnumType>
llvm::Optional<EnumType> symbolizeEnum(llvm::StringRef);

template <>
inline llvm::Optional<AtomicRMWKind> symbolizeEnum<AtomicRMWKind>(llvm::StringRef str) {
  return symbolizeAtomicRMWKind(str);
}
} // namespace mlir

namespace llvm {
template<> struct DenseMapInfo<::mlir::AtomicRMWKind> {
  using StorageInfo = llvm::DenseMapInfo<uint64_t>;

  static inline ::mlir::AtomicRMWKind getEmptyKey() {
    return static_cast<::mlir::AtomicRMWKind>(StorageInfo::getEmptyKey());
  }

  static inline ::mlir::AtomicRMWKind getTombstoneKey() {
    return static_cast<::mlir::AtomicRMWKind>(StorageInfo::getTombstoneKey());
  }

  static unsigned getHashValue(const ::mlir::AtomicRMWKind &val) {
    return StorageInfo::getHashValue(static_cast<uint64_t>(val));
  }

  static bool isEqual(const ::mlir::AtomicRMWKind &lhs, const ::mlir::AtomicRMWKind &rhs) {
    return lhs == rhs;
  }
};
}

namespace mlir {
// allowed 64-bit signless integer cases: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
enum class CmpFPredicate : uint64_t {
  AlwaysFalse = 0,
  OEQ = 1,
  OGT = 2,
  OGE = 3,
  OLT = 4,
  OLE = 5,
  ONE = 6,
  ORD = 7,
  UEQ = 8,
  UGT = 9,
  UGE = 10,
  ULT = 11,
  ULE = 12,
  UNE = 13,
  UNO = 14,
  AlwaysTrue = 15,
};

llvm::Optional<CmpFPredicate> symbolizeCmpFPredicate(uint64_t);
llvm::StringRef stringifyCmpFPredicate(CmpFPredicate);
llvm::Optional<CmpFPredicate> symbolizeCmpFPredicate(llvm::StringRef);
inline constexpr unsigned getMaxEnumValForCmpFPredicate() {
  return 15;
}


inline llvm::StringRef stringifyEnum(CmpFPredicate enumValue) {
  return stringifyCmpFPredicate(enumValue);
}

template <typename EnumType>
llvm::Optional<EnumType> symbolizeEnum(llvm::StringRef);

template <>
inline llvm::Optional<CmpFPredicate> symbolizeEnum<CmpFPredicate>(llvm::StringRef str) {
  return symbolizeCmpFPredicate(str);
}
} // namespace mlir

namespace llvm {
template<> struct DenseMapInfo<::mlir::CmpFPredicate> {
  using StorageInfo = llvm::DenseMapInfo<uint64_t>;

  static inline ::mlir::CmpFPredicate getEmptyKey() {
    return static_cast<::mlir::CmpFPredicate>(StorageInfo::getEmptyKey());
  }

  static inline ::mlir::CmpFPredicate getTombstoneKey() {
    return static_cast<::mlir::CmpFPredicate>(StorageInfo::getTombstoneKey());
  }

  static unsigned getHashValue(const ::mlir::CmpFPredicate &val) {
    return StorageInfo::getHashValue(static_cast<uint64_t>(val));
  }

  static bool isEqual(const ::mlir::CmpFPredicate &lhs, const ::mlir::CmpFPredicate &rhs) {
    return lhs == rhs;
  }
};
}

namespace mlir {
// allowed 64-bit signless integer cases: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
enum class CmpIPredicate : uint64_t {
  eq = 0,
  ne = 1,
  slt = 2,
  sle = 3,
  sgt = 4,
  sge = 5,
  ult = 6,
  ule = 7,
  ugt = 8,
  uge = 9,
};

llvm::Optional<CmpIPredicate> symbolizeCmpIPredicate(uint64_t);
llvm::StringRef stringifyCmpIPredicate(CmpIPredicate);
llvm::Optional<CmpIPredicate> symbolizeCmpIPredicate(llvm::StringRef);
inline constexpr unsigned getMaxEnumValForCmpIPredicate() {
  return 9;
}


inline llvm::StringRef stringifyEnum(CmpIPredicate enumValue) {
  return stringifyCmpIPredicate(enumValue);
}

template <typename EnumType>
llvm::Optional<EnumType> symbolizeEnum(llvm::StringRef);

template <>
inline llvm::Optional<CmpIPredicate> symbolizeEnum<CmpIPredicate>(llvm::StringRef str) {
  return symbolizeCmpIPredicate(str);
}
} // namespace mlir

namespace llvm {
template<> struct DenseMapInfo<::mlir::CmpIPredicate> {
  using StorageInfo = llvm::DenseMapInfo<uint64_t>;

  static inline ::mlir::CmpIPredicate getEmptyKey() {
    return static_cast<::mlir::CmpIPredicate>(StorageInfo::getEmptyKey());
  }

  static inline ::mlir::CmpIPredicate getTombstoneKey() {
    return static_cast<::mlir::CmpIPredicate>(StorageInfo::getTombstoneKey());
  }

  static unsigned getHashValue(const ::mlir::CmpIPredicate &val) {
    return StorageInfo::getHashValue(static_cast<uint64_t>(val));
  }

  static bool isEqual(const ::mlir::CmpIPredicate &lhs, const ::mlir::CmpIPredicate &rhs) {
    return lhs == rhs;
  }
};
}


Line	Count	Source (jump to first uncovered line)
1		/===- TableGen'erated file -------------------------------------- C++ --===\
2		\|* *\|
3		\|* Enum Utility Declarations *\|
4		\|* *\|
5		\|* Automatically generated file, do not edit! *\|
6		\|* *\|
7		\===----------------------------------------------------------------------===/
8
9		namespace mlir {
10		// allowed 64-bit signless integer cases: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
11		enum class AtomicRMWKind : uint64_t {
12		addf = 0,
13		addi = 1,
14		assign = 2,
15		maxf = 3,
16		maxs = 4,
17		maxu = 5,
18		minf = 6,
19		mins = 7,
20		minu = 8,
21		mulf = 9,
22		muli = 10,
23		};
24
25		llvm::Optional<AtomicRMWKind> symbolizeAtomicRMWKind(uint64_t);
26		llvm::StringRef stringifyAtomicRMWKind(AtomicRMWKind);
27		llvm::Optional<AtomicRMWKind> symbolizeAtomicRMWKind(llvm::StringRef);
28	0	inline constexpr unsigned getMaxEnumValForAtomicRMWKind() {
29	0	return 10;
30	0	}
31
32
33	0	inline llvm::StringRef stringifyEnum(AtomicRMWKind enumValue) {
34	0	return stringifyAtomicRMWKind(enumValue);
35	0	}
36
37		template <typename EnumType>
38		llvm::Optional<EnumType> symbolizeEnum(llvm::StringRef);
39
40		template <>
41	0	inline llvm::Optional<AtomicRMWKind> symbolizeEnum<AtomicRMWKind>(llvm::StringRef str) {
42	0	return symbolizeAtomicRMWKind(str);
43	0	}
44		} // namespace mlir
45
46		namespace llvm {
47		template<> struct DenseMapInfo<::mlir::AtomicRMWKind> {
48		using StorageInfo = llvm::DenseMapInfo<uint64_t>;
49
50	0	static inline ::mlir::AtomicRMWKind getEmptyKey() {
51	0	return static_cast<::mlir::AtomicRMWKind>(StorageInfo::getEmptyKey());
52	0	}
53
54	0	static inline ::mlir::AtomicRMWKind getTombstoneKey() {
55	0	return static_cast<::mlir::AtomicRMWKind>(StorageInfo::getTombstoneKey());
56	0	}
57
58	0	static unsigned getHashValue(const ::mlir::AtomicRMWKind &val) {
59	0	return StorageInfo::getHashValue(static_cast<uint64_t>(val));
60	0	}
61
62	0	static bool isEqual(const ::mlir::AtomicRMWKind &lhs, const ::mlir::AtomicRMWKind &rhs) {
63	0	return lhs == rhs;
64	0	}
65		};
66		}
67
68		namespace mlir {
69		// allowed 64-bit signless integer cases: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
70		enum class CmpFPredicate : uint64_t {
71		AlwaysFalse = 0,
72		OEQ = 1,
73		OGT = 2,
74		OGE = 3,
75		OLT = 4,
76		OLE = 5,
77		ONE = 6,
78		ORD = 7,
79		UEQ = 8,
80		UGT = 9,
81		UGE = 10,
82		ULT = 11,
83		ULE = 12,
84		UNE = 13,
85		UNO = 14,
86		AlwaysTrue = 15,
87		};
88
89		llvm::Optional<CmpFPredicate> symbolizeCmpFPredicate(uint64_t);
90		llvm::StringRef stringifyCmpFPredicate(CmpFPredicate);
91		llvm::Optional<CmpFPredicate> symbolizeCmpFPredicate(llvm::StringRef);
92	0	inline constexpr unsigned getMaxEnumValForCmpFPredicate() {
93	0	return 15;
94	0	}
95
96
97	0	inline llvm::StringRef stringifyEnum(CmpFPredicate enumValue) {
98	0	return stringifyCmpFPredicate(enumValue);
99	0	}
100
101		template <typename EnumType>
102		llvm::Optional<EnumType> symbolizeEnum(llvm::StringRef);
103
104		template <>
105	0	inline llvm::Optional<CmpFPredicate> symbolizeEnum<CmpFPredicate>(llvm::StringRef str) {
106	0	return symbolizeCmpFPredicate(str);
107	0	}
108		} // namespace mlir
109
110		namespace llvm {
111		template<> struct DenseMapInfo<::mlir::CmpFPredicate> {
112		using StorageInfo = llvm::DenseMapInfo<uint64_t>;
113
114	0	static inline ::mlir::CmpFPredicate getEmptyKey() {
115	0	return static_cast<::mlir::CmpFPredicate>(StorageInfo::getEmptyKey());
116	0	}
117
118	0	static inline ::mlir::CmpFPredicate getTombstoneKey() {
119	0	return static_cast<::mlir::CmpFPredicate>(StorageInfo::getTombstoneKey());
120	0	}
121
122	0	static unsigned getHashValue(const ::mlir::CmpFPredicate &val) {
123	0	return StorageInfo::getHashValue(static_cast<uint64_t>(val));
124	0	}
125
126	0	static bool isEqual(const ::mlir::CmpFPredicate &lhs, const ::mlir::CmpFPredicate &rhs) {
127	0	return lhs == rhs;
128	0	}
129		};
130		}
131
132		namespace mlir {
133		// allowed 64-bit signless integer cases: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
134		enum class CmpIPredicate : uint64_t {
135		eq = 0,
136		ne = 1,
137		slt = 2,
138		sle = 3,
139		sgt = 4,
140		sge = 5,
141		ult = 6,
142		ule = 7,
143		ugt = 8,
144		uge = 9,
145		};
146
147		llvm::Optional<CmpIPredicate> symbolizeCmpIPredicate(uint64_t);
148		llvm::StringRef stringifyCmpIPredicate(CmpIPredicate);
149		llvm::Optional<CmpIPredicate> symbolizeCmpIPredicate(llvm::StringRef);
150	0	inline constexpr unsigned getMaxEnumValForCmpIPredicate() {
151	0	return 9;
152	0	}
153
154
155	0	inline llvm::StringRef stringifyEnum(CmpIPredicate enumValue) {
156	0	return stringifyCmpIPredicate(enumValue);
157	0	}
158
159		template <typename EnumType>
160		llvm::Optional<EnumType> symbolizeEnum(llvm::StringRef);
161
162		template <>
163	0	inline llvm::Optional<CmpIPredicate> symbolizeEnum<CmpIPredicate>(llvm::StringRef str) {
164	0	return symbolizeCmpIPredicate(str);
165	0	}
166		} // namespace mlir
167
168		namespace llvm {
169		template<> struct DenseMapInfo<::mlir::CmpIPredicate> {
170		using StorageInfo = llvm::DenseMapInfo<uint64_t>;
171
172	0	static inline ::mlir::CmpIPredicate getEmptyKey() {
173	0	return static_cast<::mlir::CmpIPredicate>(StorageInfo::getEmptyKey());
174	0	}
175
176	0	static inline ::mlir::CmpIPredicate getTombstoneKey() {
177	0	return static_cast<::mlir::CmpIPredicate>(StorageInfo::getTombstoneKey());
178	0	}
179
180	0	static unsigned getHashValue(const ::mlir::CmpIPredicate &val) {
181	0	return StorageInfo::getHashValue(static_cast<uint64_t>(val));
182	0	}
183
184	0	static bool isEqual(const ::mlir::CmpIPredicate &lhs, const ::mlir::CmpIPredicate &rhs) {
185	0	return lhs == rhs;
186	0	}
187		};
188		}
189

Coverage Report

Created: 2020-06-26 05:44