1 | //===- toyc.cpp - The Toy Compiler ----------------------------------------===// |
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 | // This file implements the entry point for the Toy compiler. |
10 | // |
11 | //===----------------------------------------------------------------------===// |
12 | |
13 | #include "mlir/IR/Diagnostics.h" |
14 | #include "toy/AST.h" |
15 | #include "toy/Dialect.h" |
16 | #include "toy/Lexer.h" |
17 | #include "toy/MLIRGen.h" |
18 | #include "toy/Parser.h" |
19 | |
20 | #include "mlir/IR/AsmState.h" |
21 | #include "mlir/IR/BuiltinOps.h" |
22 | #include "mlir/IR/MLIRContext.h" |
23 | #include "mlir/IR/Verifier.h" |
24 | #include "mlir/Parser/Parser.h" |
25 | #include "mlir/Pass/PassManager.h" |
26 | #include "mlir/Transforms/Passes.h" |
27 | |
28 | #include "llvm/ADT/StringRef.h" |
29 | #include "llvm/Support/CommandLine.h" |
30 | #include "llvm/Support/ErrorOr.h" |
31 | #include "llvm/Support/MemoryBuffer.h" |
32 | #include "llvm/Support/SourceMgr.h" |
33 | #include "llvm/Support/raw_ostream.h" |
34 | #include <memory> |
35 | #include <string> |
36 | #include <system_error> |
37 | #include <utility> |
38 | |
39 | using namespace toy; |
40 | namespace cl = llvm::cl; |
41 | |
42 | static cl::opt<std::string> inputFilename(cl::Positional, |
43 | cl::desc("<input toy file>" ), |
44 | cl::init(Val: "-" ), |
45 | cl::value_desc("filename" )); |
46 | |
47 | namespace { |
48 | enum InputType { Toy, MLIR }; |
49 | } // namespace |
50 | static cl::opt<enum InputType> inputType( |
51 | "x" , cl::init(Val: Toy), cl::desc("Decided the kind of output desired" ), |
52 | cl::values(clEnumValN(Toy, "toy" , "load the input file as a Toy source." )), |
53 | cl::values(clEnumValN(MLIR, "mlir" , |
54 | "load the input file as an MLIR file" ))); |
55 | |
56 | namespace { |
57 | enum Action { None, DumpAST, DumpMLIR }; |
58 | } // namespace |
59 | static cl::opt<enum Action> emitAction( |
60 | "emit" , cl::desc("Select the kind of output desired" ), |
61 | cl::values(clEnumValN(DumpAST, "ast" , "output the AST dump" )), |
62 | cl::values(clEnumValN(DumpMLIR, "mlir" , "output the MLIR dump" ))); |
63 | |
64 | static cl::opt<bool> enableOpt("opt" , cl::desc("Enable optimizations" )); |
65 | |
66 | /// Returns a Toy AST resulting from parsing the file or a nullptr on error. |
67 | std::unique_ptr<toy::ModuleAST> parseInputFile(llvm::StringRef filename) { |
68 | llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> fileOrErr = |
69 | llvm::MemoryBuffer::getFileOrSTDIN(Filename: filename); |
70 | if (std::error_code ec = fileOrErr.getError()) { |
71 | llvm::errs() << "Could not open input file: " << ec.message() << "\n" ; |
72 | return nullptr; |
73 | } |
74 | auto buffer = fileOrErr.get()->getBuffer(); |
75 | LexerBuffer lexer(buffer.begin(), buffer.end(), std::string(filename)); |
76 | Parser parser(lexer); |
77 | return parser.parseModule(); |
78 | } |
79 | |
80 | int loadMLIR(llvm::SourceMgr &sourceMgr, mlir::MLIRContext &context, |
81 | mlir::OwningOpRef<mlir::ModuleOp> &module) { |
82 | // Handle '.toy' input to the compiler. |
83 | if (inputType != InputType::MLIR && |
84 | !llvm::StringRef(inputFilename).ends_with(Suffix: ".mlir" )) { |
85 | auto moduleAST = parseInputFile(filename: inputFilename); |
86 | if (!moduleAST) |
87 | return 6; |
88 | module = mlirGen(context, moduleAST&: *moduleAST); |
89 | return !module ? 1 : 0; |
90 | } |
91 | |
92 | // Otherwise, the input is '.mlir'. |
93 | llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> fileOrErr = |
94 | llvm::MemoryBuffer::getFileOrSTDIN(Filename: inputFilename); |
95 | if (std::error_code ec = fileOrErr.getError()) { |
96 | llvm::errs() << "Could not open input file: " << ec.message() << "\n" ; |
97 | return -1; |
98 | } |
99 | |
100 | // Parse the input mlir. |
101 | sourceMgr.AddNewSourceBuffer(F: std::move(*fileOrErr), IncludeLoc: llvm::SMLoc()); |
102 | module = mlir::parseSourceFile<mlir::ModuleOp>(sourceMgr, config: &context); |
103 | if (!module) { |
104 | llvm::errs() << "Error can't load file " << inputFilename << "\n" ; |
105 | return 3; |
106 | } |
107 | return 0; |
108 | } |
109 | |
110 | int dumpMLIR() { |
111 | mlir::MLIRContext context; |
112 | // Load our Dialect in this MLIR Context. |
113 | context.getOrLoadDialect<mlir::toy::ToyDialect>(); |
114 | |
115 | mlir::OwningOpRef<mlir::ModuleOp> module; |
116 | llvm::SourceMgr sourceMgr; |
117 | mlir::SourceMgrDiagnosticHandler sourceMgrHandler(sourceMgr, &context); |
118 | if (int error = loadMLIR(sourceMgr, context, module)) |
119 | return error; |
120 | |
121 | if (enableOpt) { |
122 | mlir::PassManager pm(module.get()->getName()); |
123 | // Apply any generic pass manager command line options and run the pipeline. |
124 | if (mlir::failed(Result: mlir::applyPassManagerCLOptions(pm))) |
125 | return 4; |
126 | |
127 | // Add a run of the canonicalizer to optimize the mlir module. |
128 | pm.addNestedPass<mlir::toy::FuncOp>(mlir::createCanonicalizerPass()); |
129 | if (mlir::failed(Result: pm.run(op: *module))) |
130 | return 4; |
131 | } |
132 | |
133 | module->dump(); |
134 | return 0; |
135 | } |
136 | |
137 | int dumpAST() { |
138 | if (inputType == InputType::MLIR) { |
139 | llvm::errs() << "Can't dump a Toy AST when the input is MLIR\n" ; |
140 | return 5; |
141 | } |
142 | |
143 | auto moduleAST = parseInputFile(filename: inputFilename); |
144 | if (!moduleAST) |
145 | return 1; |
146 | |
147 | dump(*moduleAST); |
148 | return 0; |
149 | } |
150 | |
151 | int main(int argc, char **argv) { |
152 | // Register any command line options. |
153 | mlir::registerAsmPrinterCLOptions(); |
154 | mlir::registerMLIRContextCLOptions(); |
155 | mlir::registerPassManagerCLOptions(); |
156 | |
157 | cl::ParseCommandLineOptions(argc, argv, Overview: "toy compiler\n" ); |
158 | |
159 | switch (emitAction) { |
160 | case Action::DumpAST: |
161 | return dumpAST(); |
162 | case Action::DumpMLIR: |
163 | return dumpMLIR(); |
164 | default: |
165 | llvm::errs() << "No action specified (parsing only?), use -emit=<action>\n" ; |
166 | } |
167 | |
168 | return 0; |
169 | } |
170 | |