13 #ifndef MLIR_IR_OPIMPLEMENTATION_H
14 #define MLIR_IR_OPIMPLEMENTATION_H
20 #include "llvm/ADT/Twine.h"
21 #include "llvm/Support/SMLoc.h"
26 template <
typename T,
typename =
void>
27 struct HasStaticName : std::false_type {};
30 struct HasStaticName<T,
31 typename std::enable_if<
32 std::is_same<::llvm::StringLiteral,
33 std::decay_t<decltype(T::name)>>::value,
34 void>::type> : std::true_type {};
38 class AsmParsedResourceEntry;
39 class AsmResourceBuilder;
51 : resource(resource), opaqueID(resourceID), dialect(dialect) {}
53 return resource == other.resource;
67 void *resource =
nullptr;
77 template <
typename DerivedT,
typename ResourceT,
typename DialectT>
88 assert(handle.
getTypeID() == TypeID::get<DerivedT>());
106 return handle->
getTypeID() == TypeID::get<DerivedT>();
136 virtual void printFloat(
const APFloat &value);
142 template <
typename AttrOrType>
144 decltype(std::declval<AttrOrType>().
print(std::declval<AsmPrinter &>()));
145 template <
typename AttrOrType>
147 llvm::is_detected<has_print_method, AttrOrType>;
152 template <
typename AttrOrType,
153 std::enable_if_t<detect_has_print_method<AttrOrType>::value>
160 uint64_t posPrior = os.tell();
161 attrOrType.print(*
this);
162 if (posPrior != os.tell())
174 template <
typename AttrOrType,
175 std::enable_if_t<detect_has_print_method<AttrOrType>::value>
178 llvm::interleaveComma(
186 template <
typename AttrOrType,
187 std::enable_if_t<!detect_has_print_method<AttrOrType>::value>
224 template <
typename TypeRange>
226 if (types.begin() != types.end())
229 template <
typename TypeRange>
233 bool wrapped = !llvm::hasSingleElement(types) ||
234 llvm::isa<FunctionType>((*types.begin()));
237 llvm::interleaveComma(types, *
this);
243 template <
typename InputRangeT,
typename ResultRangeT>
247 llvm::interleaveComma(inputs, *
this);
269 : printer(std::exchange(rhs.printer, nullptr)) {}
272 printer = std::exchange(rhs.printer,
nullptr);
289 template <
class AttrOrTypeT>
295 "Only mutable attributes or types can be cyclic");
325 template <
typename AsmPr
interT>
326 inline std::enable_if_t<std::is_base_of<AsmPrinter, AsmPrinterT>::value,
333 template <
typename AsmPr
interT>
334 inline std::enable_if_t<std::is_base_of<AsmPrinter, AsmPrinterT>::value,
337 p.printAttribute(attr);
341 template <
typename AsmPr
interT>
342 inline std::enable_if_t<std::is_base_of<AsmPrinter, AsmPrinterT>::value,
344 operator<<(AsmPrinterT &p,
const APFloat &value) {
348 template <
typename AsmPr
interT>
349 inline std::enable_if_t<std::is_base_of<AsmPrinter, AsmPrinterT>::value,
352 return p << APFloat(value);
354 template <
typename AsmPr
interT>
355 inline std::enable_if_t<std::is_base_of<AsmPrinter, AsmPrinterT>::value,
358 return p << APFloat(value);
364 template <
typename AsmPrinterT,
typename T,
365 std::enable_if_t<!std::is_convertible<T &, Value &>::value &&
366 !std::is_convertible<T &, Type &>::value &&
367 !std::is_convertible<T &, Attribute &>::value &&
368 !std::is_convertible<T &, ValueRange>::value &&
369 !std::is_convertible<T &, APFloat &>::value &&
370 !llvm::is_one_of<T, bool, float, double>::value,
372 inline std::enable_if_t<std::is_base_of<AsmPrinter, AsmPrinterT>::value,
375 p.getStream() << other;
379 template <
typename AsmPr
interT>
380 inline std::enable_if_t<std::is_base_of<AsmPrinter, AsmPrinterT>::value,
383 return p << (value ? StringRef(
"true") :
"false");
386 template <
typename AsmPr
interT,
typename ValueRangeT>
387 inline std::enable_if_t<std::is_base_of<AsmPrinter, AsmPrinterT>::value,
389 operator<<(AsmPrinterT &p,
const ValueTypeRange<ValueRangeT> &types) {
390 llvm::interleaveComma(types, p);
394 template <
typename AsmPr
interT>
395 inline std::enable_if_t<std::is_base_of<AsmPrinter, AsmPrinterT>::value,
397 operator<<(AsmPrinterT &p,
const TypeRange &types) {
398 llvm::interleaveComma(types, p);
407 template <
typename AsmPr
interT,
typename T>
408 inline std::enable_if_t<std::is_same<AsmPrinter, AsmPrinterT>::value &&
409 std::is_convertible<T &, ValueRange>::value,
411 operator<<(AsmPrinterT &p,
const T &other) =
delete;
413 template <
typename AsmPr
interT,
typename ElementT>
414 inline std::enable_if_t<std::is_base_of<AsmPrinter, AsmPrinterT>::value,
416 operator<<(AsmPrinterT &p, ArrayRef<ElementT> types) {
417 llvm::interleaveComma(types, p);
452 bool omitType =
false) = 0;
459 template <
typename ContainerType>
465 template <
typename IteratorType>
467 llvm::interleaveComma(llvm::make_range(it, end),
getStream(),
506 bool printBlockTerminators =
true,
507 bool printEmptyBlock =
false) = 0;
540 template <
typename T,
541 std::enable_if_t<std::is_convertible<T &, ValueRange>::value &&
542 !std::is_convertible<T &, Value &>::value,
576 const Twine &message = {}) = 0;
687 return emitError(loc,
"expected string");
731 virtual ParseResult
parseFloat(
const llvm::fltSemantics &semantics,
732 APFloat &result) = 0;
735 template <
typename IntT>
740 return emitError(loc,
"expected integer value");
745 template <
typename IntT>
750 return emitError(loc,
"expected decimal integer value");
759 template <
typename IntT,
typename ParseFn>
765 if (!parseResult.
has_value() || failed(*parseResult))
772 (IntT)uintResult.sextOrTrunc(
sizeof(IntT) * CHAR_BIT).getLimitedValue();
773 if (APInt(uintResult.getBitWidth(), result,
774 std::is_signed_v<IntT>,
776 return emitError(loc,
"integer value too large");
781 template <
typename IntT>
783 return parseOptionalIntegerAndCheck(
787 template <
typename IntT>
789 return parseOptionalIntegerAndCheck(result, [&](APInt &result) {
826 StringRef contextMessage = StringRef()) = 0;
844 template <
typename ResultT = ParseResult>
849 if (keyword && !keyword->empty())
850 this->keyword = *keyword;
856 return Case(str, [&](StringRef, SMLoc) {
return std::move(value); });
859 return Default([&](StringRef, SMLoc) {
return std::move(value); });
864 template <
typename FnT>
865 std::enable_if_t<!std::is_convertible<FnT, ResultT>::value,
KeywordSwitch &>
866 Case(StringLiteral str, FnT &&fn) {
873 else if (keyword == str)
874 result.emplace(std::move(fn(keyword, loc)));
877 template <
typename FnT>
878 std::enable_if_t<!std::is_convertible<FnT, ResultT>::value,
KeywordSwitch &>
881 result.emplace(fn(keyword, loc));
886 bool hasValue()
const {
return result.has_value(); }
889 [[nodiscard]]
operator ResultT() {
891 return parser.
emitError(loc,
"unexpected keyword: ") << keyword;
892 return std::move(*result);
906 std::optional<ResultT> result;
913 virtual ParseResult
parseKeyword(StringRef keyword,
const Twine &msg) = 0;
919 return emitError(loc,
"expected valid keyword");
939 <<
"expected valid keyword or string";
954 template <
typename T,
typename... ParamsT>
956 return T::getChecked([&] {
return emitError(loc); },
957 std::forward<ParamsT>(params)...);
961 template <
typename T,
typename... ParamsT>
964 std::forward<ParamsT>(params)...);
982 template <
typename AttrType>
992 if (!(result = llvm::dyn_cast<AttrType>(attr)))
993 return emitError(loc,
"invalid kind of attribute specified");
1006 template <
typename AttrType>
1015 template <
typename AttrType>
1026 result = llvm::dyn_cast<AttrType>(attr);
1028 return emitError(loc,
"invalid kind of attribute specified");
1030 attrs.
append(attrName, result);
1035 template <
typename AttrType>
1037 std::declval<Type>()));
1038 template <
typename AttrType>
1045 template <
typename AttrType>
1046 std::enable_if_t<detect_has_parse_method<AttrType>::value, ParseResult>
1054 attr, type, [&](
Attribute &result,
Type type) -> ParseResult {
1063 result = llvm::dyn_cast<AttrType>(attr);
1065 return emitError(loc,
"invalid kind of attribute specified");
1067 attrs.
append(attrName, result);
1072 template <
typename AttrType>
1073 std::enable_if_t<!detect_has_parse_method<AttrType>::value, ParseResult>
1082 template <
typename AttrType>
1083 std::enable_if_t<detect_has_parse_method<AttrType>::value, ParseResult>
1090 attr, type, [&](
Attribute &result,
Type type) -> ParseResult {
1092 return success(!!result);
1097 result = llvm::dyn_cast<AttrType>(attr);
1099 return emitError(loc,
"invalid kind of attribute specified");
1104 template <
typename AttrType>
1105 std::enable_if_t<!detect_has_parse_method<AttrType>::value, ParseResult>
1113 Type type = {}) = 0;
1117 Type type = {}) = 0;
1121 Type type = {}) = 0;
1125 Type type = {}) = 0;
1129 template <
typename AttrType>
1138 template <
typename AttrType>
1143 if (parseResult.
has_value() && succeeded(*parseResult))
1144 attrs.
append(attrName, result);
1177 <<
"expected valid '@'-identifier for symbol name";
1187 attrs.
append(attrName, result);
1200 attrs.
append(attrName, result);
1211 template <
typename ResourceT>
1220 <<
"dialect '" << ResourceT::Dialect::getDialectNamespace()
1227 if (
auto *result = dyn_cast<ResourceT>(&*handle))
1228 return std::move(*result);
1229 return emitError(handleLoc) <<
"provided resource handle differs from the "
1230 "expected resource type";
1249 template <
typename TypeT>
1259 result = llvm::dyn_cast<TypeT>(type);
1262 emitError(loc,
"invalid kind of type specified");
1263 if constexpr (HasStaticName<TypeT>::value)
1264 diag <<
": expected " << TypeT::name <<
", but found " << type;
1272 template <
typename TypeT>
1275 template <
typename TypeT>
1277 llvm::is_detected<type_has_parse_method, TypeT>;
1282 template <
typename TypeT>
1283 std::enable_if_t<detect_type_has_parse_method<TypeT>::value, ParseResult>
1291 return success(!!result);
1296 result = llvm::dyn_cast<TypeT>(type);
1299 emitError(loc,
"invalid kind of type specified");
1300 if constexpr (HasStaticName<TypeT>::value)
1301 diag <<
": expected " << TypeT::name <<
", but found " << type;
1308 template <
typename TypeT>
1309 std::enable_if_t<!detect_type_has_parse_method<TypeT>::value, ParseResult>
1328 template <
typename TypeType>
1338 result = llvm::dyn_cast<TypeType>(type);
1341 emitError(loc,
"invalid kind of type specified");
1342 if constexpr (HasStaticName<TypeType>::value)
1343 diag <<
": expected " << TypeType::name <<
", but found " << type;
1367 result.push_back(type);
1376 result.append(types.begin(), types.end());
1394 bool allowDynamic =
true,
1395 bool withTrailingX =
true) = 0;
1415 : parser(std::exchange(rhs.parser, nullptr)) {}
1417 parser = std::exchange(rhs.parser,
nullptr);
1433 template <
class AttrOrTypeT>
1439 "Only mutable attributes or types can be cyclic");
1449 virtual FailureOr<AsmDialectResourceHandle>
1476 void operator=(
const AsmParser &) =
delete;
1521 virtual std::pair<StringRef, unsigned>
1565 std::optional<
MutableArrayRef<std::unique_ptr<Region>>> parsedRegions =
1568 std::optional<Attribute> parsedPropertiesAttribute = std::nullopt,
1569 std::optional<FunctionType> parsedFnType = std::nullopt) = 0;
1574 bool allowResultNumber =
true) = 0;
1579 bool allowResultNumber =
true) = 0;
1586 bool allowResultNumber =
true,
1587 int requiredOperandCount = -1) = 0;
1591 int requiredOperandCount,
1594 true, requiredOperandCount);
1617 template <
typename Operands = ArrayRef<UnresolvedOperand>>
1625 template <
typename Operands = ArrayRef<UnresolvedOperand>>
1628 return resolveOperands(std::forward<Operands>(operands), type, result);
1634 template <
typename Operands = ArrayRef<UnresolvedOperand>,
1635 typename Types = ArrayRef<Type>>
1636 std::enable_if_t<!std::is_convertible<Types, Type>::value, ParseResult>
1639 size_t operandSize = llvm::range_size(operands);
1640 size_t typeSize = llvm::range_size(types);
1641 if (operandSize != typeSize) {
1644 <<
"number of operands and types do not match: got " << operandSize
1645 <<
" operands and " << typeSize <<
" types";
1648 for (
auto [operand, type] : llvm::zip_equal(operands, types))
1689 bool allowAttrs =
false) = 0;
1694 bool allowAttrs =
false) = 0;
1699 bool allowType =
false,
1700 bool allowAttrs =
false) = 0;
1716 bool enableNameShadowing =
false) = 0;
1721 bool enableNameShadowing =
false) = 0;
1729 bool enableNameShadowing =
false) = 0;
1756 return result.
value();
1794 virtual FailureOr<AsmDialectResourceHandle>
1804 "Dialect must implement `getResourceKey` when defining resources");
1828 ArrayRef<int64_t> dimensions);
1839 #include "mlir/IR/OpAsmOpInterface.h.inc"
static std::string diag(const llvm::Value &value)
static void print(spirv::VerCapExtAttr triple, DialectAsmPrinter &printer)
Base type for affine expression.
A multi-dimensional affine map Affine map's are immutable like Type's, and they are uniqued.
This class represents a CRTP base class for dialect resource handles.
const ResourceT * getResource() const
AsmDialectResourceHandleBase(AsmDialectResourceHandle handle)
ResourceT * getResource()
Return the resource referenced by this handle.
static bool classof(const AsmDialectResourceHandle *handle)
Support llvm style casting.
AsmDialectResourceHandleBase(ResourceT *resource, DialectT *dialect)
Construct a handle from a pointer to the resource.
DialectT * getDialect() const
Return the dialect that owns the resource.
This class represents an opaque handle to a dialect resource entry.
AsmDialectResourceHandle()=default
Dialect * getDialect() const
Return the dialect that owns the resource.
TypeID getTypeID() const
Return the type ID of the resource.
bool operator==(const AsmDialectResourceHandle &other) const
AsmDialectResourceHandle(void *resource, TypeID resourceID, Dialect *dialect)
void * getResource() const
Return an opaque pointer to the referenced resource.
This class represents a single parsed resource entry.
Class used to automatically end a cyclic region on destruction.
CyclicParseReset & operator=(CyclicParseReset &&rhs)
CyclicParseReset & operator=(const CyclicParseReset &)=delete
CyclicParseReset(const CyclicParseReset &)=delete
CyclicParseReset(AsmParser *parser)
CyclicParseReset(CyclicParseReset &&rhs)
This class represents a StringSwitch like class that is useful for parsing expected keywords.
std::enable_if_t<!std::is_convertible< FnT, ResultT >::value, KeywordSwitch & > Default(FnT &&fn)
KeywordSwitch & Case(StringLiteral str, ResultT value)
Case that uses the provided value when true.
bool hasValue() const
Returns true if this switch has a value yet.
std::enable_if_t<!std::is_convertible< FnT, ResultT >::value, KeywordSwitch & > Case(StringLiteral str, FnT &&fn)
Case that invokes the provided functor when true.
KeywordSwitch & Default(ResultT value)
KeywordSwitch(AsmParser &parser, StringRef *keyword=nullptr)
This base class exposes generic asm parser hooks, usable across the various derived parsers.
virtual ParseResult parseMinus()=0
Parse a '-' token.
llvm::is_detected< has_parse_method, AttrType > detect_has_parse_method
ParseResult parseSymbolName(StringAttr &result)
Parse an -identifier and store it (without the '@' symbol) in a string attribute.
virtual ParseResult parseLBrace()=0
Parse a { token.
Delimiter
These are the supported delimiters around operand lists and region argument lists,...
@ Paren
Parens surrounding zero or more operands.
@ None
Zero or more operands with no delimiters.
@ OptionalLessGreater
<> brackets supporting zero or more ops, or nothing.
@ Braces
{} brackets surrounding zero or more operands.
@ OptionalBraces
{} brackets surrounding zero or more operands, or nothing.
@ OptionalParen
Parens supporting zero or more operands, or nothing.
@ Square
Square brackets surrounding zero or more operands.
@ LessGreater
<> brackets surrounding zero or more operands.
@ OptionalSquare
Square brackets supporting zero or more ops, or nothing.
virtual OptionalParseResult parseOptionalInteger(APInt &result)=0
Parse an optional integer value from the stream.
virtual ParseResult parseColonTypeList(SmallVectorImpl< Type > &result)=0
Parse a colon followed by a type list, which must have at least one type.
virtual ParseResult parseIntegerSet(IntegerSet &set)=0
Parse an integer set instance into 'set'.
virtual ParseResult parseOptionalKeywordOrString(std::string *result)=0
Parse an optional keyword or string.
virtual ParseResult parseOptionalSymbolName(StringAttr &result)=0
Parse an optional -identifier and store it (without the '@' symbol) in a string attribute.
FailureOr< CyclicParseReset > tryStartCyclicParse(AttrOrTypeT attrOrType)
Attempts to start a cyclic parsing region for attrOrType.
virtual ParseResult parseOptionalRBrace()=0
Parse a } token if present.
ParseResult parseDecimalInteger(IntT &result)
Parse a decimal integer value from the stream.
virtual ParseResult parseOptionalMinus()=0
Parse a '-' token if present.
virtual ParseResult parsePlus()=0
Parse a '+' token.
ParseResult parseKeyword(StringRef *keyword)
Parse a keyword into 'keyword'.
virtual ParseResult parseCommaSeparatedList(Delimiter delimiter, function_ref< ParseResult()> parseElementFn, StringRef contextMessage=StringRef())=0
Parse a list of comma-separated items with an optional delimiter.
decltype(AttrType::parse(std::declval< AsmParser & >(), std::declval< Type >())) has_parse_method
Trait to check if AttrType provides a parse method.
virtual void popCyclicParsing()=0
Removes the element that was last inserted with a successful call to pushCyclicParsing.
virtual Builder & getBuilder() const =0
Return a builder which provides useful access to MLIRContext, global objects like types and attribute...
virtual ParseResult parseOptionalAttrDict(NamedAttrList &result)=0
Parse a named dictionary into 'result' if it is present.
virtual ParseResult parseOptionalEqual()=0
Parse a = token if present.
virtual ParseResult parseOptionalKeyword(StringRef keyword)=0
Parse the given keyword if present.
virtual OptionalParseResult parseOptionalType(Type &result)=0
Parse an optional type.
MLIRContext * getContext() const
virtual Location getEncodedSourceLoc(SMLoc loc)=0
Re-encode the given source location as an MLIR location and return it.
std::enable_if_t<!detect_type_has_parse_method< TypeT >::value, ParseResult > parseCustomTypeWithFallback(TypeT &result)
SFINAE parsing method for Type that don't implement a parse method.
virtual ParseResult parseRParen()=0
Parse a ) token.
virtual InFlightDiagnostic emitError(SMLoc loc, const Twine &message={})=0
Emit a diagnostic at the specified location and return failure.
virtual ParseResult parseOptionalColon()=0
Parse a : token if present.
virtual ParseResult parseLSquare()=0
Parse a [ token.
virtual ParseResult parseRSquare()=0
Parse a ] token.
virtual ParseResult parseOptionalColonTypeList(SmallVectorImpl< Type > &result)=0
Parse an optional colon followed by a type list, which if present must have at least one type.
ParseResult parseInteger(IntT &result)
Parse an integer value from the stream.
virtual ParseResult parseOptionalArrow()=0
Parse a '->' token if present.
ParseResult parseOptionalSymbolName(StringAttr &result, StringRef attrName, NamedAttrList &attrs)
Parse an optional -identifier and store it (without the '@' symbol) in a string attribute named 'attr...
virtual OptionalParseResult parseOptionalDecimalInteger(APInt &result)=0
ParseResult parseAttribute(AttrType &result, Type type, StringRef attrName, NamedAttrList &attrs)
Parse an arbitrary attribute of a given type and populate it in result.
ParseResult parseAttribute(AttrType &result, Type type={})
Parse an attribute of a specific kind and type.
ParseResult parseKeywordOrString(std::string *result)
Parse a keyword or a quoted string.
virtual void codeCompleteExpectedTokens(ArrayRef< StringRef > tokens)=0
Signal the code completion of a set of expected tokens.
virtual ParseResult parseRBrace()=0
Parse a } token.
virtual ParseResult parseAffineMap(AffineMap &map)=0
Parse an affine map instance into 'map'.
ParseResult addTypeToList(Type type, SmallVectorImpl< Type > &result)
Add the specified type to the end of the specified type list and return success.
virtual ParseResult parseOptionalRParen()=0
Parse a ) token if present.
virtual ParseResult parseCustomAttributeWithFallback(Attribute &result, Type type, function_ref< ParseResult(Attribute &result, Type type)> parseAttribute)=0
Parse a custom attribute with the provided callback, unless the next token is #, in which case the ge...
virtual ParseResult parseLess()=0
Parse a '<' token.
virtual ParseResult parseDimensionList(SmallVectorImpl< int64_t > &dimensions, bool allowDynamic=true, bool withTrailingX=true)=0
Parse a dimension list of a tensor or memref type.
ParseResult parseString(std::string *string)
Parse a quoted string token.
virtual ParseResult parseOptionalPlus()=0
Parse a '+' token if present.
virtual ParseResult parseOptionalKeyword(StringRef *keyword, ArrayRef< StringRef > allowedValues)=0
Parse a keyword, if present, and if one of the 'allowedValues', into 'keyword'.
virtual ParseResult parseOptionalGreater()=0
Parse a '>' token if present.
virtual ParseResult parseEqual()=0
Parse a = token.
std::enable_if_t<!detect_has_parse_method< AttrType >::value, ParseResult > parseCustomAttributeWithFallback(AttrType &result, Type type, StringRef attrName, NamedAttrList &attrs)
SFINAE parsing method for Attribute that don't implement a parse method.
virtual ParseResult parseCustomTypeWithFallback(Type &result, function_ref< ParseResult(Type &result)> parseType)=0
Parse a custom type with the provided callback, unless the next token is #, in which case the generic...
virtual ParseResult parseFloat(const llvm::fltSemantics &semantics, APFloat &result)=0
Parse a floating point value into APFloat from the stream.
virtual OptionalParseResult parseOptionalAttribute(ArrayAttr &result, Type type={})=0
Parse an optional array attribute and return it in result.
virtual ParseResult parseStar()=0
Parse a '*' token.
virtual ParseResult parseOptionalAttrDictWithKeyword(NamedAttrList &result)=0
Parse a named dictionary into 'result' if the attributes keyword is present.
virtual ParseResult parseColonType(Type &result)=0
Parse a colon followed by a type.
virtual OptionalParseResult parseOptionalAttribute(Attribute &result, Type type={})=0
Parse an arbitrary optional attribute of a given type and return it in result.
virtual ParseResult parseSlash()=0
Parse a '/' token.
std::enable_if_t< detect_has_parse_method< AttrType >::value, ParseResult > parseCustomAttributeWithFallback(AttrType &result, Type type={})
Parse a custom attribute of a given type unless the next token is #, in which case the generic parser...
ParseResult parseCommaSeparatedList(function_ref< ParseResult()> parseElementFn)
Parse a comma separated list of elements that must have at least one entry in it.
virtual ParseResult parseVerticalBar()=0
Parse a '|' token.
virtual SMLoc getCurrentLocation()=0
Get the location of the next token and store it into the argument.
virtual ParseResult parseOptionalComma()=0
Parse a , token if present.
OptionalParseResult parseOptionalAttribute(AttrType &result, StringRef attrName, NamedAttrList &attrs)
Parse an optional attribute of a specific type and add it to the list with the specified name.
auto getChecked(SMLoc loc, ParamsT &&...params)
Invoke the getChecked method of the given Attribute or Type class, using the provided location to emi...
virtual ParseResult parseColon()=0
Parse a : token.
ParseResult addTypesToList(ArrayRef< Type > types, SmallVectorImpl< Type > &result)
Add the specified types to the end of the specified type list and return success.
std::enable_if_t< detect_type_has_parse_method< TypeT >::value, ParseResult > parseCustomTypeWithFallback(TypeT &result)
Parse a custom Type of a given type unless the next token is #, in which case the generic parser is i...
ParseResult parseAttribute(Attribute &result, StringRef attrName, NamedAttrList &attrs)
Parse an arbitrary attribute and return it in result.
virtual OptionalParseResult parseOptionalAttribute(StringAttr &result, Type type={})=0
Parse an optional string attribute and return it in result.
virtual SMLoc getNameLoc() const =0
Return the location of the original name token.
virtual ParseResult parseOptionalString(std::string *string)=0
Parse a quoted string token if present.
OptionalParseResult parseOptionalInteger(IntT &result)
ParseResult getCurrentLocation(SMLoc *loc)
virtual ParseResult parseOptionalLess()=0
Parse a '<' token if present.
virtual ParseResult parseOptionalStar()=0
Parse a '*' token if present.
OptionalParseResult parseOptionalAttribute(AttrType &result, Type type, StringRef attrName, NamedAttrList &attrs)
Parse an optional attribute of a specific type and add it to the list with the specified name.
virtual OptionalParseResult parseOptionalAttribute(SymbolRefAttr &result, Type type={})=0
Parse an optional symbol ref attribute and return it in result.
virtual ParseResult parseQuestion()=0
Parse a '?' token.
virtual ParseResult parseOptionalSlash()=0
Parse a '/' token if present.
ParseResult parseType(TypeT &result)
Parse a type of a specific type.
virtual ParseResult parseOptionalRSquare()=0
Parse a ] token if present.
virtual ParseResult parseArrow()=0
Parse a '->' token.
ParseResult parseColonType(TypeType &result)
Parse a colon followed by a type of a specific kind, e.g. a FunctionType.
virtual ParseResult parseGreater()=0
Parse a '>' token.
OptionalParseResult parseOptionalDecimalInteger(IntT &result)
virtual ParseResult parseLParen()=0
Parse a ( token.
virtual ParseResult parseOptionalEllipsis()=0
Parse a ... token if present;.
std::enable_if_t<!detect_has_parse_method< AttrType >::value, ParseResult > parseCustomAttributeWithFallback(AttrType &result, Type type={})
SFINAE parsing method for Attribute that don't implement a parse method.
virtual ParseResult parseType(Type &result)=0
Parse a type.
ParseResult parseAttribute(AttrType &result, StringRef attrName, NamedAttrList &attrs)
Parse an attribute of a specific kind and type.
virtual ParseResult parseEllipsis()=0
Parse a ... token.
auto getChecked(ParamsT &&...params)
A variant of getChecked that uses the result of getNameLoc to emit errors.
virtual ParseResult parseAffineExpr(ArrayRef< std::pair< StringRef, AffineExpr >> symbolSet, AffineExpr &expr)=0
Parse an affine expr instance into 'expr' using the already computed mapping from symbols to affine e...
virtual ParseResult parseComma()=0
Parse a , token.
virtual ParseResult parseOptionalArrowTypeList(SmallVectorImpl< Type > &result)=0
Parse an optional arrow followed by a type list.
virtual ParseResult parseOptionalLParen()=0
Parse a ( token if present.
ParseResult parseKeywordType(const char *keyword, Type &result)
Parse a keyword followed by a type.
virtual ParseResult parseArrowTypeList(SmallVectorImpl< Type > &result)=0
Parse an arrow followed by a type list.
virtual ParseResult parseOptionalVerticalBar()=0
Parse a '|' token if present.
ParseResult parseTypeList(SmallVectorImpl< Type > &result)
Parse a type list.
virtual ParseResult parseBase64Bytes(std::vector< char > *bytes)=0
Parses a Base64 encoded string of bytes.
llvm::is_detected< type_has_parse_method, TypeT > detect_type_has_parse_method
virtual ParseResult parseKeywordOrCompletion(StringRef *keyword)=0
Parse a keyword, or an empty string if the current location signals a code completion.
virtual ParseResult parseFloat(double &result)=0
Parse a floating point value from the stream.
ParseResult parseSymbolName(StringAttr &result, StringRef attrName, NamedAttrList &attrs)
Parse an -identifier and store it (without the '@' symbol) in a string attribute named 'attrName'.
virtual ParseResult parseOptionalKeyword(StringRef *keyword)=0
Parse a keyword, if present, into 'keyword'.
decltype(TypeT::parse(std::declval< AsmParser & >())) type_has_parse_method
Trait to check if TypeT provides a parse method.
ParseResult parseKeyword(StringRef keyword)
Parse a given keyword.
virtual ParseResult parseOptionalLSquare()=0
Parse a [ token if present.
virtual LogicalResult pushCyclicParsing(const void *opaquePointer)=0
Pushes a new attribute or type in the form of a type erased pointer into an internal set.
virtual FailureOr< AsmDialectResourceHandle > parseResourceHandle(Dialect *dialect)=0
Parse a handle to a resource within the assembly format for the given dialect.
virtual ParseResult parseOptionalQuestion()=0
Parse a '?' token if present.
std::enable_if_t< detect_has_parse_method< AttrType >::value, ParseResult > parseCustomAttributeWithFallback(AttrType &result, Type type, StringRef attrName, NamedAttrList &attrs)
Parse a custom attribute of a given type unless the next token is #, in which case the generic parser...
FailureOr< ResourceT > parseResourceHandle()
Parse a handle to a resource within the assembly format.
virtual ParseResult parseAttribute(Attribute &result, Type type={})=0
Parse an arbitrary attribute of a given type and return it in result.
virtual ParseResult parseXInDimensionList()=0
Parse an 'x' token in a dimension list, handling the case where the x is juxtaposed with an element t...
virtual ParseResult parseOptionalLBrace()=0
Parse a { token if present.
virtual ParseResult parseKeyword(StringRef keyword, const Twine &msg)=0
Class used to automatically end a cyclic region on destruction.
CyclicPrintReset(AsmPrinter *printer)
CyclicPrintReset & operator=(const CyclicPrintReset &)=delete
CyclicPrintReset(const CyclicPrintReset &)=delete
CyclicPrintReset & operator=(CyclicPrintReset &&rhs)
CyclicPrintReset(CyclicPrintReset &&rhs)
This base class exposes generic asm printer hooks, usable across the various derived printers.
void printStrippedAttrOrType(ArrayRef< AttrOrType > attrOrTypes)
Print the provided array of attributes or types in the context of an operation custom printer/parser:...
FailureOr< CyclicPrintReset > tryStartCyclicPrint(AttrOrTypeT attrOrType)
Attempts to start a cyclic printing region for attrOrType.
virtual void printAttributeWithoutType(Attribute attr)
Print the given attribute without its type.
virtual LogicalResult printAlias(Attribute attr)
Print the alias for the given attribute, return failure if no alias could be printed.
virtual void popCyclicPrinting()
Removes the element that was last inserted with a successful call to pushCyclicPrinting.
AsmPrinter()=default
Initialize the printer with no internal implementation.
void printFunctionalType(InputRangeT &&inputs, ResultRangeT &&results)
Print the two given type ranges in a functional form.
virtual LogicalResult pushCyclicPrinting(const void *opaquePointer)
Pushes a new attribute or type in the form of a type erased pointer into an internal set.
virtual void printType(Type type)
virtual void printKeywordOrString(StringRef keyword)
Print the given string as a keyword, or a quoted and escaped string if it has any special or non-prin...
llvm::is_detected< has_print_method, AttrOrType > detect_has_print_method
virtual void printSymbolName(StringRef symbolRef)
Print the given string as a symbol reference, i.e.
virtual void printString(StringRef string)
Print the given string as a quoted string, escaping any special or non-printable characters in it.
void printOptionalArrowTypeList(TypeRange &&types)
Print an optional arrow followed by a type list.
virtual void printAttribute(Attribute attr)
void printDimensionList(ArrayRef< int64_t > shape)
void printArrowTypeList(TypeRange &&types)
virtual raw_ostream & getStream() const
Return the raw output stream used by this printer.
virtual void printResourceHandle(const AsmDialectResourceHandle &resource)
Print a handle to the given dialect resource.
decltype(std::declval< AttrOrType >().print(std::declval< AsmPrinter & >())) has_print_method
Trait to check if AttrType provides a print method.
virtual void printFloat(const APFloat &value)
Print the given floating point value in a stabilized form that can be roundtripped through the IR.
void printStrippedAttrOrType(AttrOrType attrOrType)
Print the provided attribute in the context of an operation custom printer/parser: this will invoke d...
AsmPrinter(Impl &impl)
Initialize the printer with the given internal implementation.
This class is used to build resource entries for use by the printer.
Attributes are known-constant values of operations.
This class represents an argument of a Block.
Block represents an ordered list of Operations.
OpListType::iterator iterator
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.
An integer set representing a conjunction of one or more affine equalities and inequalities.
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.
T * getOrLoadDialect()
Get (or create) a dialect for the given derived dialect type.
NamedAttrList is array of NamedAttributes that tracks whether it is sorted and does some basic work t...
void append(StringRef name, Attribute attr)
Add an attribute with the specified name.
virtual void buildResources(Operation *op, const SetVector< AsmDialectResourceHandle > &referencedResources, AsmResourceBuilder &builder) const
Hook for building resources to use during printing.
virtual AliasResult getAlias(Attribute attr, raw_ostream &os) const
Hooks for getting an alias identifier alias for a given symbol, that is not necessarily a part of thi...
OpAsmDialectInterface(Dialect *dialect)
virtual AliasResult getAlias(Type type, raw_ostream &os) const
virtual std::string getResourceKey(const AsmDialectResourceHandle &handle) const
Return a key to use for the given resource.
virtual FailureOr< AsmDialectResourceHandle > declareResource(StringRef key) const
Declare a resource with the given key, returning a handle to use for any references of this resource ...
virtual LogicalResult parseResource(AsmParsedResourceEntry &entry) const
Hook for parsing resource entries.
The OpAsmParser has methods for interacting with the asm parser: parsing things from it,...
virtual std::pair< StringRef, unsigned > getResultName(unsigned resultNo) const =0
Return the name of the specified result in the specified syntax, as well as the sub-element in the na...
virtual size_t getNumResults() const =0
Return the number of declared SSA results.
virtual OptionalParseResult parseOptionalAssignmentList(SmallVectorImpl< Argument > &lhs, SmallVectorImpl< UnresolvedOperand > &rhs)=0
virtual ParseResult parseRegion(Region ®ion, ArrayRef< Argument > arguments={}, bool enableNameShadowing=false)=0
Parses a region.
virtual ParseResult parseSuccessor(Block *&dest)=0
Parse a single operation successor.
virtual ParseResult parseArgument(Argument &result, bool allowType=false, bool allowAttrs=false)=0
Parse a single argument with the following syntax:
virtual ParseResult parseGenericOperationAfterOpName(OperationState &result, std::optional< ArrayRef< UnresolvedOperand >> parsedOperandType=std::nullopt, std::optional< ArrayRef< Block * >> parsedSuccessors=std::nullopt, std::optional< MutableArrayRef< std::unique_ptr< Region >>> parsedRegions=std::nullopt, std::optional< ArrayRef< NamedAttribute >> parsedAttributes=std::nullopt, std::optional< Attribute > parsedPropertiesAttribute=std::nullopt, std::optional< FunctionType > parsedFnType=std::nullopt)=0
Parse different components, viz., use-info of operand(s), successor(s), region(s),...
ParseResult parseTrailingOperandList(SmallVectorImpl< UnresolvedOperand > &result, Delimiter delimiter=Delimiter::None)
Parse zero or more trailing SSA comma-separated trailing operand references with a specified surround...
ParseResult resolveOperands(Operands &&operands, Type type, SMLoc loc, SmallVectorImpl< Value > &result)
virtual ParseResult parseArgumentList(SmallVectorImpl< Argument > &result, Delimiter delimiter=Delimiter::None, bool allowType=false, bool allowAttrs=false)=0
Parse zero or more arguments with a specified surrounding delimiter.
virtual ParseResult parseAffineMapOfSSAIds(SmallVectorImpl< UnresolvedOperand > &operands, Attribute &map, StringRef attrName, NamedAttrList &attrs, Delimiter delimiter=Delimiter::Square)=0
Parses an affine map attribute where dims and symbols are SSA operands.
virtual OptionalParseResult parseOptionalArgument(Argument &result, bool allowType=false, bool allowAttrs=false)=0
Parse a single argument if present.
virtual ParseResult parseOptionalLocationSpecifier(std::optional< Location > &result)=0
Parse a loc(...) specifier if present, filling in result if so.
ParseResult parseAssignmentList(SmallVectorImpl< Argument > &lhs, SmallVectorImpl< UnresolvedOperand > &rhs)
Parse a list of assignments of the form (x1 = y1, x2 = y2, ...)
virtual ParseResult resolveOperand(const UnresolvedOperand &operand, Type type, SmallVectorImpl< Value > &result)=0
Resolve an operand to an SSA value, emitting an error on failure.
virtual OptionalParseResult parseOptionalOperand(UnresolvedOperand &result, bool allowResultNumber=true)=0
Parse a single operand if present.
virtual ParseResult parseSuccessorAndUseList(Block *&dest, SmallVectorImpl< Value > &operands)=0
Parse a single operation successor and its operand list.
virtual OptionalParseResult parseOptionalRegion(Region ®ion, ArrayRef< Argument > arguments={}, bool enableNameShadowing=false)=0
Parses a region if present.
virtual FailureOr< OperationName > parseCustomOperationName()=0
Parse the name of an operation, in the custom form.
ParseResult parseOperandList(SmallVectorImpl< UnresolvedOperand > &result, int requiredOperandCount, Delimiter delimiter=Delimiter::None)
Parse a specified number of comma separated operands.
ParseResult resolveOperands(Operands &&operands, Type type, SmallVectorImpl< Value > &result)
Resolve a list of operands to SSA values, emitting an error on failure, or appending the results to t...
virtual Operation * parseGenericOperation(Block *insertBlock, Block::iterator insertPt)=0
Parse an operation in its generic form.
virtual ParseResult parseOperand(UnresolvedOperand &result, bool allowResultNumber=true)=0
Parse a single SSA value operand name along with a result number if allowResultNumber is true.
virtual ParseResult parseAffineExprOfSSAIds(SmallVectorImpl< UnresolvedOperand > &dimOperands, SmallVectorImpl< UnresolvedOperand > &symbOperands, AffineExpr &expr)=0
Parses an affine expression where dims and symbols are SSA operands.
virtual OptionalParseResult parseOptionalSuccessor(Block *&dest)=0
Parse an optional operation successor.
std::enable_if_t<!std::is_convertible< Types, Type >::value, ParseResult > resolveOperands(Operands &&operands, Types &&types, SMLoc loc, SmallVectorImpl< Value > &result)
Resolve a list of operands and a list of operand types to SSA values, emitting an error and returning...
virtual OptionalParseResult parseOptionalRegion(std::unique_ptr< Region > ®ion, ArrayRef< Argument > arguments={}, bool enableNameShadowing=false)=0
Parses a region if present.
virtual ParseResult parseOperandList(SmallVectorImpl< UnresolvedOperand > &result, Delimiter delimiter=Delimiter::None, bool allowResultNumber=true, int requiredOperandCount=-1)=0
Parse zero or more SSA comma-separated operand references with a specified surrounding delimiter,...
This is a pure-virtual base class that exposes the asmprinter hooks necessary to implement a custom p...
void printOperands(IteratorType it, IteratorType end)
Print a comma separated list of operands.
virtual void shadowRegionArgs(Region ®ion, ValueRange namesToUse)=0
Renumber the arguments for the specified region to the same names as the SSA values in namesToUse.
virtual void printNewline()=0
Print a newline and indent the printer to the start of the current operation.
virtual void increaseIndent()=0
Increase indentation.
virtual void printSuccessorAndUseList(Block *successor, ValueRange succOperands)=0
Print the successor and its operands.
void printOperands(const ContainerType &container)
Print a comma separated list of operands.
virtual void printOptionalAttrDictWithKeyword(ArrayRef< NamedAttribute > attrs, ArrayRef< StringRef > elidedAttrs={})=0
If the specified operation has attributes, print out an attribute dictionary prefixed with 'attribute...
virtual void printOptionalAttrDict(ArrayRef< NamedAttribute > attrs, ArrayRef< StringRef > elidedAttrs={})=0
If the specified operation has attributes, print out an attribute dictionary with their values.
virtual void printOptionalLocationSpecifier(Location loc)=0
Print a loc(...) specifier if printing debug info is enabled.
virtual void printCustomOrGenericOp(Operation *op)=0
Prints the entire operation with the custom assembly form, if available, or the generic assembly form...
virtual void decreaseIndent()=0
Decrease indentation.
virtual void printOperand(Value value, raw_ostream &os)=0
virtual void printSuccessor(Block *successor)=0
Print the given successor.
virtual void printAffineExprOfSSAIds(AffineExpr expr, ValueRange dimOperands, ValueRange symOperands)=0
Prints an affine expression of SSA ids with SSA id names used instead of dims and symbols.
void printFunctionalType(Operation *op)
Print the complete type of an operation in functional form.
virtual void printAffineMapOfSSAIds(AffineMapAttr mapAttr, ValueRange operands)=0
Prints an affine map of SSA ids, where SSA id names are used in place of dims/symbols.
virtual void printGenericOp(Operation *op, bool printOpName=true)=0
Print the entire operation with the default generic assembly form.
virtual void printRegion(Region &blocks, bool printEntryBlockArgs=true, bool printBlockTerminators=true, bool printEmptyBlock=false)=0
Prints a region.
virtual void printRegionArgument(BlockArgument arg, ArrayRef< NamedAttribute > argAttrs={}, bool omitType=false)=0
Print a block argument in the usual format of: ssaName : type {attr1=42} loc("here") where location p...
virtual void printOperand(Value value)=0
Print implementations for various things an operation contains.
Operation is the basic unit of execution within MLIR.
This class implements Optional functionality for ParseResult.
ParseResult value() const
Access the internal ParseResult value.
bool has_value() const
Returns true if we contain a valid ParseResult value.
This class contains a list of basic blocks and a link to the parent operation it is attached to.
This class provides an efficient unique identifier for a specific C++ type.
This class provides an abstraction over the various different ranges of value types.
Instances of the Type class are uniqued, have an immutable identifier and an optional mutable compone...
This class provides an abstraction over the different types of ranges over Values.
This class represents an instance of an SSA value in the MLIR system, representing a computable value...
The base class used for all derived interface types.
The OpAsmOpInterface, see OpAsmInterface.td for more details.
QueryRef parse(llvm::StringRef line, const QuerySession &qs)
Include the generated interface declarations.
ParseResult parseDimensionList(OpAsmParser &parser, DenseI64ArrayAttr &dimensions)
void printDimensionList(OpAsmPrinter &printer, Operation *op, ArrayRef< int64_t > dimensions)
detail::DenseArrayAttrImpl< int64_t > DenseI64ArrayAttr
OpAsmAliasResult
Holds the result of OpAsm{Dialect,Attr,Type}Interface::getAlias hook call.
@ NoAlias
The object (type or attribute) is not supported by the hook and an alias was not provided.
llvm::hash_code hash_value(const AsmDialectResourceHandle ¶m)
auto get(MLIRContext *context, Ts &&...params)
Helper method that injects context only if needed, this helps unify some of the attribute constructio...
inline ::llvm::hash_code hash_value(AffineExpr arg)
Make AffineExpr hashable.
raw_ostream & operator<<(raw_ostream &os, const AliasResult &result)
static mlir::AsmDialectResourceHandle getTombstoneKey()
static unsigned getHashValue(const mlir::AsmDialectResourceHandle &handle)
static mlir::AsmDialectResourceHandle getEmptyKey()
static bool isEqual(const mlir::AsmDialectResourceHandle &lhs, const mlir::AsmDialectResourceHandle &rhs)
UnresolvedOperand ssaName
std::optional< Location > sourceLoc
This is the representation of an operand reference.
This represents an operation in an abstracted form, suitable for use with the builder APIs.
This trait is used to determine if a storage user, like Type, is mutable or not.