[flang][driver] Add support for the -emit-llvm option

This patch adds support for the `-emit-llvm` option in the frontend
driver. Similarly to Clang, `flang-new -fc1 -emit-llvm file.f` will
generate an LLVM IR file.

In order to better facilitate code re-use, common functionality for
`-emit-llvm` and `-emit-mlir` is extracted into
`CodeGenAction::BeginSourceFileAction`. The pass pipeline creation is
extracted from tco.cpp and moved to flang/Tools/CLOptions.inc (see
`createTCOPassPipeline`).

Also, `fromDefaultKinds` in FrontendActions.cpp is deleted. We should be
using the shared implementation from flang/Optimizer/Support/Utils.h
instead (introduced in
#1117).

Author: banach-space

clang/include/clang/Driver/Options.td

@@ -1063,7 +1063,7 @@ def d_Flag : Flag<["-"], "d">, Group<d_Group>;
 def d_Joined : Joined<["-"], "d">, Group<d_Group>;
 def emit_ast : Flag<["-"], "emit-ast">,
   HelpText<"Emit Clang AST files for source inputs">;
-def emit_llvm : Flag<["-"], "emit-llvm">, Flags<[CC1Option]>, Group<Action_Group>,
+def emit_llvm : Flag<["-"], "emit-llvm">, Flags<[CC1Option, FC1Option]>, Group<Action_Group>,
   HelpText<"Use the LLVM representation for assembler and object files">;
 def emit_interface_stubs : Flag<["-"], "emit-interface-stubs">, Flags<[CC1Option]>, Group<Action_Group>,
   HelpText<"Generate Interface Stub Files.">;

flang/include/flang/Frontend/CompilerInstance.h

@@ -8,6 +8,7 @@
 #ifndef LLVM_FLANG_FRONTEND_COMPILERINSTANCE_H
 #define LLVM_FLANG_FRONTEND_COMPILERINSTANCE_H
 
+#include "mlir/IR/BuiltinOps.h"
 #include "flang/Frontend/CompilerInvocation.h"
 #include "flang/Frontend/FrontendAction.h"
 #include "flang/Frontend/PreprocessorOptions.h"
@@ -72,6 +73,10 @@ class CompilerInstance {
   /// facilitate this. It is optional and will normally be just a nullptr.
   std::unique_ptr<llvm::raw_pwrite_stream> outputStream_;
 
+  std::unique_ptr<mlir::MLIRContext> mlirCtx_;
+
+  std::unique_ptr<mlir::ModuleOp> mlirModule_;
+
 public:
   explicit CompilerInstance();
 
@@ -129,6 +134,22 @@ class CompilerInstance {
     semantics_ = std::move(semantics);
   }
 
+  /// }
+  /// @name MLIR
+  mlir::MLIRContext &mlirCtx() { return *mlirCtx_; }
+  const mlir::MLIRContext &mlirCtx() const { return *mlirCtx_; }
+
+  void setMlirCtx(std::unique_ptr<mlir::MLIRContext> mlirCtx) {
+    mlirCtx_ = std::move(mlirCtx);
+  }
+
+  mlir::ModuleOp &mlirModule() { return *mlirModule_; }
+  const mlir::ModuleOp &mlirModule() const { return *mlirModule_; }
+
+  void setMlirModule(std::unique_ptr<mlir::ModuleOp> module) {
+    mlirModule_ = std::move(module);
+  }
+
   /// }
   /// @name High-Level Operations
   /// {

flang/include/flang/Frontend/FrontendActions.h

@@ -159,6 +159,10 @@ class EmitMLIRAction : public CodeGenAction {
   void ExecuteAction() override;
 };
 
+class EmitLLVMAction : public CodeGenAction {
+  void ExecuteAction() override;
+};
+
 } // namespace Fortran::frontend
 
 #endif // LLVM_FLANG_FRONTEND_FRONTENDACTIONS_H

flang/include/flang/Frontend/FrontendOptions.h

@@ -34,6 +34,9 @@ enum ActionKind {
   /// Emit a .mlir file
   EmitMLIR,
 
+  /// Emit a .llvm file
+  EmitLLVM,
+
   /// Emit a .o file.
   EmitObj,
 

flang/include/flang/Tools/CLOptions.inc

@@ -9,6 +9,13 @@
 // This file defines some shared command-line options that can be used when
 // debugging the test tools. This file must be included into the tool.
 
+#include "flang/Optimizer/CodeGen/CodeGen.h"
+#include "flang/Optimizer/Transforms/Passes.h"
+#include "mlir/Conversion/SCFToStandard/SCFToStandard.h"
+#include "mlir/Pass/PassManager.h"
+#include "mlir/Transforms/Passes.h"
+#include "llvm/Support/CommandLine.h"
+
 #define DisableOption(DOName, DOOption, DODescription) \
   static llvm::cl::opt<bool> disable##DOName("disable-" DOOption, \
       llvm::cl::desc("disable " DODescription " pass"), llvm::cl::init(false), \
@@ -77,6 +84,35 @@ inline void addLLVMDialectToLLVMPass(
   addPassConditionally(pm, disableLlvmIrToLlvm,
       [&]() { return fir::createLLVMDialectToLLVMPass(output); });
 }
+
+/// Create a pass pipeline for lowering from MLIR to LLVM IR
+///
+/// \param pm - MLIR pass manager that will hold the pipeline definition
+inline void createMLIRToLLVMPassPipeline(mlir::PassManager &pm)
+{
+  // simplify the IR
+  fir::addCSE(pm);
+  pm.addNestedPass<mlir::FuncOp>(fir::createArrayValueCopyPass());
+  pm.addNestedPass<mlir::FuncOp>(fir::createCharacterConversionPass());
+  pm.addPass(mlir::createCanonicalizerPass());
+  fir::addCSE(pm);
+  pm.addPass(mlir::createInlinerPass());
+  pm.addPass(mlir::createCSEPass());
+
+  // convert control flow to CFG form
+  fir::addCfgConversionPass(pm);
+  pm.addNestedPass<mlir::FuncOp>(fir::createControlFlowLoweringPass());
+  pm.addPass(mlir::createLowerToCFGPass());
+
+  pm.addPass(mlir::createCanonicalizerPass());
+  fir::addCSE(pm);
+
+  pm.addNestedPass<mlir::FuncOp>(fir::createAbstractResultOptPass());
+  fir::addCodeGenRewritePass(pm);
+  fir::addTargetRewritePass(pm);
+  fir::addFIRToLLVMPass(pm);
+}
+
 #undef FLANG_EXCLUDE_CODEGEN
 #endif
 

flang/lib/Frontend/CMakeLists.txt

@@ -29,6 +29,11 @@ add_flang_library(flangFrontend
   FIRAnalysis
   FIRSupport
   FIRBuilder
+  FIRCodeGen
+  FIRTransforms
+  MLIRTransforms
+  MLIRLLVMToLLVMIRTranslation
+  MLIRSCFToStandard
   ${dialect_libs}
 
   LINK_COMPONENTS

flang/lib/Frontend/CompilerInvocation.cpp

@@ -126,6 +126,9 @@ static bool ParseFrontendArgs(FrontendOptions &opts, llvm::opt::ArgList &args,
     case clang::driver::options::OPT_emit_mlir:
       opts.programAction = EmitMLIR;
       break;
+    case clang::driver::options::OPT_emit_llvm:
+      opts.programAction = EmitLLVM;
+      break;
     case clang::driver::options::OPT_emit_obj:
       opts.programAction = EmitObj;
       break;

flang/lib/Frontend/FrontendActions.cpp

@@ -10,16 +10,21 @@
 #include "mlir/IR/Dialect.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Support/LogicalResult.h"
+#include "mlir/Target/LLVMIR/ModuleTranslation.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/CodeGen/CodeGen.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
+#include "flang/Optimizer/Support//Utils.h"
+#include "flang/Optimizer/Support/FIRContext.h"
 #include "flang/Optimizer/Support/InitFIR.h"
 #include "flang/Optimizer/Support/KindMapping.h"
+#include "flang/Optimizer/Transforms/Passes.h"
 #include "flang/Parser/dump-parse-tree.h"
 #include "flang/Parser/parsing.h"
 #include "flang/Parser/provenance.h"
@@ -32,7 +37,6 @@
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 #include <clang/Basic/Diagnostic.h>
-#include <memory>
 
 using namespace Fortran::frontend;
 
@@ -55,7 +59,45 @@ bool PrescanAndSemaDebugAction::BeginSourceFileAction() {
 }
 
 bool CodeGenAction::BeginSourceFileAction() {
-  return RunPrescan() & RunParse() && RunSemanticChecks();
+  bool res = RunPrescan() && RunParse() && RunSemanticChecks();
+  if (!res)
+    return res;
+
+  CompilerInstance &ci = this->instance();
+
+  // Load the MLIR dialects required by Flang
+  mlir::DialectRegistry registry;
+  ci.setMlirCtx(std::make_unique<mlir::MLIRContext>(registry));
+  fir::support::registerNonCodegenDialects(registry);
+  fir::support::loadNonCodegenDialects(ci.mlirCtx());
+
+  // Create a LoweringBridge
+  auto &defKinds = ci.invocation().semanticsContext().defaultKinds();
+  fir::KindMapping kindMap(&ci.mlirCtx(),
+      llvm::ArrayRef<fir::KindTy>{fir::fromDefaultKinds(defKinds)});
+  auto lb = Fortran::lower::LoweringBridge::create(ci.mlirCtx(), defKinds,
+      ci.invocation().semanticsContext().intrinsics(), ci.parsing().allCooked(),
+      "", kindMap);
+
+  // Create a parse tree and lower it to FIR
+  auto &parseTree{*ci.parsing().parseTree()};
+  lb.lower(parseTree, ci.invocation().semanticsContext());
+  ci.setMlirModule(std::make_unique<mlir::ModuleOp>(lb.getModule()));
+
+  // Run the default passes.
+  mlir::PassManager pm(&ci.mlirCtx(), mlir::OpPassManager::Nesting::Implicit);
+  pm.enableVerifier(/*verifyPasses=*/true);
+  pm.addPass(std::make_unique<Fortran::lower::VerifierPass>());
+
+  if (mlir::failed(pm.run(ci.mlirModule()))) {
+    unsigned diagID =
+        ci.diagnostics().getCustomDiagID(clang::DiagnosticsEngine::Error,
+            "verification of lowering to FIR failed");
+    ci.diagnostics().Report(diagID);
+    return false;
+  }
+
+  return true;
 }
 
 //===----------------------------------------------------------------------===//
@@ -369,61 +411,13 @@ void GetSymbolsSourcesAction::ExecuteAction() {
   ci.semantics().DumpSymbolsSources(llvm::outs());
 }
 
-// Translate front-end KINDs for use in the IR and code gen. Extracted from
-// bbc.cpp.
-static std::vector<fir::KindTy>
-fromDefaultKinds(const Fortran::common::IntrinsicTypeDefaultKinds &defKinds) {
-  return {static_cast<fir::KindTy>(defKinds.GetDefaultKind(
-              Fortran::common::TypeCategory::Character)),
-          static_cast<fir::KindTy>(
-              defKinds.GetDefaultKind(Fortran::common::TypeCategory::Complex)),
-          static_cast<fir::KindTy>(defKinds.doublePrecisionKind()),
-          static_cast<fir::KindTy>(
-              defKinds.GetDefaultKind(Fortran::common::TypeCategory::Integer)),
-          static_cast<fir::KindTy>(
-              defKinds.GetDefaultKind(Fortran::common::TypeCategory::Logical)),
-          static_cast<fir::KindTy>(
-              defKinds.GetDefaultKind(Fortran::common::TypeCategory::Real))};
-}
-
 void EmitMLIRAction::ExecuteAction() {
   CompilerInstance &ci = this->instance();
 
-  // Load the MLIR dialects required by Flang
-  mlir::DialectRegistry registry;
-  mlir::MLIRContext ctx(registry);
-  fir::support::registerNonCodegenDialects(registry);
-  fir::support::loadNonCodegenDialects(ctx);
-
-  // Create a LoweringBridge
-  auto &defKinds = ci.invocation().semanticsContext().defaultKinds();
-  fir::KindMapping kindMap(
-      &ctx, llvm::ArrayRef<fir::KindTy>{fromDefaultKinds(defKinds)});
-  auto lb = Fortran::lower::LoweringBridge::create(ctx, defKinds,
-      ci.invocation().semanticsContext().intrinsics(), ci.parsing().allCooked(),
-      "", kindMap);
-
-  // Create a parse tree and lower it to FIR
-  auto &parseTree{*ci.parsing().parseTree()};
-  lb.lower(parseTree, ci.invocation().semanticsContext());
-
-  // Run the default passes.
-  mlir::PassManager pm(&ctx, mlir::OpPassManager::Nesting::Implicit);
-  pm.enableVerifier(/*verifyPasses=*/true);
-  pm.addPass(std::make_unique<Fortran::lower::VerifierPass>());
-  mlir::ModuleOp mlirModule = lb.getModule();
-  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;
-  }
-
   // Print the output. If a pre-defined output stream exists, dump the MLIR
   // content there.
   if (!ci.IsOutputStreamNull()) {
-    mlirModule.print(ci.GetOutputStream());
+    ci.mlirModule().print(ci.GetOutputStream());
     return;
   }
 
@@ -437,7 +431,77 @@ void EmitMLIRAction::ExecuteAction() {
     return;
   }
 
-  mlirModule.print(*os);
+  ci.mlirModule().print(*os);
+}
+
+#include "flang/Tools/CLOptions.inc"
+
+void EmitLLVMAction::ExecuteAction() {
+  CompilerInstance &ci = this->instance();
+  auto mlirMod = ci.mlirModule();
+
+  auto &ctx = ci.mlirCtx();
+  fir::support::loadDialects(ctx);
+  fir::support::registerLLVMTranslation(ctx);
+
+  // Set-up the pass manager
+  fir::setTargetTriple(mlirMod, "native");
+  auto &defKinds = ci.invocation().semanticsContext().defaultKinds();
+  fir::KindMapping kindMap(&ci.mlirCtx(),
+      llvm::ArrayRef<fir::KindTy>{fir::fromDefaultKinds(defKinds)});
+  fir::setKindMapping(mlirMod, kindMap);
+  mlir::PassManager pm(&ci.mlirCtx(), mlir::OpPassManager::Nesting::Implicit);
+
+  pm.addPass(std::make_unique<Fortran::lower::VerifierPass>());
+  pm.enableVerifier(/*verifyPasses=*/true);
+  mlir::PassPipelineCLParser passPipeline("", "Compiler passes to run");
+
+  // Create the pass pipeline
+  fir::createMLIRToLLVMPassPipeline(pm);
+
+  // Run the pass manager
+  if (!mlir::succeeded(pm.run(mlirMod))) {
+    unsigned diagID = ci.diagnostics().getCustomDiagID(
+        clang::DiagnosticsEngine::Error, "Lowering to LLVM IR failed");
+    ci.diagnostics().Report(diagID);
+  }
+
+  // Translate to LLVM IR
+  auto optName = mlirMod.getName();
+  llvm::LLVMContext llvmCtx;
+  auto llvmModule = (mlir::translateModuleToLLVMIR(
+      mlirMod, llvmCtx, optName ? *optName : "FIRModule"));
+
+  if (!llvmModule) {
+    unsigned diagID = ci.diagnostics().getCustomDiagID(
+        clang::DiagnosticsEngine::Error, "failed to create the LLVM module");
+    ci.diagnostics().Report(diagID);
+    return;
+  }
+
+  // Print the generated LLVM IR. If there is no pre-defined output stream to
+  // print to, create an output file.
+  std::unique_ptr<llvm::raw_ostream> os;
+  if (ci.IsOutputStreamNull()) {
+    // Lower from the LLVM dialect to LLVM IR
+    os = ci.CreateDefaultOutputFile(
+        /*Binary=*/true, /*InFile=*/GetCurrentFileOrBufferName(), "ll");
+    if (!os) {
+      unsigned diagID = ci.diagnostics().getCustomDiagID(
+          clang::DiagnosticsEngine::Error, "failed to create the output file");
+      ci.diagnostics().Report(diagID);
+      return;
+    }
+  }
+
+  if (!ci.IsOutputStreamNull()) {
+    llvmModule->print(
+        ci.GetOutputStream(), /*AssemblyAnnotationWriter=*/nullptr);
+  } else {
+    llvmModule->print(*os, /*AssemblyAnnotationWriter=*/nullptr);
+  }
+
+  return;
 }
 
 void EmitObjAction::ExecuteAction() {

flang/lib/FrontendTool/ExecuteCompilerInvocation.cpp

@@ -35,6 +35,8 @@ static std::unique_ptr<FrontendAction> CreateFrontendBaseAction(
     return std::make_unique<ParseSyntaxOnlyAction>();
   case EmitMLIR:
     return std::make_unique<EmitMLIRAction>();
+  case EmitLLVM:
+    return std::make_unique<EmitLLVMAction>();
   case EmitObj:
     return std::make_unique<EmitObjAction>();
   case DebugUnparse:

flang/test/Driver/driver-help.f90

@@ -65,6 +65,7 @@
 ! 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-llvm             Use the LLVM representation for assembler and object files
 ! HELP-FC1-NEXT: -emit-mlir             Build the parse tree, then lower it to MLIR and dump
 ! HELP-FC1-NEXT: -emit-obj Emit native object files
 ! HELP-FC1-NEXT: -E                     Only run the preprocessor