MLIR  19.0.0git
Translation.cpp
Go to the documentation of this file.
1 //===- Translation.cpp - Translation registry -----------------------------===//
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 //
9 // Definitions of the translation registry.
10 //
11 //===----------------------------------------------------------------------===//
12 
14 #include "mlir/IR/AsmState.h"
15 #include "mlir/IR/BuiltinOps.h"
16 #include "mlir/IR/Dialect.h"
17 #include "mlir/IR/Verifier.h"
18 #include "mlir/Parser/Parser.h"
20 #include "llvm/Support/SourceMgr.h"
21 #include <optional>
22 
23 using namespace mlir;
24 
25 //===----------------------------------------------------------------------===//
26 // Translation CommandLine Options
27 //===----------------------------------------------------------------------===//
28 
30  llvm::cl::opt<bool> noImplicitModule{
31  "no-implicit-module",
32  llvm::cl::desc("Disable the parsing of an implicit top-level module op"),
33  llvm::cl::init(false)};
34 };
35 
36 static llvm::ManagedStatic<TranslationOptions> clOptions;
37 
39 
40 //===----------------------------------------------------------------------===//
41 // Translation Registry
42 //===----------------------------------------------------------------------===//
43 
44 /// Get the mutable static map between registered file-to-file MLIR
45 /// translations.
46 static llvm::StringMap<Translation> &getTranslationRegistry() {
47  static llvm::StringMap<Translation> translationBundle;
48  return translationBundle;
49 }
50 
51 /// Register the given translation.
52 static void registerTranslation(StringRef name, StringRef description,
53  std::optional<llvm::Align> inputAlignment,
54  const TranslateFunction &function) {
55  auto &registry = getTranslationRegistry();
56  if (registry.count(name))
57  llvm::report_fatal_error(
58  "Attempting to overwrite an existing <file-to-file> function");
59  assert(function &&
60  "Attempting to register an empty translate <file-to-file> function");
61  registry[name] = Translation(function, description, inputAlignment);
62 }
63 
65  StringRef name, StringRef description, const TranslateFunction &function) {
66  registerTranslation(name, description, /*inputAlignment=*/std::nullopt,
67  function);
68 }
69 
70 //===----------------------------------------------------------------------===//
71 // Translation to MLIR
72 //===----------------------------------------------------------------------===//
73 
74 // Puts `function` into the to-MLIR translation registry unless there is already
75 // a function registered for the same name.
77  StringRef name, StringRef description,
78  const DialectRegistrationFunction &dialectRegistration,
79  std::optional<llvm::Align> inputAlignment,
80  const TranslateSourceMgrToMLIRFunction &function) {
81  auto wrappedFn = [function, dialectRegistration](
82  const std::shared_ptr<llvm::SourceMgr> &sourceMgr,
83  raw_ostream &output, MLIRContext *context) {
84  DialectRegistry registry;
85  dialectRegistration(registry);
86  context->appendDialectRegistry(registry);
87  OwningOpRef<Operation *> op = function(sourceMgr, context);
88  if (!op || failed(verify(*op)))
89  return failure();
90  op.get()->print(output);
91  return success();
92  };
93  registerTranslation(name, description, inputAlignment, wrappedFn);
94 }
95 
97  StringRef name, StringRef description,
98  const TranslateSourceMgrToMLIRFunction &function,
99  const DialectRegistrationFunction &dialectRegistration,
100  std::optional<llvm::Align> inputAlignment) {
101  registerTranslateToMLIRFunction(name, description, dialectRegistration,
102  inputAlignment, function);
103 }
105  StringRef name, StringRef description,
106  const TranslateRawSourceMgrToMLIRFunction &function,
107  const DialectRegistrationFunction &dialectRegistration,
108  std::optional<llvm::Align> inputAlignment) {
110  name, description, dialectRegistration, inputAlignment,
111  [function](const std::shared_ptr<llvm::SourceMgr> &sourceMgr,
112  MLIRContext *ctx) { return function(*sourceMgr, ctx); });
113 }
114 /// Wraps `function` with a lambda that extracts a StringRef from a source
115 /// manager and registers the wrapper lambda as a to-MLIR conversion.
117  StringRef name, StringRef description,
118  const TranslateStringRefToMLIRFunction &function,
119  const DialectRegistrationFunction &dialectRegistration,
120  std::optional<llvm::Align> inputAlignment) {
122  name, description, dialectRegistration, inputAlignment,
123  [function](const std::shared_ptr<llvm::SourceMgr> &sourceMgr,
124  MLIRContext *ctx) {
125  const llvm::MemoryBuffer *buffer =
126  sourceMgr->getMemoryBuffer(sourceMgr->getMainFileID());
127  return function(buffer->getBuffer(), ctx);
128  });
129 }
130 
131 //===----------------------------------------------------------------------===//
132 // Translation from MLIR
133 //===----------------------------------------------------------------------===//
134 
136  StringRef name, StringRef description,
137  const TranslateFromMLIRFunction &function,
138  const DialectRegistrationFunction &dialectRegistration) {
140  name, description, /*inputAlignment=*/std::nullopt,
141  [function,
142  dialectRegistration](const std::shared_ptr<llvm::SourceMgr> &sourceMgr,
143  raw_ostream &output, MLIRContext *context) {
144  DialectRegistry registry;
145  dialectRegistration(registry);
146  context->appendDialectRegistry(registry);
147  bool implicitModule =
148  (!clOptions.isConstructed() || !clOptions->noImplicitModule);
150  parseSourceFileForTool(sourceMgr, context, implicitModule);
151  if (!op || failed(verify(*op)))
152  return failure();
153  return function(op.get(), output);
154  });
155 }
156 
157 //===----------------------------------------------------------------------===//
158 // Translation Parser
159 //===----------------------------------------------------------------------===//
160 
162  : llvm::cl::parser<const Translation *>(opt) {
163  for (const auto &kv : getTranslationRegistry())
164  addLiteralOption(kv.first(), &kv.second, kv.second.getDescription());
165 }
166 
167 void TranslationParser::printOptionInfo(const llvm::cl::Option &o,
168  size_t globalWidth) const {
169  TranslationParser *tp = const_cast<TranslationParser *>(this);
170  llvm::array_pod_sort(tp->Values.begin(), tp->Values.end(),
171  [](const TranslationParser::OptionInfo *lhs,
172  const TranslationParser::OptionInfo *rhs) {
173  return lhs->Name.compare(rhs->Name);
174  });
176 }
static llvm::ManagedStatic< TranslationOptions > clOptions
Definition: Translation.cpp:36
static llvm::StringMap< Translation > & getTranslationRegistry()
Get the mutable static map between registered file-to-file MLIR translations.
Definition: Translation.cpp:46
static void registerTranslateToMLIRFunction(StringRef name, StringRef description, const DialectRegistrationFunction &dialectRegistration, std::optional< llvm::Align > inputAlignment, const TranslateSourceMgrToMLIRFunction &function)
Definition: Translation.cpp:76
static void registerTranslation(StringRef name, StringRef description, std::optional< llvm::Align > inputAlignment, const TranslateFunction &function)
Register the given translation.
Definition: Translation.cpp:52
The DialectRegistry maps a dialect namespace to a constructor for the matching dialect.
MLIRContext is the top-level object for a collection of MLIR operations.
Definition: MLIRContext.h:60
void appendDialectRegistry(const DialectRegistry &registry)
Append the contents of the given dialect registry to the registry associated with this context.
void print(raw_ostream &os, const OpPrintingFlags &flags=std::nullopt)
This class acts as an owning reference to an op, and will automatically destroy the held op on destru...
Definition: OwningOpRef.h:28
This class contains all of the components necessary for performing a translation.
Definition: Translation.h:61
Include the generated interface declarations.
Definition: CallGraph.h:229
Include the generated interface declarations.
LogicalResult failure(bool isFailure=true)
Utility function to generate a LogicalResult.
Definition: LogicalResult.h:62
std::function< LogicalResult(const std::shared_ptr< llvm::SourceMgr > &sourceMgr, llvm::raw_ostream &output, MLIRContext *)> TranslateFunction
Interface of the function that performs file-to-file translation involving MLIR.
Definition: Translation.h:53
std::function< OwningOpRef< Operation * >(llvm::SourceMgr &sourceMgr, MLIRContext *)> TranslateRawSourceMgrToMLIRFunction
Definition: Translation.h:32
void registerTranslationCLOptions()
Register command-line options used by the translation registry.
Definition: Translation.cpp:38
std::function< void(DialectRegistry &)> DialectRegistrationFunction
Interface of the function that adds all dialects and dialect extensions used for the translation to t...
Definition: Translation.h:57
LogicalResult success(bool isSuccess=true)
Utility function to generate a LogicalResult.
Definition: LogicalResult.h:56
OwningOpRef< Operation * > parseSourceFileForTool(const std::shared_ptr< llvm::SourceMgr > &sourceMgr, const ParserConfig &config, bool insertImplicitModule)
This parses the file specified by the indicated SourceMgr.
std::function< LogicalResult(Operation *, llvm::raw_ostream &output)> TranslateFromMLIRFunction
Interface of the function that translates MLIR to a different format and outputs the result to a stre...
Definition: Translation.h:44
std::function< OwningOpRef< Operation * >(llvm::StringRef, MLIRContext *)> TranslateStringRefToMLIRFunction
Interface of the function that translates the given string to MLIR.
Definition: Translation.h:39
std::function< OwningOpRef< Operation * >(const std::shared_ptr< llvm::SourceMgr > &sourceMgr, MLIRContext *)> TranslateSourceMgrToMLIRFunction
Interface of the function that translates the sources managed by sourceMgr to MLIR.
Definition: Translation.h:29
LogicalResult verify(Operation *op, bool verifyRecursively=true)
Perform (potentially expensive) checks of invariants, used to detect compiler bugs,...
Definition: Verifier.cpp:421
bool failed(LogicalResult result)
Utility function that returns true if the provided LogicalResult corresponds to a failure value.
Definition: LogicalResult.h:72
TranslateFromMLIRRegistration(llvm::StringRef name, llvm::StringRef description, const TranslateFromMLIRFunction &function, const DialectRegistrationFunction &dialectRegistration=[](DialectRegistry &) {})
TranslateRegistration(llvm::StringRef name, llvm::StringRef description, const TranslateFunction &function)
Definition: Translation.cpp:64
TranslateToMLIRRegistration(llvm::StringRef name, llvm::StringRef description, const TranslateSourceMgrToMLIRFunction &function, const DialectRegistrationFunction &dialectRegistration=[](DialectRegistry &) {}, std::optional< llvm::Align > inputAlignment=std::nullopt)
A command line parser for translation functions.
Definition: Translation.h:162
void printOptionInfo(const llvm::cl::Option &o, size_t globalWidth) const override
TranslationParser(llvm::cl::Option &opt)