[flang][driver] Add support for `-emit-mlir`

[awarzynski]

Summary

This patch adds support for generating MLIR files in Flang's frontend
driver (i.e. flang-new -fc1). -emit-fir is added as an alias for
-emit-mlir. We may want to decide to split the two in the future.

A new parent class for code-gen frontend actions is introduced:
CodeGenAction. We will be using this class to encapsulate logic shared
between all code-generation actions, but not required otherwise. For
now, it will:

• run prescanning, parsing and semantic checks,
• lower the input to MLIR.

EmitObjAction is updated to inherit from this class. This means that
the behaviour of flang-new -fc1 -emit-obj is also updated (previously,
it would just exit immediately). This change required
flang/test/Driver/syntax-only.f90 to be updated.

For -emit-fir, a specialisation of CodeGenAction is introduced:
EmitMLIRAction. The key logic for this class is implemented in
EmitMLIRAction::ExecuteAction.

[awarzynski]

fir-dev PR: https://github.com/flang-compiler/f18-llvm-project/pull/1008. I've also incorporated a few small changes from the subsequent PRs.

[awarzynski]

Add missing CMake dependency

[schweitz]

LGTM

flang/include/flang/Frontend/FrontendActions.h

150

This appears in a header file. Should there be doxygen comments?

160

The LLVM coding conventions do not require trailing undescores.

[awarzynski]

flang/include/flang/Frontend/FrontendActions.h

150

Good point, I'll add something here.

160

Good point, I'll change this.

[awarzynski]

Removed trailing "_" from member variable names, added a comment, updated CMake dependencies (needed after https://reviews.llvm.org/D118966)

@schweitz, thank you for reviewing! If there are no new comments, I'll merge this today/tomorrow.

[kiranchandramohan]

Few Nits/questions.

flang/lib/Frontend/FrontendActions.cpp

69

Nit: Can we remove the three autos below?

420

Nit: Should we test the existence of such a file?

421

Nit: can we remove auto?

flang/test/Driver/emit-mlir.f90

2

Nit: The the

flang/test/Driver/syntax-only.f90

16

Nit: Do you have another test for fsyntax-only?

23

Do we currently run the stages before codegen and then issue this error?

[awarzynski]

flang/lib/Frontend/FrontendActions.cpp

69

Sure!

420

We do :) Sort of!

To me, "existence" is a low level concept. Files are handled through e.g. llvm::raw_fd_ostream (and occasionally other streams) and IMO all low level details should be dealt with there (and indeed are). flang-new should only verify that os is not a nullptr. If the file does not exist, os will be a nullptr and that's checked further down. If the file does exist, then everything is fine and we can move to the next step.

421

Sure!

flang/test/Driver/emit-mlir.f90

2

Thanks :) Also, should be -emit-mlir instead of -emit-fir.

flang/test/Driver/syntax-only.f90

16

No, but there are many tests that use it: https://github.com/llvm/llvm-project/blob/main/flang/test/Semantics/call17.f90

23

Yes, but this error is here only temporarily. I will be removing it shortly (once -emit-obj is implemented).

[awarzynski]

Remove auto, update comment

[kiranchandramohan]

LGTM.

flang/lib/Frontend/FrontendActions.cpp

420

OK, that was sounds fine. I was also meaning to ask whether we should have a test that a *.mlir file is generated in a test.

[awarzynski]

flang/lib/Frontend/FrontendActions.cpp

420

I can add one, yes!

[awarzynski]

• Add a test to verify that an .mlir file is created
• Set the target triple to native (as opposed to relying on it being set elsewhere, e.g. https://github.com/llvm/llvm-project/blob/81cde474e2c5a6280cb693b777ddcf473825ae8a/flang/lib/Optimizer/Support/FIRContext.cpp#L53-L62 )

clang/include/clang/Driver/Options.td

def fget_symbols_sources : Flag<["-"], "fget-symbols-sources">, Group<Action_Group>,
   HelpText<"Dump symbols and their source code locations">;
 
 def module_suffix : Separate<["-"], "module-suffix">,  Group<f_Group>, MetaVarName<"<suffix>">,
   HelpText<"Use <suffix> as the suffix for module files (the default value is `.mod`)">;
 def fno_reformat : Flag<["-"], "fno-reformat">, Group<Preprocessor_Group>,
   HelpText<"Dump the cooked character stream in -E mode">;
 defm analyzed_objects_for_unparse : OptOutFC1FFlag<"analyzed-objects-for-unparse", "", "Do not use the analyzed objects when unparsing">;
 
+def emit_mlir : Flag<["-"], "emit-mlir">, Group<Action_Group>,
+  HelpText<"Build the parse tree, then lower it to MLIR">;
+def emit_fir : Flag<["-"], "emit-fir">, Alias<emit_mlir>;
+
 }
 
 //===----------------------------------------------------------------------===//
 // CC1 Options
 //===----------------------------------------------------------------------===//
 
 let Flags = [CC1Option, NoDriverOption] in {
 

flang/include/flang/Frontend/CompilerInstance.h

public:
   }
 
   bool IsOutputStreamNull() { return (outputStream_ == nullptr); }
 
   // Allow the frontend compiler to write in the output stream.
   void WriteOutputStream(const std::string &message) {
     *outputStream_ << message;
   }
+
+  /// Get the user specified output stream.
+  llvm::raw_pwrite_stream &GetOutputStream() {
+    assert(outputStream_ &&
+        "Compiler instance has no user-specified output stream!");
+    return *outputStream_;
+  }
 };
 
 } // end namespace Fortran::frontend
 #endif // LLVM_FLANG_FRONTEND_COMPILERINSTANCE_H

flang/include/flang/Frontend/FrontendActions.h

 //===- FrontendActions.h -----------------------------------------*- C++-*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_FLANG_FRONTEND_FRONTENDACTIONS_H
 #define LLVM_FLANG_FRONTEND_FRONTENDACTIONS_H
 
 #include "flang/Frontend/FrontendAction.h"
 #include "flang/Semantics/semantics.h"
+
+#include "mlir/IR/BuiltinOps.h"
 #include <memory>
 
 namespace Fortran::frontend {
 
 // TODO: This is a copy from f18.cpp. It doesn't really belong here and should
 // be moved to a more suitable place in future.
 struct MeasurementVisitor {
   template <typename A> bool Pre(const A &) { return true; }
   template <typename A> void Post(const A &) {
     ++objects;
     bytes += sizeof(A);
   }
   size_t objects{0}, bytes{0};
 };
 
 //===----------------------------------------------------------------------===//
 // Custom Consumer Actions
 //===----------------------------------------------------------------------===//
 
 class InputOutputTestAction : public FrontendAction {
   void ExecuteAction() override;
 };
 
-class EmitObjAction : public FrontendAction {
-  void ExecuteAction() override;
-};
-
 class InitOnlyAction : public FrontendAction {
   void ExecuteAction() override;
 };
 
 //===----------------------------------------------------------------------===//
 // Prescan Actions
 //===----------------------------------------------------------------------===//
 class PrescanAction : public FrontendAction {
class PrescanAndSemaDebugAction : public FrontendAction {
   void ExecuteAction() override = 0;
   bool BeginSourceFileAction() override;
 };
 
 class DebugDumpAllAction : public PrescanAndSemaDebugAction {
   void ExecuteAction() override;
 };
 
+//===----------------------------------------------------------------------===//
+// CodeGen Actions
+//===----------------------------------------------------------------------===//
+/// Abstract base class for actions that generate code (MLIR, LLVM IR, assembly
+/// and machine code). Every action that inherits from this class will at
+/// least run the prescanning, parsing, semantic checks and lower the parse
+/// tree to an MLIR module.
+class CodeGenAction : public FrontendAction {
+
+  void ExecuteAction() override = 0;
+  /// Runs prescan, parsing, sema and lowers to MLIR.
+  bool BeginSourceFileAction() override;
+
+protected:
+  /// @name MLIR
+  /// {
+  std::unique_ptr<mlir::ModuleOp> mlirModule;
+  std::unique_ptr<mlir::MLIRContext> mlirCtx;
+  /// }
+};
+
+class EmitMLIRAction : public CodeGenAction {
+  void ExecuteAction() override;
+};
+
+class EmitObjAction : public CodeGenAction {
+  void ExecuteAction() override;
+};
+
 } // namespace Fortran::frontend
 
 #endif // LLVM_FLANG_FRONTEND_FRONTENDACTIONS_H

flang/include/flang/Frontend/FrontendOptions.h

enum ActionKind {
   InputOutputTest,
 
   /// -E mode
   PrintPreprocessedInput,
 
   /// -fsyntax-only
   ParseSyntaxOnly,
 
+  /// Emit a .mlir file
+  EmitMLIR,
+
   /// Emit a .o file.
   EmitObj,
 
   /// Parse, unparse the parse-tree and output a Fortran source file
   DebugUnparse,
 
   /// Parse, unparse the parse-tree and output a Fortran source file, skip the
   /// semantic checks

flang/lib/Frontend/CMakeLists.txt

+get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
+
 add_flang_library(flangFrontend
   CompilerInstance.cpp
   CompilerInvocation.cpp
   FrontendAction.cpp
   FrontendActions.cpp
   FrontendOptions.cpp
   TextDiagnosticPrinter.cpp
   TextDiagnosticBuffer.cpp
   TextDiagnostic.cpp
 
   DEPENDS
   clangBasic
+  FIRBuilder
+  FIRDialect
+  FIRSupport
+  ${dialect_libs}
 
   LINK_LIBS
   FortranParser
   FortranSemantics
   FortranEvaluate
   FortranCommon
   FortranLower
   clangBasic
   clangDriver
+  FIRDialect
+  FIRSupport
+  FIRBuilder
+  FIRCodeGen
+  FIRTransforms
+  MLIRTransforms
+  MLIRLLVMToLLVMIRTranslation
+  MLIRSCFToControlFlow
+  ${dialect_libs}
 
   LINK_COMPONENTS
   Option
   Support
   FrontendOpenACC
   FrontendOpenMP
 )

flang/lib/Frontend/CompilerInvocation.cpp

case clang::driver::options::OPT_test_io:
       opts.programAction = InputOutputTest;
       break;
     case clang::driver::options::OPT_E:
       opts.programAction = PrintPreprocessedInput;
       break;
     case clang::driver::options::OPT_fsyntax_only:
       opts.programAction = ParseSyntaxOnly;
       break;
+    case clang::driver::options::OPT_emit_mlir:
+      opts.programAction = EmitMLIR;
+      break;
     case clang::driver::options::OPT_emit_obj:
       opts.programAction = EmitObj;
       break;
     case clang::driver::options::OPT_fdebug_unparse:
       opts.programAction = DebugUnparse;
       break;
     case clang::driver::options::OPT_fdebug_unparse_no_sema:
       opts.programAction = DebugUnparseNoSema;

flang/lib/Frontend/FrontendActions.cpp

 //===--- FrontendActions.cpp ----------------------------------------------===//
 //
 // 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 "flang/Frontend/FrontendActions.h"
 #include "flang/Common/default-kinds.h"
 #include "flang/Frontend/CompilerInstance.h"
 #include "flang/Frontend/FrontendOptions.h"
 #include "flang/Frontend/PreprocessorOptions.h"
+#include "flang/Lower/Bridge.h"
 #include "flang/Lower/PFTBuilder.h"
+#include "flang/Lower/Support/Verifier.h"
+#include "flang/Optimizer/Support/InitFIR.h"
+#include "flang/Optimizer/Support/KindMapping.h"
+#include "flang/Optimizer/Support/Utils.h"
 #include "flang/Parser/dump-parse-tree.h"
 #include "flang/Parser/parsing.h"
 #include "flang/Parser/provenance.h"
 #include "flang/Parser/source.h"
 #include "flang/Parser/unparse.h"
 #include "flang/Semantics/runtime-type-info.h"
 #include "flang/Semantics/semantics.h"
 #include "flang/Semantics/unparse-with-symbols.h"
+
+#include "mlir/IR/Dialect.h"
+#include "mlir/Pass/PassManager.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/ErrorHandling.h"
 #include <clang/Basic/Diagnostic.h>
 #include <memory>
 
 using namespace Fortran::frontend;
 
 //===----------------------------------------------------------------------===//
bool PrescanAndSemaAction::BeginSourceFileAction() {
   return RunPrescan() && RunParse() && RunSemanticChecks();
 }
 
 bool PrescanAndSemaDebugAction::BeginSourceFileAction() {
   // Semantic checks are made to succeed unconditionally.
   return RunPrescan() && RunParse() && (RunSemanticChecks() || true);
 }
 
+bool CodeGenAction::BeginSourceFileAction() {
+  bool res = RunPrescan() && RunParse() && RunSemanticChecks();
+  if (!res)
+    return res;
+
+  CompilerInstance &ci = this->instance();
+
+  // Load the MLIR dialects required by Flang
+  mlir::DialectRegistry registry;
+  mlirCtx = std::make_unique<mlir::MLIRContext>(registry);
+  fir::support::registerNonCodegenDialects(registry);
+  fir::support::loadNonCodegenDialects(*mlirCtx);
+
+  // Create a LoweringBridge
+  const common::IntrinsicTypeDefaultKinds &defKinds =
+      ci.invocation().semanticsContext().defaultKinds();
+  fir::KindMapping kindMap(mlirCtx.get(),
+      llvm::ArrayRef<fir::KindTy>{fir::fromDefaultKinds(defKinds)});
+  lower::LoweringBridge lb = Fortran::lower::LoweringBridge::create(*mlirCtx,
+      defKinds, ci.invocation().semanticsContext().intrinsics(),
+      ci.parsing().allCooked(), /*triple=*/"native", kindMap);
+
+  // Create a parse tree and lower it to FIR
+  Fortran::parser::Program &parseTree{*ci.parsing().parseTree()};
+  lb.lower(parseTree, ci.invocation().semanticsContext());
+  mlirModule = std::make_unique<mlir::ModuleOp>(lb.getModule());
+
+  // Run the default passes.
+  mlir::PassManager pm(mlirCtx.get(), mlir::OpPassManager::Nesting::Implicit);
+  pm.enableVerifier(/*verifyPasses=*/true);
+  pm.addPass(std::make_unique<Fortran::lower::VerifierPass>());
+
+  if (mlir::failed(pm.run(*mlirModule))) {
+    unsigned diagID =
+        ci.diagnostics().getCustomDiagID(clang::DiagnosticsEngine::Error,
+            "verification of lowering to FIR failed");
+    ci.diagnostics().Report(diagID);
+    return false;
+  }
+
+  return true;
+}
+
 //===----------------------------------------------------------------------===//
 // Custom ExecuteAction
 //===----------------------------------------------------------------------===//
 void InputOutputTestAction::ExecuteAction() {
   CompilerInstance &ci = instance();
 
   // Create a stream for errors
   std::string buf;
void GetSymbolsSourcesAction::ExecuteAction() {
   // Report and exit if fatal semantic errors are present
   if (reportFatalSemanticErrors()) {
     return;
   }
 
   ci.semantics().DumpSymbolsSources(llvm::outs());
 }
 
+void EmitMLIRAction::ExecuteAction() {
+  CompilerInstance &ci = this->instance();
+
+  // Print the output. If a pre-defined output stream exists, dump the MLIR
+  // content there.
+  if (!ci.IsOutputStreamNull()) {
+    mlirModule->print(ci.GetOutputStream());
+    return;
+  }
+
+  // ... otherwise, print to a file.
+  std::unique_ptr<llvm::raw_pwrite_stream> os{ci.CreateDefaultOutputFile(
+      /*Binary=*/true, /*InFile=*/GetCurrentFileOrBufferName(), "mlir")};
+  if (!os) {
+    unsigned diagID = ci.diagnostics().getCustomDiagID(
+        clang::DiagnosticsEngine::Error, "failed to create the output file");
+    ci.diagnostics().Report(diagID);
+    return;
+  }
+
+  mlirModule->print(*os);
+}
+
 void EmitObjAction::ExecuteAction() {
   CompilerInstance &ci = this->instance();
   unsigned DiagID = ci.diagnostics().getCustomDiagID(
       clang::DiagnosticsEngine::Error, "code-generation is not available yet");
   ci.diagnostics().Report(DiagID);
 }
 
 void InitOnlyAction::ExecuteAction() {
   CompilerInstance &ci = this->instance();
   unsigned DiagID =
       ci.diagnostics().getCustomDiagID(clang::DiagnosticsEngine::Warning,
           "Use `-init-only` for testing purposes only");
   ci.diagnostics().Report(DiagID);
 }
 
 void PluginParseTreeAction::ExecuteAction() {}

flang/lib/FrontendTool/CMakeLists.txt

 add_flang_library(flangFrontendTool
   ExecuteCompilerInvocation.cpp
 
   DEPENDS
+  # This makes sure that the MLIR dependencies of flangFrontend (which are
+  # transitively required here) are generated before this target is build.
+  flangFrontend
   clangBasic
 
   LINK_LIBS
   flangFrontend
   clangBasic
   clangDriver
 
   LINK_COMPONENTS
   Option
   Support
 )

flang/lib/FrontendTool/ExecuteCompilerInvocation.cpp

static std::unique_ptr<FrontendAction> CreateFrontendBaseAction(
   ActionKind ak = ci.frontendOpts().programAction;
   switch (ak) {
   case InputOutputTest:
     return std::make_unique<InputOutputTestAction>();
   case PrintPreprocessedInput:
     return std::make_unique<PrintPreprocessedAction>();
   case ParseSyntaxOnly:
     return std::make_unique<ParseSyntaxOnlyAction>();
+  case EmitMLIR:
+    return std::make_unique<EmitMLIRAction>();
   case EmitObj:
     return std::make_unique<EmitObjAction>();
   case DebugUnparse:
     return std::make_unique<DebugUnparseAction>();
   case DebugUnparseNoSema:
     return std::make_unique<DebugUnparseNoSemaAction>();
   case DebugUnparseWithSymbols:
     return std::make_unique<DebugUnparseWithSymbolsAction>();

flang/test/Driver/driver-help.f90

 !-------------------------------------------------------------
 ! EXPECTED OUTPUT FOR FLANG FRONTEND DRIVER (flang -fc1)
 !-------------------------------------------------------------
 ! HELP-FC1:USAGE: flang
 ! HELP-FC1-EMPTY:
 ! HELP-FC1-NEXT:OPTIONS:
 ! HELP-FC1-NEXT: -cpp                   Enable predefined and command line preprocessor macros
 ! HELP-FC1-NEXT: -D <macro>=<value>     Define <macro> to <value> (or 1 if <value> omitted)
+! HELP-FC1-NEXT: -emit-mlir Build the parse tree, then lower it to MLIR
 ! HELP-FC1-NEXT: -emit-obj Emit native object files
 ! HELP-FC1-NEXT: -E                     Only run the preprocessor
 ! HELP-FC1-NEXT: -falternative-parameter-statement
 ! HELP-FC1-NEXT: Enable the old style PARAMETER statement
 ! HELP-FC1-NEXT: -fbackslash            Specify that backslash in string introduces an escape character
 ! HELP-FC1-NEXT: -fdebug-dump-all       Dump symbols and the parse tree after the semantic checks
 ! HELP-FC1-NEXT: -fdebug-dump-parse-tree-no-sema
 ! HELP-FC1-NEXT:                        Dump the parse tree (skips the semantic checks)

flang/test/Driver/emit-mlir.f90

+! Test the `-emit-mlir` option
+
+!-------------
+! RUN COMMANDS
+!-------------
+! RUN: %flang_fc1 -emit-mlir %s -o - | FileCheck %s
+! RUN: %flang_fc1 -emit-fir %s -o - | FileCheck %s
+
+! Verify that an `.mlir` file is created when `-emit-mlir` is used. Do it in a temporary directory, which will be cleaned up by the
+! LIT runner.
+! RUN: rm -rf %t-dir && mkdir -p %t-dir && cd %t-dir
+! RUN: cp %s .
+! RUN: %flang_fc1 -emit-mlir emit-mlir.f90 && ls emit-mlir.mlir
+
+!----------------
+! EXPECTED OUTPUT
+!----------------
+! CHECK: module attributes {
+! CHECK-LABEL: func @_QQmain() {
+! CHECK-NEXT:  return
+! CHECK-NEXT: }
+! CHECK-NEXT: }
+
+!------
+! INPUT
+!------
+end program

flang/test/Driver/syntax-only.f90

-! Verify that the compiler driver correctly processes `-fsyntax-only`. By
-! default it will try to run code-generation, but that's not supported yet. We
-! don't need to test the frontend driver here - it runs `-fsyntax-only` by
-! default.
+! Verify that the driver correctly processes `-fsyntax-only`.
+!
+! By default, the compiler driver (`flang`) will create actions/phases to
+! generate machine code (i.e. object files). The `-fsyntax-only` flag is a
+! "phase-control" flag that controls this behavior and makes the driver stop
+! once the semantic checks have been run. The frontend driver (`flang -fc1`)
+! runs `-fsyntax-only` by default (i.e. that's the default action), so the flag
+! can be skipped.
 
 !-----------
 ! RUN LINES
 !-----------
-! RUN: not %flang -fsyntax-only %s 2>&1 | FileCheck %s --check-prefix=FSYNTAX_ONLY
+! RUN: %flang -fsyntax-only %s 2>&1 | FileCheck %s --allow-empty
+! RUN: %flang_fc1 %s 2>&1 | FileCheck %s --allow-empty
+
 ! RUN: not %flang  %s 2>&1 | FileCheck %s --check-prefix=NO_FSYNTAX_ONLY
+! RUN: not %flang_fc1 -emit-obj %s 2>&1 | FileCheck %s --check-prefix=NO_FSYNTAX_ONLY
 
 !-----------------
 ! EXPECTED OUTPUT
 !-----------------
-! FSYNTAX_ONLY: IF statement is not allowed in IF statement
-! FSYNTAX_ONLY_NEXT: Semantic errors in {{.*}}syntax-only.f90
-
+! CHECK-NOT: error
 ! NO_FSYNTAX_ONLY: error: code-generation is not available yet
 
 !-------
 ! INPUT
 !-------
-IF (A > 0.0) IF (B < 0.0) A = LOG (A)
-END
+end program