forked from OSchip/llvm-project
4224 lines
145 KiB
C++
4224 lines
145 KiB
C++
//===- Parser.cpp - MLIR Parser Implementation ----------------------------===//
|
|
//
|
|
// Copyright 2019 The MLIR Authors.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
// =============================================================================
|
|
//
|
|
// This file implements the parser for the MLIR textual form.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "mlir/Parser.h"
|
|
#include "Lexer.h"
|
|
#include "mlir/Analysis/Verifier.h"
|
|
#include "mlir/IR/AffineExpr.h"
|
|
#include "mlir/IR/AffineMap.h"
|
|
#include "mlir/IR/Attributes.h"
|
|
#include "mlir/IR/Builders.h"
|
|
#include "mlir/IR/Dialect.h"
|
|
#include "mlir/IR/IntegerSet.h"
|
|
#include "mlir/IR/Location.h"
|
|
#include "mlir/IR/MLIRContext.h"
|
|
#include "mlir/IR/Module.h"
|
|
#include "mlir/IR/OpImplementation.h"
|
|
#include "mlir/IR/StandardTypes.h"
|
|
#include "mlir/Support/STLExtras.h"
|
|
#include "llvm/ADT/APInt.h"
|
|
#include "llvm/ADT/DenseMap.h"
|
|
#include "llvm/ADT/StringSet.h"
|
|
#include "llvm/ADT/bit.h"
|
|
#include "llvm/Support/MemoryBuffer.h"
|
|
#include "llvm/Support/PrettyStackTrace.h"
|
|
#include "llvm/Support/SMLoc.h"
|
|
#include "llvm/Support/SourceMgr.h"
|
|
#include <algorithm>
|
|
using namespace mlir;
|
|
using llvm::MemoryBuffer;
|
|
using llvm::SMLoc;
|
|
using llvm::SourceMgr;
|
|
|
|
namespace {
|
|
class Parser;
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ParserState
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// This class refers to all of the state maintained globally by the parser,
|
|
/// such as the current lexer position etc. The Parser base class provides
|
|
/// methods to access this.
|
|
class ParserState {
|
|
public:
|
|
ParserState(const llvm::SourceMgr &sourceMgr, MLIRContext *ctx)
|
|
: context(ctx), lex(sourceMgr, ctx), curToken(lex.lexToken()) {}
|
|
|
|
// A map from attribute alias identifier to Attribute.
|
|
llvm::StringMap<Attribute> attributeAliasDefinitions;
|
|
|
|
// A map from type alias identifier to Type.
|
|
llvm::StringMap<Type> typeAliasDefinitions;
|
|
|
|
private:
|
|
ParserState(const ParserState &) = delete;
|
|
void operator=(const ParserState &) = delete;
|
|
|
|
friend class Parser;
|
|
|
|
// The context we're parsing into.
|
|
MLIRContext *const context;
|
|
|
|
// The lexer for the source file we're parsing.
|
|
Lexer lex;
|
|
|
|
// This is the next token that hasn't been consumed yet.
|
|
Token curToken;
|
|
};
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Parser
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// This class implement support for parsing global entities like types and
|
|
/// shared entities like SSA names. It is intended to be subclassed by
|
|
/// specialized subparsers that include state, e.g. when a local symbol table.
|
|
class Parser {
|
|
public:
|
|
Builder builder;
|
|
|
|
Parser(ParserState &state) : builder(state.context), state(state) {}
|
|
|
|
// Helper methods to get stuff from the parser-global state.
|
|
ParserState &getState() const { return state; }
|
|
MLIRContext *getContext() const { return state.context; }
|
|
const llvm::SourceMgr &getSourceMgr() { return state.lex.getSourceMgr(); }
|
|
|
|
/// Parse a comma-separated list of elements up until the specified end token.
|
|
ParseResult
|
|
parseCommaSeparatedListUntil(Token::Kind rightToken,
|
|
const std::function<ParseResult()> &parseElement,
|
|
bool allowEmptyList = true);
|
|
|
|
/// Parse a comma separated list of elements that must have at least one entry
|
|
/// in it.
|
|
ParseResult
|
|
parseCommaSeparatedList(const std::function<ParseResult()> &parseElement);
|
|
|
|
ParseResult parsePrettyDialectSymbolName(StringRef &prettyName);
|
|
|
|
// We have two forms of parsing methods - those that return a non-null
|
|
// pointer on success, and those that return a ParseResult to indicate whether
|
|
// they returned a failure. The second class fills in by-reference arguments
|
|
// as the results of their action.
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
// Error Handling
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
/// Emit an error and return failure.
|
|
InFlightDiagnostic emitError(const Twine &message = {}) {
|
|
return emitError(state.curToken.getLoc(), message);
|
|
}
|
|
InFlightDiagnostic emitError(SMLoc loc, const Twine &message = {});
|
|
|
|
/// Encode the specified source location information into an attribute for
|
|
/// attachment to the IR.
|
|
Location getEncodedSourceLocation(llvm::SMLoc loc) {
|
|
return state.lex.getEncodedSourceLocation(loc);
|
|
}
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
// Token Parsing
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
/// Return the current token the parser is inspecting.
|
|
const Token &getToken() const { return state.curToken; }
|
|
StringRef getTokenSpelling() const { return state.curToken.getSpelling(); }
|
|
|
|
/// If the current token has the specified kind, consume it and return true.
|
|
/// If not, return false.
|
|
bool consumeIf(Token::Kind kind) {
|
|
if (state.curToken.isNot(kind))
|
|
return false;
|
|
consumeToken(kind);
|
|
return true;
|
|
}
|
|
|
|
/// Advance the current lexer onto the next token.
|
|
void consumeToken() {
|
|
assert(state.curToken.isNot(Token::eof, Token::error) &&
|
|
"shouldn't advance past EOF or errors");
|
|
state.curToken = state.lex.lexToken();
|
|
}
|
|
|
|
/// Advance the current lexer onto the next token, asserting what the expected
|
|
/// current token is. This is preferred to the above method because it leads
|
|
/// to more self-documenting code with better checking.
|
|
void consumeToken(Token::Kind kind) {
|
|
assert(state.curToken.is(kind) && "consumed an unexpected token");
|
|
consumeToken();
|
|
}
|
|
|
|
/// Consume the specified token if present and return success. On failure,
|
|
/// output a diagnostic and return failure.
|
|
ParseResult parseToken(Token::Kind expectedToken, const Twine &message);
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
// Type Parsing
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
ParseResult parseFunctionResultTypes(SmallVectorImpl<Type> &elements);
|
|
ParseResult parseTypeListNoParens(SmallVectorImpl<Type> &elements);
|
|
ParseResult parseTypeListParens(SmallVectorImpl<Type> &elements);
|
|
|
|
/// Parse an arbitrary type.
|
|
Type parseType();
|
|
|
|
/// Parse a complex type.
|
|
Type parseComplexType();
|
|
|
|
/// Parse an extended type.
|
|
Type parseExtendedType();
|
|
|
|
/// Parse a function type.
|
|
Type parseFunctionType();
|
|
|
|
/// Parse a memref type.
|
|
Type parseMemRefType();
|
|
|
|
/// Parse a non function type.
|
|
Type parseNonFunctionType();
|
|
|
|
/// Parse a tensor type.
|
|
Type parseTensorType();
|
|
|
|
/// Parse a tuple type.
|
|
Type parseTupleType();
|
|
|
|
/// Parse a vector type.
|
|
VectorType parseVectorType();
|
|
ParseResult parseDimensionListRanked(SmallVectorImpl<int64_t> &dimensions,
|
|
bool allowDynamic = true);
|
|
ParseResult parseXInDimensionList();
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
// Attribute Parsing
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
/// Parse an arbitrary attribute with an optional type.
|
|
Attribute parseAttribute(Type type = {});
|
|
|
|
/// Parse an attribute dictionary.
|
|
ParseResult parseAttributeDict(SmallVectorImpl<NamedAttribute> &attributes);
|
|
|
|
/// Parse an extended attribute.
|
|
Attribute parseExtendedAttr(Type type);
|
|
|
|
/// Parse a float attribute.
|
|
Attribute parseFloatAttr(Type type, bool isNegative);
|
|
|
|
/// Parse a decimal or a hexadecimal literal, which can be either an integer
|
|
/// or a float attribute.
|
|
Attribute parseDecOrHexAttr(Type type, bool isNegative);
|
|
|
|
/// Parse an opaque elements attribute.
|
|
Attribute parseOpaqueElementsAttr();
|
|
|
|
/// Parse a dense elements attribute.
|
|
Attribute parseDenseElementsAttr();
|
|
ShapedType parseElementsLiteralType();
|
|
|
|
/// Parse a sparse elements attribute.
|
|
Attribute parseSparseElementsAttr();
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
// Location Parsing
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
/// Parse an inline location.
|
|
ParseResult parseLocation(LocationAttr &loc);
|
|
|
|
/// Parse a raw location instance.
|
|
ParseResult parseLocationInstance(LocationAttr &loc);
|
|
|
|
/// Parse a callsite location instance.
|
|
ParseResult parseCallSiteLocation(LocationAttr &loc);
|
|
|
|
/// Parse a fused location instance.
|
|
ParseResult parseFusedLocation(LocationAttr &loc);
|
|
|
|
/// Parse a name or FileLineCol location instance.
|
|
ParseResult parseNameOrFileLineColLocation(LocationAttr &loc);
|
|
|
|
/// Parse an optional trailing location.
|
|
///
|
|
/// trailing-location ::= location?
|
|
///
|
|
template <typename Owner>
|
|
ParseResult parseOptionalTrailingLocation(Owner *owner) {
|
|
// If there is a 'loc' we parse a trailing location.
|
|
if (!getToken().is(Token::kw_loc))
|
|
return success();
|
|
|
|
// Parse the location.
|
|
LocationAttr directLoc;
|
|
if (parseLocation(directLoc))
|
|
return failure();
|
|
owner->setLoc(directLoc);
|
|
return success();
|
|
}
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
// Affine Parsing
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
ParseResult parseAffineMapOrIntegerSetReference(AffineMap &map,
|
|
IntegerSet &set);
|
|
|
|
/// Parse an AffineMap where the dim and symbol identifiers are SSA ids.
|
|
ParseResult
|
|
parseAffineMapOfSSAIds(AffineMap &map,
|
|
llvm::function_ref<ParseResult(bool)> parseElement);
|
|
|
|
private:
|
|
/// The Parser is subclassed and reinstantiated. Do not add additional
|
|
/// non-trivial state here, add it to the ParserState class.
|
|
ParserState &state;
|
|
};
|
|
} // end anonymous namespace
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Helper methods.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// Parse a comma separated list of elements that must have at least one entry
|
|
/// in it.
|
|
ParseResult Parser::parseCommaSeparatedList(
|
|
const std::function<ParseResult()> &parseElement) {
|
|
// Non-empty case starts with an element.
|
|
if (parseElement())
|
|
return failure();
|
|
|
|
// Otherwise we have a list of comma separated elements.
|
|
while (consumeIf(Token::comma)) {
|
|
if (parseElement())
|
|
return failure();
|
|
}
|
|
return success();
|
|
}
|
|
|
|
/// Parse a comma-separated list of elements, terminated with an arbitrary
|
|
/// token. This allows empty lists if allowEmptyList is true.
|
|
///
|
|
/// abstract-list ::= rightToken // if allowEmptyList == true
|
|
/// abstract-list ::= element (',' element)* rightToken
|
|
///
|
|
ParseResult Parser::parseCommaSeparatedListUntil(
|
|
Token::Kind rightToken, const std::function<ParseResult()> &parseElement,
|
|
bool allowEmptyList) {
|
|
// Handle the empty case.
|
|
if (getToken().is(rightToken)) {
|
|
if (!allowEmptyList)
|
|
return emitError("expected list element");
|
|
consumeToken(rightToken);
|
|
return success();
|
|
}
|
|
|
|
if (parseCommaSeparatedList(parseElement) ||
|
|
parseToken(rightToken, "expected ',' or '" +
|
|
Token::getTokenSpelling(rightToken) + "'"))
|
|
return failure();
|
|
|
|
return success();
|
|
}
|
|
|
|
/// Parse the body of a pretty dialect symbol, which starts and ends with <>'s,
|
|
/// and may be recursive. Return with the 'prettyName' StringRef encompasing
|
|
/// the entire pretty name.
|
|
///
|
|
/// pretty-dialect-sym-body ::= '<' pretty-dialect-sym-contents+ '>'
|
|
/// pretty-dialect-sym-contents ::= pretty-dialect-sym-body
|
|
/// | '(' pretty-dialect-sym-contents+ ')'
|
|
/// | '[' pretty-dialect-sym-contents+ ']'
|
|
/// | '{' pretty-dialect-sym-contents+ '}'
|
|
/// | '[^[<({>\])}\0]+'
|
|
///
|
|
ParseResult Parser::parsePrettyDialectSymbolName(StringRef &prettyName) {
|
|
// Pretty symbol names are a relatively unstructured format that contains a
|
|
// series of properly nested punctuation, with anything else in the middle.
|
|
// Scan ahead to find it and consume it if successful, otherwise emit an
|
|
// error.
|
|
auto *curPtr = getTokenSpelling().data();
|
|
|
|
SmallVector<char, 8> nestedPunctuation;
|
|
|
|
// Scan over the nested punctuation, bailing out on error and consuming until
|
|
// we find the end. We know that we're currently looking at the '<', so we
|
|
// can go until we find the matching '>' character.
|
|
assert(*curPtr == '<');
|
|
do {
|
|
char c = *curPtr++;
|
|
switch (c) {
|
|
case '\0':
|
|
// This also handles the EOF case.
|
|
return emitError("unexpected nul or EOF in pretty dialect name");
|
|
case '<':
|
|
case '[':
|
|
case '(':
|
|
case '{':
|
|
nestedPunctuation.push_back(c);
|
|
continue;
|
|
|
|
case '-':
|
|
// The sequence `->` is treated as special token.
|
|
if (*curPtr == '>')
|
|
++curPtr;
|
|
continue;
|
|
|
|
case '>':
|
|
if (nestedPunctuation.pop_back_val() != '<')
|
|
return emitError("unbalanced '>' character in pretty dialect name");
|
|
break;
|
|
case ']':
|
|
if (nestedPunctuation.pop_back_val() != '[')
|
|
return emitError("unbalanced ']' character in pretty dialect name");
|
|
break;
|
|
case ')':
|
|
if (nestedPunctuation.pop_back_val() != '(')
|
|
return emitError("unbalanced ')' character in pretty dialect name");
|
|
break;
|
|
case '}':
|
|
if (nestedPunctuation.pop_back_val() != '{')
|
|
return emitError("unbalanced '}' character in pretty dialect name");
|
|
break;
|
|
|
|
default:
|
|
continue;
|
|
}
|
|
} while (!nestedPunctuation.empty());
|
|
|
|
// Ok, we succeeded, remember where we stopped, reset the lexer to know it is
|
|
// consuming all this stuff, and return.
|
|
state.lex.resetPointer(curPtr);
|
|
|
|
unsigned length = curPtr - prettyName.begin();
|
|
prettyName = StringRef(prettyName.begin(), length);
|
|
consumeToken();
|
|
return success();
|
|
}
|
|
|
|
/// Parse an extended dialect symbol.
|
|
template <typename Symbol, typename SymbolAliasMap, typename CreateFn>
|
|
static Symbol parseExtendedSymbol(Parser &p, Token::Kind identifierTok,
|
|
SymbolAliasMap &aliases,
|
|
CreateFn &&createSymbol) {
|
|
// Parse the dialect namespace.
|
|
StringRef identifier = p.getTokenSpelling().drop_front();
|
|
auto loc = p.getToken().getLoc();
|
|
p.consumeToken(identifierTok);
|
|
|
|
// If there is no '<' token following this, and if the typename contains no
|
|
// dot, then we are parsing a symbol alias.
|
|
if (p.getToken().isNot(Token::less) && !identifier.contains('.')) {
|
|
// Check for an alias for this type.
|
|
auto aliasIt = aliases.find(identifier);
|
|
if (aliasIt == aliases.end())
|
|
return (p.emitError("undefined symbol alias id '" + identifier + "'"),
|
|
nullptr);
|
|
return aliasIt->second;
|
|
}
|
|
|
|
// Otherwise, we are parsing a dialect-specific symbol. If the name contains
|
|
// a dot, then this is the "pretty" form. If not, it is the verbose form that
|
|
// looks like <"...">.
|
|
std::string symbolData;
|
|
auto dialectName = identifier;
|
|
|
|
// Handle the verbose form, where "identifier" is a simple dialect name.
|
|
if (!identifier.contains('.')) {
|
|
// Consume the '<'.
|
|
if (p.parseToken(Token::less, "expected '<' in dialect type"))
|
|
return nullptr;
|
|
|
|
// Parse the symbol specific data.
|
|
if (p.getToken().isNot(Token::string))
|
|
return (p.emitError("expected string literal data in dialect symbol"),
|
|
nullptr);
|
|
symbolData = p.getToken().getStringValue();
|
|
loc = p.getToken().getLoc();
|
|
p.consumeToken(Token::string);
|
|
|
|
// Consume the '>'.
|
|
if (p.parseToken(Token::greater, "expected '>' in dialect symbol"))
|
|
return nullptr;
|
|
} else {
|
|
// Ok, the dialect name is the part of the identifier before the dot, the
|
|
// part after the dot is the dialect's symbol, or the start thereof.
|
|
auto dotHalves = identifier.split('.');
|
|
dialectName = dotHalves.first;
|
|
auto prettyName = dotHalves.second;
|
|
|
|
// If the dialect's symbol is followed immediately by a <, then lex the body
|
|
// of it into prettyName.
|
|
if (p.getToken().is(Token::less) &&
|
|
prettyName.bytes_end() == p.getTokenSpelling().bytes_begin()) {
|
|
if (p.parsePrettyDialectSymbolName(prettyName))
|
|
return nullptr;
|
|
}
|
|
|
|
symbolData = prettyName.str();
|
|
}
|
|
|
|
// Call into the provided symbol construction function.
|
|
auto encodedLoc = p.getEncodedSourceLocation(loc);
|
|
return createSymbol(dialectName, symbolData, encodedLoc);
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Error Handling
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
InFlightDiagnostic Parser::emitError(SMLoc loc, const Twine &message) {
|
|
auto diag = mlir::emitError(getEncodedSourceLocation(loc), message);
|
|
|
|
// If we hit a parse error in response to a lexer error, then the lexer
|
|
// already reported the error.
|
|
if (getToken().is(Token::error))
|
|
diag.abandon();
|
|
return diag;
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Token Parsing
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// Consume the specified token if present and return success. On failure,
|
|
/// output a diagnostic and return failure.
|
|
ParseResult Parser::parseToken(Token::Kind expectedToken,
|
|
const Twine &message) {
|
|
if (consumeIf(expectedToken))
|
|
return success();
|
|
return emitError(message);
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Type Parsing
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// Parse an arbitrary type.
|
|
///
|
|
/// type ::= function-type
|
|
/// | non-function-type
|
|
///
|
|
Type Parser::parseType() {
|
|
if (getToken().is(Token::l_paren))
|
|
return parseFunctionType();
|
|
return parseNonFunctionType();
|
|
}
|
|
|
|
/// Parse a function result type.
|
|
///
|
|
/// function-result-type ::= type-list-parens
|
|
/// | non-function-type
|
|
///
|
|
ParseResult Parser::parseFunctionResultTypes(SmallVectorImpl<Type> &elements) {
|
|
if (getToken().is(Token::l_paren))
|
|
return parseTypeListParens(elements);
|
|
|
|
Type t = parseNonFunctionType();
|
|
if (!t)
|
|
return failure();
|
|
elements.push_back(t);
|
|
return success();
|
|
}
|
|
|
|
/// Parse a list of types without an enclosing parenthesis. The list must have
|
|
/// at least one member.
|
|
///
|
|
/// type-list-no-parens ::= type (`,` type)*
|
|
///
|
|
ParseResult Parser::parseTypeListNoParens(SmallVectorImpl<Type> &elements) {
|
|
auto parseElt = [&]() -> ParseResult {
|
|
auto elt = parseType();
|
|
elements.push_back(elt);
|
|
return elt ? success() : failure();
|
|
};
|
|
|
|
return parseCommaSeparatedList(parseElt);
|
|
}
|
|
|
|
/// Parse a parenthesized list of types.
|
|
///
|
|
/// type-list-parens ::= `(` `)`
|
|
/// | `(` type-list-no-parens `)`
|
|
///
|
|
ParseResult Parser::parseTypeListParens(SmallVectorImpl<Type> &elements) {
|
|
if (parseToken(Token::l_paren, "expected '('"))
|
|
return failure();
|
|
|
|
// Handle empty lists.
|
|
if (getToken().is(Token::r_paren))
|
|
return consumeToken(), success();
|
|
|
|
if (parseTypeListNoParens(elements) ||
|
|
parseToken(Token::r_paren, "expected ')'"))
|
|
return failure();
|
|
return success();
|
|
}
|
|
|
|
/// Parse a complex type.
|
|
///
|
|
/// complex-type ::= `complex` `<` type `>`
|
|
///
|
|
Type Parser::parseComplexType() {
|
|
consumeToken(Token::kw_complex);
|
|
|
|
// Parse the '<'.
|
|
if (parseToken(Token::less, "expected '<' in complex type"))
|
|
return nullptr;
|
|
|
|
auto typeLocation = getEncodedSourceLocation(getToken().getLoc());
|
|
auto elementType = parseType();
|
|
if (!elementType ||
|
|
parseToken(Token::greater, "expected '>' in complex type"))
|
|
return nullptr;
|
|
|
|
return ComplexType::getChecked(elementType, typeLocation);
|
|
}
|
|
|
|
/// Parse an extended type.
|
|
///
|
|
/// extended-type ::= (dialect-type | type-alias)
|
|
/// dialect-type ::= `!` dialect-namespace `<` `"` type-data `"` `>`
|
|
/// dialect-type ::= `!` alias-name pretty-dialect-attribute-body?
|
|
/// type-alias ::= `!` alias-name
|
|
///
|
|
Type Parser::parseExtendedType() {
|
|
return parseExtendedSymbol<Type>(
|
|
*this, Token::exclamation_identifier, state.typeAliasDefinitions,
|
|
[&](StringRef dialectName, StringRef symbolData, Location loc) -> Type {
|
|
// If we found a registered dialect, then ask it to parse the type.
|
|
if (auto *dialect = state.context->getRegisteredDialect(dialectName))
|
|
return dialect->parseType(symbolData, loc);
|
|
|
|
// Otherwise, form a new opaque type.
|
|
return OpaqueType::getChecked(
|
|
Identifier::get(dialectName, state.context), symbolData,
|
|
state.context, loc);
|
|
});
|
|
}
|
|
|
|
/// Parse a function type.
|
|
///
|
|
/// function-type ::= type-list-parens `->` function-result-type
|
|
///
|
|
Type Parser::parseFunctionType() {
|
|
assert(getToken().is(Token::l_paren));
|
|
|
|
SmallVector<Type, 4> arguments, results;
|
|
if (parseTypeListParens(arguments) ||
|
|
parseToken(Token::arrow, "expected '->' in function type") ||
|
|
parseFunctionResultTypes(results))
|
|
return nullptr;
|
|
|
|
return builder.getFunctionType(arguments, results);
|
|
}
|
|
|
|
/// Parse a memref type.
|
|
///
|
|
/// memref-type ::= `memref` `<` dimension-list-ranked type
|
|
/// (`,` semi-affine-map-composition)? (`,` memory-space)? `>`
|
|
///
|
|
/// semi-affine-map-composition ::= (semi-affine-map `,` )* semi-affine-map
|
|
/// memory-space ::= integer-literal /* | TODO: address-space-id */
|
|
///
|
|
Type Parser::parseMemRefType() {
|
|
consumeToken(Token::kw_memref);
|
|
|
|
if (parseToken(Token::less, "expected '<' in memref type"))
|
|
return nullptr;
|
|
|
|
SmallVector<int64_t, 4> dimensions;
|
|
if (parseDimensionListRanked(dimensions))
|
|
return nullptr;
|
|
|
|
// Parse the element type.
|
|
auto typeLoc = getToken().getLoc();
|
|
auto elementType = parseType();
|
|
if (!elementType)
|
|
return nullptr;
|
|
|
|
// Parse semi-affine-map-composition.
|
|
SmallVector<AffineMap, 2> affineMapComposition;
|
|
unsigned memorySpace = 0;
|
|
bool parsedMemorySpace = false;
|
|
|
|
auto parseElt = [&]() -> ParseResult {
|
|
if (getToken().is(Token::integer)) {
|
|
// Parse memory space.
|
|
if (parsedMemorySpace)
|
|
return emitError("multiple memory spaces specified in memref type");
|
|
auto v = getToken().getUnsignedIntegerValue();
|
|
if (!v.hasValue())
|
|
return emitError("invalid memory space in memref type");
|
|
memorySpace = v.getValue();
|
|
consumeToken(Token::integer);
|
|
parsedMemorySpace = true;
|
|
} else {
|
|
// Parse affine map.
|
|
if (parsedMemorySpace)
|
|
return emitError("affine map after memory space in memref type");
|
|
auto affineMap = parseAttribute();
|
|
if (!affineMap)
|
|
return failure();
|
|
|
|
// Verify that the parsed attribute is an affine map.
|
|
if (auto affineMapAttr = affineMap.dyn_cast<AffineMapAttr>())
|
|
affineMapComposition.push_back(affineMapAttr.getValue());
|
|
else
|
|
return emitError("expected affine map in memref type");
|
|
}
|
|
return success();
|
|
};
|
|
|
|
// Parse a list of mappings and address space if present.
|
|
if (consumeIf(Token::comma)) {
|
|
// Parse comma separated list of affine maps, followed by memory space.
|
|
if (parseCommaSeparatedListUntil(Token::greater, parseElt,
|
|
/*allowEmptyList=*/false)) {
|
|
return nullptr;
|
|
}
|
|
} else {
|
|
if (parseToken(Token::greater, "expected ',' or '>' in memref type"))
|
|
return nullptr;
|
|
}
|
|
|
|
return MemRefType::getChecked(dimensions, elementType, affineMapComposition,
|
|
memorySpace, getEncodedSourceLocation(typeLoc));
|
|
}
|
|
|
|
/// Parse any type except the function type.
|
|
///
|
|
/// non-function-type ::= integer-type
|
|
/// | index-type
|
|
/// | float-type
|
|
/// | extended-type
|
|
/// | vector-type
|
|
/// | tensor-type
|
|
/// | memref-type
|
|
/// | complex-type
|
|
/// | tuple-type
|
|
/// | none-type
|
|
///
|
|
/// index-type ::= `index`
|
|
/// float-type ::= `f16` | `bf16` | `f32` | `f64`
|
|
/// none-type ::= `none`
|
|
///
|
|
Type Parser::parseNonFunctionType() {
|
|
switch (getToken().getKind()) {
|
|
default:
|
|
return (emitError("expected non-function type"), nullptr);
|
|
case Token::kw_memref:
|
|
return parseMemRefType();
|
|
case Token::kw_tensor:
|
|
return parseTensorType();
|
|
case Token::kw_complex:
|
|
return parseComplexType();
|
|
case Token::kw_tuple:
|
|
return parseTupleType();
|
|
case Token::kw_vector:
|
|
return parseVectorType();
|
|
// integer-type
|
|
case Token::inttype: {
|
|
auto width = getToken().getIntTypeBitwidth();
|
|
if (!width.hasValue())
|
|
return (emitError("invalid integer width"), nullptr);
|
|
auto loc = getEncodedSourceLocation(getToken().getLoc());
|
|
consumeToken(Token::inttype);
|
|
return IntegerType::getChecked(width.getValue(), builder.getContext(), loc);
|
|
}
|
|
|
|
// float-type
|
|
case Token::kw_bf16:
|
|
consumeToken(Token::kw_bf16);
|
|
return builder.getBF16Type();
|
|
case Token::kw_f16:
|
|
consumeToken(Token::kw_f16);
|
|
return builder.getF16Type();
|
|
case Token::kw_f32:
|
|
consumeToken(Token::kw_f32);
|
|
return builder.getF32Type();
|
|
case Token::kw_f64:
|
|
consumeToken(Token::kw_f64);
|
|
return builder.getF64Type();
|
|
|
|
// index-type
|
|
case Token::kw_index:
|
|
consumeToken(Token::kw_index);
|
|
return builder.getIndexType();
|
|
|
|
// none-type
|
|
case Token::kw_none:
|
|
consumeToken(Token::kw_none);
|
|
return builder.getNoneType();
|
|
|
|
// extended type
|
|
case Token::exclamation_identifier:
|
|
return parseExtendedType();
|
|
}
|
|
}
|
|
|
|
/// Parse a tensor type.
|
|
///
|
|
/// tensor-type ::= `tensor` `<` dimension-list type `>`
|
|
/// dimension-list ::= dimension-list-ranked | `*x`
|
|
///
|
|
Type Parser::parseTensorType() {
|
|
consumeToken(Token::kw_tensor);
|
|
|
|
if (parseToken(Token::less, "expected '<' in tensor type"))
|
|
return nullptr;
|
|
|
|
bool isUnranked;
|
|
SmallVector<int64_t, 4> dimensions;
|
|
|
|
if (consumeIf(Token::star)) {
|
|
// This is an unranked tensor type.
|
|
isUnranked = true;
|
|
|
|
if (parseXInDimensionList())
|
|
return nullptr;
|
|
|
|
} else {
|
|
isUnranked = false;
|
|
if (parseDimensionListRanked(dimensions))
|
|
return nullptr;
|
|
}
|
|
|
|
// Parse the element type.
|
|
auto typeLocation = getEncodedSourceLocation(getToken().getLoc());
|
|
auto elementType = parseType();
|
|
if (!elementType || parseToken(Token::greater, "expected '>' in tensor type"))
|
|
return nullptr;
|
|
|
|
if (isUnranked)
|
|
return UnrankedTensorType::getChecked(elementType, typeLocation);
|
|
return RankedTensorType::getChecked(dimensions, elementType, typeLocation);
|
|
}
|
|
|
|
/// Parse a tuple type.
|
|
///
|
|
/// tuple-type ::= `tuple` `<` (type (`,` type)*)? `>`
|
|
///
|
|
Type Parser::parseTupleType() {
|
|
consumeToken(Token::kw_tuple);
|
|
|
|
// Parse the '<'.
|
|
if (parseToken(Token::less, "expected '<' in tuple type"))
|
|
return nullptr;
|
|
|
|
// Check for an empty tuple by directly parsing '>'.
|
|
if (consumeIf(Token::greater))
|
|
return TupleType::get(getContext());
|
|
|
|
// Parse the element types and the '>'.
|
|
SmallVector<Type, 4> types;
|
|
if (parseTypeListNoParens(types) ||
|
|
parseToken(Token::greater, "expected '>' in tuple type"))
|
|
return nullptr;
|
|
|
|
return TupleType::get(types, getContext());
|
|
}
|
|
|
|
/// Parse a vector type.
|
|
///
|
|
/// vector-type ::= `vector` `<` non-empty-static-dimension-list type `>`
|
|
/// non-empty-static-dimension-list ::= decimal-literal `x`
|
|
/// static-dimension-list
|
|
/// static-dimension-list ::= (decimal-literal `x`)*
|
|
///
|
|
VectorType Parser::parseVectorType() {
|
|
consumeToken(Token::kw_vector);
|
|
|
|
if (parseToken(Token::less, "expected '<' in vector type"))
|
|
return nullptr;
|
|
|
|
SmallVector<int64_t, 4> dimensions;
|
|
if (parseDimensionListRanked(dimensions, /*allowDynamic=*/false))
|
|
return nullptr;
|
|
if (dimensions.empty())
|
|
return (emitError("expected dimension size in vector type"), nullptr);
|
|
|
|
// Parse the element type.
|
|
auto typeLoc = getToken().getLoc();
|
|
auto elementType = parseType();
|
|
if (!elementType || parseToken(Token::greater, "expected '>' in vector type"))
|
|
return nullptr;
|
|
|
|
return VectorType::getChecked(dimensions, elementType,
|
|
getEncodedSourceLocation(typeLoc));
|
|
}
|
|
|
|
/// Parse a dimension list of a tensor or memref type. This populates the
|
|
/// dimension list, using -1 for the `?` dimensions if `allowDynamic` is set and
|
|
/// errors out on `?` otherwise.
|
|
///
|
|
/// dimension-list-ranked ::= (dimension `x`)*
|
|
/// dimension ::= `?` | decimal-literal
|
|
///
|
|
/// When `allowDynamic` is not set, this is used to parse:
|
|
///
|
|
/// static-dimension-list ::= (decimal-literal `x`)*
|
|
ParseResult
|
|
Parser::parseDimensionListRanked(SmallVectorImpl<int64_t> &dimensions,
|
|
bool allowDynamic) {
|
|
while (getToken().isAny(Token::integer, Token::question)) {
|
|
if (consumeIf(Token::question)) {
|
|
if (!allowDynamic)
|
|
return emitError("expected static shape");
|
|
dimensions.push_back(-1);
|
|
} else {
|
|
// Hexadecimal integer literals (starting with `0x`) are not allowed in
|
|
// aggregate type declarations. Therefore, `0xf32` should be processed as
|
|
// a sequence of separate elements `0`, `x`, `f32`.
|
|
if (getTokenSpelling().size() > 1 && getTokenSpelling()[1] == 'x') {
|
|
// We can get here only if the token is an integer literal. Hexadecimal
|
|
// integer literals can only start with `0x` (`1x` wouldn't lex as a
|
|
// literal, just `1` would, at which point we don't get into this
|
|
// branch).
|
|
assert(getTokenSpelling()[0] == '0' && "invalid integer literal");
|
|
dimensions.push_back(0);
|
|
state.lex.resetPointer(getTokenSpelling().data() + 1);
|
|
consumeToken();
|
|
} else {
|
|
// Make sure this integer value is in bound and valid.
|
|
auto dimension = getToken().getUnsignedIntegerValue();
|
|
if (!dimension.hasValue())
|
|
return emitError("invalid dimension");
|
|
dimensions.push_back((int64_t)dimension.getValue());
|
|
consumeToken(Token::integer);
|
|
}
|
|
}
|
|
|
|
// Make sure we have an 'x' or something like 'xbf32'.
|
|
if (parseXInDimensionList())
|
|
return failure();
|
|
}
|
|
|
|
return success();
|
|
}
|
|
|
|
/// Parse an 'x' token in a dimension list, handling the case where the x is
|
|
/// juxtaposed with an element type, as in "xf32", leaving the "f32" as the next
|
|
/// token.
|
|
ParseResult Parser::parseXInDimensionList() {
|
|
if (getToken().isNot(Token::bare_identifier) || getTokenSpelling()[0] != 'x')
|
|
return emitError("expected 'x' in dimension list");
|
|
|
|
// If we had a prefix of 'x', lex the next token immediately after the 'x'.
|
|
if (getTokenSpelling().size() != 1)
|
|
state.lex.resetPointer(getTokenSpelling().data() + 1);
|
|
|
|
// Consume the 'x'.
|
|
consumeToken(Token::bare_identifier);
|
|
|
|
return success();
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Attribute parsing.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// Parse an arbitrary attribute.
|
|
///
|
|
/// attribute-value ::= `unit`
|
|
/// | bool-literal
|
|
/// | integer-literal (`:` (index-type | integer-type))?
|
|
/// | float-literal (`:` float-type)?
|
|
/// | string-literal (`:` type)?
|
|
/// | type
|
|
/// | `[` (attribute-value (`,` attribute-value)*)? `]`
|
|
/// | `{` (attribute-entry (`,` attribute-entry)*)? `}`
|
|
/// | symbol-ref-id
|
|
/// | `dense` `<` attribute-value `>` `:`
|
|
/// (tensor-type | vector-type)
|
|
/// | `sparse` `<` attribute-value `,` attribute-value `>`
|
|
/// `:` (tensor-type | vector-type)
|
|
/// | `opaque` `<` dialect-namespace `,` hex-string-literal
|
|
/// `>` `:` (tensor-type | vector-type)
|
|
/// | extended-attribute
|
|
///
|
|
Attribute Parser::parseAttribute(Type type) {
|
|
switch (getToken().getKind()) {
|
|
// Parse an AffineMap or IntegerSet attribute.
|
|
case Token::l_paren: {
|
|
// Try to parse an affine map or an integer set reference.
|
|
AffineMap map;
|
|
IntegerSet set;
|
|
if (parseAffineMapOrIntegerSetReference(map, set))
|
|
return nullptr;
|
|
if (map)
|
|
return builder.getAffineMapAttr(map);
|
|
assert(set);
|
|
return builder.getIntegerSetAttr(set);
|
|
}
|
|
|
|
// Parse an array attribute.
|
|
case Token::l_square: {
|
|
consumeToken(Token::l_square);
|
|
|
|
SmallVector<Attribute, 4> elements;
|
|
auto parseElt = [&]() -> ParseResult {
|
|
elements.push_back(parseAttribute());
|
|
return elements.back() ? success() : failure();
|
|
};
|
|
|
|
if (parseCommaSeparatedListUntil(Token::r_square, parseElt))
|
|
return nullptr;
|
|
return builder.getArrayAttr(elements);
|
|
}
|
|
|
|
// Parse a boolean attribute.
|
|
case Token::kw_false:
|
|
consumeToken(Token::kw_false);
|
|
return builder.getBoolAttr(false);
|
|
case Token::kw_true:
|
|
consumeToken(Token::kw_true);
|
|
return builder.getBoolAttr(true);
|
|
|
|
// Parse a dense elements attribute.
|
|
case Token::kw_dense:
|
|
return parseDenseElementsAttr();
|
|
|
|
// Parse a dictionary attribute.
|
|
case Token::l_brace: {
|
|
SmallVector<NamedAttribute, 4> elements;
|
|
if (parseAttributeDict(elements))
|
|
return nullptr;
|
|
return builder.getDictionaryAttr(elements);
|
|
}
|
|
|
|
// Parse an extended attribute, i.e. alias or dialect attribute.
|
|
case Token::hash_identifier:
|
|
return parseExtendedAttr(type);
|
|
|
|
// Parse floating point and integer attributes.
|
|
case Token::floatliteral:
|
|
return parseFloatAttr(type, /*isNegative=*/false);
|
|
case Token::integer:
|
|
return parseDecOrHexAttr(type, /*isNegative=*/false);
|
|
case Token::minus: {
|
|
consumeToken(Token::minus);
|
|
if (getToken().is(Token::integer))
|
|
return parseDecOrHexAttr(type, /*isNegative=*/true);
|
|
if (getToken().is(Token::floatliteral))
|
|
return parseFloatAttr(type, /*isNegative=*/true);
|
|
|
|
return (emitError("expected constant integer or floating point value"),
|
|
nullptr);
|
|
}
|
|
|
|
// Parse a location attribute.
|
|
case Token::kw_loc: {
|
|
LocationAttr attr;
|
|
return failed(parseLocation(attr)) ? Attribute() : attr;
|
|
}
|
|
|
|
// Parse an opaque elements attribute.
|
|
case Token::kw_opaque:
|
|
return parseOpaqueElementsAttr();
|
|
|
|
// Parse a sparse elements attribute.
|
|
case Token::kw_sparse:
|
|
return parseSparseElementsAttr();
|
|
|
|
// Parse a string attribute.
|
|
case Token::string: {
|
|
auto val = getToken().getStringValue();
|
|
consumeToken(Token::string);
|
|
// Parse the optional trailing colon type if one wasn't explicitly provided.
|
|
if (!type && consumeIf(Token::colon) && !(type = parseType()))
|
|
return Attribute();
|
|
|
|
return type ? StringAttr::get(val, type)
|
|
: StringAttr::get(val, getContext());
|
|
}
|
|
|
|
// Parse a symbol reference attribute.
|
|
case Token::at_identifier: {
|
|
auto nameStr = getTokenSpelling();
|
|
consumeToken(Token::at_identifier);
|
|
return builder.getSymbolRefAttr(nameStr.drop_front());
|
|
}
|
|
|
|
// Parse a 'unit' attribute.
|
|
case Token::kw_unit:
|
|
consumeToken(Token::kw_unit);
|
|
return builder.getUnitAttr();
|
|
|
|
default:
|
|
// Parse a type attribute.
|
|
if (Type type = parseType())
|
|
return builder.getTypeAttr(type);
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
/// Attribute dictionary.
|
|
///
|
|
/// attribute-dict ::= `{` `}`
|
|
/// | `{` attribute-entry (`,` attribute-entry)* `}`
|
|
/// attribute-entry ::= bare-id `=` attribute-value
|
|
///
|
|
ParseResult
|
|
Parser::parseAttributeDict(SmallVectorImpl<NamedAttribute> &attributes) {
|
|
if (!consumeIf(Token::l_brace))
|
|
return failure();
|
|
|
|
auto parseElt = [&]() -> ParseResult {
|
|
// We allow keywords as attribute names.
|
|
if (getToken().isNot(Token::bare_identifier, Token::inttype) &&
|
|
!getToken().isKeyword())
|
|
return emitError("expected attribute name");
|
|
Identifier nameId = builder.getIdentifier(getTokenSpelling());
|
|
consumeToken();
|
|
|
|
// Try to parse the '=' for the attribute value.
|
|
if (!consumeIf(Token::equal)) {
|
|
// If there is no '=', we treat this as a unit attribute.
|
|
attributes.push_back({nameId, builder.getUnitAttr()});
|
|
return success();
|
|
}
|
|
|
|
auto attr = parseAttribute();
|
|
if (!attr)
|
|
return failure();
|
|
|
|
attributes.push_back({nameId, attr});
|
|
return success();
|
|
};
|
|
|
|
if (parseCommaSeparatedListUntil(Token::r_brace, parseElt))
|
|
return failure();
|
|
|
|
return success();
|
|
}
|
|
|
|
/// Parse an extended attribute.
|
|
///
|
|
/// extended-attribute ::= (dialect-attribute | attribute-alias)
|
|
/// dialect-attribute ::= `#` dialect-namespace `<` `"` attr-data `"` `>`
|
|
/// dialect-attribute ::= `#` alias-name pretty-dialect-sym-body?
|
|
/// attribute-alias ::= `#` alias-name
|
|
///
|
|
Attribute Parser::parseExtendedAttr(Type type) {
|
|
Attribute attr = parseExtendedSymbol<Attribute>(
|
|
*this, Token::hash_identifier, state.attributeAliasDefinitions,
|
|
[&](StringRef dialectName, StringRef symbolData,
|
|
Location loc) -> Attribute {
|
|
// Parse an optional trailing colon type.
|
|
Type attrType = type;
|
|
if (consumeIf(Token::colon) && !(attrType = parseType()))
|
|
return Attribute();
|
|
|
|
// If we found a registered dialect, then ask it to parse the attribute.
|
|
if (auto *dialect = state.context->getRegisteredDialect(dialectName))
|
|
return dialect->parseAttribute(symbolData, attrType, loc);
|
|
|
|
// Otherwise, form a new opaque attribute.
|
|
return OpaqueAttr::getChecked(
|
|
Identifier::get(dialectName, state.context), symbolData,
|
|
attrType ? attrType : NoneType::get(state.context), loc);
|
|
});
|
|
|
|
// Ensure that the attribute has the same type as requested.
|
|
if (attr && type && attr.getType() != type) {
|
|
emitError("attribute type different than expected: expected ")
|
|
<< type << ", but got " << attr.getType();
|
|
return nullptr;
|
|
}
|
|
return attr;
|
|
}
|
|
|
|
/// Parse a float attribute.
|
|
Attribute Parser::parseFloatAttr(Type type, bool isNegative) {
|
|
auto val = getToken().getFloatingPointValue();
|
|
if (!val.hasValue())
|
|
return (emitError("floating point value too large for attribute"), nullptr);
|
|
consumeToken(Token::floatliteral);
|
|
if (!type) {
|
|
// Default to F64 when no type is specified.
|
|
if (!consumeIf(Token::colon))
|
|
type = builder.getF64Type();
|
|
else if (!(type = parseType()))
|
|
return nullptr;
|
|
}
|
|
if (!type.isa<FloatType>())
|
|
return (emitError("floating point value not valid for specified type"),
|
|
nullptr);
|
|
return FloatAttr::get(type, isNegative ? -val.getValue() : val.getValue());
|
|
}
|
|
|
|
/// Construct a float attribute bitwise equivalent to the integer literal.
|
|
static FloatAttr buildHexadecimalFloatLiteral(Parser *p, FloatType type,
|
|
uint64_t value) {
|
|
int width = type.getIntOrFloatBitWidth();
|
|
APInt apInt(width, value);
|
|
if (apInt != value) {
|
|
p->emitError("hexadecimal float constant out of range for type");
|
|
return nullptr;
|
|
}
|
|
APFloat apFloat(type.getFloatSemantics(), apInt);
|
|
return p->builder.getFloatAttr(type, apFloat);
|
|
}
|
|
|
|
/// Parse a decimal or a hexadecimal literal, which can be either an integer
|
|
/// or a float attribute.
|
|
Attribute Parser::parseDecOrHexAttr(Type type, bool isNegative) {
|
|
auto val = getToken().getUInt64IntegerValue();
|
|
if (!val.hasValue())
|
|
return (emitError("integer constant out of range for attribute"), nullptr);
|
|
|
|
// Remember if the literal is hexadecimal.
|
|
StringRef spelling = getToken().getSpelling();
|
|
bool isHex = spelling.size() > 1 && spelling[1] == 'x';
|
|
|
|
consumeToken(Token::integer);
|
|
if (!type) {
|
|
// Default to i64 if not type is specified.
|
|
if (!consumeIf(Token::colon))
|
|
type = builder.getIntegerType(64);
|
|
else if (!(type = parseType()))
|
|
return nullptr;
|
|
}
|
|
|
|
// Hexadecimal representation of float literals is not supported for bfloat16.
|
|
// When supported, the literal should be unsigned.
|
|
auto floatType = type.dyn_cast<FloatType>();
|
|
if (floatType && !type.isBF16()) {
|
|
if (isNegative) {
|
|
emitError("hexadecimal float literal should not have a leading minus");
|
|
return nullptr;
|
|
}
|
|
if (!isHex) {
|
|
emitError("unexpected decimal integer literal for a float attribute")
|
|
.attachNote()
|
|
<< "add a trailing dot to make the literal a float";
|
|
return nullptr;
|
|
}
|
|
|
|
// Construct a float attribute bitwise equivalent to the integer literal.
|
|
return buildHexadecimalFloatLiteral(this, floatType, *val);
|
|
}
|
|
|
|
if (!type.isIntOrIndex())
|
|
return (emitError("integer literal not valid for specified type"), nullptr);
|
|
|
|
// Parse the integer literal.
|
|
int width = type.isIndex() ? 64 : type.getIntOrFloatBitWidth();
|
|
APInt apInt(width, *val, isNegative);
|
|
if (apInt != *val)
|
|
return (emitError("integer constant out of range for attribute"), nullptr);
|
|
|
|
// Otherwise construct an integer attribute.
|
|
if (isNegative ? (int64_t)-val.getValue() >= 0 : (int64_t)val.getValue() < 0)
|
|
return (emitError("integer constant out of range for attribute"), nullptr);
|
|
|
|
return builder.getIntegerAttr(type, isNegative ? -apInt : apInt);
|
|
}
|
|
|
|
/// Parse an opaque elements attribute.
|
|
Attribute Parser::parseOpaqueElementsAttr() {
|
|
consumeToken(Token::kw_opaque);
|
|
if (parseToken(Token::less, "expected '<' after 'opaque'"))
|
|
return nullptr;
|
|
|
|
if (getToken().isNot(Token::string))
|
|
return (emitError("expected dialect namespace"), nullptr);
|
|
|
|
auto name = getToken().getStringValue();
|
|
auto *dialect = builder.getContext()->getRegisteredDialect(name);
|
|
// TODO(shpeisman): Allow for having an unknown dialect on an opaque
|
|
// attribute. Otherwise, it can't be roundtripped without having the dialect
|
|
// registered.
|
|
if (!dialect)
|
|
return (emitError("no registered dialect with namespace '" + name + "'"),
|
|
nullptr);
|
|
|
|
consumeToken(Token::string);
|
|
if (parseToken(Token::comma, "expected ','"))
|
|
return nullptr;
|
|
|
|
if (getToken().getKind() != Token::string)
|
|
return (emitError("opaque string should start with '0x'"), nullptr);
|
|
|
|
auto val = getToken().getStringValue();
|
|
if (val.size() < 2 || val[0] != '0' || val[1] != 'x')
|
|
return (emitError("opaque string should start with '0x'"), nullptr);
|
|
|
|
val = val.substr(2);
|
|
if (!llvm::all_of(val, llvm::isHexDigit))
|
|
return (emitError("opaque string only contains hex digits"), nullptr);
|
|
|
|
consumeToken(Token::string);
|
|
if (parseToken(Token::greater, "expected '>'") ||
|
|
parseToken(Token::colon, "expected ':'"))
|
|
return nullptr;
|
|
|
|
auto type = parseElementsLiteralType();
|
|
if (!type)
|
|
return nullptr;
|
|
|
|
return builder.getOpaqueElementsAttr(dialect, type, llvm::fromHex(val));
|
|
}
|
|
|
|
namespace {
|
|
class TensorLiteralParser {
|
|
public:
|
|
TensorLiteralParser(Parser &p) : p(p) {}
|
|
|
|
ParseResult parse() {
|
|
if (p.getToken().is(Token::l_square))
|
|
return parseList(shape);
|
|
return parseElement();
|
|
}
|
|
|
|
/// Build a dense attribute instance with the parsed elements and the given
|
|
/// shaped type.
|
|
DenseElementsAttr getAttr(llvm::SMLoc loc, ShapedType type);
|
|
|
|
ArrayRef<int64_t> getShape() const { return shape; }
|
|
|
|
private:
|
|
enum class ElementKind { Boolean, Integer, Float };
|
|
|
|
/// Return a string to represent the given element kind.
|
|
const char *getElementKindStr(ElementKind kind) {
|
|
switch (kind) {
|
|
case ElementKind::Boolean:
|
|
return "'boolean'";
|
|
case ElementKind::Integer:
|
|
return "'integer'";
|
|
case ElementKind::Float:
|
|
return "'float'";
|
|
}
|
|
llvm_unreachable("unknown element kind");
|
|
}
|
|
|
|
/// Build a Dense Integer attribute for the given type.
|
|
DenseElementsAttr getIntAttr(llvm::SMLoc loc, ShapedType type,
|
|
IntegerType eltTy);
|
|
|
|
/// Build a Dense Float attribute for the given type.
|
|
DenseElementsAttr getFloatAttr(llvm::SMLoc loc, ShapedType type,
|
|
FloatType eltTy);
|
|
|
|
/// Parse a single element, returning failure if it isn't a valid element
|
|
/// literal. For example:
|
|
/// parseElement(1) -> Success, 1
|
|
/// parseElement([1]) -> Failure
|
|
ParseResult parseElement();
|
|
|
|
/// Parse a list of either lists or elements, returning the dimensions of the
|
|
/// parsed sub-tensors in dims. For example:
|
|
/// parseList([1, 2, 3]) -> Success, [3]
|
|
/// parseList([[1, 2], [3, 4]]) -> Success, [2, 2]
|
|
/// parseList([[1, 2], 3]) -> Failure
|
|
/// parseList([[1, [2, 3]], [4, [5]]]) -> Failure
|
|
ParseResult parseList(llvm::SmallVectorImpl<int64_t> &dims);
|
|
|
|
Parser &p;
|
|
|
|
/// The shape inferred from the parsed elements.
|
|
SmallVector<int64_t, 4> shape;
|
|
|
|
/// Storage used when parsing elements, this is a pair of <is_negated, token>.
|
|
std::vector<std::pair<bool, Token>> storage;
|
|
|
|
/// A flag that indicates the type of elements that have been parsed.
|
|
llvm::Optional<ElementKind> knownEltKind;
|
|
};
|
|
} // namespace
|
|
|
|
/// Build a dense attribute instance with the parsed elements and the given
|
|
/// shaped type.
|
|
DenseElementsAttr TensorLiteralParser::getAttr(llvm::SMLoc loc,
|
|
ShapedType type) {
|
|
// Check that the parsed storage size has the same number of elements to the
|
|
// type, or is a known splat.
|
|
if (!shape.empty() && getShape() != type.getShape()) {
|
|
p.emitError(loc) << "inferred shape of elements literal ([" << getShape()
|
|
<< "]) does not match type ([" << type.getShape() << "])";
|
|
return nullptr;
|
|
}
|
|
|
|
// If the type is an integer, build a set of APInt values from the storage
|
|
// with the correct bitwidth.
|
|
if (auto intTy = type.getElementType().dyn_cast<IntegerType>())
|
|
return getIntAttr(loc, type, intTy);
|
|
|
|
// Otherwise, this must be a floating point type.
|
|
auto floatTy = type.getElementType().dyn_cast<FloatType>();
|
|
if (!floatTy) {
|
|
p.emitError(loc) << "expected floating-point or integer element type, got "
|
|
<< type.getElementType();
|
|
return nullptr;
|
|
}
|
|
return getFloatAttr(loc, type, floatTy);
|
|
}
|
|
|
|
/// Build a Dense Integer attribute for the given type.
|
|
DenseElementsAttr TensorLiteralParser::getIntAttr(llvm::SMLoc loc,
|
|
ShapedType type,
|
|
IntegerType eltTy) {
|
|
std::vector<APInt> intElements;
|
|
intElements.reserve(storage.size());
|
|
for (const auto &signAndToken : storage) {
|
|
bool isNegative = signAndToken.first;
|
|
const Token &token = signAndToken.second;
|
|
|
|
// Check to see if floating point values were parsed.
|
|
if (token.is(Token::floatliteral)) {
|
|
p.emitError() << "expected integer elements, but parsed floating-point";
|
|
return nullptr;
|
|
}
|
|
|
|
assert(token.isAny(Token::integer, Token::kw_true, Token::kw_false) &&
|
|
"unexpected token type");
|
|
if (token.isAny(Token::kw_true, Token::kw_false)) {
|
|
if (!eltTy.isInteger(1))
|
|
p.emitError() << "expected i1 type for 'true' or 'false' values";
|
|
APInt apInt(eltTy.getWidth(), token.is(Token::kw_true),
|
|
/*isSigned=*/false);
|
|
intElements.push_back(apInt);
|
|
continue;
|
|
}
|
|
|
|
// Create APInt values for each element with the correct bitwidth.
|
|
auto val = token.getUInt64IntegerValue();
|
|
if (!val.hasValue() || (isNegative ? (int64_t)-val.getValue() >= 0
|
|
: (int64_t)val.getValue() < 0)) {
|
|
p.emitError(token.getLoc(),
|
|
"integer constant out of range for attribute");
|
|
return nullptr;
|
|
}
|
|
APInt apInt(eltTy.getWidth(), val.getValue(), isNegative);
|
|
if (apInt != val.getValue())
|
|
return (p.emitError("integer constant out of range for type"), nullptr);
|
|
intElements.push_back(isNegative ? -apInt : apInt);
|
|
}
|
|
|
|
return DenseElementsAttr::get(type, intElements);
|
|
}
|
|
|
|
/// Build a Dense Float attribute for the given type.
|
|
DenseElementsAttr TensorLiteralParser::getFloatAttr(llvm::SMLoc loc,
|
|
ShapedType type,
|
|
FloatType eltTy) {
|
|
std::vector<Attribute> floatValues;
|
|
floatValues.reserve(storage.size());
|
|
for (const auto &signAndToken : storage) {
|
|
bool isNegative = signAndToken.first;
|
|
const Token &token = signAndToken.second;
|
|
|
|
// Handle hexadecimal float literals.
|
|
if (token.is(Token::integer) && token.getSpelling().startswith("0x")) {
|
|
if (isNegative) {
|
|
p.emitError(token.getLoc())
|
|
<< "hexadecimal float literal should not have a leading minus";
|
|
return nullptr;
|
|
}
|
|
auto val = token.getUInt64IntegerValue();
|
|
if (!val.hasValue()) {
|
|
p.emitError("hexadecimal float constant out of range for attribute");
|
|
return nullptr;
|
|
}
|
|
FloatAttr attr = buildHexadecimalFloatLiteral(&p, eltTy, *val);
|
|
if (!attr)
|
|
return nullptr;
|
|
floatValues.push_back(attr);
|
|
continue;
|
|
}
|
|
|
|
// Check to see if any decimal integers or booleans were parsed.
|
|
if (!token.is(Token::floatliteral)) {
|
|
p.emitError() << "expected floating-point elements, but parsed integer";
|
|
return nullptr;
|
|
}
|
|
|
|
// Build the float values from tokens.
|
|
auto val = token.getFloatingPointValue();
|
|
if (!val.hasValue()) {
|
|
p.emitError("floating point value too large for attribute");
|
|
return nullptr;
|
|
}
|
|
floatValues.push_back(FloatAttr::get(eltTy, isNegative ? -*val : *val));
|
|
}
|
|
|
|
return DenseElementsAttr::get(type, floatValues);
|
|
}
|
|
|
|
ParseResult TensorLiteralParser::parseElement() {
|
|
switch (p.getToken().getKind()) {
|
|
// Parse a boolean element.
|
|
case Token::kw_true:
|
|
case Token::kw_false:
|
|
case Token::floatliteral:
|
|
case Token::integer:
|
|
storage.emplace_back(/*isNegative=*/false, p.getToken());
|
|
p.consumeToken();
|
|
break;
|
|
|
|
// Parse a signed integer or a negative floating-point element.
|
|
case Token::minus:
|
|
p.consumeToken(Token::minus);
|
|
if (!p.getToken().isAny(Token::floatliteral, Token::integer))
|
|
return p.emitError("expected integer or floating point literal");
|
|
storage.emplace_back(/*isNegative=*/true, p.getToken());
|
|
p.consumeToken();
|
|
break;
|
|
|
|
default:
|
|
return p.emitError("expected element literal of primitive type");
|
|
}
|
|
|
|
return success();
|
|
}
|
|
|
|
/// Parse a list of either lists or elements, returning the dimensions of the
|
|
/// parsed sub-tensors in dims. For example:
|
|
/// parseList([1, 2, 3]) -> Success, [3]
|
|
/// parseList([[1, 2], [3, 4]]) -> Success, [2, 2]
|
|
/// parseList([[1, 2], 3]) -> Failure
|
|
/// parseList([[1, [2, 3]], [4, [5]]]) -> Failure
|
|
ParseResult
|
|
TensorLiteralParser::parseList(llvm::SmallVectorImpl<int64_t> &dims) {
|
|
p.consumeToken(Token::l_square);
|
|
|
|
auto checkDims =
|
|
[&](const llvm::SmallVectorImpl<int64_t> &prevDims,
|
|
const llvm::SmallVectorImpl<int64_t> &newDims) -> ParseResult {
|
|
if (prevDims == newDims)
|
|
return success();
|
|
return p.emitError("tensor literal is invalid; ranks are not consistent "
|
|
"between elements");
|
|
};
|
|
|
|
bool first = true;
|
|
llvm::SmallVector<int64_t, 4> newDims;
|
|
unsigned size = 0;
|
|
auto parseCommaSeparatedList = [&]() -> ParseResult {
|
|
llvm::SmallVector<int64_t, 4> thisDims;
|
|
if (p.getToken().getKind() == Token::l_square) {
|
|
if (parseList(thisDims))
|
|
return failure();
|
|
} else if (parseElement()) {
|
|
return failure();
|
|
}
|
|
++size;
|
|
if (!first)
|
|
return checkDims(newDims, thisDims);
|
|
newDims = thisDims;
|
|
first = false;
|
|
return success();
|
|
};
|
|
if (p.parseCommaSeparatedListUntil(Token::r_square, parseCommaSeparatedList))
|
|
return failure();
|
|
|
|
// Return the sublists' dimensions with 'size' prepended.
|
|
dims.clear();
|
|
dims.push_back(size);
|
|
dims.append(newDims.begin(), newDims.end());
|
|
return success();
|
|
}
|
|
|
|
/// Parse a dense elements attribute.
|
|
Attribute Parser::parseDenseElementsAttr() {
|
|
consumeToken(Token::kw_dense);
|
|
if (parseToken(Token::less, "expected '<' after 'dense'"))
|
|
return nullptr;
|
|
|
|
// Parse the literal data.
|
|
TensorLiteralParser literalParser(*this);
|
|
if (literalParser.parse())
|
|
return nullptr;
|
|
|
|
if (parseToken(Token::greater, "expected '>'") ||
|
|
parseToken(Token::colon, "expected ':'"))
|
|
return nullptr;
|
|
|
|
auto typeLoc = getToken().getLoc();
|
|
auto type = parseElementsLiteralType();
|
|
if (!type)
|
|
return nullptr;
|
|
return literalParser.getAttr(typeLoc, type);
|
|
}
|
|
|
|
/// Shaped type for elements attribute.
|
|
///
|
|
/// elements-literal-type ::= vector-type | ranked-tensor-type
|
|
///
|
|
/// This method also checks the type has static shape.
|
|
ShapedType Parser::parseElementsLiteralType() {
|
|
auto type = parseType();
|
|
if (!type)
|
|
return nullptr;
|
|
|
|
if (!type.isa<RankedTensorType>() && !type.isa<VectorType>()) {
|
|
emitError("elements literal must be a ranked tensor or vector type");
|
|
return nullptr;
|
|
}
|
|
|
|
auto sType = type.cast<ShapedType>();
|
|
if (!sType.hasStaticShape())
|
|
return (emitError("elements literal type must have static shape"), nullptr);
|
|
|
|
return sType;
|
|
}
|
|
|
|
/// Parse a sparse elements attribute.
|
|
Attribute Parser::parseSparseElementsAttr() {
|
|
consumeToken(Token::kw_sparse);
|
|
if (parseToken(Token::less, "Expected '<' after 'sparse'"))
|
|
return nullptr;
|
|
|
|
/// Parse indices
|
|
auto indicesLoc = getToken().getLoc();
|
|
TensorLiteralParser indiceParser(*this);
|
|
if (indiceParser.parse())
|
|
return nullptr;
|
|
|
|
if (parseToken(Token::comma, "expected ','"))
|
|
return nullptr;
|
|
|
|
/// Parse values.
|
|
auto valuesLoc = getToken().getLoc();
|
|
TensorLiteralParser valuesParser(*this);
|
|
if (valuesParser.parse())
|
|
return nullptr;
|
|
|
|
if (parseToken(Token::greater, "expected '>'") ||
|
|
parseToken(Token::colon, "expected ':'"))
|
|
return nullptr;
|
|
|
|
auto type = parseElementsLiteralType();
|
|
if (!type)
|
|
return nullptr;
|
|
|
|
// If the indices are a splat, i.e. the literal parser parsed an element and
|
|
// not a list, we set the shape explicitly. The indices are represented by a
|
|
// 2-dimensional shape where the second dimension is the rank of the type.
|
|
// Given that the parsed indices is a splat, we know that we only have one
|
|
// indice and thus one for the first dimension.
|
|
auto indiceEltType = builder.getIntegerType(64);
|
|
ShapedType indicesType;
|
|
if (indiceParser.getShape().empty()) {
|
|
indicesType = RankedTensorType::get({1, type.getRank()}, indiceEltType);
|
|
} else {
|
|
// Otherwise, set the shape to the one parsed by the literal parser.
|
|
indicesType = RankedTensorType::get(indiceParser.getShape(), indiceEltType);
|
|
}
|
|
auto indices = indiceParser.getAttr(indicesLoc, indicesType);
|
|
|
|
// If the values are a splat, set the shape explicitly based on the number of
|
|
// indices. The number of indices is encoded in the first dimension of the
|
|
// indice shape type.
|
|
auto valuesEltType = type.getElementType();
|
|
ShapedType valuesType =
|
|
valuesParser.getShape().empty()
|
|
? RankedTensorType::get({indicesType.getDimSize(0)}, valuesEltType)
|
|
: RankedTensorType::get(valuesParser.getShape(), valuesEltType);
|
|
auto values = valuesParser.getAttr(valuesLoc, valuesType);
|
|
|
|
/// Sanity check.
|
|
if (valuesType.getRank() != 1)
|
|
return (emitError("expected 1-d tensor for values"), nullptr);
|
|
|
|
auto sameShape = (indicesType.getRank() == 1) ||
|
|
(type.getRank() == indicesType.getDimSize(1));
|
|
auto sameElementNum = indicesType.getDimSize(0) == valuesType.getDimSize(0);
|
|
if (!sameShape || !sameElementNum) {
|
|
emitError() << "expected shape ([" << type.getShape()
|
|
<< "]); inferred shape of indices literal (["
|
|
<< indicesType.getShape()
|
|
<< "]); inferred shape of values literal (["
|
|
<< valuesType.getShape() << "])";
|
|
return nullptr;
|
|
}
|
|
|
|
// Build the sparse elements attribute by the indices and values.
|
|
return SparseElementsAttr::get(type, indices, values);
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Location parsing.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// Parse a location.
|
|
///
|
|
/// location ::= `loc` inline-location
|
|
/// inline-location ::= '(' location-inst ')'
|
|
///
|
|
ParseResult Parser::parseLocation(LocationAttr &loc) {
|
|
// Check for 'loc' identifier.
|
|
if (parseToken(Token::kw_loc, "expected 'loc' keyword"))
|
|
return emitError();
|
|
|
|
// Parse the inline-location.
|
|
if (parseToken(Token::l_paren, "expected '(' in inline location") ||
|
|
parseLocationInstance(loc) ||
|
|
parseToken(Token::r_paren, "expected ')' in inline location"))
|
|
return failure();
|
|
return success();
|
|
}
|
|
|
|
/// Specific location instances.
|
|
///
|
|
/// location-inst ::= filelinecol-location |
|
|
/// name-location |
|
|
/// callsite-location |
|
|
/// fused-location |
|
|
/// unknown-location
|
|
/// filelinecol-location ::= string-literal ':' integer-literal
|
|
/// ':' integer-literal
|
|
/// name-location ::= string-literal
|
|
/// callsite-location ::= 'callsite' '(' location-inst 'at' location-inst ')'
|
|
/// fused-location ::= fused ('<' attribute-value '>')?
|
|
/// '[' location-inst (location-inst ',')* ']'
|
|
/// unknown-location ::= 'unknown'
|
|
///
|
|
ParseResult Parser::parseCallSiteLocation(LocationAttr &loc) {
|
|
consumeToken(Token::bare_identifier);
|
|
|
|
// Parse the '('.
|
|
if (parseToken(Token::l_paren, "expected '(' in callsite location"))
|
|
return failure();
|
|
|
|
// Parse the callee location.
|
|
LocationAttr calleeLoc;
|
|
if (parseLocationInstance(calleeLoc))
|
|
return failure();
|
|
|
|
// Parse the 'at'.
|
|
if (getToken().isNot(Token::bare_identifier) ||
|
|
getToken().getSpelling() != "at")
|
|
return emitError("expected 'at' in callsite location");
|
|
consumeToken(Token::bare_identifier);
|
|
|
|
// Parse the caller location.
|
|
LocationAttr callerLoc;
|
|
if (parseLocationInstance(callerLoc))
|
|
return failure();
|
|
|
|
// Parse the ')'.
|
|
if (parseToken(Token::r_paren, "expected ')' in callsite location"))
|
|
return failure();
|
|
|
|
// Return the callsite location.
|
|
loc = CallSiteLoc::get(calleeLoc, callerLoc);
|
|
return success();
|
|
}
|
|
|
|
ParseResult Parser::parseFusedLocation(LocationAttr &loc) {
|
|
consumeToken(Token::bare_identifier);
|
|
|
|
// Try to parse the optional metadata.
|
|
Attribute metadata;
|
|
if (consumeIf(Token::less)) {
|
|
metadata = parseAttribute();
|
|
if (!metadata)
|
|
return emitError("expected valid attribute metadata");
|
|
// Parse the '>' token.
|
|
if (parseToken(Token::greater,
|
|
"expected '>' after fused location metadata"))
|
|
return failure();
|
|
}
|
|
|
|
llvm::SmallVector<Location, 4> locations;
|
|
auto parseElt = [&] {
|
|
LocationAttr newLoc;
|
|
if (parseLocationInstance(newLoc))
|
|
return failure();
|
|
locations.push_back(newLoc);
|
|
return success();
|
|
};
|
|
|
|
if (parseToken(Token::l_square, "expected '[' in fused location") ||
|
|
parseCommaSeparatedList(parseElt) ||
|
|
parseToken(Token::r_square, "expected ']' in fused location"))
|
|
return failure();
|
|
|
|
// Return the fused location.
|
|
loc = FusedLoc::get(locations, metadata, getContext());
|
|
return success();
|
|
}
|
|
|
|
ParseResult Parser::parseNameOrFileLineColLocation(LocationAttr &loc) {
|
|
auto *ctx = getContext();
|
|
auto str = getToken().getStringValue();
|
|
consumeToken(Token::string);
|
|
|
|
// If the next token is ':' this is a filelinecol location.
|
|
if (consumeIf(Token::colon)) {
|
|
// Parse the line number.
|
|
if (getToken().isNot(Token::integer))
|
|
return emitError("expected integer line number in FileLineColLoc");
|
|
auto line = getToken().getUnsignedIntegerValue();
|
|
if (!line.hasValue())
|
|
return emitError("expected integer line number in FileLineColLoc");
|
|
consumeToken(Token::integer);
|
|
|
|
// Parse the ':'.
|
|
if (parseToken(Token::colon, "expected ':' in FileLineColLoc"))
|
|
return failure();
|
|
|
|
// Parse the column number.
|
|
if (getToken().isNot(Token::integer))
|
|
return emitError("expected integer column number in FileLineColLoc");
|
|
auto column = getToken().getUnsignedIntegerValue();
|
|
if (!column.hasValue())
|
|
return emitError("expected integer column number in FileLineColLoc");
|
|
consumeToken(Token::integer);
|
|
|
|
loc = FileLineColLoc::get(str, line.getValue(), column.getValue(), ctx);
|
|
return success();
|
|
}
|
|
|
|
// Otherwise, this is a NameLoc.
|
|
|
|
// Check for a child location.
|
|
if (consumeIf(Token::l_paren)) {
|
|
auto childSourceLoc = getToken().getLoc();
|
|
|
|
// Parse the child location.
|
|
LocationAttr childLoc;
|
|
if (parseLocationInstance(childLoc))
|
|
return failure();
|
|
|
|
// The child must not be another NameLoc.
|
|
if (childLoc.isa<NameLoc>())
|
|
return emitError(childSourceLoc,
|
|
"child of NameLoc cannot be another NameLoc");
|
|
loc = NameLoc::get(Identifier::get(str, ctx), childLoc);
|
|
|
|
// Parse the closing ')'.
|
|
if (parseToken(Token::r_paren,
|
|
"expected ')' after child location of NameLoc"))
|
|
return failure();
|
|
} else {
|
|
loc = NameLoc::get(Identifier::get(str, ctx), ctx);
|
|
}
|
|
|
|
return success();
|
|
}
|
|
|
|
ParseResult Parser::parseLocationInstance(LocationAttr &loc) {
|
|
// Handle either name or filelinecol locations.
|
|
if (getToken().is(Token::string))
|
|
return parseNameOrFileLineColLocation(loc);
|
|
|
|
// Bare tokens required for other cases.
|
|
if (!getToken().is(Token::bare_identifier))
|
|
return emitError("expected location instance");
|
|
|
|
// Check for the 'callsite' signifying a callsite location.
|
|
if (getToken().getSpelling() == "callsite")
|
|
return parseCallSiteLocation(loc);
|
|
|
|
// If the token is 'fused', then this is a fused location.
|
|
if (getToken().getSpelling() == "fused")
|
|
return parseFusedLocation(loc);
|
|
|
|
// Check for a 'unknown' for an unknown location.
|
|
if (getToken().getSpelling() == "unknown") {
|
|
consumeToken(Token::bare_identifier);
|
|
loc = UnknownLoc::get(getContext());
|
|
return success();
|
|
}
|
|
|
|
return emitError("expected location instance");
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Affine parsing.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// Lower precedence ops (all at the same precedence level). LNoOp is false in
|
|
/// the boolean sense.
|
|
enum AffineLowPrecOp {
|
|
/// Null value.
|
|
LNoOp,
|
|
Add,
|
|
Sub
|
|
};
|
|
|
|
/// Higher precedence ops - all at the same precedence level. HNoOp is false
|
|
/// in the boolean sense.
|
|
enum AffineHighPrecOp {
|
|
/// Null value.
|
|
HNoOp,
|
|
Mul,
|
|
FloorDiv,
|
|
CeilDiv,
|
|
Mod
|
|
};
|
|
|
|
namespace {
|
|
/// This is a specialized parser for affine structures (affine maps, affine
|
|
/// expressions, and integer sets), maintaining the state transient to their
|
|
/// bodies.
|
|
class AffineParser : public Parser {
|
|
public:
|
|
AffineParser(ParserState &state, bool allowParsingSSAIds = false,
|
|
llvm::function_ref<ParseResult(bool)> parseElement = nullptr)
|
|
: Parser(state), allowParsingSSAIds(allowParsingSSAIds),
|
|
parseElement(parseElement), numDimOperands(0), numSymbolOperands(0) {}
|
|
|
|
AffineMap parseAffineMapRange(unsigned numDims, unsigned numSymbols);
|
|
ParseResult parseAffineMapOrIntegerSetInline(AffineMap &map, IntegerSet &set);
|
|
IntegerSet parseIntegerSetConstraints(unsigned numDims, unsigned numSymbols);
|
|
ParseResult parseAffineMapOfSSAIds(AffineMap &map);
|
|
void getDimsAndSymbolSSAIds(SmallVectorImpl<StringRef> &dimAndSymbolSSAIds,
|
|
unsigned &numDims);
|
|
|
|
private:
|
|
// Binary affine op parsing.
|
|
AffineLowPrecOp consumeIfLowPrecOp();
|
|
AffineHighPrecOp consumeIfHighPrecOp();
|
|
|
|
// Identifier lists for polyhedral structures.
|
|
ParseResult parseDimIdList(unsigned &numDims);
|
|
ParseResult parseSymbolIdList(unsigned &numSymbols);
|
|
ParseResult parseDimAndOptionalSymbolIdList(unsigned &numDims,
|
|
unsigned &numSymbols);
|
|
ParseResult parseIdentifierDefinition(AffineExpr idExpr);
|
|
|
|
AffineExpr parseAffineExpr();
|
|
AffineExpr parseParentheticalExpr();
|
|
AffineExpr parseNegateExpression(AffineExpr lhs);
|
|
AffineExpr parseIntegerExpr();
|
|
AffineExpr parseBareIdExpr();
|
|
AffineExpr parseSSAIdExpr(bool isSymbol);
|
|
AffineExpr parseSymbolSSAIdExpr();
|
|
|
|
AffineExpr getAffineBinaryOpExpr(AffineHighPrecOp op, AffineExpr lhs,
|
|
AffineExpr rhs, SMLoc opLoc);
|
|
AffineExpr getAffineBinaryOpExpr(AffineLowPrecOp op, AffineExpr lhs,
|
|
AffineExpr rhs);
|
|
AffineExpr parseAffineOperandExpr(AffineExpr lhs);
|
|
AffineExpr parseAffineLowPrecOpExpr(AffineExpr llhs, AffineLowPrecOp llhsOp);
|
|
AffineExpr parseAffineHighPrecOpExpr(AffineExpr llhs, AffineHighPrecOp llhsOp,
|
|
SMLoc llhsOpLoc);
|
|
AffineExpr parseAffineConstraint(bool *isEq);
|
|
|
|
private:
|
|
bool allowParsingSSAIds;
|
|
llvm::function_ref<ParseResult(bool)> parseElement;
|
|
unsigned numDimOperands;
|
|
unsigned numSymbolOperands;
|
|
SmallVector<std::pair<StringRef, AffineExpr>, 4> dimsAndSymbols;
|
|
};
|
|
} // end anonymous namespace
|
|
|
|
/// Create an affine binary high precedence op expression (mul's, div's, mod).
|
|
/// opLoc is the location of the op token to be used to report errors
|
|
/// for non-conforming expressions.
|
|
AffineExpr AffineParser::getAffineBinaryOpExpr(AffineHighPrecOp op,
|
|
AffineExpr lhs, AffineExpr rhs,
|
|
SMLoc opLoc) {
|
|
// TODO: make the error location info accurate.
|
|
switch (op) {
|
|
case Mul:
|
|
if (!lhs.isSymbolicOrConstant() && !rhs.isSymbolicOrConstant()) {
|
|
emitError(opLoc, "non-affine expression: at least one of the multiply "
|
|
"operands has to be either a constant or symbolic");
|
|
return nullptr;
|
|
}
|
|
return lhs * rhs;
|
|
case FloorDiv:
|
|
if (!rhs.isSymbolicOrConstant()) {
|
|
emitError(opLoc, "non-affine expression: right operand of floordiv "
|
|
"has to be either a constant or symbolic");
|
|
return nullptr;
|
|
}
|
|
return lhs.floorDiv(rhs);
|
|
case CeilDiv:
|
|
if (!rhs.isSymbolicOrConstant()) {
|
|
emitError(opLoc, "non-affine expression: right operand of ceildiv "
|
|
"has to be either a constant or symbolic");
|
|
return nullptr;
|
|
}
|
|
return lhs.ceilDiv(rhs);
|
|
case Mod:
|
|
if (!rhs.isSymbolicOrConstant()) {
|
|
emitError(opLoc, "non-affine expression: right operand of mod "
|
|
"has to be either a constant or symbolic");
|
|
return nullptr;
|
|
}
|
|
return lhs % rhs;
|
|
case HNoOp:
|
|
llvm_unreachable("can't create affine expression for null high prec op");
|
|
return nullptr;
|
|
}
|
|
llvm_unreachable("Unknown AffineHighPrecOp");
|
|
}
|
|
|
|
/// Create an affine binary low precedence op expression (add, sub).
|
|
AffineExpr AffineParser::getAffineBinaryOpExpr(AffineLowPrecOp op,
|
|
AffineExpr lhs, AffineExpr rhs) {
|
|
switch (op) {
|
|
case AffineLowPrecOp::Add:
|
|
return lhs + rhs;
|
|
case AffineLowPrecOp::Sub:
|
|
return lhs - rhs;
|
|
case AffineLowPrecOp::LNoOp:
|
|
llvm_unreachable("can't create affine expression for null low prec op");
|
|
return nullptr;
|
|
}
|
|
llvm_unreachable("Unknown AffineLowPrecOp");
|
|
}
|
|
|
|
/// Consume this token if it is a lower precedence affine op (there are only
|
|
/// two precedence levels).
|
|
AffineLowPrecOp AffineParser::consumeIfLowPrecOp() {
|
|
switch (getToken().getKind()) {
|
|
case Token::plus:
|
|
consumeToken(Token::plus);
|
|
return AffineLowPrecOp::Add;
|
|
case Token::minus:
|
|
consumeToken(Token::minus);
|
|
return AffineLowPrecOp::Sub;
|
|
default:
|
|
return AffineLowPrecOp::LNoOp;
|
|
}
|
|
}
|
|
|
|
/// Consume this token if it is a higher precedence affine op (there are only
|
|
/// two precedence levels)
|
|
AffineHighPrecOp AffineParser::consumeIfHighPrecOp() {
|
|
switch (getToken().getKind()) {
|
|
case Token::star:
|
|
consumeToken(Token::star);
|
|
return Mul;
|
|
case Token::kw_floordiv:
|
|
consumeToken(Token::kw_floordiv);
|
|
return FloorDiv;
|
|
case Token::kw_ceildiv:
|
|
consumeToken(Token::kw_ceildiv);
|
|
return CeilDiv;
|
|
case Token::kw_mod:
|
|
consumeToken(Token::kw_mod);
|
|
return Mod;
|
|
default:
|
|
return HNoOp;
|
|
}
|
|
}
|
|
|
|
/// Parse a high precedence op expression list: mul, div, and mod are high
|
|
/// precedence binary ops, i.e., parse a
|
|
/// expr_1 op_1 expr_2 op_2 ... expr_n
|
|
/// where op_1, op_2 are all a AffineHighPrecOp (mul, div, mod).
|
|
/// All affine binary ops are left associative.
|
|
/// Given llhs, returns (llhs llhsOp lhs) op rhs, or (lhs op rhs) if llhs is
|
|
/// null. If no rhs can be found, returns (llhs llhsOp lhs) or lhs if llhs is
|
|
/// null. llhsOpLoc is the location of the llhsOp token that will be used to
|
|
/// report an error for non-conforming expressions.
|
|
AffineExpr AffineParser::parseAffineHighPrecOpExpr(AffineExpr llhs,
|
|
AffineHighPrecOp llhsOp,
|
|
SMLoc llhsOpLoc) {
|
|
AffineExpr lhs = parseAffineOperandExpr(llhs);
|
|
if (!lhs)
|
|
return nullptr;
|
|
|
|
// Found an LHS. Parse the remaining expression.
|
|
auto opLoc = getToken().getLoc();
|
|
if (AffineHighPrecOp op = consumeIfHighPrecOp()) {
|
|
if (llhs) {
|
|
AffineExpr expr = getAffineBinaryOpExpr(llhsOp, llhs, lhs, opLoc);
|
|
if (!expr)
|
|
return nullptr;
|
|
return parseAffineHighPrecOpExpr(expr, op, opLoc);
|
|
}
|
|
// No LLHS, get RHS
|
|
return parseAffineHighPrecOpExpr(lhs, op, opLoc);
|
|
}
|
|
|
|
// This is the last operand in this expression.
|
|
if (llhs)
|
|
return getAffineBinaryOpExpr(llhsOp, llhs, lhs, llhsOpLoc);
|
|
|
|
// No llhs, 'lhs' itself is the expression.
|
|
return lhs;
|
|
}
|
|
|
|
/// Parse an affine expression inside parentheses.
|
|
///
|
|
/// affine-expr ::= `(` affine-expr `)`
|
|
AffineExpr AffineParser::parseParentheticalExpr() {
|
|
if (parseToken(Token::l_paren, "expected '('"))
|
|
return nullptr;
|
|
if (getToken().is(Token::r_paren))
|
|
return (emitError("no expression inside parentheses"), nullptr);
|
|
|
|
auto expr = parseAffineExpr();
|
|
if (!expr)
|
|
return nullptr;
|
|
if (parseToken(Token::r_paren, "expected ')'"))
|
|
return nullptr;
|
|
|
|
return expr;
|
|
}
|
|
|
|
/// Parse the negation expression.
|
|
///
|
|
/// affine-expr ::= `-` affine-expr
|
|
AffineExpr AffineParser::parseNegateExpression(AffineExpr lhs) {
|
|
if (parseToken(Token::minus, "expected '-'"))
|
|
return nullptr;
|
|
|
|
AffineExpr operand = parseAffineOperandExpr(lhs);
|
|
// Since negation has the highest precedence of all ops (including high
|
|
// precedence ops) but lower than parentheses, we are only going to use
|
|
// parseAffineOperandExpr instead of parseAffineExpr here.
|
|
if (!operand)
|
|
// Extra error message although parseAffineOperandExpr would have
|
|
// complained. Leads to a better diagnostic.
|
|
return (emitError("missing operand of negation"), nullptr);
|
|
return (-1) * operand;
|
|
}
|
|
|
|
/// Parse a bare id that may appear in an affine expression.
|
|
///
|
|
/// affine-expr ::= bare-id
|
|
AffineExpr AffineParser::parseBareIdExpr() {
|
|
if (getToken().isNot(Token::bare_identifier))
|
|
return (emitError("expected bare identifier"), nullptr);
|
|
|
|
StringRef sRef = getTokenSpelling();
|
|
for (auto entry : dimsAndSymbols) {
|
|
if (entry.first == sRef) {
|
|
consumeToken(Token::bare_identifier);
|
|
return entry.second;
|
|
}
|
|
}
|
|
|
|
return (emitError("use of undeclared identifier"), nullptr);
|
|
}
|
|
|
|
/// Parse an SSA id which may appear in an affine expression.
|
|
AffineExpr AffineParser::parseSSAIdExpr(bool isSymbol) {
|
|
if (!allowParsingSSAIds)
|
|
return (emitError("unexpected ssa identifier"), nullptr);
|
|
if (getToken().isNot(Token::percent_identifier))
|
|
return (emitError("expected ssa identifier"), nullptr);
|
|
auto name = getTokenSpelling();
|
|
// Check if we already parsed this SSA id.
|
|
for (auto entry : dimsAndSymbols) {
|
|
if (entry.first == name) {
|
|
consumeToken(Token::percent_identifier);
|
|
return entry.second;
|
|
}
|
|
}
|
|
// Parse the SSA id and add an AffineDim/SymbolExpr to represent it.
|
|
if (parseElement(isSymbol))
|
|
return (emitError("failed to parse ssa identifier"), nullptr);
|
|
auto idExpr = isSymbol
|
|
? getAffineSymbolExpr(numSymbolOperands++, getContext())
|
|
: getAffineDimExpr(numDimOperands++, getContext());
|
|
dimsAndSymbols.push_back({name, idExpr});
|
|
return idExpr;
|
|
}
|
|
|
|
AffineExpr AffineParser::parseSymbolSSAIdExpr() {
|
|
if (parseToken(Token::kw_symbol, "expected symbol keyword") ||
|
|
parseToken(Token::l_paren, "expected '(' at start of SSA symbol"))
|
|
return nullptr;
|
|
AffineExpr symbolExpr = parseSSAIdExpr(/*isSymbol=*/true);
|
|
if (!symbolExpr)
|
|
return nullptr;
|
|
if (parseToken(Token::r_paren, "expected ')' at end of SSA symbol"))
|
|
return nullptr;
|
|
return symbolExpr;
|
|
}
|
|
|
|
/// Parse a positive integral constant appearing in an affine expression.
|
|
///
|
|
/// affine-expr ::= integer-literal
|
|
AffineExpr AffineParser::parseIntegerExpr() {
|
|
auto val = getToken().getUInt64IntegerValue();
|
|
if (!val.hasValue() || (int64_t)val.getValue() < 0)
|
|
return (emitError("constant too large for index"), nullptr);
|
|
|
|
consumeToken(Token::integer);
|
|
return builder.getAffineConstantExpr((int64_t)val.getValue());
|
|
}
|
|
|
|
/// Parses an expression that can be a valid operand of an affine expression.
|
|
/// lhs: if non-null, lhs is an affine expression that is the lhs of a binary
|
|
/// operator, the rhs of which is being parsed. This is used to determine
|
|
/// whether an error should be emitted for a missing right operand.
|
|
// Eg: for an expression without parentheses (like i + j + k + l), each
|
|
// of the four identifiers is an operand. For i + j*k + l, j*k is not an
|
|
// operand expression, it's an op expression and will be parsed via
|
|
// parseAffineHighPrecOpExpression(). However, for i + (j*k) + -l, (j*k) and
|
|
// -l are valid operands that will be parsed by this function.
|
|
AffineExpr AffineParser::parseAffineOperandExpr(AffineExpr lhs) {
|
|
switch (getToken().getKind()) {
|
|
case Token::bare_identifier:
|
|
return parseBareIdExpr();
|
|
case Token::kw_symbol:
|
|
return parseSymbolSSAIdExpr();
|
|
case Token::percent_identifier:
|
|
return parseSSAIdExpr(/*isSymbol=*/false);
|
|
case Token::integer:
|
|
return parseIntegerExpr();
|
|
case Token::l_paren:
|
|
return parseParentheticalExpr();
|
|
case Token::minus:
|
|
return parseNegateExpression(lhs);
|
|
case Token::kw_ceildiv:
|
|
case Token::kw_floordiv:
|
|
case Token::kw_mod:
|
|
case Token::plus:
|
|
case Token::star:
|
|
if (lhs)
|
|
emitError("missing right operand of binary operator");
|
|
else
|
|
emitError("missing left operand of binary operator");
|
|
return nullptr;
|
|
default:
|
|
if (lhs)
|
|
emitError("missing right operand of binary operator");
|
|
else
|
|
emitError("expected affine expression");
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
/// Parse affine expressions that are bare-id's, integer constants,
|
|
/// parenthetical affine expressions, and affine op expressions that are a
|
|
/// composition of those.
|
|
///
|
|
/// All binary op's associate from left to right.
|
|
///
|
|
/// {add, sub} have lower precedence than {mul, div, and mod}.
|
|
///
|
|
/// Add, sub'are themselves at the same precedence level. Mul, floordiv,
|
|
/// ceildiv, and mod are at the same higher precedence level. Negation has
|
|
/// higher precedence than any binary op.
|
|
///
|
|
/// llhs: the affine expression appearing on the left of the one being parsed.
|
|
/// This function will return ((llhs llhsOp lhs) op rhs) if llhs is non null,
|
|
/// and lhs op rhs otherwise; if there is no rhs, llhs llhsOp lhs is returned
|
|
/// if llhs is non-null; otherwise lhs is returned. This is to deal with left
|
|
/// associativity.
|
|
///
|
|
/// Eg: when the expression is e1 + e2*e3 + e4, with e1 as llhs, this function
|
|
/// will return the affine expr equivalent of (e1 + (e2*e3)) + e4, where
|
|
/// (e2*e3) will be parsed using parseAffineHighPrecOpExpr().
|
|
AffineExpr AffineParser::parseAffineLowPrecOpExpr(AffineExpr llhs,
|
|
AffineLowPrecOp llhsOp) {
|
|
AffineExpr lhs;
|
|
if (!(lhs = parseAffineOperandExpr(llhs)))
|
|
return nullptr;
|
|
|
|
// Found an LHS. Deal with the ops.
|
|
if (AffineLowPrecOp lOp = consumeIfLowPrecOp()) {
|
|
if (llhs) {
|
|
AffineExpr sum = getAffineBinaryOpExpr(llhsOp, llhs, lhs);
|
|
return parseAffineLowPrecOpExpr(sum, lOp);
|
|
}
|
|
// No LLHS, get RHS and form the expression.
|
|
return parseAffineLowPrecOpExpr(lhs, lOp);
|
|
}
|
|
auto opLoc = getToken().getLoc();
|
|
if (AffineHighPrecOp hOp = consumeIfHighPrecOp()) {
|
|
// We have a higher precedence op here. Get the rhs operand for the llhs
|
|
// through parseAffineHighPrecOpExpr.
|
|
AffineExpr highRes = parseAffineHighPrecOpExpr(lhs, hOp, opLoc);
|
|
if (!highRes)
|
|
return nullptr;
|
|
|
|
// If llhs is null, the product forms the first operand of the yet to be
|
|
// found expression. If non-null, the op to associate with llhs is llhsOp.
|
|
AffineExpr expr =
|
|
llhs ? getAffineBinaryOpExpr(llhsOp, llhs, highRes) : highRes;
|
|
|
|
// Recurse for subsequent low prec op's after the affine high prec op
|
|
// expression.
|
|
if (AffineLowPrecOp nextOp = consumeIfLowPrecOp())
|
|
return parseAffineLowPrecOpExpr(expr, nextOp);
|
|
return expr;
|
|
}
|
|
// Last operand in the expression list.
|
|
if (llhs)
|
|
return getAffineBinaryOpExpr(llhsOp, llhs, lhs);
|
|
// No llhs, 'lhs' itself is the expression.
|
|
return lhs;
|
|
}
|
|
|
|
/// Parse an affine expression.
|
|
/// affine-expr ::= `(` affine-expr `)`
|
|
/// | `-` affine-expr
|
|
/// | affine-expr `+` affine-expr
|
|
/// | affine-expr `-` affine-expr
|
|
/// | affine-expr `*` affine-expr
|
|
/// | affine-expr `floordiv` affine-expr
|
|
/// | affine-expr `ceildiv` affine-expr
|
|
/// | affine-expr `mod` affine-expr
|
|
/// | bare-id
|
|
/// | integer-literal
|
|
///
|
|
/// Additional conditions are checked depending on the production. For eg.,
|
|
/// one of the operands for `*` has to be either constant/symbolic; the second
|
|
/// operand for floordiv, ceildiv, and mod has to be a positive integer.
|
|
AffineExpr AffineParser::parseAffineExpr() {
|
|
return parseAffineLowPrecOpExpr(nullptr, AffineLowPrecOp::LNoOp);
|
|
}
|
|
|
|
/// Parse a dim or symbol from the lists appearing before the actual
|
|
/// expressions of the affine map. Update our state to store the
|
|
/// dimensional/symbolic identifier.
|
|
ParseResult AffineParser::parseIdentifierDefinition(AffineExpr idExpr) {
|
|
if (getToken().isNot(Token::bare_identifier))
|
|
return emitError("expected bare identifier");
|
|
|
|
auto name = getTokenSpelling();
|
|
for (auto entry : dimsAndSymbols) {
|
|
if (entry.first == name)
|
|
return emitError("redefinition of identifier '" + name + "'");
|
|
}
|
|
consumeToken(Token::bare_identifier);
|
|
|
|
dimsAndSymbols.push_back({name, idExpr});
|
|
return success();
|
|
}
|
|
|
|
/// Parse the list of dimensional identifiers to an affine map.
|
|
ParseResult AffineParser::parseDimIdList(unsigned &numDims) {
|
|
if (parseToken(Token::l_paren,
|
|
"expected '(' at start of dimensional identifiers list")) {
|
|
return failure();
|
|
}
|
|
|
|
auto parseElt = [&]() -> ParseResult {
|
|
auto dimension = getAffineDimExpr(numDims++, getContext());
|
|
return parseIdentifierDefinition(dimension);
|
|
};
|
|
return parseCommaSeparatedListUntil(Token::r_paren, parseElt);
|
|
}
|
|
|
|
/// Parse the list of symbolic identifiers to an affine map.
|
|
ParseResult AffineParser::parseSymbolIdList(unsigned &numSymbols) {
|
|
consumeToken(Token::l_square);
|
|
auto parseElt = [&]() -> ParseResult {
|
|
auto symbol = getAffineSymbolExpr(numSymbols++, getContext());
|
|
return parseIdentifierDefinition(symbol);
|
|
};
|
|
return parseCommaSeparatedListUntil(Token::r_square, parseElt);
|
|
}
|
|
|
|
/// Parse the list of symbolic identifiers to an affine map.
|
|
ParseResult
|
|
AffineParser::parseDimAndOptionalSymbolIdList(unsigned &numDims,
|
|
unsigned &numSymbols) {
|
|
if (parseDimIdList(numDims)) {
|
|
return failure();
|
|
}
|
|
if (!getToken().is(Token::l_square)) {
|
|
numSymbols = 0;
|
|
return success();
|
|
}
|
|
return parseSymbolIdList(numSymbols);
|
|
}
|
|
|
|
/// Parses an ambiguous affine map or integer set definition inline.
|
|
ParseResult AffineParser::parseAffineMapOrIntegerSetInline(AffineMap &map,
|
|
IntegerSet &set) {
|
|
unsigned numDims = 0, numSymbols = 0;
|
|
|
|
// List of dimensional and optional symbol identifiers.
|
|
if (parseDimAndOptionalSymbolIdList(numDims, numSymbols)) {
|
|
return failure();
|
|
}
|
|
|
|
// This is needed for parsing attributes as we wouldn't know whether we would
|
|
// be parsing an integer set attribute or an affine map attribute.
|
|
bool isArrow = getToken().is(Token::arrow);
|
|
bool isColon = getToken().is(Token::colon);
|
|
if (!isArrow && !isColon) {
|
|
return emitError("expected '->' or ':'");
|
|
} else if (isArrow) {
|
|
parseToken(Token::arrow, "expected '->' or '['");
|
|
map = parseAffineMapRange(numDims, numSymbols);
|
|
return map ? success() : failure();
|
|
} else if (parseToken(Token::colon, "expected ':' or '['")) {
|
|
return failure();
|
|
}
|
|
|
|
if ((set = parseIntegerSetConstraints(numDims, numSymbols)))
|
|
return success();
|
|
|
|
return failure();
|
|
}
|
|
|
|
/// Parse an AffineMap where the dim and symbol identifiers are SSA ids.
|
|
ParseResult AffineParser::parseAffineMapOfSSAIds(AffineMap &map) {
|
|
if (parseToken(Token::l_square, "expected '['"))
|
|
return failure();
|
|
|
|
SmallVector<AffineExpr, 4> exprs;
|
|
auto parseElt = [&]() -> ParseResult {
|
|
auto elt = parseAffineExpr();
|
|
exprs.push_back(elt);
|
|
return elt ? success() : failure();
|
|
};
|
|
|
|
// Parse a multi-dimensional affine expression (a comma-separated list of
|
|
// 1-d affine expressions); the list cannot be empty. Grammar:
|
|
// multi-dim-affine-expr ::= `(` affine-expr (`,` affine-expr)* `)
|
|
if (parseCommaSeparatedListUntil(Token::r_square, parseElt,
|
|
/*allowEmptyList=*/true))
|
|
return failure();
|
|
// Parsed a valid affine map.
|
|
if (exprs.empty())
|
|
map = AffineMap();
|
|
else
|
|
map = builder.getAffineMap(numDimOperands,
|
|
dimsAndSymbols.size() - numDimOperands, exprs);
|
|
return success();
|
|
}
|
|
|
|
/// Parse the range and sizes affine map definition inline.
|
|
///
|
|
/// affine-map ::= dim-and-symbol-id-lists `->` multi-dim-affine-expr
|
|
///
|
|
/// multi-dim-affine-expr ::= `(` affine-expr (`,` affine-expr)* `)
|
|
AffineMap AffineParser::parseAffineMapRange(unsigned numDims,
|
|
unsigned numSymbols) {
|
|
parseToken(Token::l_paren, "expected '(' at start of affine map range");
|
|
|
|
SmallVector<AffineExpr, 4> exprs;
|
|
auto parseElt = [&]() -> ParseResult {
|
|
auto elt = parseAffineExpr();
|
|
ParseResult res = elt ? success() : failure();
|
|
exprs.push_back(elt);
|
|
return res;
|
|
};
|
|
|
|
// Parse a multi-dimensional affine expression (a comma-separated list of
|
|
// 1-d affine expressions); the list cannot be empty. Grammar:
|
|
// multi-dim-affine-expr ::= `(` affine-expr (`,` affine-expr)* `)
|
|
if (parseCommaSeparatedListUntil(Token::r_paren, parseElt, false))
|
|
return AffineMap();
|
|
|
|
// Parsed a valid affine map.
|
|
return builder.getAffineMap(numDims, numSymbols, exprs);
|
|
}
|
|
|
|
/// Parse an affine constraint.
|
|
/// affine-constraint ::= affine-expr `>=` `0`
|
|
/// | affine-expr `==` `0`
|
|
///
|
|
/// isEq is set to true if the parsed constraint is an equality, false if it
|
|
/// is an inequality (greater than or equal).
|
|
///
|
|
AffineExpr AffineParser::parseAffineConstraint(bool *isEq) {
|
|
AffineExpr expr = parseAffineExpr();
|
|
if (!expr)
|
|
return nullptr;
|
|
|
|
if (consumeIf(Token::greater) && consumeIf(Token::equal) &&
|
|
getToken().is(Token::integer)) {
|
|
auto dim = getToken().getUnsignedIntegerValue();
|
|
if (dim.hasValue() && dim.getValue() == 0) {
|
|
consumeToken(Token::integer);
|
|
*isEq = false;
|
|
return expr;
|
|
}
|
|
return (emitError("expected '0' after '>='"), nullptr);
|
|
}
|
|
|
|
if (consumeIf(Token::equal) && consumeIf(Token::equal) &&
|
|
getToken().is(Token::integer)) {
|
|
auto dim = getToken().getUnsignedIntegerValue();
|
|
if (dim.hasValue() && dim.getValue() == 0) {
|
|
consumeToken(Token::integer);
|
|
*isEq = true;
|
|
return expr;
|
|
}
|
|
return (emitError("expected '0' after '=='"), nullptr);
|
|
}
|
|
|
|
return (emitError("expected '== 0' or '>= 0' at end of affine constraint"),
|
|
nullptr);
|
|
}
|
|
|
|
/// Parse the constraints that are part of an integer set definition.
|
|
/// integer-set-inline
|
|
/// ::= dim-and-symbol-id-lists `:`
|
|
/// '(' affine-constraint-conjunction? ')'
|
|
/// affine-constraint-conjunction ::= affine-constraint (`,`
|
|
/// affine-constraint)*
|
|
///
|
|
IntegerSet AffineParser::parseIntegerSetConstraints(unsigned numDims,
|
|
unsigned numSymbols) {
|
|
if (parseToken(Token::l_paren,
|
|
"expected '(' at start of integer set constraint list"))
|
|
return IntegerSet();
|
|
|
|
SmallVector<AffineExpr, 4> constraints;
|
|
SmallVector<bool, 4> isEqs;
|
|
auto parseElt = [&]() -> ParseResult {
|
|
bool isEq;
|
|
auto elt = parseAffineConstraint(&isEq);
|
|
ParseResult res = elt ? success() : failure();
|
|
if (elt) {
|
|
constraints.push_back(elt);
|
|
isEqs.push_back(isEq);
|
|
}
|
|
return res;
|
|
};
|
|
|
|
// Parse a list of affine constraints (comma-separated).
|
|
if (parseCommaSeparatedListUntil(Token::r_paren, parseElt, true))
|
|
return IntegerSet();
|
|
|
|
// If no constraints were parsed, then treat this as a degenerate 'true' case.
|
|
if (constraints.empty()) {
|
|
/* 0 == 0 */
|
|
auto zero = getAffineConstantExpr(0, getContext());
|
|
return builder.getIntegerSet(numDims, numSymbols, zero, true);
|
|
}
|
|
|
|
// Parsed a valid integer set.
|
|
return builder.getIntegerSet(numDims, numSymbols, constraints, isEqs);
|
|
}
|
|
|
|
/// Parse an ambiguous reference to either and affine map or an integer set.
|
|
ParseResult Parser::parseAffineMapOrIntegerSetReference(AffineMap &map,
|
|
IntegerSet &set) {
|
|
return AffineParser(state).parseAffineMapOrIntegerSetInline(map, set);
|
|
}
|
|
|
|
/// Parse an AffineMap of SSA ids. The callback 'parseElement' is used to
|
|
/// parse SSA value uses encountered while parsing affine expressions.
|
|
ParseResult Parser::parseAffineMapOfSSAIds(
|
|
AffineMap &map, llvm::function_ref<ParseResult(bool)> parseElement) {
|
|
return AffineParser(state, /*allowParsingSSAIds=*/true, parseElement)
|
|
.parseAffineMapOfSSAIds(map);
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// OperationParser
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace {
|
|
/// This class provides support for parsing operations and regions of
|
|
/// operations.
|
|
class OperationParser : public Parser {
|
|
public:
|
|
OperationParser(ParserState &state, ModuleOp moduleOp)
|
|
: Parser(state), opBuilder(moduleOp.getBodyRegion()), moduleOp(moduleOp) {
|
|
}
|
|
|
|
~OperationParser();
|
|
|
|
/// After parsing is finished, this function must be called to see if there
|
|
/// are any remaining issues.
|
|
ParseResult finalize();
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
// SSA Value Handling
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
/// This represents a use of an SSA value in the program. The first two
|
|
/// entries in the tuple are the name and result number of a reference. The
|
|
/// third is the location of the reference, which is used in case this ends
|
|
/// up being a use of an undefined value.
|
|
struct SSAUseInfo {
|
|
StringRef name; // Value name, e.g. %42 or %abc
|
|
unsigned number; // Number, specified with #12
|
|
SMLoc loc; // Location of first definition or use.
|
|
};
|
|
|
|
/// Push a new SSA name scope to the parser.
|
|
void pushSSANameScope(bool isIsolated);
|
|
|
|
/// Pop the last SSA name scope from the parser.
|
|
ParseResult popSSANameScope();
|
|
|
|
/// Register a definition of a value with the symbol table.
|
|
ParseResult addDefinition(SSAUseInfo useInfo, Value *value);
|
|
|
|
/// Parse an optional list of SSA uses into 'results'.
|
|
ParseResult parseOptionalSSAUseList(SmallVectorImpl<SSAUseInfo> &results);
|
|
|
|
/// Parse a single SSA use into 'result'.
|
|
ParseResult parseSSAUse(SSAUseInfo &result);
|
|
|
|
/// Given a reference to an SSA value and its type, return a reference. This
|
|
/// returns null on failure.
|
|
Value *resolveSSAUse(SSAUseInfo useInfo, Type type);
|
|
|
|
ParseResult parseSSADefOrUseAndType(
|
|
const std::function<ParseResult(SSAUseInfo, Type)> &action);
|
|
|
|
ParseResult parseOptionalSSAUseAndTypeList(SmallVectorImpl<Value *> &results);
|
|
|
|
/// Return the location of the value identified by its name and number if it
|
|
/// has been already reference.
|
|
llvm::Optional<SMLoc> getReferenceLoc(StringRef name, unsigned number) {
|
|
auto &values = isolatedNameScopes.back().values;
|
|
if (!values.count(name) || number >= values[name].size())
|
|
return {};
|
|
if (values[name][number].first)
|
|
return values[name][number].second;
|
|
return {};
|
|
}
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
// Operation Parsing
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
/// Parse an operation instance.
|
|
ParseResult parseOperation();
|
|
|
|
/// Parse a single operation successor and its operand list.
|
|
ParseResult parseSuccessorAndUseList(Block *&dest,
|
|
SmallVectorImpl<Value *> &operands);
|
|
|
|
/// Parse a comma-separated list of operation successors in brackets.
|
|
ParseResult
|
|
parseSuccessors(SmallVectorImpl<Block *> &destinations,
|
|
SmallVectorImpl<SmallVector<Value *, 4>> &operands);
|
|
|
|
/// Parse an operation instance that is in the generic form.
|
|
Operation *parseGenericOperation();
|
|
|
|
/// Parse an operation instance that is in the op-defined custom form.
|
|
Operation *parseCustomOperation();
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
// Region Parsing
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
/// Parse a region into 'region' with the provided entry block arguments.
|
|
/// 'isIsolatedNameScope' indicates if the naming scope of this region is
|
|
/// isolated from those above.
|
|
ParseResult parseRegion(Region ®ion,
|
|
ArrayRef<std::pair<SSAUseInfo, Type>> entryArguments,
|
|
bool isIsolatedNameScope = false);
|
|
|
|
/// Parse a region body into 'region'.
|
|
ParseResult parseRegionBody(Region ®ion);
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
// Block Parsing
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
/// Parse a new block into 'block'.
|
|
ParseResult parseBlock(Block *&block);
|
|
|
|
/// Parse a list of operations into 'block'.
|
|
ParseResult parseBlockBody(Block *block);
|
|
|
|
/// Parse a (possibly empty) list of block arguments.
|
|
ParseResult
|
|
parseOptionalBlockArgList(SmallVectorImpl<BlockArgument *> &results,
|
|
Block *owner);
|
|
|
|
/// Get the block with the specified name, creating it if it doesn't
|
|
/// already exist. The location specified is the point of use, which allows
|
|
/// us to diagnose references to blocks that are not defined precisely.
|
|
Block *getBlockNamed(StringRef name, SMLoc loc);
|
|
|
|
/// Define the block with the specified name. Returns the Block* or nullptr in
|
|
/// the case of redefinition.
|
|
Block *defineBlockNamed(StringRef name, SMLoc loc, Block *existing);
|
|
|
|
private:
|
|
/// Returns the info for a block at the current scope for the given name.
|
|
std::pair<Block *, SMLoc> &getBlockInfoByName(StringRef name) {
|
|
return blocksByName.back()[name];
|
|
}
|
|
|
|
/// Insert a new forward reference to the given block.
|
|
void insertForwardRef(Block *block, SMLoc loc) {
|
|
forwardRef.back().try_emplace(block, loc);
|
|
}
|
|
|
|
/// Erase any forward reference to the given block.
|
|
bool eraseForwardRef(Block *block) { return forwardRef.back().erase(block); }
|
|
|
|
/// Record that a definition was added at the current scope.
|
|
void recordDefinition(StringRef def);
|
|
|
|
/// Get the value entry for the given SSA name.
|
|
SmallVectorImpl<std::pair<Value *, SMLoc>> &getSSAValueEntry(StringRef name);
|
|
|
|
/// Create a forward reference placeholder value with the given location and
|
|
/// result type.
|
|
Value *createForwardRefPlaceholder(SMLoc loc, Type type);
|
|
|
|
/// Return true if this is a forward reference.
|
|
bool isForwardRefPlaceholder(Value *value) {
|
|
return forwardRefPlaceholders.count(value);
|
|
}
|
|
|
|
/// This struct represents an isolated SSA name scope. This scope may contain
|
|
/// other nested non-isolated scopes. These scopes are used for operations
|
|
/// that are known to be isolated to allow for reusing names within their
|
|
/// regions, even if those names are used above.
|
|
struct IsolatedSSANameScope {
|
|
/// Record that a definition was added at the current scope.
|
|
void recordDefinition(StringRef def) {
|
|
definitionsPerScope.back().insert(def);
|
|
}
|
|
|
|
/// Push a nested name scope.
|
|
void pushSSANameScope() { definitionsPerScope.push_back({}); }
|
|
|
|
/// Pop a nested name scope.
|
|
void popSSANameScope() {
|
|
for (auto &def : definitionsPerScope.pop_back_val())
|
|
values.erase(def.getKey());
|
|
}
|
|
|
|
/// This keeps track of all of the SSA values we are tracking for each name
|
|
/// scope, indexed by their name. This has one entry per result number.
|
|
llvm::StringMap<SmallVector<std::pair<Value *, SMLoc>, 1>> values;
|
|
|
|
/// This keeps track of all of the values defined by a specific name scope.
|
|
SmallVector<llvm::StringSet<>, 2> definitionsPerScope;
|
|
};
|
|
|
|
/// A list of isolated name scopes.
|
|
SmallVector<IsolatedSSANameScope, 2> isolatedNameScopes;
|
|
|
|
/// This keeps track of the block names as well as the location of the first
|
|
/// reference for each nested name scope. This is used to diagnose invalid
|
|
/// block references and memoize them.
|
|
SmallVector<DenseMap<StringRef, std::pair<Block *, SMLoc>>, 2> blocksByName;
|
|
SmallVector<DenseMap<Block *, SMLoc>, 2> forwardRef;
|
|
|
|
/// These are all of the placeholders we've made along with the location of
|
|
/// their first reference, to allow checking for use of undefined values.
|
|
DenseMap<Value *, SMLoc> forwardRefPlaceholders;
|
|
|
|
/// The builder used when creating parsed operation instances.
|
|
OpBuilder opBuilder;
|
|
|
|
/// The top level module operation.
|
|
ModuleOp moduleOp;
|
|
};
|
|
} // end anonymous namespace
|
|
|
|
OperationParser::~OperationParser() {
|
|
for (auto &fwd : forwardRefPlaceholders) {
|
|
// Drop all uses of undefined forward declared reference and destroy
|
|
// defining operation.
|
|
fwd.first->dropAllUses();
|
|
fwd.first->getDefiningOp()->destroy();
|
|
}
|
|
}
|
|
|
|
/// After parsing is finished, this function must be called to see if there are
|
|
/// any remaining issues.
|
|
ParseResult OperationParser::finalize() {
|
|
// Check for any forward references that are left. If we find any, error
|
|
// out.
|
|
if (!forwardRefPlaceholders.empty()) {
|
|
SmallVector<std::pair<const char *, Value *>, 4> errors;
|
|
// Iteration over the map isn't deterministic, so sort by source location.
|
|
for (auto entry : forwardRefPlaceholders)
|
|
errors.push_back({entry.second.getPointer(), entry.first});
|
|
llvm::array_pod_sort(errors.begin(), errors.end());
|
|
|
|
for (auto entry : errors) {
|
|
auto loc = SMLoc::getFromPointer(entry.first);
|
|
emitError(loc, "use of undeclared SSA value name");
|
|
}
|
|
return failure();
|
|
}
|
|
|
|
return success();
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// SSA Value Handling
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
void OperationParser::pushSSANameScope(bool isIsolated) {
|
|
blocksByName.push_back(DenseMap<StringRef, std::pair<Block *, SMLoc>>());
|
|
forwardRef.push_back(DenseMap<Block *, SMLoc>());
|
|
|
|
// Push back a new name definition scope.
|
|
if (isIsolated)
|
|
isolatedNameScopes.push_back({});
|
|
isolatedNameScopes.back().pushSSANameScope();
|
|
}
|
|
|
|
ParseResult OperationParser::popSSANameScope() {
|
|
auto forwardRefInCurrentScope = forwardRef.pop_back_val();
|
|
|
|
// Verify that all referenced blocks were defined.
|
|
if (!forwardRefInCurrentScope.empty()) {
|
|
SmallVector<std::pair<const char *, Block *>, 4> errors;
|
|
// Iteration over the map isn't deterministic, so sort by source location.
|
|
for (auto entry : forwardRefInCurrentScope) {
|
|
errors.push_back({entry.second.getPointer(), entry.first});
|
|
// Add this block to the top-level region to allow for automatic cleanup.
|
|
moduleOp.getOperation()->getRegion(0).push_back(entry.first);
|
|
}
|
|
llvm::array_pod_sort(errors.begin(), errors.end());
|
|
|
|
for (auto entry : errors) {
|
|
auto loc = SMLoc::getFromPointer(entry.first);
|
|
emitError(loc, "reference to an undefined block");
|
|
}
|
|
return failure();
|
|
}
|
|
|
|
// Pop the next nested namescope. If there is only one internal namescope,
|
|
// just pop the isolated scope.
|
|
auto ¤tNameScope = isolatedNameScopes.back();
|
|
if (currentNameScope.definitionsPerScope.size() == 1)
|
|
isolatedNameScopes.pop_back();
|
|
else
|
|
currentNameScope.popSSANameScope();
|
|
|
|
blocksByName.pop_back();
|
|
return success();
|
|
}
|
|
|
|
/// Register a definition of a value with the symbol table.
|
|
ParseResult OperationParser::addDefinition(SSAUseInfo useInfo, Value *value) {
|
|
auto &entries = getSSAValueEntry(useInfo.name);
|
|
|
|
// Make sure there is a slot for this value.
|
|
if (entries.size() <= useInfo.number)
|
|
entries.resize(useInfo.number + 1);
|
|
|
|
// If we already have an entry for this, check to see if it was a definition
|
|
// or a forward reference.
|
|
if (auto *existing = entries[useInfo.number].first) {
|
|
if (!isForwardRefPlaceholder(existing)) {
|
|
return emitError(useInfo.loc)
|
|
.append("redefinition of SSA value '", useInfo.name, "'")
|
|
.attachNote(getEncodedSourceLocation(entries[useInfo.number].second))
|
|
.append("previously defined here");
|
|
}
|
|
|
|
// If it was a forward reference, update everything that used it to use
|
|
// the actual definition instead, delete the forward ref, and remove it
|
|
// from our set of forward references we track.
|
|
existing->replaceAllUsesWith(value);
|
|
existing->getDefiningOp()->destroy();
|
|
forwardRefPlaceholders.erase(existing);
|
|
}
|
|
|
|
/// Record this definition for the current scope.
|
|
entries[useInfo.number] = {value, useInfo.loc};
|
|
recordDefinition(useInfo.name);
|
|
return success();
|
|
}
|
|
|
|
/// Parse a (possibly empty) list of SSA operands.
|
|
///
|
|
/// ssa-use-list ::= ssa-use (`,` ssa-use)*
|
|
/// ssa-use-list-opt ::= ssa-use-list?
|
|
///
|
|
ParseResult
|
|
OperationParser::parseOptionalSSAUseList(SmallVectorImpl<SSAUseInfo> &results) {
|
|
if (getToken().isNot(Token::percent_identifier))
|
|
return success();
|
|
return parseCommaSeparatedList([&]() -> ParseResult {
|
|
SSAUseInfo result;
|
|
if (parseSSAUse(result))
|
|
return failure();
|
|
results.push_back(result);
|
|
return success();
|
|
});
|
|
}
|
|
|
|
/// Parse a SSA operand for an operation.
|
|
///
|
|
/// ssa-use ::= ssa-id
|
|
///
|
|
ParseResult OperationParser::parseSSAUse(SSAUseInfo &result) {
|
|
result.name = getTokenSpelling();
|
|
result.number = 0;
|
|
result.loc = getToken().getLoc();
|
|
if (parseToken(Token::percent_identifier, "expected SSA operand"))
|
|
return failure();
|
|
|
|
// If we have an attribute ID, it is a result number.
|
|
if (getToken().is(Token::hash_identifier)) {
|
|
if (auto value = getToken().getHashIdentifierNumber())
|
|
result.number = value.getValue();
|
|
else
|
|
return emitError("invalid SSA value result number");
|
|
consumeToken(Token::hash_identifier);
|
|
}
|
|
|
|
return success();
|
|
}
|
|
|
|
/// Given an unbound reference to an SSA value and its type, return the value
|
|
/// it specifies. This returns null on failure.
|
|
Value *OperationParser::resolveSSAUse(SSAUseInfo useInfo, Type type) {
|
|
auto &entries = getSSAValueEntry(useInfo.name);
|
|
|
|
// If we have already seen a value of this name, return it.
|
|
if (useInfo.number < entries.size() && entries[useInfo.number].first) {
|
|
auto *result = entries[useInfo.number].first;
|
|
// Check that the type matches the other uses.
|
|
if (result->getType() == type)
|
|
return result;
|
|
|
|
emitError(useInfo.loc, "use of value '")
|
|
.append(useInfo.name,
|
|
"' expects different type than prior uses: ", type, " vs ",
|
|
result->getType())
|
|
.attachNote(getEncodedSourceLocation(entries[useInfo.number].second))
|
|
.append("prior use here");
|
|
return nullptr;
|
|
}
|
|
|
|
// Make sure we have enough slots for this.
|
|
if (entries.size() <= useInfo.number)
|
|
entries.resize(useInfo.number + 1);
|
|
|
|
// If the value has already been defined and this is an overly large result
|
|
// number, diagnose that.
|
|
if (entries[0].first && !isForwardRefPlaceholder(entries[0].first))
|
|
return (emitError(useInfo.loc, "reference to invalid result number"),
|
|
nullptr);
|
|
|
|
// Otherwise, this is a forward reference. Create a placeholder and remember
|
|
// that we did so.
|
|
auto *result = createForwardRefPlaceholder(useInfo.loc, type);
|
|
entries[useInfo.number].first = result;
|
|
entries[useInfo.number].second = useInfo.loc;
|
|
return result;
|
|
}
|
|
|
|
/// Parse an SSA use with an associated type.
|
|
///
|
|
/// ssa-use-and-type ::= ssa-use `:` type
|
|
ParseResult OperationParser::parseSSADefOrUseAndType(
|
|
const std::function<ParseResult(SSAUseInfo, Type)> &action) {
|
|
SSAUseInfo useInfo;
|
|
if (parseSSAUse(useInfo) ||
|
|
parseToken(Token::colon, "expected ':' and type for SSA operand"))
|
|
return failure();
|
|
|
|
auto type = parseType();
|
|
if (!type)
|
|
return failure();
|
|
|
|
return action(useInfo, type);
|
|
}
|
|
|
|
/// Parse a (possibly empty) list of SSA operands, followed by a colon, then
|
|
/// followed by a type list.
|
|
///
|
|
/// ssa-use-and-type-list
|
|
/// ::= ssa-use-list ':' type-list-no-parens
|
|
///
|
|
ParseResult OperationParser::parseOptionalSSAUseAndTypeList(
|
|
SmallVectorImpl<Value *> &results) {
|
|
SmallVector<SSAUseInfo, 4> valueIDs;
|
|
if (parseOptionalSSAUseList(valueIDs))
|
|
return failure();
|
|
|
|
// If there were no operands, then there is no colon or type lists.
|
|
if (valueIDs.empty())
|
|
return success();
|
|
|
|
SmallVector<Type, 4> types;
|
|
if (parseToken(Token::colon, "expected ':' in operand list") ||
|
|
parseTypeListNoParens(types))
|
|
return failure();
|
|
|
|
if (valueIDs.size() != types.size())
|
|
return emitError("expected ")
|
|
<< valueIDs.size() << " types to match operand list";
|
|
|
|
results.reserve(valueIDs.size());
|
|
for (unsigned i = 0, e = valueIDs.size(); i != e; ++i) {
|
|
if (auto *value = resolveSSAUse(valueIDs[i], types[i]))
|
|
results.push_back(value);
|
|
else
|
|
return failure();
|
|
}
|
|
|
|
return success();
|
|
}
|
|
|
|
/// Record that a definition was added at the current scope.
|
|
void OperationParser::recordDefinition(StringRef def) {
|
|
isolatedNameScopes.back().recordDefinition(def);
|
|
}
|
|
|
|
/// Get the value entry for the given SSA name.
|
|
SmallVectorImpl<std::pair<Value *, SMLoc>> &
|
|
OperationParser::getSSAValueEntry(StringRef name) {
|
|
return isolatedNameScopes.back().values[name];
|
|
}
|
|
|
|
/// Create and remember a new placeholder for a forward reference.
|
|
Value *OperationParser::createForwardRefPlaceholder(SMLoc loc, Type type) {
|
|
// Forward references are always created as operations, because we just need
|
|
// something with a def/use chain.
|
|
//
|
|
// We create these placeholders as having an empty name, which we know
|
|
// cannot be created through normal user input, allowing us to distinguish
|
|
// them.
|
|
auto name = OperationName("placeholder", getContext());
|
|
auto *op = Operation::create(
|
|
getEncodedSourceLocation(loc), name, /*operands=*/{}, type,
|
|
/*attributes=*/llvm::None, /*successors=*/{}, /*numRegions=*/0,
|
|
/*resizableOperandList=*/false);
|
|
forwardRefPlaceholders[op->getResult(0)] = loc;
|
|
return op->getResult(0);
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Operation Parsing
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// Parse an operation.
|
|
///
|
|
/// operation ::=
|
|
/// operation-result? string '(' ssa-use-list? ')' attribute-dict?
|
|
/// `:` function-type trailing-location?
|
|
/// operation-result ::= ssa-id ((`:` integer-literal) | (`,` ssa-id)*) `=`
|
|
///
|
|
ParseResult OperationParser::parseOperation() {
|
|
auto loc = getToken().getLoc();
|
|
SmallVector<std::pair<StringRef, SMLoc>, 1> resultIDs;
|
|
size_t numExpectedResults;
|
|
if (getToken().is(Token::percent_identifier)) {
|
|
// Parse the first result id.
|
|
resultIDs.emplace_back(getTokenSpelling(), loc);
|
|
consumeToken(Token::percent_identifier);
|
|
|
|
// If the next token is a ':', we parse the expected result count.
|
|
if (consumeIf(Token::colon)) {
|
|
// Check that the next token is an integer.
|
|
if (!getToken().is(Token::integer))
|
|
return emitError("expected integer number of results");
|
|
|
|
// Check that number of results is > 0.
|
|
auto val = getToken().getUInt64IntegerValue();
|
|
if (!val.hasValue() || val.getValue() < 1)
|
|
return emitError("expected named operation to have atleast 1 result");
|
|
consumeToken(Token::integer);
|
|
numExpectedResults = *val;
|
|
} else {
|
|
// Otherwise, this is a comma separated list of result ids.
|
|
if (consumeIf(Token::comma)) {
|
|
auto parseNextResult = [&]() -> ParseResult {
|
|
// Parse the next result id.
|
|
if (!getToken().is(Token::percent_identifier))
|
|
return emitError("expected valid ssa identifier");
|
|
|
|
resultIDs.emplace_back(getTokenSpelling(), getToken().getLoc());
|
|
consumeToken(Token::percent_identifier);
|
|
return success();
|
|
};
|
|
|
|
if (parseCommaSeparatedList(parseNextResult))
|
|
return failure();
|
|
}
|
|
numExpectedResults = resultIDs.size();
|
|
}
|
|
|
|
if (parseToken(Token::equal, "expected '=' after SSA name"))
|
|
return failure();
|
|
}
|
|
|
|
Operation *op;
|
|
if (getToken().is(Token::bare_identifier) || getToken().isKeyword())
|
|
op = parseCustomOperation();
|
|
else if (getToken().is(Token::string))
|
|
op = parseGenericOperation();
|
|
else
|
|
return emitError("expected operation name in quotes");
|
|
|
|
// If parsing of the basic operation failed, then this whole thing fails.
|
|
if (!op)
|
|
return failure();
|
|
|
|
// If the operation had a name, register it.
|
|
if (!resultIDs.empty()) {
|
|
if (op->getNumResults() == 0)
|
|
return emitError(loc, "cannot name an operation with no results");
|
|
if (numExpectedResults != op->getNumResults())
|
|
return emitError(loc, "operation defines ")
|
|
<< op->getNumResults() << " results but was provided "
|
|
<< numExpectedResults << " to bind";
|
|
|
|
// If the number of result names matches the number of operation results, we
|
|
// can directly use the provided names.
|
|
if (resultIDs.size() == op->getNumResults()) {
|
|
for (unsigned i = 0, e = op->getNumResults(); i != e; ++i)
|
|
if (addDefinition({resultIDs[i].first, 0, resultIDs[i].second},
|
|
op->getResult(i)))
|
|
return failure();
|
|
} else {
|
|
// Otherwise, we use the same name for all results.
|
|
StringRef name = resultIDs.front().first;
|
|
for (unsigned i = 0, e = op->getNumResults(); i != e; ++i)
|
|
if (addDefinition({name, i, loc}, op->getResult(i)))
|
|
return failure();
|
|
}
|
|
}
|
|
|
|
// Try to parse the optional trailing location.
|
|
if (parseOptionalTrailingLocation(op))
|
|
return failure();
|
|
|
|
return success();
|
|
}
|
|
|
|
/// Parse a single operation successor and its operand list.
|
|
///
|
|
/// successor ::= block-id branch-use-list?
|
|
/// branch-use-list ::= `(` ssa-use-list ':' type-list-no-parens `)`
|
|
///
|
|
ParseResult
|
|
OperationParser::parseSuccessorAndUseList(Block *&dest,
|
|
SmallVectorImpl<Value *> &operands) {
|
|
// Verify branch is identifier and get the matching block.
|
|
if (!getToken().is(Token::caret_identifier))
|
|
return emitError("expected block name");
|
|
dest = getBlockNamed(getTokenSpelling(), getToken().getLoc());
|
|
consumeToken();
|
|
|
|
// Handle optional arguments.
|
|
if (consumeIf(Token::l_paren) &&
|
|
(parseOptionalSSAUseAndTypeList(operands) ||
|
|
parseToken(Token::r_paren, "expected ')' to close argument list"))) {
|
|
return failure();
|
|
}
|
|
|
|
return success();
|
|
}
|
|
|
|
/// Parse a comma-separated list of operation successors in brackets.
|
|
///
|
|
/// successor-list ::= `[` successor (`,` successor )* `]`
|
|
///
|
|
ParseResult OperationParser::parseSuccessors(
|
|
SmallVectorImpl<Block *> &destinations,
|
|
SmallVectorImpl<SmallVector<Value *, 4>> &operands) {
|
|
if (parseToken(Token::l_square, "expected '['"))
|
|
return failure();
|
|
|
|
auto parseElt = [this, &destinations, &operands]() {
|
|
Block *dest;
|
|
SmallVector<Value *, 4> destOperands;
|
|
auto res = parseSuccessorAndUseList(dest, destOperands);
|
|
destinations.push_back(dest);
|
|
operands.push_back(destOperands);
|
|
return res;
|
|
};
|
|
return parseCommaSeparatedListUntil(Token::r_square, parseElt,
|
|
/*allowEmptyList=*/false);
|
|
}
|
|
|
|
namespace {
|
|
// RAII-style guard for cleaning up the regions in the operation state before
|
|
// deleting them. Within the parser, regions may get deleted if parsing failed,
|
|
// and other errors may be present, in praticular undominated uses. This makes
|
|
// sure such uses are deleted.
|
|
struct CleanupOpStateRegions {
|
|
~CleanupOpStateRegions() {
|
|
SmallVector<Region *, 4> regionsToClean;
|
|
regionsToClean.reserve(state.regions.size());
|
|
for (auto ®ion : state.regions)
|
|
if (region)
|
|
for (auto &block : *region)
|
|
block.dropAllDefinedValueUses();
|
|
}
|
|
OperationState &state;
|
|
};
|
|
} // namespace
|
|
|
|
Operation *OperationParser::parseGenericOperation() {
|
|
// Get location information for the operation.
|
|
auto srcLocation = getEncodedSourceLocation(getToken().getLoc());
|
|
|
|
auto name = getToken().getStringValue();
|
|
if (name.empty())
|
|
return (emitError("empty operation name is invalid"), nullptr);
|
|
if (name.find('\0') != StringRef::npos)
|
|
return (emitError("null character not allowed in operation name"), nullptr);
|
|
|
|
consumeToken(Token::string);
|
|
|
|
OperationState result(srcLocation, name);
|
|
|
|
// Generic operations have a resizable operation list.
|
|
result.setOperandListToResizable();
|
|
|
|
// Parse the operand list.
|
|
SmallVector<SSAUseInfo, 8> operandInfos;
|
|
|
|
if (parseToken(Token::l_paren, "expected '(' to start operand list") ||
|
|
parseOptionalSSAUseList(operandInfos) ||
|
|
parseToken(Token::r_paren, "expected ')' to end operand list")) {
|
|
return nullptr;
|
|
}
|
|
|
|
// Parse the successor list but don't add successors to the result yet to
|
|
// avoid messing up with the argument order.
|
|
SmallVector<Block *, 2> successors;
|
|
SmallVector<SmallVector<Value *, 4>, 2> successorOperands;
|
|
if (getToken().is(Token::l_square)) {
|
|
// Check if the operation is a known terminator.
|
|
const AbstractOperation *abstractOp = result.name.getAbstractOperation();
|
|
if (abstractOp && !abstractOp->hasProperty(OperationProperty::Terminator))
|
|
return emitError("successors in non-terminator"), nullptr;
|
|
if (parseSuccessors(successors, successorOperands))
|
|
return nullptr;
|
|
}
|
|
|
|
// Parse the region list.
|
|
CleanupOpStateRegions guard{result};
|
|
if (consumeIf(Token::l_paren)) {
|
|
do {
|
|
// Create temporary regions with the top level region as parent.
|
|
result.regions.emplace_back(new Region(moduleOp));
|
|
if (parseRegion(*result.regions.back(), /*entryArguments=*/{}))
|
|
return nullptr;
|
|
} while (consumeIf(Token::comma));
|
|
if (parseToken(Token::r_paren, "expected ')' to end region list"))
|
|
return nullptr;
|
|
}
|
|
|
|
if (getToken().is(Token::l_brace)) {
|
|
if (parseAttributeDict(result.attributes))
|
|
return nullptr;
|
|
}
|
|
|
|
if (parseToken(Token::colon, "expected ':' followed by operation type"))
|
|
return nullptr;
|
|
|
|
auto typeLoc = getToken().getLoc();
|
|
auto type = parseType();
|
|
if (!type)
|
|
return nullptr;
|
|
auto fnType = type.dyn_cast<FunctionType>();
|
|
if (!fnType)
|
|
return (emitError(typeLoc, "expected function type"), nullptr);
|
|
|
|
result.addTypes(fnType.getResults());
|
|
|
|
// Check that we have the right number of types for the operands.
|
|
auto operandTypes = fnType.getInputs();
|
|
if (operandTypes.size() != operandInfos.size()) {
|
|
auto plural = "s"[operandInfos.size() == 1];
|
|
return (emitError(typeLoc, "expected ")
|
|
<< operandInfos.size() << " operand type" << plural
|
|
<< " but had " << operandTypes.size(),
|
|
nullptr);
|
|
}
|
|
|
|
// Resolve all of the operands.
|
|
for (unsigned i = 0, e = operandInfos.size(); i != e; ++i) {
|
|
result.operands.push_back(resolveSSAUse(operandInfos[i], operandTypes[i]));
|
|
if (!result.operands.back())
|
|
return nullptr;
|
|
}
|
|
|
|
// Add the sucessors, and their operands after the proper operands.
|
|
for (const auto &succ : llvm::zip(successors, successorOperands)) {
|
|
Block *successor = std::get<0>(succ);
|
|
const SmallVector<Value *, 4> &operands = std::get<1>(succ);
|
|
result.addSuccessor(successor, operands);
|
|
}
|
|
|
|
return opBuilder.createOperation(result);
|
|
}
|
|
|
|
namespace {
|
|
class CustomOpAsmParser : public OpAsmParser {
|
|
public:
|
|
CustomOpAsmParser(SMLoc nameLoc, const AbstractOperation *opDefinition,
|
|
OperationParser &parser)
|
|
: nameLoc(nameLoc), opDefinition(opDefinition), parser(parser) {}
|
|
|
|
/// Parse an instance of the operation described by 'opDefinition' into the
|
|
/// provided operation state.
|
|
ParseResult parseOperation(OperationState *opState) {
|
|
if (opDefinition->parseAssembly(this, opState))
|
|
return failure();
|
|
return success();
|
|
}
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
// Utilities
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
/// Return if any errors were emitted during parsing.
|
|
bool didEmitError() const { return emittedError; }
|
|
|
|
/// Emit a diagnostic at the specified location and return failure.
|
|
InFlightDiagnostic emitError(llvm::SMLoc loc, const Twine &message) override {
|
|
emittedError = true;
|
|
return parser.emitError(loc, "custom op '" + opDefinition->name + "' " +
|
|
message);
|
|
}
|
|
|
|
llvm::SMLoc getCurrentLocation() override {
|
|
return parser.getToken().getLoc();
|
|
}
|
|
|
|
Builder &getBuilder() const override { return parser.builder; }
|
|
|
|
llvm::SMLoc getNameLoc() const override { return nameLoc; }
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
// Token Parsing
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
/// Parse a `->` token.
|
|
ParseResult parseArrow() override {
|
|
return parser.parseToken(Token::arrow, "expected '->'");
|
|
}
|
|
|
|
/// Parses a `->` if present.
|
|
ParseResult parseOptionalArrow() override {
|
|
return success(parser.consumeIf(Token::arrow));
|
|
}
|
|
|
|
/// Parse a `:` token.
|
|
ParseResult parseColon() override {
|
|
return parser.parseToken(Token::colon, "expected ':'");
|
|
}
|
|
|
|
/// Parse a `:` token if present.
|
|
ParseResult parseOptionalColon() override {
|
|
return success(parser.consumeIf(Token::colon));
|
|
}
|
|
|
|
/// Parse a `,` token.
|
|
ParseResult parseComma() override {
|
|
return parser.parseToken(Token::comma, "expected ','");
|
|
}
|
|
|
|
/// Parse a `,` token if present.
|
|
ParseResult parseOptionalComma() override {
|
|
return success(parser.consumeIf(Token::comma));
|
|
}
|
|
|
|
/// Parses a `...` if present.
|
|
ParseResult parseOptionalEllipsis() override {
|
|
return success(parser.consumeIf(Token::ellipsis));
|
|
}
|
|
|
|
/// Parse a `=` token.
|
|
ParseResult parseEqual() override {
|
|
return parser.parseToken(Token::equal, "expected '='");
|
|
}
|
|
|
|
/// Parse a keyword if present.
|
|
ParseResult parseOptionalKeyword(const char *keyword) override {
|
|
// Check that the current token is a bare identifier or keyword.
|
|
if (parser.getToken().isNot(Token::bare_identifier) &&
|
|
!parser.getToken().isKeyword())
|
|
return failure();
|
|
|
|
if (parser.getTokenSpelling() == keyword) {
|
|
parser.consumeToken();
|
|
return success();
|
|
}
|
|
return failure();
|
|
}
|
|
|
|
/// Parse a `(` token.
|
|
ParseResult parseLParen() override {
|
|
return parser.parseToken(Token::l_paren, "expected '('");
|
|
}
|
|
|
|
/// Parses a '(' if present.
|
|
ParseResult parseOptionalLParen() override {
|
|
return success(parser.consumeIf(Token::l_paren));
|
|
}
|
|
|
|
/// Parse a `)` token.
|
|
ParseResult parseRParen() override {
|
|
return parser.parseToken(Token::r_paren, "expected ')'");
|
|
}
|
|
|
|
/// Parses a ')' if present.
|
|
ParseResult parseOptionalRParen() override {
|
|
return success(parser.consumeIf(Token::r_paren));
|
|
}
|
|
|
|
/// Parse a `[` token.
|
|
ParseResult parseLSquare() override {
|
|
return parser.parseToken(Token::l_square, "expected '['");
|
|
}
|
|
|
|
/// Parses a '[' if present.
|
|
ParseResult parseOptionalLSquare() override {
|
|
return success(parser.consumeIf(Token::l_square));
|
|
}
|
|
|
|
/// Parse a `]` token.
|
|
ParseResult parseRSquare() override {
|
|
return parser.parseToken(Token::r_square, "expected ']'");
|
|
}
|
|
|
|
/// Parses a ']' if present.
|
|
ParseResult parseOptionalRSquare() override {
|
|
return success(parser.consumeIf(Token::r_square));
|
|
}
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
// Attribute Parsing
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
/// Parse an arbitrary attribute of a given type and return it in result. This
|
|
/// also adds the attribute to the specified attribute list with the specified
|
|
/// name.
|
|
ParseResult parseAttribute(Attribute &result, Type type, StringRef attrName,
|
|
SmallVectorImpl<NamedAttribute> &attrs) override {
|
|
result = parser.parseAttribute(type);
|
|
if (!result)
|
|
return failure();
|
|
|
|
attrs.push_back(parser.builder.getNamedAttr(attrName, result));
|
|
return success();
|
|
}
|
|
|
|
/// Parse a named dictionary into 'result' if it is present.
|
|
ParseResult
|
|
parseOptionalAttributeDict(SmallVectorImpl<NamedAttribute> &result) override {
|
|
if (parser.getToken().isNot(Token::l_brace))
|
|
return success();
|
|
return parser.parseAttributeDict(result);
|
|
}
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
// Identifier Parsing
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
/// Parse an @-identifier and store it (without the '@' symbol) in a string
|
|
/// attribute named 'attrName'.
|
|
ParseResult parseSymbolName(StringAttr &result, StringRef attrName,
|
|
SmallVectorImpl<NamedAttribute> &attrs) override {
|
|
if (parser.getToken().isNot(Token::at_identifier))
|
|
return failure();
|
|
result = getBuilder().getStringAttr(parser.getTokenSpelling().drop_front());
|
|
attrs.push_back(getBuilder().getNamedAttr(attrName, result));
|
|
parser.consumeToken();
|
|
return success();
|
|
}
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
// Operand Parsing
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
/// Parse a single operand.
|
|
ParseResult parseOperand(OperandType &result) override {
|
|
OperationParser::SSAUseInfo useInfo;
|
|
if (parser.parseSSAUse(useInfo))
|
|
return failure();
|
|
|
|
result = {useInfo.loc, useInfo.name, useInfo.number};
|
|
return success();
|
|
}
|
|
|
|
/// Parse zero or more SSA comma-separated operand references with a specified
|
|
/// surrounding delimiter, and an optional required operand count.
|
|
ParseResult parseOperandList(SmallVectorImpl<OperandType> &result,
|
|
int requiredOperandCount = -1,
|
|
Delimiter delimiter = Delimiter::None) override {
|
|
return parseOperandOrRegionArgList(result, /*isOperandList=*/true,
|
|
requiredOperandCount, delimiter);
|
|
}
|
|
|
|
/// Parse zero or more SSA comma-separated operand or region arguments with
|
|
/// optional surrounding delimiter and required operand count.
|
|
ParseResult
|
|
parseOperandOrRegionArgList(SmallVectorImpl<OperandType> &result,
|
|
bool isOperandList, int requiredOperandCount = -1,
|
|
Delimiter delimiter = Delimiter::None) {
|
|
auto startLoc = parser.getToken().getLoc();
|
|
|
|
// Handle delimiters.
|
|
switch (delimiter) {
|
|
case Delimiter::None:
|
|
// Don't check for the absence of a delimiter if the number of operands
|
|
// is unknown (and hence the operand list could be empty).
|
|
if (requiredOperandCount == -1)
|
|
break;
|
|
// Token already matches an identifier and so can't be a delimiter.
|
|
if (parser.getToken().is(Token::percent_identifier))
|
|
break;
|
|
// Test against known delimiters.
|
|
if (parser.getToken().is(Token::l_paren) ||
|
|
parser.getToken().is(Token::l_square))
|
|
return emitError(startLoc, "unexpected delimiter");
|
|
return emitError(startLoc, "invalid operand");
|
|
case Delimiter::OptionalParen:
|
|
if (parser.getToken().isNot(Token::l_paren))
|
|
return success();
|
|
LLVM_FALLTHROUGH;
|
|
case Delimiter::Paren:
|
|
if (parser.parseToken(Token::l_paren, "expected '(' in operand list"))
|
|
return failure();
|
|
break;
|
|
case Delimiter::OptionalSquare:
|
|
if (parser.getToken().isNot(Token::l_square))
|
|
return success();
|
|
LLVM_FALLTHROUGH;
|
|
case Delimiter::Square:
|
|
if (parser.parseToken(Token::l_square, "expected '[' in operand list"))
|
|
return failure();
|
|
break;
|
|
}
|
|
|
|
// Check for zero operands.
|
|
if (parser.getToken().is(Token::percent_identifier)) {
|
|
do {
|
|
OperandType operandOrArg;
|
|
if (isOperandList ? parseOperand(operandOrArg)
|
|
: parseRegionArgument(operandOrArg))
|
|
return failure();
|
|
result.push_back(operandOrArg);
|
|
} while (parser.consumeIf(Token::comma));
|
|
}
|
|
|
|
// Handle delimiters. If we reach here, the optional delimiters were
|
|
// present, so we need to parse their closing one.
|
|
switch (delimiter) {
|
|
case Delimiter::None:
|
|
break;
|
|
case Delimiter::OptionalParen:
|
|
case Delimiter::Paren:
|
|
if (parser.parseToken(Token::r_paren, "expected ')' in operand list"))
|
|
return failure();
|
|
break;
|
|
case Delimiter::OptionalSquare:
|
|
case Delimiter::Square:
|
|
if (parser.parseToken(Token::r_square, "expected ']' in operand list"))
|
|
return failure();
|
|
break;
|
|
}
|
|
|
|
if (requiredOperandCount != -1 &&
|
|
result.size() != static_cast<size_t>(requiredOperandCount))
|
|
return emitError(startLoc, "expected ")
|
|
<< requiredOperandCount << " operands";
|
|
return success();
|
|
}
|
|
|
|
/// Parse zero or more trailing SSA comma-separated trailing operand
|
|
/// references with a specified surrounding delimiter, and an optional
|
|
/// required operand count. A leading comma is expected before the operands.
|
|
ParseResult parseTrailingOperandList(SmallVectorImpl<OperandType> &result,
|
|
int requiredOperandCount,
|
|
Delimiter delimiter) override {
|
|
if (parser.getToken().is(Token::comma)) {
|
|
parseComma();
|
|
return parseOperandList(result, requiredOperandCount, delimiter);
|
|
}
|
|
if (requiredOperandCount != -1)
|
|
return emitError(parser.getToken().getLoc(), "expected ")
|
|
<< requiredOperandCount << " operands";
|
|
return success();
|
|
}
|
|
|
|
/// Resolve an operand to an SSA value, emitting an error on failure.
|
|
ParseResult resolveOperand(const OperandType &operand, Type type,
|
|
SmallVectorImpl<Value *> &result) override {
|
|
OperationParser::SSAUseInfo operandInfo = {operand.name, operand.number,
|
|
operand.location};
|
|
if (auto *value = parser.resolveSSAUse(operandInfo, type)) {
|
|
result.push_back(value);
|
|
return success();
|
|
}
|
|
return failure();
|
|
}
|
|
|
|
/// Parse an AffineMap of SSA ids.
|
|
ParseResult
|
|
parseAffineMapOfSSAIds(SmallVectorImpl<OperandType> &operands,
|
|
Attribute &mapAttr, StringRef attrName,
|
|
SmallVectorImpl<NamedAttribute> &attrs) override {
|
|
SmallVector<OperandType, 2> dimOperands;
|
|
SmallVector<OperandType, 1> symOperands;
|
|
|
|
auto parseElement = [&](bool isSymbol) -> ParseResult {
|
|
OperandType operand;
|
|
if (parseOperand(operand))
|
|
return failure();
|
|
if (isSymbol)
|
|
symOperands.push_back(operand);
|
|
else
|
|
dimOperands.push_back(operand);
|
|
return success();
|
|
};
|
|
|
|
AffineMap map;
|
|
if (parser.parseAffineMapOfSSAIds(map, parseElement))
|
|
return failure();
|
|
// Add AffineMap attribute.
|
|
if (map) {
|
|
mapAttr = parser.builder.getAffineMapAttr(map);
|
|
attrs.push_back(parser.builder.getNamedAttr(attrName, mapAttr));
|
|
}
|
|
|
|
// Add dim operands before symbol operands in 'operands'.
|
|
operands.assign(dimOperands.begin(), dimOperands.end());
|
|
operands.append(symOperands.begin(), symOperands.end());
|
|
return success();
|
|
}
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
// Region Parsing
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
/// Parse a region that takes `arguments` of `argTypes` types. This
|
|
/// effectively defines the SSA values of `arguments` and assignes their type.
|
|
ParseResult parseRegion(Region ®ion, ArrayRef<OperandType> arguments,
|
|
ArrayRef<Type> argTypes,
|
|
bool enableNameShadowing) override {
|
|
assert(arguments.size() == argTypes.size() &&
|
|
"mismatching number of arguments and types");
|
|
|
|
SmallVector<std::pair<OperationParser::SSAUseInfo, Type>, 2>
|
|
regionArguments;
|
|
for (const auto &pair : llvm::zip(arguments, argTypes)) {
|
|
const OperandType &operand = std::get<0>(pair);
|
|
Type type = std::get<1>(pair);
|
|
OperationParser::SSAUseInfo operandInfo = {operand.name, operand.number,
|
|
operand.location};
|
|
regionArguments.emplace_back(operandInfo, type);
|
|
}
|
|
|
|
// Try to parse the region.
|
|
assert((!enableNameShadowing ||
|
|
opDefinition->hasProperty(OperationProperty::IsolatedFromAbove)) &&
|
|
"name shadowing is only allowed on isolated regions");
|
|
if (parser.parseRegion(region, regionArguments, enableNameShadowing))
|
|
return failure();
|
|
return success();
|
|
}
|
|
|
|
/// Parses a region if present.
|
|
ParseResult parseOptionalRegion(Region ®ion,
|
|
ArrayRef<OperandType> arguments,
|
|
ArrayRef<Type> argTypes,
|
|
bool enableNameShadowing) override {
|
|
if (parser.getToken().isNot(Token::l_brace))
|
|
return success();
|
|
return parseRegion(region, arguments, argTypes, enableNameShadowing);
|
|
}
|
|
|
|
/// Parse a region argument. The type of the argument will be resolved later
|
|
/// by a call to `parseRegion`.
|
|
ParseResult parseRegionArgument(OperandType &argument) override {
|
|
return parseOperand(argument);
|
|
}
|
|
|
|
/// Parse a region argument if present.
|
|
ParseResult parseOptionalRegionArgument(OperandType &argument) override {
|
|
if (parser.getToken().isNot(Token::percent_identifier))
|
|
return success();
|
|
return parseRegionArgument(argument);
|
|
}
|
|
|
|
ParseResult
|
|
parseRegionArgumentList(SmallVectorImpl<OperandType> &result,
|
|
int requiredOperandCount = -1,
|
|
Delimiter delimiter = Delimiter::None) override {
|
|
return parseOperandOrRegionArgList(result, /*isOperandList=*/false,
|
|
requiredOperandCount, delimiter);
|
|
}
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
// Successor Parsing
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
/// Parse a single operation successor and its operand list.
|
|
ParseResult
|
|
parseSuccessorAndUseList(Block *&dest,
|
|
SmallVectorImpl<Value *> &operands) override {
|
|
return parser.parseSuccessorAndUseList(dest, operands);
|
|
}
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
// Type Parsing
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
/// Parse a type.
|
|
ParseResult parseType(Type &result) override {
|
|
return failure(!(result = parser.parseType()));
|
|
}
|
|
|
|
/// Parse an optional arrow followed by a type list.
|
|
ParseResult
|
|
parseOptionalArrowTypeList(SmallVectorImpl<Type> &result) override {
|
|
if (!parser.consumeIf(Token::arrow))
|
|
return success();
|
|
return parser.parseFunctionResultTypes(result);
|
|
}
|
|
|
|
/// Parse a colon followed by a type.
|
|
ParseResult parseColonType(Type &result) override {
|
|
return failure(parser.parseToken(Token::colon, "expected ':'") ||
|
|
!(result = parser.parseType()));
|
|
}
|
|
|
|
/// Parse a colon followed by a type list, which must have at least one type.
|
|
ParseResult parseColonTypeList(SmallVectorImpl<Type> &result) override {
|
|
if (parser.parseToken(Token::colon, "expected ':'"))
|
|
return failure();
|
|
return parser.parseTypeListNoParens(result);
|
|
}
|
|
|
|
/// Parse an optional colon followed by a type list, which if present must
|
|
/// have at least one type.
|
|
ParseResult
|
|
parseOptionalColonTypeList(SmallVectorImpl<Type> &result) override {
|
|
if (!parser.consumeIf(Token::colon))
|
|
return success();
|
|
return parser.parseTypeListNoParens(result);
|
|
}
|
|
|
|
private:
|
|
/// The source location of the operation name.
|
|
SMLoc nameLoc;
|
|
|
|
/// The abstract information of the operation.
|
|
const AbstractOperation *opDefinition;
|
|
|
|
/// The main operation parser.
|
|
OperationParser &parser;
|
|
|
|
/// A flag that indicates if any errors were emitted during parsing.
|
|
bool emittedError = false;
|
|
};
|
|
} // end anonymous namespace.
|
|
|
|
Operation *OperationParser::parseCustomOperation() {
|
|
auto opLoc = getToken().getLoc();
|
|
auto opName = getTokenSpelling();
|
|
|
|
auto *opDefinition = AbstractOperation::lookup(opName, getContext());
|
|
if (!opDefinition && !opName.contains('.')) {
|
|
// If the operation name has no namespace prefix we treat it as a standard
|
|
// operation and prefix it with "std".
|
|
// TODO: Would it be better to just build a mapping of the registered
|
|
// operations in the standard dialect?
|
|
opDefinition =
|
|
AbstractOperation::lookup(Twine("std." + opName).str(), getContext());
|
|
}
|
|
|
|
if (!opDefinition) {
|
|
emitError(opLoc) << "custom op '" << opName << "' is unknown";
|
|
return nullptr;
|
|
}
|
|
|
|
consumeToken();
|
|
|
|
// If the custom op parser crashes, produce some indication to help
|
|
// debugging.
|
|
std::string opNameStr = opName.str();
|
|
llvm::PrettyStackTraceFormat fmt("MLIR Parser: custom op parser '%s'",
|
|
opNameStr.c_str());
|
|
|
|
// Get location information for the operation.
|
|
auto srcLocation = getEncodedSourceLocation(opLoc);
|
|
|
|
// Have the op implementation take a crack and parsing this.
|
|
OperationState opState(srcLocation, opDefinition->name);
|
|
CleanupOpStateRegions guard{opState};
|
|
CustomOpAsmParser opAsmParser(opLoc, opDefinition, *this);
|
|
if (opAsmParser.parseOperation(&opState))
|
|
return nullptr;
|
|
|
|
// If it emitted an error, we failed.
|
|
if (opAsmParser.didEmitError())
|
|
return nullptr;
|
|
|
|
// Otherwise, we succeeded. Use the state it parsed as our op information.
|
|
return opBuilder.createOperation(opState);
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Region Parsing
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// Region.
|
|
///
|
|
/// region ::= '{' region-body
|
|
///
|
|
ParseResult OperationParser::parseRegion(
|
|
Region ®ion,
|
|
ArrayRef<std::pair<OperationParser::SSAUseInfo, Type>> entryArguments,
|
|
bool isIsolatedNameScope) {
|
|
// Parse the '{'.
|
|
if (parseToken(Token::l_brace, "expected '{' to begin a region"))
|
|
return failure();
|
|
|
|
// Check for an empty region.
|
|
if (entryArguments.empty() && consumeIf(Token::r_brace))
|
|
return success();
|
|
auto currentPt = opBuilder.saveInsertionPoint();
|
|
|
|
// Push a new named value scope.
|
|
pushSSANameScope(isIsolatedNameScope);
|
|
|
|
// Parse the first block directly to allow for it to be unnamed.
|
|
Block *block = new Block();
|
|
|
|
// Add arguments to the entry block.
|
|
if (!entryArguments.empty()) {
|
|
for (auto &placeholderArgPair : entryArguments) {
|
|
auto &argInfo = placeholderArgPair.first;
|
|
// Ensure that the argument was not already defined.
|
|
if (auto defLoc = getReferenceLoc(argInfo.name, argInfo.number)) {
|
|
return emitError(argInfo.loc, "region entry argument '" + argInfo.name +
|
|
"' is already in use")
|
|
.attachNote(getEncodedSourceLocation(*defLoc))
|
|
<< "previously referenced here";
|
|
}
|
|
if (addDefinition(placeholderArgPair.first,
|
|
block->addArgument(placeholderArgPair.second))) {
|
|
delete block;
|
|
return failure();
|
|
}
|
|
}
|
|
|
|
// If we had named arguments, then don't allow a block name.
|
|
if (getToken().is(Token::caret_identifier))
|
|
return emitError("invalid block name in region with named arguments");
|
|
}
|
|
|
|
if (parseBlock(block)) {
|
|
delete block;
|
|
return failure();
|
|
}
|
|
|
|
// Verify that no other arguments were parsed.
|
|
if (!entryArguments.empty() &&
|
|
block->getNumArguments() > entryArguments.size()) {
|
|
delete block;
|
|
return emitError("entry block arguments were already defined");
|
|
}
|
|
|
|
// Parse the rest of the region.
|
|
region.push_back(block);
|
|
if (parseRegionBody(region))
|
|
return failure();
|
|
|
|
// Pop the SSA value scope for this region.
|
|
if (popSSANameScope())
|
|
return failure();
|
|
|
|
// Reset the original insertion point.
|
|
opBuilder.restoreInsertionPoint(currentPt);
|
|
return success();
|
|
}
|
|
|
|
/// Region.
|
|
///
|
|
/// region-body ::= block* '}'
|
|
///
|
|
ParseResult OperationParser::parseRegionBody(Region ®ion) {
|
|
// Parse the list of blocks.
|
|
while (!consumeIf(Token::r_brace)) {
|
|
Block *newBlock = nullptr;
|
|
if (parseBlock(newBlock))
|
|
return failure();
|
|
region.push_back(newBlock);
|
|
}
|
|
return success();
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Block Parsing
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// Block declaration.
|
|
///
|
|
/// block ::= block-label? operation*
|
|
/// block-label ::= block-id block-arg-list? `:`
|
|
/// block-id ::= caret-id
|
|
/// block-arg-list ::= `(` ssa-id-and-type-list? `)`
|
|
///
|
|
ParseResult OperationParser::parseBlock(Block *&block) {
|
|
// The first block of a region may already exist, if it does the caret
|
|
// identifier is optional.
|
|
if (block && getToken().isNot(Token::caret_identifier))
|
|
return parseBlockBody(block);
|
|
|
|
SMLoc nameLoc = getToken().getLoc();
|
|
auto name = getTokenSpelling();
|
|
if (parseToken(Token::caret_identifier, "expected block name"))
|
|
return failure();
|
|
|
|
block = defineBlockNamed(name, nameLoc, block);
|
|
|
|
// Fail if the block was already defined.
|
|
if (!block)
|
|
return emitError(nameLoc, "redefinition of block '") << name << "'";
|
|
|
|
// If an argument list is present, parse it.
|
|
if (consumeIf(Token::l_paren)) {
|
|
SmallVector<BlockArgument *, 8> bbArgs;
|
|
if (parseOptionalBlockArgList(bbArgs, block) ||
|
|
parseToken(Token::r_paren, "expected ')' to end argument list"))
|
|
return failure();
|
|
}
|
|
|
|
if (parseToken(Token::colon, "expected ':' after block name"))
|
|
return failure();
|
|
|
|
return parseBlockBody(block);
|
|
}
|
|
|
|
ParseResult OperationParser::parseBlockBody(Block *block) {
|
|
// Set the insertion point to the end of the block to parse.
|
|
opBuilder.setInsertionPointToEnd(block);
|
|
|
|
// Parse the list of operations that make up the body of the block.
|
|
while (getToken().isNot(Token::caret_identifier, Token::r_brace))
|
|
if (parseOperation())
|
|
return failure();
|
|
|
|
return success();
|
|
}
|
|
|
|
/// Get the block with the specified name, creating it if it doesn't already
|
|
/// exist. The location specified is the point of use, which allows
|
|
/// us to diagnose references to blocks that are not defined precisely.
|
|
Block *OperationParser::getBlockNamed(StringRef name, SMLoc loc) {
|
|
auto &blockAndLoc = getBlockInfoByName(name);
|
|
if (!blockAndLoc.first) {
|
|
blockAndLoc = {new Block(), loc};
|
|
insertForwardRef(blockAndLoc.first, loc);
|
|
}
|
|
|
|
return blockAndLoc.first;
|
|
}
|
|
|
|
/// Define the block with the specified name. Returns the Block* or nullptr in
|
|
/// the case of redefinition.
|
|
Block *OperationParser::defineBlockNamed(StringRef name, SMLoc loc,
|
|
Block *existing) {
|
|
auto &blockAndLoc = getBlockInfoByName(name);
|
|
if (!blockAndLoc.first) {
|
|
// If the caller provided a block, use it. Otherwise create a new one.
|
|
if (!existing)
|
|
existing = new Block();
|
|
blockAndLoc.first = existing;
|
|
blockAndLoc.second = loc;
|
|
return blockAndLoc.first;
|
|
}
|
|
|
|
// Forward declarations are removed once defined, so if we are defining a
|
|
// existing block and it is not a forward declaration, then it is a
|
|
// redeclaration.
|
|
if (!eraseForwardRef(blockAndLoc.first))
|
|
return nullptr;
|
|
return blockAndLoc.first;
|
|
}
|
|
|
|
/// Parse a (possibly empty) list of SSA operands with types as block arguments.
|
|
///
|
|
/// ssa-id-and-type-list ::= ssa-id-and-type (`,` ssa-id-and-type)*
|
|
///
|
|
ParseResult OperationParser::parseOptionalBlockArgList(
|
|
SmallVectorImpl<BlockArgument *> &results, Block *owner) {
|
|
if (getToken().is(Token::r_brace))
|
|
return success();
|
|
|
|
// If the block already has arguments, then we're handling the entry block.
|
|
// Parse and register the names for the arguments, but do not add them.
|
|
bool definingExistingArgs = owner->getNumArguments() != 0;
|
|
unsigned nextArgument = 0;
|
|
|
|
return parseCommaSeparatedList([&]() -> ParseResult {
|
|
return parseSSADefOrUseAndType(
|
|
[&](SSAUseInfo useInfo, Type type) -> ParseResult {
|
|
// If this block did not have existing arguments, define a new one.
|
|
if (!definingExistingArgs)
|
|
return addDefinition(useInfo, owner->addArgument(type));
|
|
|
|
// Otherwise, ensure that this argument has already been created.
|
|
if (nextArgument >= owner->getNumArguments())
|
|
return emitError("too many arguments specified in argument list");
|
|
|
|
// Finally, make sure the existing argument has the correct type.
|
|
auto *arg = owner->getArgument(nextArgument++);
|
|
if (arg->getType() != type)
|
|
return emitError("argument and block argument type mismatch");
|
|
return addDefinition(useInfo, arg);
|
|
});
|
|
});
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Top-level entity parsing.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace {
|
|
/// This parser handles entities that are only valid at the top level of the
|
|
/// file.
|
|
class ModuleParser : public Parser {
|
|
public:
|
|
explicit ModuleParser(ParserState &state) : Parser(state) {}
|
|
|
|
ParseResult parseModule(ModuleOp module);
|
|
|
|
private:
|
|
/// Parse an attribute alias declaration.
|
|
ParseResult parseAttributeAliasDef();
|
|
|
|
/// Parse an attribute alias declaration.
|
|
ParseResult parseTypeAliasDef();
|
|
};
|
|
} // end anonymous namespace
|
|
|
|
/// Parses an attribute alias declaration.
|
|
///
|
|
/// attribute-alias-def ::= '#' alias-name `=` attribute-value
|
|
///
|
|
ParseResult ModuleParser::parseAttributeAliasDef() {
|
|
assert(getToken().is(Token::hash_identifier));
|
|
StringRef aliasName = getTokenSpelling().drop_front();
|
|
|
|
// Check for redefinitions.
|
|
if (getState().attributeAliasDefinitions.count(aliasName) > 0)
|
|
return emitError("redefinition of attribute alias id '" + aliasName + "'");
|
|
|
|
// Make sure this isn't invading the dialect attribute namespace.
|
|
if (aliasName.contains('.'))
|
|
return emitError("attribute names with a '.' are reserved for "
|
|
"dialect-defined names");
|
|
|
|
consumeToken(Token::hash_identifier);
|
|
|
|
// Parse the '='.
|
|
if (parseToken(Token::equal, "expected '=' in attribute alias definition"))
|
|
return failure();
|
|
|
|
// Parse the attribute value.
|
|
Attribute attr = parseAttribute();
|
|
if (!attr)
|
|
return failure();
|
|
|
|
getState().attributeAliasDefinitions[aliasName] = attr;
|
|
return success();
|
|
}
|
|
|
|
/// Parse a type alias declaration.
|
|
///
|
|
/// type-alias-def ::= '!' alias-name `=` 'type' type
|
|
///
|
|
ParseResult ModuleParser::parseTypeAliasDef() {
|
|
assert(getToken().is(Token::exclamation_identifier));
|
|
StringRef aliasName = getTokenSpelling().drop_front();
|
|
|
|
// Check for redefinitions.
|
|
if (getState().typeAliasDefinitions.count(aliasName) > 0)
|
|
return emitError("redefinition of type alias id '" + aliasName + "'");
|
|
|
|
// Make sure this isn't invading the dialect type namespace.
|
|
if (aliasName.contains('.'))
|
|
return emitError("type names with a '.' are reserved for "
|
|
"dialect-defined names");
|
|
|
|
consumeToken(Token::exclamation_identifier);
|
|
|
|
// Parse the '=' and 'type'.
|
|
if (parseToken(Token::equal, "expected '=' in type alias definition") ||
|
|
parseToken(Token::kw_type, "expected 'type' in type alias definition"))
|
|
return failure();
|
|
|
|
// Parse the type.
|
|
Type aliasedType = parseType();
|
|
if (!aliasedType)
|
|
return failure();
|
|
|
|
// Register this alias with the parser state.
|
|
getState().typeAliasDefinitions.try_emplace(aliasName, aliasedType);
|
|
return success();
|
|
}
|
|
|
|
/// This is the top-level module parser.
|
|
ParseResult ModuleParser::parseModule(ModuleOp module) {
|
|
OperationParser opParser(getState(), module);
|
|
|
|
// Module itself is a name scope.
|
|
opParser.pushSSANameScope(/*isIsolated=*/true);
|
|
|
|
while (1) {
|
|
switch (getToken().getKind()) {
|
|
default:
|
|
// Parse a top-level operation.
|
|
if (opParser.parseOperation())
|
|
return failure();
|
|
break;
|
|
|
|
// If we got to the end of the file, then we're done.
|
|
case Token::eof: {
|
|
if (opParser.finalize())
|
|
return failure();
|
|
|
|
// Handle the case where the top level module was explicitly defined.
|
|
auto &bodyBlocks = module.getBodyRegion().getBlocks();
|
|
auto &operations = bodyBlocks.front().getOperations();
|
|
assert(!operations.empty() && "expected a valid module terminator");
|
|
|
|
// Check that the first operation is a module, and it is the only
|
|
// non-terminator operation.
|
|
ModuleOp nested = dyn_cast<ModuleOp>(operations.front());
|
|
if (nested && std::next(operations.begin(), 2) == operations.end()) {
|
|
// Merge the data of the nested module operation into 'module'.
|
|
module.setLoc(nested.getLoc());
|
|
module.setAttrs(nested.getOperation()->getAttrList());
|
|
bodyBlocks.splice(bodyBlocks.end(), nested.getBodyRegion().getBlocks());
|
|
|
|
// Erase the original module body.
|
|
bodyBlocks.pop_front();
|
|
}
|
|
|
|
return opParser.popSSANameScope();
|
|
}
|
|
|
|
// If we got an error token, then the lexer already emitted an error, just
|
|
// stop. Someday we could introduce error recovery if there was demand
|
|
// for it.
|
|
case Token::error:
|
|
return failure();
|
|
|
|
// Parse an attribute alias.
|
|
case Token::hash_identifier:
|
|
if (parseAttributeAliasDef())
|
|
return failure();
|
|
break;
|
|
|
|
// Parse a type alias.
|
|
case Token::exclamation_identifier:
|
|
if (parseTypeAliasDef())
|
|
return failure();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// This parses the file specified by the indicated SourceMgr and returns an
|
|
/// MLIR module if it was valid. If not, it emits diagnostics and returns
|
|
/// null.
|
|
ModuleOp mlir::parseSourceFile(const llvm::SourceMgr &sourceMgr,
|
|
MLIRContext *context) {
|
|
auto sourceBuf = sourceMgr.getMemoryBuffer(sourceMgr.getMainFileID());
|
|
|
|
// This is the result module we are parsing into.
|
|
OwningModuleRef module(ModuleOp::create(FileLineColLoc::get(
|
|
sourceBuf->getBufferIdentifier(), /*line=*/0, /*column=*/0, context)));
|
|
|
|
ParserState state(sourceMgr, context);
|
|
if (ModuleParser(state).parseModule(*module))
|
|
return nullptr;
|
|
|
|
// Make sure the parse module has no other structural problems detected by
|
|
// the verifier.
|
|
if (failed(verify(*module)))
|
|
return nullptr;
|
|
|
|
return module.release();
|
|
}
|
|
|
|
/// This parses the file specified by the indicated filename and returns an
|
|
/// MLIR module if it was valid. If not, the error message is emitted through
|
|
/// the error handler registered in the context, and a null pointer is returned.
|
|
ModuleOp mlir::parseSourceFile(StringRef filename, MLIRContext *context) {
|
|
llvm::SourceMgr sourceMgr;
|
|
return parseSourceFile(filename, sourceMgr, context);
|
|
}
|
|
|
|
/// This parses the file specified by the indicated filename using the provided
|
|
/// SourceMgr and returns an MLIR module if it was valid. If not, the error
|
|
/// message is emitted through the error handler registered in the context, and
|
|
/// a null pointer is returned.
|
|
ModuleOp mlir::parseSourceFile(StringRef filename, llvm::SourceMgr &sourceMgr,
|
|
MLIRContext *context) {
|
|
if (sourceMgr.getNumBuffers() != 0) {
|
|
// TODO(b/136086478): Extend to support multiple buffers.
|
|
emitError(mlir::UnknownLoc::get(context),
|
|
"only main buffer parsed at the moment");
|
|
return nullptr;
|
|
}
|
|
auto file_or_err = llvm::MemoryBuffer::getFileOrSTDIN(filename);
|
|
if (std::error_code error = file_or_err.getError()) {
|
|
emitError(mlir::UnknownLoc::get(context),
|
|
"could not open input file " + filename);
|
|
return nullptr;
|
|
}
|
|
|
|
// Load the MLIR module.
|
|
sourceMgr.AddNewSourceBuffer(std::move(*file_or_err), llvm::SMLoc());
|
|
return parseSourceFile(sourceMgr, context);
|
|
}
|
|
|
|
/// This parses the program string to a MLIR module if it was valid. If not,
|
|
/// it emits diagnostics and returns null.
|
|
ModuleOp mlir::parseSourceString(StringRef moduleStr, MLIRContext *context) {
|
|
auto memBuffer = MemoryBuffer::getMemBuffer(moduleStr);
|
|
if (!memBuffer)
|
|
return nullptr;
|
|
|
|
SourceMgr sourceMgr;
|
|
sourceMgr.AddNewSourceBuffer(std::move(memBuffer), SMLoc());
|
|
return parseSourceFile(sourceMgr, context);
|
|
}
|
|
|
|
Type mlir::parseType(llvm::StringRef typeStr, MLIRContext *context) {
|
|
SourceMgr sourceMgr;
|
|
auto memBuffer =
|
|
MemoryBuffer::getMemBuffer(typeStr, /*BufferName=*/"<mlir_type_buffer>",
|
|
/*RequiresNullTerminator=*/false);
|
|
sourceMgr.AddNewSourceBuffer(std::move(memBuffer), SMLoc());
|
|
SourceMgrDiagnosticHandler sourceMgrHandler(sourceMgr, context);
|
|
ParserState state(sourceMgr, context);
|
|
Parser parser(state);
|
|
auto start = parser.getToken().getLoc();
|
|
auto ty = parser.parseType();
|
|
if (!ty)
|
|
return Type();
|
|
|
|
auto end = parser.getToken().getLoc();
|
|
auto read = end.getPointer() - start.getPointer();
|
|
// Make sure that the parsing of type consumes the entire string
|
|
if (static_cast<size_t>(read) < typeStr.size()) {
|
|
parser.emitError("unexpected additional tokens: '")
|
|
<< typeStr.substr(read) << "' after parsing type: " << ty;
|
|
return Type();
|
|
}
|
|
return ty;
|
|
}
|