376 lines · c
1//===- Parser.h - MLIR Base Parser Class ------------------------*- C++ -*-===//2//3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.4// See https://llvm.org/LICENSE.txt for license information.5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception6//7//===----------------------------------------------------------------------===//8 9#ifndef MLIR_LIB_ASMPARSER_PARSER_H10#define MLIR_LIB_ASMPARSER_PARSER_H11 12#include "ParserState.h"13#include "mlir/IR/Builders.h"14#include "mlir/IR/OpImplementation.h"15#include <optional>16 17namespace mlir {18namespace detail {19 20//===----------------------------------------------------------------------===//21// Parser22//===----------------------------------------------------------------------===//23 24/// This class implement support for parsing global entities like attributes and25/// types. It is intended to be subclassed by specialized subparsers that26/// include state.27class Parser {28public:29 using Delimiter = OpAsmParser::Delimiter;30 31 Builder builder;32 33 Parser(ParserState &state)34 : builder(state.config.getContext()), state(state) {}35 36 // Helper methods to get stuff from the parser-global state.37 ParserState &getState() const { return state; }38 MLIRContext *getContext() const { return state.config.getContext(); }39 const llvm::SourceMgr &getSourceMgr() { return state.lex.getSourceMgr(); }40 41 /// Parse a comma-separated list of elements up until the specified end token.42 ParseResult43 parseCommaSeparatedListUntil(Token::Kind rightToken,44 function_ref<ParseResult()> parseElement,45 bool allowEmptyList = true);46 47 /// Parse a list of comma-separated items with an optional delimiter. If a48 /// delimiter is provided, then an empty list is allowed. If not, then at49 /// least one element will be parsed.50 ParseResult51 parseCommaSeparatedList(Delimiter delimiter,52 function_ref<ParseResult()> parseElementFn,53 StringRef contextMessage = StringRef());54 55 /// Parse a comma separated list of elements that must have at least one entry56 /// in it.57 ParseResult58 parseCommaSeparatedList(function_ref<ParseResult()> parseElementFn) {59 return parseCommaSeparatedList(Delimiter::None, parseElementFn);60 }61 62 /// Parse the body of a dialect symbol, which starts and ends with <>'s, and63 /// may be recursive. Return with the 'body' StringRef encompassing the entire64 /// body. `isCodeCompletion` is set to true if the body contained a code65 /// completion location, in which case the body is only populated up to the66 /// completion.67 ParseResult parseDialectSymbolBody(StringRef &body, bool &isCodeCompletion);68 ParseResult parseDialectSymbolBody(StringRef &body) {69 bool isCodeCompletion = false;70 return parseDialectSymbolBody(body, isCodeCompletion);71 }72 73 // We have two forms of parsing methods - those that return a non-null74 // pointer on success, and those that return a ParseResult to indicate whether75 // they returned a failure. The second class fills in by-reference arguments76 // as the results of their action.77 78 //===--------------------------------------------------------------------===//79 // Error Handling80 //===--------------------------------------------------------------------===//81 82 /// Emit an error and return failure.83 InFlightDiagnostic emitError(const Twine &message = {});84 InFlightDiagnostic emitError(SMLoc loc, const Twine &message = {});85 86 /// Emit an error about a "wrong token". If the current token is at the87 /// start of a source line, this will apply heuristics to back up and report88 /// the error at the end of the previous line, which is where the expected89 /// token is supposed to be.90 InFlightDiagnostic emitWrongTokenError(const Twine &message = {});91 92 /// Encode the specified source location information into an attribute for93 /// attachment to the IR.94 Location getEncodedSourceLocation(SMLoc loc) {95 return state.lex.getEncodedSourceLocation(loc);96 }97 98 //===--------------------------------------------------------------------===//99 // Token Parsing100 //===--------------------------------------------------------------------===//101 102 /// Return the current token the parser is inspecting.103 const Token &getToken() const { return state.curToken; }104 StringRef getTokenSpelling() const { return state.curToken.getSpelling(); }105 106 /// Return the last parsed token.107 const Token &getLastToken() const { return state.lastToken; }108 109 /// If the current token has the specified kind, consume it and return true.110 /// If not, return false.111 bool consumeIf(Token::Kind kind) {112 if (state.curToken.isNot(kind))113 return false;114 consumeToken(kind);115 return true;116 }117 118 /// Advance the current lexer onto the next token.119 void consumeToken() {120 assert(state.curToken.isNot(Token::eof, Token::error) &&121 "shouldn't advance past EOF or errors");122 state.lastToken = state.curToken;123 state.curToken = state.lex.lexToken();124 }125 126 /// Advance the current lexer onto the next token, asserting what the expected127 /// current token is. This is preferred to the above method because it leads128 /// to more self-documenting code with better checking.129 void consumeToken(Token::Kind kind) {130 assert(state.curToken.is(kind) && "consumed an unexpected token");131 consumeToken();132 }133 134 /// Reset the parser to the given lexer position. Resetting the parser/lexer135 /// position does not update 'state.lastToken'. 'state.lastToken' is the136 /// last parsed token, and is used to provide the scope end location for137 /// OperationDefinitions. To ensure the correctness of the end location, the138 /// last consumed token of an OperationDefinition needs to be the last token139 /// belonging to it.140 void resetToken(const char *tokPos) {141 state.lex.resetPointer(tokPos);142 state.curToken = state.lex.lexToken();143 }144 145 /// Consume the specified token if present and return success. On failure,146 /// output a diagnostic and return failure.147 ParseResult parseToken(Token::Kind expectedToken, const Twine &message);148 149 /// Parses a quoted string token if present.150 ParseResult parseOptionalString(std::string *string);151 152 /// Parse an optional integer value from the stream.153 OptionalParseResult parseOptionalInteger(APInt &result);154 155 /// Parse an optional integer value only in decimal format from the stream.156 OptionalParseResult parseOptionalDecimalInteger(APInt &result);157 158 /// Parse a floating point value from a literal.159 ParseResult parseFloatFromLiteral(std::optional<APFloat> &result,160 const Token &tok, bool isNegative,161 const llvm::fltSemantics &semantics);162 163 /// Parse a floating point value from an integer literal token.164 ParseResult parseFloatFromIntegerLiteral(std::optional<APFloat> &result,165 const Token &tok, bool isNegative,166 const llvm::fltSemantics &semantics);167 168 /// Returns true if the current token corresponds to a keyword.169 bool isCurrentTokenAKeyword() const {170 return getToken().isAny(Token::bare_identifier, Token::inttype) ||171 getToken().isKeyword();172 }173 174 /// Parse a keyword, if present, into 'keyword'.175 ParseResult parseOptionalKeyword(StringRef *keyword);176 177 /// Parse an optional keyword or string and set instance into 'result'.`178 ParseResult parseOptionalKeywordOrString(std::string *result);179 180 //===--------------------------------------------------------------------===//181 // Resource Parsing182 //===--------------------------------------------------------------------===//183 184 /// Parse a handle to a dialect resource within the assembly format.185 FailureOr<AsmDialectResourceHandle>186 parseResourceHandle(const OpAsmDialectInterface *dialect, std::string &name);187 FailureOr<AsmDialectResourceHandle> parseResourceHandle(Dialect *dialect);188 189 //===--------------------------------------------------------------------===//190 // Type Parsing191 //===--------------------------------------------------------------------===//192 193 /// Invoke the `getChecked` method of the given Attribute or Type class, using194 /// the provided location to emit errors in the case of failure. Note that195 /// unlike `OpBuilder::getType`, this method does not implicitly insert a196 /// context parameter.197 template <typename T, typename... ParamsT>198 T getChecked(SMLoc loc, ParamsT &&...params) {199 return T::getChecked([&] { return emitError(loc); },200 std::forward<ParamsT>(params)...);201 }202 203 ParseResult parseFunctionResultTypes(SmallVectorImpl<Type> &elements);204 ParseResult parseTypeListNoParens(SmallVectorImpl<Type> &elements);205 ParseResult parseTypeListParens(SmallVectorImpl<Type> &elements);206 207 /// Optionally parse a type.208 OptionalParseResult parseOptionalType(Type &type);209 210 /// Parse an arbitrary type.211 Type parseType();212 213 /// Parse a complex type.214 Type parseComplexType();215 216 /// Parse an extended type.217 Type parseExtendedType();218 219 /// Parse a function type.220 Type parseFunctionType();221 222 /// Parse a memref type.223 Type parseMemRefType();224 225 /// Parse a non function type.226 Type parseNonFunctionType();227 228 /// Parse a tensor type.229 Type parseTensorType();230 231 /// Parse a tuple type.232 Type parseTupleType();233 234 /// Parse a vector type.235 VectorType parseVectorType();236 ParseResult parseVectorDimensionList(SmallVectorImpl<int64_t> &dimensions,237 SmallVectorImpl<bool> &scalableDims);238 ParseResult parseDimensionListRanked(SmallVectorImpl<int64_t> &dimensions,239 bool allowDynamic = true,240 bool withTrailingX = true);241 ParseResult parseIntegerInDimensionList(int64_t &value);242 ParseResult parseXInDimensionList();243 244 //===--------------------------------------------------------------------===//245 // Attribute Parsing246 //===--------------------------------------------------------------------===//247 248 /// Parse an arbitrary attribute with an optional type.249 Attribute parseAttribute(Type type = {});250 251 /// Parse an optional attribute with the provided type.252 OptionalParseResult parseOptionalAttribute(Attribute &attribute,253 Type type = {});254 OptionalParseResult parseOptionalAttribute(ArrayAttr &attribute, Type type);255 OptionalParseResult parseOptionalAttribute(StringAttr &attribute, Type type);256 OptionalParseResult parseOptionalAttribute(SymbolRefAttr &result, Type type);257 258 /// Parse an optional attribute that is demarcated by a specific token.259 template <typename AttributeT>260 OptionalParseResult parseOptionalAttributeWithToken(Token::Kind kind,261 AttributeT &attr,262 Type type = {}) {263 if (getToken().isNot(kind))264 return std::nullopt;265 266 if (Attribute parsedAttr = parseAttribute(type)) {267 attr = cast<AttributeT>(parsedAttr);268 return success();269 }270 return failure();271 }272 273 /// Parse an attribute dictionary.274 ParseResult parseAttributeDict(NamedAttrList &attributes);275 276 /// Parse a distinct attribute.277 Attribute parseDistinctAttr(Type type);278 279 /// Parse an extended attribute.280 Attribute parseExtendedAttr(Type type);281 282 /// Parse a float attribute.283 Attribute parseFloatAttr(Type type, bool isNegative);284 285 /// Parse a decimal or a hexadecimal literal, which can be either an integer286 /// or a float attribute.287 Attribute parseDecOrHexAttr(Type type, bool isNegative);288 289 /// Parse a dense elements attribute.290 Attribute parseDenseElementsAttr(Type attrType);291 ShapedType parseElementsLiteralType(SMLoc loc, Type type);292 293 /// Parse a dense resource elements attribute.294 Attribute parseDenseResourceElementsAttr(Type attrType);295 296 /// Parse a DenseArrayAttr.297 Attribute parseDenseArrayAttr(Type type);298 299 /// Parse a sparse elements attribute.300 Attribute parseSparseElementsAttr(Type attrType);301 302 /// Parse a strided layout attribute.303 Attribute parseStridedLayoutAttr();304 305 //===--------------------------------------------------------------------===//306 // Location Parsing307 //===--------------------------------------------------------------------===//308 309 /// Parse a raw location instance.310 ParseResult parseLocationInstance(LocationAttr &loc);311 312 /// Parse a callsite location instance.313 ParseResult parseCallSiteLocation(LocationAttr &loc);314 315 /// Parse a fused location instance.316 ParseResult parseFusedLocation(LocationAttr &loc);317 318 /// Parse a name or FileLineCol location instance.319 ParseResult parseNameOrFileLineColRange(LocationAttr &loc);320 321 //===--------------------------------------------------------------------===//322 // Affine Parsing323 //===--------------------------------------------------------------------===//324 325 /// Parse a reference to either an affine map, expr, or an integer set.326 ParseResult parseAffineMapOrIntegerSetReference(AffineMap &map,327 IntegerSet &set);328 ParseResult parseAffineMapReference(AffineMap &map);329 ParseResult330 parseAffineExprReference(ArrayRef<std::pair<StringRef, AffineExpr>> symbolSet,331 AffineExpr &expr);332 ParseResult parseIntegerSetReference(IntegerSet &set);333 334 /// Parse an AffineMap where the dim and symbol identifiers are SSA ids.335 ParseResult336 parseAffineMapOfSSAIds(AffineMap &map,337 function_ref<ParseResult(bool)> parseElement,338 Delimiter delimiter);339 340 /// Parse an AffineExpr where dim and symbol identifiers are SSA ids.341 ParseResult342 parseAffineExprOfSSAIds(AffineExpr &expr,343 function_ref<ParseResult(bool)> parseElement);344 345 //===--------------------------------------------------------------------===//346 // Code Completion347 //===--------------------------------------------------------------------===//348 349 /// The set of various code completion methods. Every completion method350 /// returns `failure` to signal that parsing should abort after any desired351 /// completions have been enqueued. Note that `failure` is does not mean352 /// completion failed, it's just a signal to the parser to stop.353 354 ParseResult codeCompleteDialectName();355 ParseResult codeCompleteOperationName(StringRef dialectName);356 ParseResult codeCompleteDialectOrElidedOpName(SMLoc loc);357 ParseResult codeCompleteStringDialectOrOperationName(StringRef name);358 ParseResult codeCompleteExpectedTokens(ArrayRef<StringRef> tokens);359 ParseResult codeCompleteOptionalTokens(ArrayRef<StringRef> tokens);360 361 Attribute codeCompleteAttribute();362 Type codeCompleteType();363 Attribute364 codeCompleteDialectSymbol(const llvm::StringMap<Attribute> &aliases);365 Type codeCompleteDialectSymbol(const llvm::StringMap<Type> &aliases);366 367protected:368 /// The Parser is subclassed and reinstantiated. Do not add additional369 /// non-trivial state here, add it to the ParserState class.370 ParserState &state;371};372} // namespace detail373} // namespace mlir374 375#endif // MLIR_LIB_ASMPARSER_PARSER_H376