MLIR  19.0.0git
InlinerExtension.cpp
Go to the documentation of this file.
1 //===- InlinerExtension.cpp - Func Inliner Extension ----------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
14 
15 using namespace mlir;
16 using namespace mlir::func;
17 
18 //===----------------------------------------------------------------------===//
19 // FuncDialect Interfaces
20 //===----------------------------------------------------------------------===//
21 namespace {
22 /// This class defines the interface for handling inlining with func operations.
23 struct FuncInlinerInterface : public DialectInlinerInterface {
25 
26  //===--------------------------------------------------------------------===//
27  // Analysis Hooks
28  //===--------------------------------------------------------------------===//
29 
30  /// All call operations can be inlined.
31  bool isLegalToInline(Operation *call, Operation *callable,
32  bool wouldBeCloned) const final {
33  return true;
34  }
35 
36  /// All operations can be inlined.
37  bool isLegalToInline(Operation *, Region *, bool, IRMapping &) const final {
38  return true;
39  }
40 
41  /// All functions can be inlined.
42  bool isLegalToInline(Region *, Region *, bool, IRMapping &) const final {
43  return true;
44  }
45 
46  //===--------------------------------------------------------------------===//
47  // Transformation Hooks
48  //===--------------------------------------------------------------------===//
49 
50  /// Handle the given inlined terminator by replacing it with a new operation
51  /// as necessary.
52  void handleTerminator(Operation *op, Block *newDest) const final {
53  // Only return needs to be handled here.
54  auto returnOp = dyn_cast<ReturnOp>(op);
55  if (!returnOp)
56  return;
57 
58  // Replace the return with a branch to the dest.
59  OpBuilder builder(op);
60  builder.create<cf::BranchOp>(op->getLoc(), newDest, returnOp.getOperands());
61  op->erase();
62  }
63 
64  /// Handle the given inlined terminator by replacing it with a new operation
65  /// as necessary.
66  void handleTerminator(Operation *op, ValueRange valuesToRepl) const final {
67  // Only return needs to be handled here.
68  auto returnOp = cast<ReturnOp>(op);
69 
70  // Replace the values directly with the return operands.
71  assert(returnOp.getNumOperands() == valuesToRepl.size());
72  for (const auto &it : llvm::enumerate(returnOp.getOperands()))
73  valuesToRepl[it.index()].replaceAllUsesWith(it.value());
74  }
75 };
76 } // namespace
77 
78 //===----------------------------------------------------------------------===//
79 // Registration
80 //===----------------------------------------------------------------------===//
81 
83  registry.addExtension(+[](MLIRContext *ctx, func::FuncDialect *dialect) {
84  dialect->addInterfaces<FuncInlinerInterface>();
85 
86  // The inliner extension relies on the ControlFlow dialect.
87  ctx->getOrLoadDialect<cf::ControlFlowDialect>();
88  });
89 }
static bool isLegalToInline(InlinerInterface &interface, Region *src, Region *insertRegion, bool shouldCloneInlinedRegion, IRMapping &valueMapping)
Utility to check that all of the operations within 'src' can be inlined.
Block represents an ordered list of Operations.
Definition: Block.h:31
This is the interface that must be implemented by the dialects of operations to be inlined.
Definition: InliningUtils.h:44
DialectInlinerInterface(Dialect *dialect)
Definition: InliningUtils.h:46
The DialectRegistry maps a dialect namespace to a constructor for the matching dialect.
void addExtension(std::unique_ptr< DialectExtensionBase > extension)
Add the given extension to the registry.
This is a utility class for mapping one set of IR entities to another.
Definition: IRMapping.h:26
MLIRContext is the top-level object for a collection of MLIR operations.
Definition: MLIRContext.h:60
T * getOrLoadDialect()
Get (or create) a dialect for the given derived dialect type.
Definition: MLIRContext.h:97
This class helps build Operations.
Definition: Builders.h:209
Operation is the basic unit of execution within MLIR.
Definition: Operation.h:88
Location getLoc()
The source location the operation was defined or derived from.
Definition: Operation.h:223
void erase()
Remove this operation from its parent block and delete it.
Definition: Operation.cpp:539
This class contains a list of basic blocks and a link to the parent operation it is attached to.
Definition: Region.h:26
This class provides an abstraction over the different types of ranges over Values.
Definition: ValueRange.h:381
constexpr void enumerate(std::tuple< Tys... > &tuple, CallbackT &&callback)
Definition: Matchers.h:285
void registerInlinerExtension(DialectRegistry &registry)
Register the extension used to support inlining the func dialect.
Include the generated interface declarations.