| //===- toyc.cpp - The Toy Compiler ----------------------------------------===// |
| // |
| // 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 |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // This file implements the entry point for the Toy compiler. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "toy/Dialect.h" |
| #include "toy/MLIRGen.h" |
| #include "toy/Parser.h" |
| #include <memory> |
| |
| #include "mlir/IR/AsmState.h" |
| #include "mlir/IR/BuiltinOps.h" |
| #include "mlir/IR/MLIRContext.h" |
| #include "mlir/IR/Verifier.h" |
| #include "mlir/Parser.h" |
| |
| #include "llvm/ADT/StringRef.h" |
| #include "llvm/Support/CommandLine.h" |
| #include "llvm/Support/ErrorOr.h" |
| #include "llvm/Support/MemoryBuffer.h" |
| #include "llvm/Support/SourceMgr.h" |
| #include "llvm/Support/raw_ostream.h" |
| |
| using namespace toy; |
| namespace cl = llvm::cl; |
| |
| static cl::opt<std::string> inputFilename(cl::Positional, |
| cl::desc("<input toy file>"), |
| cl::init("-"), |
| cl::value_desc("filename")); |
| |
| namespace { |
| enum InputType { Toy, MLIR }; |
| } |
| static cl::opt<enum InputType> inputType( |
| "x", cl::init(Toy), cl::desc("Decided the kind of output desired"), |
| cl::values(clEnumValN(Toy, "toy", "load the input file as a Toy source.")), |
| cl::values(clEnumValN(MLIR, "mlir", |
| "load the input file as an MLIR file"))); |
| |
| namespace { |
| enum Action { None, DumpAST, DumpMLIR }; |
| } |
| static cl::opt<enum Action> emitAction( |
| "emit", cl::desc("Select the kind of output desired"), |
| cl::values(clEnumValN(DumpAST, "ast", "output the AST dump")), |
| cl::values(clEnumValN(DumpMLIR, "mlir", "output the MLIR dump"))); |
| |
| /// Returns a Toy AST resulting from parsing the file or a nullptr on error. |
| std::unique_ptr<toy::ModuleAST> parseInputFile(llvm::StringRef filename) { |
| llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> fileOrErr = |
| llvm::MemoryBuffer::getFileOrSTDIN(filename); |
| if (std::error_code ec = fileOrErr.getError()) { |
| llvm::errs() << "Could not open input file: " << ec.message() << "\n"; |
| return nullptr; |
| } |
| auto buffer = fileOrErr.get()->getBuffer(); |
| LexerBuffer lexer(buffer.begin(), buffer.end(), std::string(filename)); |
| Parser parser(lexer); |
| return parser.parseModule(); |
| } |
| |
| int dumpMLIR() { |
| mlir::MLIRContext context; |
| // Load our Dialect in this MLIR Context. |
| context.getOrLoadDialect<mlir::toy::ToyDialect>(); |
| |
| // Handle '.toy' input to the compiler. |
| if (inputType != InputType::MLIR && |
| !llvm::StringRef(inputFilename).endswith(".mlir")) { |
| auto moduleAST = parseInputFile(inputFilename); |
| if (!moduleAST) |
| return 6; |
| mlir::OwningModuleRef module = mlirGen(context, *moduleAST); |
| if (!module) |
| return 1; |
| |
| module->dump(); |
| return 0; |
| } |
| |
| // Otherwise, the input is '.mlir'. |
| llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> fileOrErr = |
| llvm::MemoryBuffer::getFileOrSTDIN(inputFilename); |
| if (std::error_code EC = fileOrErr.getError()) { |
| llvm::errs() << "Could not open input file: " << EC.message() << "\n"; |
| return -1; |
| } |
| |
| // Parse the input mlir. |
| llvm::SourceMgr sourceMgr; |
| sourceMgr.AddNewSourceBuffer(std::move(*fileOrErr), llvm::SMLoc()); |
| mlir::OwningModuleRef module = mlir::parseSourceFile(sourceMgr, &context); |
| if (!module) { |
| llvm::errs() << "Error can't load file " << inputFilename << "\n"; |
| return 3; |
| } |
| |
| module->dump(); |
| return 0; |
| } |
| |
| int dumpAST() { |
| if (inputType == InputType::MLIR) { |
| llvm::errs() << "Can't dump a Toy AST when the input is MLIR\n"; |
| return 5; |
| } |
| |
| auto moduleAST = parseInputFile(inputFilename); |
| if (!moduleAST) |
| return 1; |
| |
| dump(*moduleAST); |
| return 0; |
| } |
| |
| int main(int argc, char **argv) { |
| // Register any command line options. |
| mlir::registerAsmPrinterCLOptions(); |
| mlir::registerMLIRContextCLOptions(); |
| cl::ParseCommandLineOptions(argc, argv, "toy compiler\n"); |
| |
| switch (emitAction) { |
| case Action::DumpAST: |
| return dumpAST(); |
| case Action::DumpMLIR: |
| return dumpMLIR(); |
| default: |
| llvm::errs() << "No action specified (parsing only?), use -emit=<action>\n"; |
| } |
| |
| return 0; |
| } |