MLIRGen.cpp | Explore in Territory

//===- MLIRGen.cpp --------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "mlir/Tools/PDLL/CodeGen/MLIRGen.h"
#include "mlir/AsmParser/AsmParser.h"
#include "mlir/Dialect/PDL/IR/PDL.h"
#include "mlir/Dialect/PDL/IR/PDLOps.h"
#include "mlir/Dialect/PDL/IR/PDLTypes.h"
#include "mlir/IR/Builders.h"
#include "mlir/IR/BuiltinOps.h"
#include "mlir/IR/Verifier.h"
#include "mlir/Tools/PDLL/AST/Context.h"
#include "mlir/Tools/PDLL/AST/Nodes.h"
#include "mlir/Tools/PDLL/AST/Types.h"
#include "mlir/Tools/PDLL/ODS/Context.h"
#include "mlir/Tools/PDLL/ODS/Operation.h"
#include "llvm/ADT/ScopedHashTable.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/TypeSwitch.h"
#include <optional>

usingnamespacemlir;
usingnamespacemlir::pdll;

//===----------------------------------------------------------------------===//
// CodeGen
//===----------------------------------------------------------------------===//

namespace {
class CodeGen { … };
} // namespace

OwningOpRef<ModuleOp> CodeGen::generate(const ast::Module &module) { … }

Location CodeGen::genLoc(llvm::SMLoc loc) { … }

Type CodeGen::genType(ast::Type type) { … }

void CodeGen::gen(const ast::Node *node) { … }

//===----------------------------------------------------------------------===//
// CodeGen: Statements
//===----------------------------------------------------------------------===//

void CodeGen::genImpl(const ast::CompoundStmt *stmt) { … }

/// If the given builder is nested under a PDL PatternOp, build a rewrite
/// operation and update the builder to nest under it. This is necessary for
/// PDLL operation rewrite statements that are directly nested within a Pattern.
static void checkAndNestUnderRewriteOp(OpBuilder &builder, Value rootExpr,
                                       Location loc) { … }

void CodeGen::genImpl(const ast::EraseStmt *stmt) { … }

void CodeGen::genImpl(const ast::LetStmt *stmt) { … }

void CodeGen::genImpl(const ast::ReplaceStmt *stmt) { … }

void CodeGen::genImpl(const ast::RewriteStmt *stmt) { … }

void CodeGen::genImpl(const ast::ReturnStmt *stmt) { … }

//===----------------------------------------------------------------------===//
// CodeGen: Decls
//===----------------------------------------------------------------------===//

void CodeGen::genImpl(const ast::UserConstraintDecl *decl) { … }

void CodeGen::genImpl(const ast::UserRewriteDecl *decl) { … }

void CodeGen::genImpl(const ast::PatternDecl *decl) { … }

SmallVector<Value> CodeGen::genVar(const ast::VariableDecl *varDecl) { … }

Value CodeGen::genNonInitializerVar(const ast::VariableDecl *varDecl,
                                    Location loc) { … }

void CodeGen::applyVarConstraints(const ast::VariableDecl *varDecl,
                                  ValueRange values) { … }

//===----------------------------------------------------------------------===//
// CodeGen: Expressions
//===----------------------------------------------------------------------===//

Value CodeGen::genSingleExpr(const ast::Expr *expr) { … }

SmallVector<Value> CodeGen::genExpr(const ast::Expr *expr) { … }

Value CodeGen::genExprImpl(const ast::AttributeExpr *expr) { … }

SmallVector<Value> CodeGen::genExprImpl(const ast::CallExpr *expr) { … }

SmallVector<Value> CodeGen::genExprImpl(const ast::DeclRefExpr *expr) { … }

Value CodeGen::genExprImpl(const ast::MemberAccessExpr *expr) { … }

Value CodeGen::genExprImpl(const ast::OperationExpr *expr) { … }

Value CodeGen::genExprImpl(const ast::RangeExpr *expr) { … }

SmallVector<Value> CodeGen::genExprImpl(const ast::TupleExpr *expr) { … }

Value CodeGen::genExprImpl(const ast::TypeExpr *expr) { … }

SmallVector<Value>
CodeGen::genConstraintCall(const ast::UserConstraintDecl *decl, Location loc,
                           ValueRange inputs, bool isNegated) { … }

SmallVector<Value> CodeGen::genRewriteCall(const ast::UserRewriteDecl *decl,
                                           Location loc, ValueRange inputs) { … }

template <typename PDLOpT, typename T>
SmallVector<Value>
CodeGen::genConstraintOrRewriteCall(const T *decl, Location loc,
                                    ValueRange inputs, bool isNegated) { … }

//===----------------------------------------------------------------------===//
// MLIRGen
//===----------------------------------------------------------------------===//

OwningOpRef<ModuleOp> mlir::pdll::codegenPDLLToMLIR(
    MLIRContext *mlirContext, const ast::Context &context,
    const llvm::SourceMgr &sourceMgr, const ast::Module &module) { … }
llvm/mlir/lib/Tools/PDLL/CodeGen/MLIRGen.cpp
