MlirTranslateMain.cpp

Go to the documentation of this file.

//===- MlirTranslateMain.cpp - MLIR Translation entry point ---------------===//
//
// 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/mlir-translate/MlirTranslateMain.h"
#include "mlir/IR/AsmState.h"
#include "mlir/Parser/Parser.h"
#include "mlir/Support/FileUtilities.h"
#include "mlir/Support/Timing.h"
#include "mlir/Support/ToolUtilities.h"
#include "mlir/Tools/mlir-translate/Translation.h"
#include "llvm/Support/SourceMgr.h"
#include "llvm/Support/ToolOutputFile.h"
 
using namespace mlir;
 
//===----------------------------------------------------------------------===//
// Diagnostic Filter
//===----------------------------------------------------------------------===//
 
namespace {
/// A scoped diagnostic handler that marks non-error diagnostics as handled. As
/// a result, the main diagnostic handler does not print non-error diagnostics.
class ErrorDiagnosticFilter : public ScopedDiagnosticHandler {
public:
  ErrorDiagnosticFilter(MLIRContext *ctx) : ScopedDiagnosticHandler(ctx) {
    setHandler([](Diagnostic &diag) {
      if (diag.getSeverity() != DiagnosticSeverity::Error)
        return success();
      return failure();
    });
  }
};
} // namespace
 
//===----------------------------------------------------------------------===//
// Translate Entry Point
//===----------------------------------------------------------------------===//
 
static LogicalResult mlirTranslateMainImpl(
    std::unique_ptr<llvm::MemoryBuffer> input, llvm::raw_ostream &output,
    ArrayRef<const Translation *> translations,
    const MlirTranslateMainConfig &config, TimingScope timing) {
  if (translations.empty()) {
    llvm::errs() << "no translation requested\n";
    return failure();
  }
 
  // Processes the memory buffer with a new MLIRContext.
  auto processBuffer = [&](std::unique_ptr<llvm::MemoryBuffer> ownedBuffer,
                           raw_ostream &os) {
    // Many of the translations expect a null-terminated buffer while splitting
    // the buffer does not guarantee null-termination. Make a copy of the buffer
    // to ensure null-termination.
    if (!ownedBuffer->getBuffer().ends_with('\0')) {
      ownedBuffer = llvm::MemoryBuffer::getMemBufferCopy(
          ownedBuffer->getBuffer(), ownedBuffer->getBufferIdentifier());
    }
    // Temporary buffers for chained translation processing.
    std::string dataIn;
    std::string dataOut;
    LogicalResult result = LogicalResult::success();
 
    for (const auto [index, translationRequested] :
         llvm::enumerate(translations)) {
      llvm::raw_ostream *stream;
      llvm::raw_string_ostream dataStream(dataOut);
 
      if (index == translations.size() - 1) {
        // Output last translation to output.
        stream = &os;
      } else {
        // Output translation to temporary data buffer.
        stream = &dataStream;
      }
 
      TimingScope translationTiming =
          timing.nest(translationRequested->getDescription());
 
      MLIRContext context;
      context.allowUnregisteredDialects(
          config.shouldAllowUnregisteredDialects());
      context.printOpOnDiagnostic(
          config.getVerifyDiagnosticsLevel() ==
          SourceMgrDiagnosticVerifierHandler::Level::None);
      auto sourceMgr = std::make_shared<llvm::SourceMgr>();
      sourceMgr->AddNewSourceBuffer(std::move(ownedBuffer), SMLoc());
 
      if (config.getVerifyDiagnosticsLevel() !=
          SourceMgrDiagnosticVerifierHandler::Level::None) {
        // In the diagnostic verification flow, we ignore whether the
        // translation failed (in most cases, it is expected to fail) and we do
        // not filter non-error diagnostics even if `errorDiagnosticsOnly` is
        // set. Instead, we check if the diagnostics were produced as expected.
        SourceMgrDiagnosticVerifierHandler sourceMgrHandler(
            *sourceMgr, &context, config.getVerifyDiagnosticsLevel());
        (void)(*translationRequested)(sourceMgr, os, &context);
        result = sourceMgrHandler.verify();
      } else if (config.shouldEmitErrorDiagnosticsOnly()) {
        SourceMgrDiagnosticHandler sourceMgrHandler(*sourceMgr, &context);
        ErrorDiagnosticFilter diagnosticFilter(&context);
        result = (*translationRequested)(sourceMgr, *stream, &context);
      } else {
        SourceMgrDiagnosticHandler sourceMgrHandler(*sourceMgr, &context);
        result = (*translationRequested)(sourceMgr, *stream, &context);
      }
      if (failed(result))
        return result;
 
      if (index < translations.size() - 1) {
        // If there are further translations, create a new buffer with the
        // output data.
        dataIn = dataOut;
        dataOut.clear();
        ownedBuffer = llvm::MemoryBuffer::getMemBuffer(dataIn);
      }
    }
    return result;
  };
 
  return splitAndProcessBuffer(std::move(input), processBuffer, output,
                               config.getInputSplitMarker(),
                               config.getOutputSplitMarker());
}
 
LogicalResult
mlir::mlirTranslateMain(std::unique_ptr<llvm::MemoryBuffer> input,
                        llvm::raw_ostream &output,
                        ArrayRef<const Translation *> translations,
                        const MlirTranslateMainConfig &config) {
  return mlirTranslateMainImpl(std::move(input), output, translations, config,
                               TimingScope());
}
 
LogicalResult mlir::mlirTranslateMain(int argc, char **argv,
                                      llvm::StringRef toolName) {
 
  static llvm::cl::opt<std::string> inputFilename(
      llvm::cl::Positional, llvm::cl::desc("<input file>"),
      llvm::cl::init("-"));
 
  static llvm::cl::opt<std::string> outputFilename(
      "o", llvm::cl::desc("Output filename"), llvm::cl::value_desc("filename"),
      llvm::cl::init("-"));
 
  static llvm::cl::opt<bool> allowUnregisteredDialects(
      "allow-unregistered-dialect",
      llvm::cl::desc("Allow operation with no registered dialects "
                     "(discouraged: testing only!)"),
      llvm::cl::init(false));
 
  static llvm::cl::opt<std::string> inputSplitMarker{
      "split-input-file", llvm::cl::ValueOptional,
      llvm::cl::callback([&](const std::string &str) {
        // Implicit value: use default marker if flag was used without value.
        if (str.empty())
          inputSplitMarker.setValue(kDefaultSplitMarker);
      }),
      llvm::cl::desc("Split the input file into chunks using the given or "
                     "default marker and process each chunk independently"),
      llvm::cl::init("")};
 
  static llvm::cl::opt<SourceMgrDiagnosticVerifierHandler::Level>
      verifyDiagnostics{
          "verify-diagnostics", llvm::cl::ValueOptional,
          llvm::cl::desc("Check that emitted diagnostics match expected-* "
                         "lines on the corresponding line"),
          llvm::cl::values(
              clEnumValN(
                  SourceMgrDiagnosticVerifierHandler::Level::All, "all",
                  "Check all diagnostics (expected, unexpected, near-misses)"),
              // Implicit value: when passed with no arguments, e.g.
              // `--verify-diagnostics` or `--verify-diagnostics=`.
              clEnumValN(
                  SourceMgrDiagnosticVerifierHandler::Level::All, "",
                  "Check all diagnostics (expected, unexpected, near-misses)"),
              clEnumValN(
                  SourceMgrDiagnosticVerifierHandler::Level::OnlyExpected,
                  "only-expected", "Check only expected diagnostics"))};
 
  static llvm::cl::opt<bool> errorDiagnosticsOnly(
      "error-diagnostics-only",
      llvm::cl::desc("Filter all non-error diagnostics "
                     "(discouraged: testing only!)"),
      llvm::cl::init(false));
 
  static llvm::cl::opt<std::string> outputSplitMarker(
      "output-split-marker",
      llvm::cl::desc("Split marker to use for merging the ouput"),
      llvm::cl::init(""));
 
  // Add flags for all the registered translations.
  llvm::cl::list<const Translation *, bool, TranslationParser>
      translationsRequested("", llvm::cl::desc("Translations to perform"),
                            llvm::cl::Required);
  registerAsmPrinterCLOptions();
  registerMLIRContextCLOptions();
  registerTranslationCLOptions();
  registerDefaultTimingManagerCLOptions();
  llvm::cl::ParseCommandLineOptions(argc, argv, toolName);
 
  // Initialize the timing manager.
  DefaultTimingManager tm;
  applyDefaultTimingManagerCLOptions(tm);
  TimingScope timing = tm.getRootScope();
 
  std::string errorMessage;
  std::unique_ptr<llvm::MemoryBuffer> input;
  if (auto inputAlignment = translationsRequested[0]->getInputAlignment())
    input = openInputFile(inputFilename, *inputAlignment, &errorMessage);
  else
    input = openInputFile(inputFilename, &errorMessage);
  if (!input) {
    llvm::errs() << errorMessage << "\n";
    return failure();
  }
 
  auto output = openOutputFile(outputFilename, &errorMessage);
  if (!output) {
    llvm::errs() << errorMessage << "\n";
    return failure();
  }
 
  MlirTranslateMainConfig config;
  config.allowUnregisteredDialects(allowUnregisteredDialects)
      .errorDiagnosticsOnly(errorDiagnosticsOnly)
      .outputSplitMarker(outputSplitMarker);
  if (inputSplitMarker.getNumOccurrences())
    config.splitInputFile(inputSplitMarker);
  if (verifyDiagnostics.getNumOccurrences())
    config.verifyDiagnostics(verifyDiagnostics);
 
  if (failed(mlirTranslateMainImpl(std::move(input), output->os(),
                                   translationsRequested, config,
                                   std::move(timing))))
    return failure();
 
  output->keep();
  return success();
}