19 #ifndef MLIR_IR_OPDEFINITION_H
20 #define MLIR_IR_OPDEFINITION_H
25 #include "llvm/Support/PointerLikeTypeTraits.h"
28 #include <type_traits>
56 std::optional<ParseResult>
impl;
67 Region ®ion, OpBuilder &builder, Location loc,
68 function_ref<Operation *(OpBuilder &, Location)> buildTerminatorOp);
70 Region ®ion, Builder &builder, Location loc,
71 function_ref<Operation *(OpBuilder &, Location)> buildTerminatorOp);
81 template <
class Op,
class =
void>
87 using type =
typename Op::Properties;
115 state->
print(os, flags);
118 state->
print(os, asmState);
139 InFlightDiagnostic
emitError(
const Twine &message = {});
143 InFlightDiagnostic
emitWarning(
const Twine &message = {});
147 InFlightDiagnostic
emitRemark(
const Twine &message = {});
161 typename Iterator = ForwardIterator,
typename FnT,
162 typename RetT = detail::walkResultType<FnT>>
163 std::enable_if_t<llvm::function_traits<std::decay_t<FnT>>::num_args == 1,
166 return state->
walk<Order, Iterator>(std::forward<FnT>(callback));
190 template <
typename FnT,
typename RetT = detail::walkResultType<FnT>>
191 std::enable_if_t<llvm::function_traits<std::decay_t<FnT>>::num_args == 2,
194 return state->
walk(std::forward<FnT>(callback));
210 LogicalResult
verify() {
return success(); }
235 static void printOpName(Operation *op, OpAsmPrinter &p,
236 StringRef defaultDialect);
247 return emptyProperties;
265 raw_ostream &
operator<<(raw_ostream &os, OpFoldResult ofr);
272 void dump()
const { llvm::errs() << *
this <<
"\n"; }
275 return is<Attribute>() ? get<Attribute>().getContext()
276 : get<Value>().getContext();
289 template <
typename To>
291 :
public CastInfo<To, mlir::OpFoldResult::PointerUnion> {};
293 template <
typename To>
295 :
public CastInfo<To, const mlir::OpFoldResult::PointerUnion> {};
303 if (
Value value = llvm::dyn_cast_if_present<Value>(ofr))
306 llvm::dyn_cast_if_present<Attribute>(ofr).print(os);
325 LogicalResult
foldCommutative(Operation *op, ArrayRef<Attribute> operands,
326 SmallVectorImpl<OpFoldResult> &results);
344 LogicalResult
verifyNResults(Operation *op,
unsigned numOperands);
361 StringRef valueGroupName,
362 size_t expectedCount);
372 template <
typename ConcreteType,
template <
typename>
class TraitType>
377 auto *concrete =
static_cast<ConcreteType *
>(
this);
378 return concrete->getOperation();
388 template <
typename ConcreteType,
template <
typename>
class TraitType>
430 template <
typename ConcreteType>
434 return cast<ConcreteType>(op).verifyInvariantsImpl();
440 template <
typename ConcreteType>
455 template <
typename ConcreteType>
472 template <
unsigned N>
475 static_assert(N > 1,
"use ZeroOperands/OneOperand for N < 2");
477 template <
typename ConcreteType>
492 template <
unsigned N>
495 template <
typename ConcreteType>
497 AtLeastNOperands<N>::Impl> {
507 template <
typename ConcreteType>
516 template <
typename ConcreteType>
527 template <
typename ConcreteType,
template <
typename>
class TraitType>
548 template <
typename ConcreteType>
555 template <
typename OpT>
557 return getRegion().template getOps<OpT>();
567 template <
unsigned N>
570 static_assert(N > 1,
"use ZeroRegions/OneRegion for N < 2");
572 template <
typename ConcreteType>
584 template <
unsigned N>
587 template <
typename ConcreteType>
589 AtLeastNRegions<N>::Impl> {
599 template <
typename ConcreteType>
608 template <
typename ConcreteType>
619 template <
typename ConcreteType,
template <
typename>
class TraitType>
634 template <
typename ValuesT>
664 template <
typename ConcreteType>
688 template <
typename ResultType>
693 template <
typename ConcreteType>
695 :
public TraitBase<ConcreteType, OneTypedResult<ResultType>::Impl> {
698 return cast<mlir::TypedValue<ResultType>>(
715 template <
unsigned N>
718 static_assert(N > 1,
"use ZeroResults/OneResult for N < 2");
720 template <
typename ConcreteType>
735 template <
unsigned N>
738 template <
typename ConcreteType>
740 AtLeastNResults<N>::Impl> {
750 template <
typename ConcreteType>
759 template <
typename ConcreteType>
763 template <
typename ConcreteType>
773 template <
typename ConcreteType>
784 template <
typename ConcreteType,
template <
typename>
class TraitType>
812 template <
typename ConcreteType>
827 template <
unsigned N>
830 static_assert(N > 1,
"use ZeroSuccessors/OneSuccessor for N < 2");
832 template <
typename ConcreteType>
834 NSuccessors<N>::Impl> {
844 template <
unsigned N>
847 template <
typename ConcreteType>
850 AtLeastNSuccessors<N>::Impl> {
860 template <
typename ConcreteType>
870 template <
typename ConcreteType>
874 for (
unsigned i = 0, e = op->getNumRegions(); i < e; ++i) {
875 Region ®ion = op->getRegion(i);
882 if (!llvm::hasSingleElement(region))
883 return op->emitOpError(
"expects region #")
884 << i <<
" to have 0 or 1 blocks";
886 if (!ConcreteType::template hasTrait<NoTerminator>()) {
889 return op->emitOpError() <<
"expects a non-empty block";
897 assert(!region.
empty() &&
"unexpected empty region");
898 return ®ion.
front();
912 template <
typename OpT,
typename T =
void>
914 std::enable_if_t<OpT::template hasTrait<OneRegion>(), T>;
916 template <
typename OpT = ConcreteType>
920 template <
typename OpT = ConcreteType>
924 template <
typename OpT = ConcreteType>
930 template <
typename OpT = ConcreteType>
936 template <
typename OpT = ConcreteType>
940 template <
typename OpT = ConcreteType>
951 template <
typename TerminatorOpType>
953 template <
typename ConcreteType>
955 TerminatorOpType>::Impl> {
961 TerminatorOpType::build(builder, state);
970 for (
unsigned i = 0, e = op->getNumRegions(); i < e; ++i) {
971 Region ®ion = op->getRegion(i);
976 if (isa<TerminatorOpType>(terminator))
979 return op->emitOpError(
"expects regions to end with '" +
980 TerminatorOpType::getOperationName() +
984 <<
"in custom textual format, the absence of terminator implies "
986 << TerminatorOpType::getOperationName() <<
'\'';
1018 template <
class Op,
bool hasTerminator =
1019 llvm::is_detected<has_implicit_terminator_t, Op>::value>
1021 static constexpr
bool value = std::is_base_of<
1023 typename Op::ImplicitTerminatorOpT>::template Impl<Op>,
1037 template <
typename ConcreteType>
1048 template <
typename ConcreteType>
1050 :
public TraitBase<ConcreteType, SameOperandsAndResultShape> {
1060 template <
typename ConcreteType>
1062 :
public TraitBase<ConcreteType, SameOperandsElementType> {
1072 template <
typename ConcreteType>
1074 :
public TraitBase<ConcreteType, SameOperandsAndResultElementType> {
1086 template <
typename ConcreteType>
1088 :
public TraitBase<ConcreteType, SameOperandsAndResultType> {
1097 template <
typename ConcreteType>
1099 :
public TraitBase<ConcreteType, SameOperandsAndResultRank> {
1108 template <
typename ConcreteType>
1118 template <
typename ConcreteType>
1120 :
public TraitBase<ConcreteType, ResultsAreFloatLike> {
1129 template <
typename ConcreteType>
1131 :
public TraitBase<ConcreteType, ResultsAreSignlessIntegerLike> {
1139 template <
typename ConcreteType>
1150 template <
typename ConcreteType>
1154 static_assert(ConcreteType::template hasTrait<OneResult>(),
1155 "expected operation to produce one result");
1156 static_assert(ConcreteType::template hasTrait<OneOperand>(),
1157 "expected operation to take one operand");
1158 static_assert(ConcreteType::template hasTrait<SameOperandsAndResultType>(),
1159 "expected operation to preserve type");
1173 template <
typename ConcreteType>
1177 static_assert(ConcreteType::template hasTrait<OneResult>(),
1178 "expected operation to produce one result");
1179 static_assert(ConcreteType::template hasTrait<OneOperand>() ||
1181 "expected operation to take one or two operands");
1182 static_assert(ConcreteType::template hasTrait<SameOperandsAndResultType>(),
1183 "expected operation to preserve type");
1196 template <
typename ConcreteType>
1198 :
public TraitBase<ConcreteType, OperandsAreFloatLike> {
1207 template <
typename ConcreteType>
1209 :
public TraitBase<ConcreteType, OperandsAreSignlessIntegerLike> {
1218 template <
typename ConcreteType>
1229 template <
typename ConcreteType>
1233 static_assert(ConcreteType::template hasTrait<OneResult>(),
1234 "expected operation to produce one result");
1235 static_assert(ConcreteType::template hasTrait<ZeroOperands>(),
1236 "expected operation to take zero operands");
1247 template <
typename ConcreteType>
1249 :
public TraitBase<ConcreteType, IsIsolatedFromAbove> {
1261 template <
typename ConcreteType>
1265 static_assert(!ConcreteType::template hasTrait<ZeroRegions>(),
1266 "expected operation to have one or more regions");
1276 template <
typename ConcreteType>
1278 :
public TraitBase<ConcreteType, AutomaticAllocationScope> {
1281 static_assert(!ConcreteType::template hasTrait<ZeroRegions>(),
1282 "expected operation to have one or more regions");
1289 template <
typename... ParentOpTypes>
1291 template <
typename ConcreteType>
1295 if (llvm::isa_and_nonnull<ParentOpTypes...>(op->getParentOp()))
1298 return op->emitOpError()
1299 <<
"expects parent op "
1300 << (
sizeof...(ParentOpTypes) != 1 ?
"to be one of '" :
"'")
1301 <<
llvm::ArrayRef({ParentOpTypes::getOperationName()...}) <<
"'";
1304 template <
typename ParentOpType =
1305 std::tuple_element_t<0, std::tuple<ParentOpTypes...>>>
1306 std::enable_if_t<
sizeof...(ParentOpTypes) == 1, ParentOpType>
1309 return llvm::cast<ParentOpType>(parent);
1324 template <
typename ConcreteType>
1332 op, getOperandSegmentSizeAttr());
1337 template <
typename ConcreteType>
1345 op, getResultSegmentSizeAttr());
1351 template <
typename ConcrentType>
1363 template <
typename ConcrentType>
1399 template <
typename ConcreteType>
1428 template <
typename ConcreteType>
1432 ConcreteType::template hasTrait<Elementwise>(),
1433 "`Scalarizable` trait is only applicable to `Elementwise` ops.");
1448 template <
typename ConcreteType>
1452 ConcreteType::template hasTrait<Elementwise>(),
1453 "`Vectorizable` trait is only applicable to `Elementwise` ops.");
1489 template <
typename ConcreteType>
1493 ConcreteType::template hasTrait<Elementwise>(),
1494 "`Tensorizable` trait is only applicable to `Elementwise` ops.");
1510 namespace op_definition_impl {
1516 template <
template <
typename T>
class... Traits>
1518 TypeID traitIDs[] = {TypeID::get<Traits>()...};
1519 for (
unsigned i = 0, e =
sizeof...(Traits); i != e; ++i)
1520 if (traitIDs[i] == traitID)
1534 template <
typename T,
typename... Args>
1537 template <
typename T>
1539 llvm::is_detected<has_single_result_fold_trait, T>;
1541 template <
typename T,
typename... Args>
1546 template <
typename T>
1549 template <
typename T>
1551 std::disjunction<detect_has_fold_trait<T>,
1556 template <
typename Trait>
1557 static std::enable_if_t<detect_has_single_result_fold_trait<Trait>::value,
1562 "expected trait on non single-result operation to implement the "
1563 "general `foldTrait` method");
1566 if (!results.empty())
1570 if (llvm::dyn_cast_if_present<Value>(result) != op->
getResult(0))
1571 results.push_back(result);
1578 template <
typename Trait>
1579 static std::enable_if_t<detect_has_fold_trait<Trait>::value, LogicalResult>
1584 return results.empty() ?
Trait::foldTrait(op, operands, results) : failure();
1586 template <
typename Trait>
1587 static inline std::enable_if_t<!detect_has_any_fold_trait<Trait>::value,
1595 template <
typename... Ts>
1598 return success((succeeded(foldTrait<Ts>(op, operands, results)) || ...));
1605 template <
typename T,
typename... Args>
1607 template <
typename T>
1611 template <
typename T,
typename... Args>
1614 template <
typename T>
1616 llvm::is_detected<has_verify_region_trait, T>;
1619 template <
typename T>
1620 std::enable_if_t<detect_has_verify_trait<T>::value, LogicalResult>
1624 template <
typename T>
1625 inline std::enable_if_t<!detect_has_verify_trait<T>::value, LogicalResult>
1631 template <
typename... Ts>
1633 return success((succeeded(verifyTrait<Ts>(op)) && ...));
1637 template <
typename T>
1638 std::enable_if_t<detect_has_verify_region_trait<T>::value, LogicalResult>
1642 template <
typename T>
1643 inline std::enable_if_t<!detect_has_verify_region_trait<T>::value,
1651 template <
typename... Ts>
1653 return success((succeeded(verifyRegionTrait<Ts>(op)) && ...));
1664 template <
typename ConcreteType,
template <
typename T>
class... Traits>
1673 template <
template <
typename T>
class Trait>
1675 return llvm::is_one_of<Trait<ConcreteType>, Traits<ConcreteType>...>::value;
1690 if (
auto info = op->getRegisteredInfo())
1691 return TypeID::get<ConcreteType>() == info->getTypeID();
1693 if (op->getName().getStringRef() == ConcreteType::getOperationName())
1694 llvm::report_fatal_error(
1695 "classof on '" + ConcreteType::getOperationName() +
1696 "' failed due to the operation not being registered");
1702 template <
typename T>
1703 static std::enable_if_t<std::is_base_of<OpState, T>::value,
bool>
1722 return static_cast<const void *
>((
Operation *)*
this);
1726 reinterpret_cast<Operation *
>(
const_cast<void *
>(pointer)));
1731 template <
typename... Models>
1733 std::optional<RegisteredOperationName> info =
1736 llvm::report_fatal_error(
1737 "Attempting to attach an interface to an unregistered operation " +
1738 ConcreteType::getOperationName() +
".");
1739 (checkInterfaceTarget<Models>(), ...);
1740 info->attachInterface<Models...>();
1747 template <
typename PropertiesTy>
1748 static LogicalResult
1751 return setPropertiesFromAttribute(prop, attr,
emitError);
1757 template <
typename PropertiesTy>
1759 const PropertiesTy &prop) {
1760 return getPropertiesAsAttribute(ctx, prop);
1766 template <
typename PropertiesTy>
1773 template <
typename T,
typename... Args>
1774 using has_single_result_fold_t =
1776 template <
typename T>
1777 constexpr
static bool has_single_result_fold_v =
1778 llvm::is_detected<has_single_result_fold_t, T>::value;
1780 template <
typename T,
typename... Args>
1781 using has_fold_t = decltype(std::declval<T>().fold(
1784 template <
typename T>
1785 constexpr
static bool has_fold_v = llvm::is_detected<has_fold_t, T>::value;
1788 template <
typename T,
typename... Args>
1789 using has_fold_adaptor_single_result_fold_t =
1790 decltype(std::declval<T>().fold(std::declval<typename T::FoldAdaptor>()));
1792 constexpr
static bool has_fold_adaptor_single_result_v =
1793 llvm::is_detected<has_fold_adaptor_single_result_fold_t, T>::value;
1795 template <
typename T,
typename... Args>
1796 using has_fold_adaptor_fold_t = decltype(std::declval<T>().fold(
1797 std::declval<typename T::FoldAdaptor>(),
1800 constexpr
static bool has_fold_adaptor_v =
1801 llvm::is_detected<has_fold_adaptor_fold_t, T>::value;
1804 template <
typename T,
typename... Args>
1806 decltype(std::declval<T>().
print(std::declval<OpAsmPrinter &>()));
1807 template <
typename T>
1808 using detect_has_print = llvm::is_detected<has_print, T>;
1812 template <
typename T,
typename... Args>
1813 using has_print_properties =
1817 template <
typename T>
1818 using detect_has_print_properties =
1819 llvm::is_detected<has_print_properties, T>;
1822 template <
typename T,
typename... Args>
1824 std::declval<OpAsmParser &>(), std::declval<T &>()));
1825 template <
typename T>
1826 using detect_has_parse_properties =
1827 llvm::is_detected<has_parse_properties, T>;
1830 template <
typename T>
1831 using has_concrete_entity_t =
typename T::ConcreteEntity;
1836 return !std::is_same_v<
1846 template <
typename T,
1847 bool = llvm::is_detected<has_concrete_entity_t, T>::value>
1848 struct InterfaceTargetOrOpT {
1849 using type =
typename T::ConcreteEntity;
1851 template <
typename T>
1852 struct InterfaceTargetOrOpT<T, false> {
1853 using type = ConcreteType;
1859 template <
typename T>
1860 static void checkInterfaceTarget() {
1861 static_assert(std::is_same<
typename InterfaceTargetOrOpT<T>::type,
1862 ConcreteType>::value,
1863 "attaching an interface to the wrong op kind");
1868 static detail::InterfaceMap getInterfaceMap() {
1869 return detail::InterfaceMap::template get<Traits<ConcreteType>...>();
1877 if constexpr (llvm::is_one_of<OpTrait::OneResult<ConcreteType>,
1878 Traits<ConcreteType>...>::value &&
1879 (has_single_result_fold_v<ConcreteType> ||
1880 has_fold_adaptor_single_result_v<ConcreteType>))
1881 return [](Operation *op, ArrayRef<Attribute> operands,
1882 SmallVectorImpl<OpFoldResult> &results) {
1883 return foldSingleResultHook<ConcreteType>(op, operands, results);
1886 if constexpr (has_fold_v<ConcreteType> || has_fold_adaptor_v<ConcreteType>)
1887 return [](Operation *op, ArrayRef<Attribute> operands,
1888 SmallVectorImpl<OpFoldResult> &results) {
1889 return foldHook<ConcreteType>(op, operands, results);
1892 return [](Operation *op, ArrayRef<Attribute> operands,
1893 SmallVectorImpl<OpFoldResult> &results) {
1895 return op_definition_impl::foldTraits<Traits<ConcreteType>...>(
1896 op, operands, results);
1901 template <
typename ConcreteOpT>
1902 static LogicalResult
1903 foldSingleResultHook(Operation *op, ArrayRef<Attribute> operands,
1904 SmallVectorImpl<OpFoldResult> &results) {
1905 OpFoldResult result;
1906 if constexpr (has_fold_adaptor_single_result_v<ConcreteOpT>) {
1907 result = cast<ConcreteOpT>(op).fold(
1908 typename ConcreteOpT::FoldAdaptor(operands, cast<ConcreteOpT>(op)));
1910 result = cast<ConcreteOpT>(op).fold(operands);
1916 llvm::dyn_cast_if_present<Value>(result) == op->getResult(0)) {
1918 op, operands, results)))
1920 return success(
static_cast<bool>(result));
1922 results.push_back(result);
1926 template <
typename ConcreteOpT>
1927 static LogicalResult foldHook(Operation *op, ArrayRef<Attribute> operands,
1928 SmallVectorImpl<OpFoldResult> &results) {
1929 auto result = LogicalResult::failure();
1930 if constexpr (has_fold_adaptor_v<ConcreteOpT>) {
1931 result = cast<ConcreteOpT>(op).fold(
1932 typename ConcreteOpT::FoldAdaptor(operands, cast<ConcreteOpT>(op)),
1935 result = cast<ConcreteOpT>(op).fold(operands, results);
1940 if (failed(result) || results.empty()) {
1942 op, operands, results)))
1955 if constexpr (detect_has_print<ConcreteType>::value)
1956 return [](Operation *op, OpAsmPrinter &p, StringRef defaultDialect) {
1958 return cast<ConcreteType>(op).print(p);
1960 return [](Operation *op, OpAsmPrinter &printer, StringRef defaultDialect) {
1966 template <
typename T>
1968 template <
typename T = ConcreteType>
1974 .template as<InferredProperties<T> *>();
1978 template <
typename T = ConcreteType>
1986 template <
typename T>
1988 const T &properties,
1990 if constexpr (detect_has_print_properties<T>::value)
1993 p, ConcreteType::getPropertiesAsAttr(ctx, properties), elidedProps);
2000 template <
typename T = ConcreteType>
2016 if (!propertyDictionary)
2029 return ConcreteOpType::setPropertiesFromParsedAttr(
2037 return ConcreteType::populateDefaultAttrs;
2040 static LogicalResult verifyInvariants(Operation *op) {
2041 static_assert(hasNoDataMembers(),
2042 "Op class shouldn't define new data members");
2045 failed(cast<ConcreteType>(op).
verify()));
2048 return static_cast<LogicalResult (*)(Operation *)
>(&verifyInvariants);
2051 static LogicalResult verifyRegionInvariants(Operation *op) {
2052 static_assert(hasNoDataMembers(),
2053 "Op class shouldn't define new data members");
2060 return static_cast<LogicalResult (*)(Operation *)
>(&verifyRegionInvariants);
2063 static constexpr
bool hasNoDataMembers() {
2066 class EmptyOp :
public Op<EmptyOp, Traits...> {};
2067 return sizeof(ConcreteType) ==
sizeof(EmptyOp);
2071 friend RegisteredOperationName;
2076 template <
typename ConcreteType,
typename Traits>
2079 Op<ConcreteType>, OpTrait::TraitBase> {
2098 *dialect, name.
getTypeID(), ConcreteType::getInterfaceID(),
2099 llvm::getTypeName<ConcreteType>());
2104 if (std::optional<RegisteredOperationName> rInfo =
2106 if (
auto *opIface = rInfo->getInterface<ConcreteType>())
2110 return rInfo->getDialect().getRegisteredInterfaceForOp<ConcreteType>(
2116 return dialect->getRegisteredInterfaceForOp<ConcreteType>(name);
2128 template <
typename T>
2130 std::enable_if_t<std::is_base_of<mlir::OpState, T>::value &&
2131 !mlir::detail::IsInterface<T>::value>> {
2134 return T::getFromOpaquePointer(pointer);
2138 return T::getFromOpaquePointer(pointer);
2143 static bool isEqual(T lhs, T rhs) {
return lhs == rhs; }
static llvm::hash_code computeHash(SymbolOpInterface symbolOp)
Computes a hash code to represent symbolOp based on all its attributes except for the symbol name.
This class provides management for the lifetime of the state used when printing the IR.
Attributes are known-constant values of operations.
Block represents an ordered list of Operations.
OpListType::iterator iterator
OpListType & getOperations()
This class is a general helper class for creating context-global objects like types,...
Dialects are groups of MLIR operations, types and attributes, as well as behavior associated with the...
This class represents a diagnostic that is inflight and set to be reported.
This class defines the main interface for locations in MLIR and acts as a non-nullable wrapper around...
MLIRContext is the top-level object for a collection of MLIR operations.
NamedAttrList is array of NamedAttributes that tracks whether it is sorted and does some basic work t...
The OpAsmParser has methods for interacting with the asm parser: parsing things from it,...
This is a pure-virtual base class that exposes the asmprinter hooks necessary to implement a custom p...
This class helps build Operations.
This class represents a single result from folding an operation.
MLIRContext * getContext() const
This class represents the base of an operation interface.
friend InterfaceBase
Allow access to getInterfaceFor.
static InterfaceBase::Concept * getInterfaceFor(Operation *op)
Returns the impl interface instance for the given operation.
Set of flags used to control the behavior of the various IR print methods (e.g.
This is the concrete base class that holds the operation pointer and has non-generic methods that onl...
void dump()
Dump this operation.
static void genericPrintProperties(OpAsmPrinter &p, Attribute properties, ArrayRef< StringRef > elidedProps={})
Print the properties as a Attribute with names not included within 'elidedProps'.
std::enable_if_t< llvm::function_traits< std::decay_t< FnT > >::num_args==2, RetT > walk(FnT &&callback)
Generic walker with a stage aware callback.
MLIRContext * getContext()
Return the context this operation belongs to.
void erase()
Remove this operation from its parent block and delete it.
bool use_empty()
Return true if there are no users of any results of this operation.
LogicalResult verify()
If the concrete type didn't implement a custom verifier hook, just fall back to this one which accept...
std::enable_if_t< llvm::function_traits< std::decay_t< FnT > >::num_args==1, RetT > walk(FnT &&callback)
Walk the operation by calling the callback for each nested operation (including this one),...
void print(raw_ostream &os, AsmState &asmState)
static EmptyProperties & getEmptyProperties()
For all op which don't have properties, we keep a single instance of EmptyProperties to be used where...
static void printOpName(Operation *op, OpAsmPrinter &p, StringRef defaultDialect)
Print an operation name, eliding the dialect prefix if necessary.
LogicalResult verifyRegions()
InFlightDiagnostic emitError(const Twine &message={})
Emit an error about fatal conditions with this operation, reporting up to any diagnostic handlers tha...
InFlightDiagnostic emitOpError(const Twine &message={})
Emit an error with the op name prefixed, like "'dim' op " which is convenient for verifiers.
InFlightDiagnostic emitWarning(const Twine &message={})
Emit a warning about this operation, reporting up to any diagnostic handlers that may be listening.
Operation * getOperation()
Return the operation that this refers to.
static void getCanonicalizationPatterns(RewritePatternSet &results, MLIRContext *context)
This hook returns any canonicalization pattern rewrites that the operation supports,...
static ParseResult genericParseProperties(OpAsmParser &parser, Attribute &result)
Parse properties as a Attribute.
static ParseResult parse(OpAsmParser &parser, OperationState &result)
Parse the custom form of an operation.
InFlightDiagnostic emitRemark(const Twine &message={})
Emit a remark about this operation, reporting up to any diagnostic handlers that may be listening.
OpState(Operation *state)
Mutability management is handled by the OpWrapper/OpConstWrapper classes, so we can cast it away here...
Location getLoc()
The source location the operation was defined or derived from.
static void populateDefaultAttrs(const OperationName &, NamedAttrList &)
This hook populates any unset default attrs.
void print(raw_ostream &os, OpPrintingFlags flags=std::nullopt)
Print the operation to the given stream.
Operation * operator->() const
Shortcut of -> to access a member of Operation.
A trait of region holding operations that defines a new scope for polyhedral optimization purposes.
static LogicalResult verifyTrait(Operation *op)
static LogicalResult verifyTrait(Operation *op)
This class provides the API for ops that are known to have a at least a specified number of operands.
static LogicalResult verifyTrait(Operation *op)
This class provides APIs for ops that are known to have at least a specified number of regions.
static LogicalResult verifyTrait(Operation *op)
This class provides the API for ops that are known to have at least a specified number of results.
static LogicalResult verifyTrait(Operation *op)
This class provides APIs for ops that are known to have at least a specified number of successors.
A trait for operations that have an attribute specifying operand segments.
static StringRef getOperandSegmentSizeAttr()
static LogicalResult verifyTrait(Operation *op)
Similar to AttrSizedOperandSegments but used for results.
static StringRef getResultSegmentSizeAttr()
static LogicalResult verifyTrait(Operation *op)
A trait of region holding operations that define a new scope for automatic allocations,...
static LogicalResult verifyTrait(Operation *op)
This class provides the API for a sub-set of ops that are known to be constant-like.
static LogicalResult verifyTrait(Operation *op)
static LogicalResult verifyTrait(Operation *op)
std::enable_if_t< sizeof...(ParentOpTypes)==1, ParentOpType > getParentOp()
This class adds property that the operation is commutative.
static LogicalResult foldTrait(Operation *op, ArrayRef< Attribute > operands, SmallVectorImpl< OpFoldResult > &results)
This class adds property that the operation is idempotent.
static OpFoldResult foldTrait(Operation *op, ArrayRef< Attribute > operands)
static LogicalResult verifyTrait(Operation *op)
This class adds property that the operation is an involution.
static LogicalResult verifyTrait(Operation *op)
static OpFoldResult foldTrait(Operation *op, ArrayRef< Attribute > operands)
This class provides the API for ops that are known to be isolated from above.
static LogicalResult verifyRegionTrait(Operation *op)
This class provides the API for ops that are known to be terminators.
static LogicalResult verifyTrait(Operation *op)
static LogicalResult verifyTrait(Operation *op)
This class provides the API for ops that are known to have a specified number of operands.
static LogicalResult verifyTrait(Operation *op)
This class provides the API for ops that are known to have a specified number of regions.
static LogicalResult verifyTrait(Operation *op)
This class provides the API for ops that are known to have a specified number of results.
static LogicalResult verifyTrait(Operation *op)
This class provides the API for ops that are known to have a specified number of successors.
This class indicates that the regions associated with this op don't have terminators.
This class provides the API for ops that are known to have exactly one SSA operand.
void setOperand(Value value)
static LogicalResult verifyTrait(Operation *op)
This class provides APIs for ops that are known to have a single region.
static LogicalResult verifyTrait(Operation *op)
auto getOps()
Returns a range of operations within the region of this operation.
This class provides return value APIs for ops that are known to have a single result.
static LogicalResult verifyTrait(Operation *op)
void replaceAllUsesWith(Operation *op)
Replace all uses of 'this' value with the result of 'op'.
void replaceAllUsesWith(Value newValue)
Replace all uses of 'this' value with the new value, updating anything in the IR that uses 'this' to ...
This class provides APIs for ops that are known to have a single successor.
void setSuccessor(Block *succ)
static LogicalResult verifyTrait(Operation *op)
This class provides return value APIs for ops that are known to have a single result.
mlir::TypedValue< ResultType > getResult()
This trait is used for return value APIs for ops that are known to have a specific type other than Ty...
verifyInvariantsImpl verifies the invariants like the types, attrs, .etc.
static LogicalResult verifyTrait(Operation *op)
This class verifies that all operands of the specified op have a float type, a vector thereof,...
static LogicalResult verifyTrait(Operation *op)
This class verifies that all operands of the specified op have a signless integer or index type,...
static LogicalResult verifyTrait(Operation *op)
This class verifies that any results of the specified op have a boolean type, a vector thereof,...
static LogicalResult verifyTrait(Operation *op)
This class verifies that any results of the specified op have a floating point type,...
static LogicalResult verifyTrait(Operation *op)
This class verifies that any results of the specified op have a signless integer or index type,...
static LogicalResult verifyTrait(Operation *op)
This class provides verification for ops that are known to have the same operand and result element t...
static LogicalResult verifyTrait(Operation *op)
This class verifies that op has same ranks for all operands and results types, if known.
static LogicalResult verifyTrait(Operation *op)
This class provides verification for ops that are known to have the same operand and result shape: bo...
static LogicalResult verifyTrait(Operation *op)
This class provides verification for ops that are known to have the same operand and result type.
static LogicalResult verifyTrait(Operation *op)
This class provides verification for ops that are known to have the same operand element type (or the...
static LogicalResult verifyTrait(Operation *op)
This class provides verification for ops that are known to have the same operand shape: all operands ...
static LogicalResult verifyTrait(Operation *op)
This class verifies that all operands of the specified op have the same type.
static LogicalResult verifyTrait(Operation *op)
static void ensureTerminator(Region ®ion, OpBuilder &builder, Location loc)
static void ensureTerminator(Region ®ion, Builder &builder, Location loc)
Ensure that the given region has the terminator required by this trait.
static LogicalResult verifyRegionTrait(Operation *op)
TerminatorOpType ImplicitTerminatorOpT
The type of the operation used as the implicit terminator type.
Helper class for implementing traits.
Operation * getOperation()
Return the ultimate Operation being worked on.
This class provides the API for ops which have an unknown number of SSA operands.
This class provides the API for ops which have an unknown number of regions.
This class provides the API for ops which have an unknown number of results.
This class provides the API for ops which have an unknown number of successors.
This class provides the API for ops that are known to have no SSA operand.
static LogicalResult verifyTrait(Operation *op)
This class provides verification for ops that are known to have zero regions.
static LogicalResult verifyTrait(Operation *op)
This class provides return value APIs for ops that are known to have zero results.
static LogicalResult verifyTrait(Operation *op)
This class provides verification for ops that are known to have zero successors.
static LogicalResult verifyTrait(Operation *op)
This provides public APIs that all operations should have.
static bool classof(Operation *op)
Return true if this "op class" can match against the specified operation.
static LogicalResult setPropertiesFromAttr(PropertiesTy &prop, Attribute attr, function_ref< InFlightDiagnostic()> emitError)
Convert the provided attribute to a property and assigned it to the provided properties.
static ConcreteOpType getFromOpaquePointer(const void *pointer)
LogicalResult verify()
If the concrete type didn't implement a custom verifier hook, just fall back to this one which accept...
Op(Operation *state)
This is a public constructor to enable access via the llvm::cast family of methods.
ConcreteType ConcreteOpType
Expose the type we are instantiated on to template machinery that may want to introspect traits on th...
static Attribute getPropertiesAsAttr(MLIRContext *ctx, const PropertiesTy &prop)
Convert the provided properties to an attribute.
LogicalResult verifyRegions()
static void printProperties(MLIRContext *ctx, OpAsmPrinter &p, const T &properties, ArrayRef< StringRef > elidedProps={})
Print the operation properties with names not included within 'elidedProps'.
ConcreteType clone()
Create a deep copy of this operation.
static std::enable_if_t< std::is_base_of< OpState, T >::value, bool > classof(const T *op)
Provide classof support for other OpBase derived classes, such as Interfaces.
Operation * getOperation()
Inherit getOperation from OpState.
static constexpr bool hasTrait()
Return if this operation contains the provided trait.
static llvm::hash_code computePropertiesHash(const PropertiesTy &prop)
Hash the provided properties.
const void * getAsOpaquePointer() const
Methods for supporting PointerLikeTypeTraits.
static constexpr bool hasProperties()
Returns true if this operation defines a Properties inner type.
InferredProperties< T > & getProperties()
Op()
This is a public constructor. Any op can be initialized to null.
static ParseResult parseProperties(OpAsmParser &parser, OperationState &result)
Parses 'prop-dict' for the operation.
static void attachInterface(MLIRContext &context)
Attach the given models as implementations of the corresponding interfaces for the concrete operation...
typename PropertiesSelector< T >::type InferredProperties
ConcreteType cloneWithoutRegions()
Create a partial copy of this operation without traversing into attached regions.
static void populateDefaultProperties(OperationName opName, InferredProperties< T > &properties)
This hook populates any unset default attrs when mapped to properties.
This class implements the operand iterators for the Operation class.
llvm::unique_function< LogicalResult(Operation *) const > VerifyInvariantsFn
StringRef getStringRef() const
Return the name of this operation. This always succeeds.
llvm::unique_function< bool(TypeID) const > HasTraitFn
Dialect * getDialect() const
Return the dialect this operation is registered to if the dialect is loaded in the context,...
llvm::unique_function< LogicalResult(Operation *) const > VerifyRegionInvariantsFn
std::optional< RegisteredOperationName > getRegisteredInfo() const
If this operation is registered, returns the registered information, std::nullopt otherwise.
llvm::unique_function< void(Operation *, OpAsmPrinter &, StringRef) const > PrintAssemblyFn
TypeID getTypeID() const
Return the unique identifier of the derived Op class, or null if not registered.
llvm::unique_function< LogicalResult(Operation *, ArrayRef< Attribute >, SmallVectorImpl< OpFoldResult > &) const > FoldHookFn
llvm::unique_function< void(const OperationName &, NamedAttrList &) const > PopulateDefaultAttrsFn
Operation is the basic unit of execution within MLIR.
ResultRange result_range
Support result iteration.
bool use_empty()
Returns true if this operation has no uses.
Value getOperand(unsigned idx)
bool hasTrait()
Returns true if the operation was registered with a particular trait, e.g.
operand_range::type_range operand_type_range
void setOperand(unsigned idx, Value value)
Block * getSuccessor(unsigned index)
unsigned getNumSuccessors()
result_iterator result_begin()
result_range::iterator result_iterator
operand_iterator operand_begin()
OpaqueProperties getPropertiesStorageUnsafe()
Returns the properties storage without checking whether properties are present.
OpResult getResult(unsigned idx)
Get the 'idx'th result of this operation.
std::enable_if_t< llvm::function_traits< std::decay_t< FnT > >::num_args==1, RetT > walk(FnT &&callback)
Walk the operation by calling the callback for each nested operation (including this one),...
void print(raw_ostream &os, const OpPrintingFlags &flags=std::nullopt)
operand_range::type_iterator operand_type_iterator
operand_type_iterator operand_type_end()
result_range::type_range result_type_range
MLIRContext * getContext()
Return the context this operation is associated with.
unsigned getNumRegions()
Returns the number of regions held by this operation.
Location getLoc()
The source location the operation was defined or derived from.
unsigned getNumOperands()
result_type_iterator result_type_end()
static Operation * create(Location location, OperationName name, TypeRange resultTypes, ValueRange operands, NamedAttrList &&attributes, OpaqueProperties properties, BlockRange successors, unsigned numRegions)
Create a new Operation with the specific fields.
Operation * getParentOp()
Returns the closest surrounding operation that contains this operation or nullptr if this is a top-le...
OperandRange operand_range
result_range::type_iterator result_type_iterator
Support result type iteration.
operand_iterator operand_end()
Region & getRegion(unsigned index)
Returns the region held by this operation at position 'index'.
result_type_iterator result_type_begin()
MutableArrayRef< Region > getRegions()
Returns the regions held by this operation.
OperationName getName()
The name of an operation is the key identifier for it.
operand_type_range getOperandTypes()
result_iterator result_end()
result_type_range getResultTypes()
operand_range getOperands()
Returns an iterator on the underlying Value's.
void setSuccessor(Block *block, unsigned index)
void replaceAllUsesWith(ValuesT &&values)
Replace all uses of results of this operation with the provided 'values'.
SuccessorRange getSuccessors()
result_range getResults()
SuccessorRange::iterator succ_iterator
operand_range::iterator operand_iterator
void erase()
Remove this operation from its parent block and delete it.
unsigned getNumResults()
Return the number of results held by this operation.
operand_type_iterator operand_type_begin()
This class implements Optional functionality for ParseResult.
OptionalParseResult()=default
ParseResult value() const
Access the internal ParseResult value.
OptionalParseResult(ParseResult result)
OptionalParseResult(std::nullopt_t)
OptionalParseResult(const InFlightDiagnostic &)
OptionalParseResult(LogicalResult result)
bool has_value() const
Returns true if we contain a valid ParseResult value.
ParseResult operator*() const
This class provides an abstraction over the different types of ranges over Regions.
This class contains a list of basic blocks and a link to the parent operation it is attached to.
iterator_range< OpIterator > getOps()
This is a "type erased" representation of a registered operation.
static std::optional< RegisteredOperationName > lookup(StringRef name, MLIRContext *ctx)
Lookup the registered operation information for the given operation.
This class implements the result iterators for the Operation class.
This class implements the successor iterators for Block.
This class provides an efficient unique identifier for a specific C++ type.
Instances of the Type class are uniqued, have an immutable identifier and an optional mutable compone...
This class implements iteration on the types of a given range of values.
This class implements iteration on the types of a given range of values.
This class represents an instance of an SSA value in the MLIR system, representing a computable value...
Type getType() const
Return the type of this value.
void replaceAllUsesWith(Value newValue)
Replace all uses of 'this' value with the new value, updating anything in the IR that uses 'this' to ...
This class represents an abstract interface.
Interface< ConcreteType, Operation *, Traits, Op< ConcreteType >, OpTrait::TraitBase > InterfaceBase
typename Traits::Concept Concept
The OpAsmOpInterface, see OpAsmInterface.td for more details.
OpFoldResult foldIdempotent(Operation *op)
LogicalResult verifyResultsAreFloatLike(Operation *op)
LogicalResult verifyAtLeastNResults(Operation *op, unsigned numOperands)
LogicalResult verifyIsIdempotent(Operation *op)
LogicalResult verifyOperandsAreSignlessIntegerLike(Operation *op)
LogicalResult verifyNOperands(Operation *op, unsigned numOperands)
LogicalResult verifyNoRegionArguments(Operation *op)
LogicalResult verifyResultsAreSignlessIntegerLike(Operation *op)
LogicalResult verifyIsInvolution(Operation *op)
LogicalResult verifyOperandsAreFloatLike(Operation *op)
LogicalResult foldCommutative(Operation *op, ArrayRef< Attribute > operands, SmallVectorImpl< OpFoldResult > &results)
LogicalResult verifyZeroRegions(Operation *op)
LogicalResult verifyNSuccessors(Operation *op, unsigned numSuccessors)
LogicalResult verifyOperandSizeAttr(Operation *op, StringRef sizeAttrName)
LogicalResult verifyAtLeastNRegions(Operation *op, unsigned numRegions)
LogicalResult verifyValueSizeAttr(Operation *op, StringRef attrName, StringRef valueGroupName, size_t expectedCount)
LogicalResult verifyZeroResults(Operation *op)
LogicalResult verifySameOperandsAndResultType(Operation *op)
LogicalResult verifySameOperandsShape(Operation *op)
LogicalResult verifyAtLeastNSuccessors(Operation *op, unsigned numSuccessors)
LogicalResult verifyIsTerminator(Operation *op)
LogicalResult verifyAtLeastNOperands(Operation *op, unsigned numOperands)
LogicalResult verifyZeroOperands(Operation *op)
LogicalResult verifyElementwise(Operation *op)
LogicalResult verifyOneRegion(Operation *op)
LogicalResult verifySameOperandsAndResultRank(Operation *op)
LogicalResult verifyOneOperand(Operation *op)
LogicalResult verifyIsIsolatedFromAbove(Operation *op)
Check for any values used by operations regions attached to the specified "IsIsolatedFromAbove" opera...
LogicalResult verifyZeroSuccessors(Operation *op)
LogicalResult verifySameOperandsElementType(Operation *op)
LogicalResult verifyOneSuccessor(Operation *op)
LogicalResult verifySameOperandsAndResultElementType(Operation *op)
OpFoldResult foldInvolution(Operation *op)
LogicalResult verifyResultsAreBoolLike(Operation *op)
LogicalResult verifyNResults(Operation *op, unsigned numOperands)
LogicalResult verifyResultSizeAttr(Operation *op, StringRef sizeAttrName)
LogicalResult verifyNRegions(Operation *op, unsigned numRegions)
LogicalResult verifyOneResult(Operation *op)
LogicalResult verifySameTypeOperands(Operation *op)
LogicalResult verifySameOperandsAndResultShape(Operation *op)
bool hasElementwiseMappableTraits(Operation *op)
Together, Elementwise, Scalarizable, Vectorizable, and Tensorizable provide an easy way for scalar op...
typename T::ImplicitTerminatorOpT has_implicit_terminator_t
Check is an op defines the ImplicitTerminatorOpT member.
NestedPattern Op(FilterFunctionType filter=defaultFilterFunction)
void handleUseOfUndefinedPromisedInterface(Dialect &dialect, TypeID interfaceRequestorID, TypeID interfaceID, StringRef interfaceName)
Checks if the given interface, which is attempting to be used, is a promised interface of this dialec...
void ensureRegionTerminator(Region ®ion, OpBuilder &builder, Location loc, function_ref< Operation *(OpBuilder &, Location)> buildTerminatorOp)
Insert an operation, generated by buildTerminatorOp, at the end of the region's only block if it does...
void ensureRegionTerminator(Region ®ion, Builder &builder, Location loc, function_ref< Operation *(OpBuilder &, Location)> buildTerminatorOp)
Create a simple OpBuilder and forward to the OpBuilder version of this function.
llvm::is_detected< has_fold_trait, T > detect_has_fold_trait
llvm::is_detected< has_verify_trait, T > detect_has_verify_trait
bool hasTrait(TypeID traitID)
bool hasTrait(TypeID traitID)
Returns true if this given Trait ID matches the IDs of any of the provided trait types Traits.
llvm::is_detected< has_verify_region_trait, T > detect_has_verify_region_trait
LogicalResult verifyTraits(Operation *op)
Given a set of traits, return the result of verifying the given operation.
std::enable_if_t<!detect_has_verify_trait< T >::value, LogicalResult > verifyTrait(Operation *)
decltype(T::verifyTrait(std::declval< Operation * >())) has_verify_trait
Trait to check if T provides a verifyTrait method.
decltype(T::foldTrait(std::declval< Operation * >(), std::declval< ArrayRef< Attribute > >(), std::declval< SmallVectorImpl< OpFoldResult > & >())) has_fold_trait
Trait to check if T provides a general 'foldTrait' method.
llvm::is_detected< has_single_result_fold_trait, T > detect_has_single_result_fold_trait
static std::enable_if_t<!detect_has_any_fold_trait< Trait >::value, LogicalResult > foldTrait(Operation *, ArrayRef< Attribute >, SmallVectorImpl< OpFoldResult > &)
std::disjunction< detect_has_fold_trait< T >, detect_has_single_result_fold_trait< T > > detect_has_any_fold_trait
Trait to check if T provides any foldTrait method.
decltype(T::verifyRegionTrait(std::declval< Operation * >())) has_verify_region_trait
Trait to check if T provides a verifyTrait method.
static LogicalResult foldTraits(Operation *op, ArrayRef< Attribute > operands, SmallVectorImpl< OpFoldResult > &results)
Given a tuple type containing a set of traits, return the result of folding the given operation.
decltype(T::foldTrait(std::declval< Operation * >(), std::declval< ArrayRef< Attribute > >())) has_single_result_fold_trait
Trait to check if T provides a 'foldTrait' method for single result operations.
LogicalResult verifyRegionTraits(Operation *op)
Given a set of traits, return the result of verifying the regions of the given operation.
std::enable_if_t<!detect_has_verify_region_trait< T >::value, LogicalResult > verifyRegionTrait(Operation *)
inline ::llvm::hash_code hash_value(const PolynomialBase< D, T > &arg)
Include the generated interface declarations.
llvm::function_ref< Fn > function_ref
std::conditional_t< std::is_same_v< Ty, mlir::Type >, mlir::Value, detail::TypedValue< Ty > > TypedValue
If Ty is mlir::Type this will select Value instead of having a wrapper around it.
InFlightDiagnostic emitError(Location loc)
Utility method to emit an error message using this location.
bool operator==(StringAttr lhs, std::nullptr_t)
Define comparisons for StringAttr against nullptr and itself to avoid the StringRef overloads from be...
WalkOrder
Traversal order for region, block and operation walk utilities.
bool operator!=(RegionBranchPoint lhs, RegionBranchPoint rhs)
auto get(MLIRContext *context, Ts &&...params)
Helper method that injects context only if needed, this helps unify some of the attribute constructio...
raw_ostream & operator<<(raw_ostream &os, const AliasResult &result)
static bool isEqual(T lhs, T rhs)
static T getTombstoneKey()
static unsigned getHashValue(T val)
Structure used by default as a "marker" when no "Properties" are set on an Operation.
This trait tags element-wise ops on vectors or tensors.
static LogicalResult verifyTrait(Operation *op)
This class provides a verifier for ops that are expecting their parent to be one of the given parent ...
This trait provides a verifier for ops that are expecting their regions to not have any arguments.
static LogicalResult verifyTrait(Operation *op)
This trait tags Elementwise operatons that can be systematically scalarized.
static LogicalResult verifyTrait(Operation *op)
This class provides APIs and verifiers for ops with regions having a single block that must terminate...
This class provides APIs and verifiers for ops with regions having a single block.
std::enable_if_t< OpT::template hasTrait< OneRegion >(), T > enable_if_single_region
The following are a set of methods only enabled when the parent operation has a single region.
enable_if_single_region< OpT > insert(Operation *insertPt, Operation *op)
Insert the operation at the given insertion point.
Region & getBodyRegion(unsigned idx=0)
enable_if_single_region< OpT > push_back(Operation *op)
Insert the operation into the back of the body.
enable_if_single_region< OpT, Block::iterator > begin()
enable_if_single_region< OpT, Operation & > front()
static LogicalResult verifyTrait(Operation *op)
enable_if_single_region< OpT > insert(Block::iterator insertPt, Operation *op)
Block * getBody(unsigned idx=0)
enable_if_single_region< OpT, Block::iterator > end()
This trait tags Elementwise operatons that can be systematically tensorized.
static LogicalResult verifyTrait(Operation *op)
This trait tags Elementwise operatons that can be systematically vectorized.
static LogicalResult verifyTrait(Operation *op)
Utility trait base that provides accessors for derived traits that have multiple operands.
Value getOperand(unsigned i)
Return the operand at index 'i'.
operand_type_range getOperandTypes()
operand_type_iterator operand_type_begin()
Operand type access.
unsigned getNumOperands()
Return the number of operands.
operand_iterator operand_begin()
Operand iterator access.
operand_type_iterator operand_type_end()
void setOperand(unsigned i, Value value)
Set the operand at index 'i' to 'value'.
Operation::operand_iterator operand_iterator
operand_iterator operand_end()
operand_range getOperands()
Utility trait base that provides accessors for derived traits that have multiple regions.
unsigned getNumRegions()
Return the number of regions.
Region & getRegion(unsigned i)
Return the region at index.
region_iterator region_begin()
Region iterator access.
region_range getRegions()
region_iterator region_end()
Utility trait base that provides accessors for derived traits that have multiple results.
result_type_iterator result_type_end()
result_type_range getResultTypes()
result_type_iterator result_type_begin()
Result type access.
result_iterator result_end()
Value getResult(unsigned i)
Return the result at index 'i'.
void replaceAllUsesWith(ValuesT &&values)
Replace all uses of results of this operation with the provided 'values'.
Operation::result_iterator result_iterator
result_iterator result_begin()
Result iterator access.
unsigned getNumResults()
Return the number of results.
result_range getResults()
Type getType(unsigned i)
Return the type of the i-th result.
Utility trait base that provides accessors for derived traits that have multiple successors.
void setSuccessor(Block *block, unsigned i)
Set the successor at index.
succ_iterator succ_begin()
Successor iterator access.
unsigned getNumSuccessors()
Return the number of successors.
Operation::succ_iterator succ_iterator
Block * getSuccessor(unsigned i)
Return the successor at index.
succ_range getSuccessors()
Support to check if an operation has the SingleBlockImplicitTerminator trait.
static constexpr bool value
This represents an operation in an abstracted form, suitable for use with the builder APIs.
T & getOrAddProperties()
Get (or create) a properties of the provided type to be set on the operation on creation.
MLIRContext * getContext() const
Get the context held by this operation state.
typename Op::Properties type
Traits to detect whether an Operation defined a Properties type, otherwise it'll default to EmptyProp...