[flang][driver] Re-organise the code-gen actions (nfc)

[awarzynski]

Summary

All frontend actions that generate code (MLIR, LLVM IR/BC,
Assembly/Object Code) are re-factored as essentially one action,
CodeGenAction, with minor specialisations. To facilate all this,
CodeGenAction is extended to hold TargetMachine and backend action
type (MLIR vs LLVM IR vs LLVM BC vs Assembly vs Object Code).

CodeGenAction is no longer a pure abstract class and the
corresponding ExecuteAction is implemented so that it covers all use
cases. All this allows a much better code re-use.

Key functionality is extracted into some helpful hooks:

• SetUpTargetMachine
• GetOutputStream
• EmitObjectCodeHelper
• EmitBCHelper

I hope that this clarifies the overall structure. I suspect that we may
need to revisit this again as the functionality grows in complexity.

Depends on D124664

[awarzynski]

@rovka That's a bit "bolder" change compared to what you suggested in https://reviews.llvm.org/D123211. WDYT?

[unterumarmung]

I have only nits and questions about the patch:

flang/include/flang/Frontend/FrontendActions.h

175–179

Do we really need Backend_ prefix here? Seems obsolete.

flang/lib/Frontend/FrontendActions.cpp

419

Why not to define the destructor in the header?

517–540

I'd suggest to unify variable names in the function

539

I'm not quite familiar with legacy pass manager, so I have a question: will CodeGenPasses delete the pass that created here?

[awarzynski]

@unterumarmung , thanks for taking a look!

flang/include/flang/Frontend/FrontendActions.h

175–179

Naming is hard :)

1. Consistency with Clang means that navigation will be easier for people familiar with it. It also means that design-wise the drivers are similar.
2. These actions use either LLVM or MLIR to run the final phase of code-gen/lowering. From the point of view of Flang, LLVM and MLIR are backends for the Flang Fortran frontend. So, these actions are "backend" actions.

Also, note that e.g. EmitObj is also defined in FrontendOptions.h. It's a completely different enum (so technically there would be no name clash), but wouldn't unique names be a bit less ambiguous?

flang/lib/Frontend/FrontendActions.cpp

419

Good question!

When you define a destructor for CodeGenAction in the header file, it will be available in every translation unit that includes that header, e.g. ExecuteCompilerInvocation.cpp. This would mean that the corresponding symbol would be defined in the flangFrontendTool library. However, that's not desirable.

The destructor for CodeGenAction needs to know how to destroy its member variables, e.g.llvm::TargetMachine. So, it depends on the library that defines the corresponding destructor. But flangFrontendTool is meant as a lightweight utility lib. It should only depend on flangFrontend (which defines CodeGenAction) and be oblivious to its implementation details.

That's a lot of text for one line of code! Does it make sense?

517–540

Sadly, the coding style in the driver is a bit of a mix.

We started with Flang's C++ style as that was the only style that was in use in LLVM Flang back then. However, lowering and code-gen that was introduced later uses the MLIR style (from Allocatable.cpp):

// Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/

As the driver also depends on Clang and uses various LLVM libs (e.g. for machine code generation), it in fact mixes 3 different styles. Not ideal and a ton of confusing - most/all of my own making!

I like your suggestion, but I'd prefer to address it in a separate patch. In fact, I intend to suggest refactoring the driver to use the MLIR style soon (probably this week). This should fix the consistency in other places too. Would that be OK with you?

539

I don't consider an expert myself :)

Sadly, there's not a single hint in the method declaration. However, there are multiple deletes in LegacyPassManager.cpp. That's a good sign!

I am also assuming that Clang would definitely be doing the right thing: CodeGenPasses.add. llc and opt do the same, see here and here. So based on that, I assume that this is OK.

[rovka]

flang/include/flang/Frontend/FrontendActions.h

175–179

Actually, since this isn't part of a class, I think the coding style says we should use something like CGAT_EmitBlah (although CG_EmitBlah might also be ok). I don't feel strongly either way, so use whatever names you prefer :)

flang/lib/Frontend/FrontendActions.cpp

511–533

Nit: ObjectCode makes me think more about bc and object files than about assembly and object files (I'm not sure MachineCode is much better, since assembly is not technically machine code, but I'm looking for something that suggests that we're running the actual backend passes and generating some kind of machine/target-specific representation).

Also a small comment saying that it only works for Backend_EmitAssembly and Backend_EmitObj would be nice (or better yet, start the body with an assert about that).

556–569

631

Nit: I would move this above the other if, so it's closer to the EmitLL handling.

[unterumarmung]

flang/include/flang/Frontend/FrontendActions.h

175–179

@awarzynski, thank you for the explanation! I agree with the chosen naming now.

flang/lib/Frontend/FrontendActions.cpp

419

Sure it does! Thank you for the explanation

517–540

Sure!

539

Seems reasonable!

[awarzynski]

flang/include/flang/Frontend/FrontendActions.h

175–179

Actually, since this isn't part of a class, I think the coding style says we should use something like CGAT_EmitBlah (although CG_EmitBlah might also be ok). I don't feel strongly either way, so use whatever names you prefer :)

Glad to see that at least one of us _actually_ read the coding style guideline :)

This clearly needs updating then. I will try BackendActionTy for the enum and then the actual fields can be kept intact. Unless I misunderstood the guideline 🤔 . WDTY?

flang/lib/Frontend/FrontendActions.cpp

511–533

Good points!

I feel that GenerateMachineCode would be a bit too similar to GenerateLLVMIR. But that is a member method that will change the internal state of the corresponding FrontendAction (it sets CodeGenAction::llvmModule). This is a free function though. Let me try GenerateMachineCodeOrAssemblyImpl instead - this way we also make sure that machine-code vs assembly distinction is addressed.

Also a small comment saying that it only works for Backend_EmitAssembly and Backend_EmitObj would be nice (or better yet, start the body with an assert about that).

Will add a comment, an assert and rename to make this limitation clear :)

556–569

Let me try GenerateLLVMBCImpl instead, just to differentiate this a bit from GenerateLLVMIR (see my earlier comment). WDYT?

631

Good point, moved!

[awarzynski]

Address comments from Diana

Moved some code around, simplified a bit, added comments, renamed CodeGenActionTy as BackendActionTy.

[awarzynski]

Rebase on top of main

[rovka]

Just one microscopic issue, otherwise looks great, thanks!

flang/lib/Frontend/FrontendActions.cpp

525

Nit: && "" ? :) Are you going to put a message there? If not you can just remove that part.

[awarzynski]

flang/lib/Frontend/FrontendActions.cpp

525

I swear there used to be some very useful message there before 🤔 :)

Good catch, will update before merging!

flang/include/flang/Frontend/FrontendActions.h

 
 #include "flang/Frontend/FrontendAction.h"
 #include "flang/Parser/parsing.h"
 #include "flang/Semantics/semantics.h"
 
 #include "mlir/IR/BuiltinOps.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/IR/Module.h"
+#include "llvm/Target/TargetMachine.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; }

 
 class DebugDumpAllAction : public PrescanAndSemaDebugAction {
   void ExecuteAction() override;
 };
 
 //===----------------------------------------------------------------------===//
 // CodeGen Actions
 //===----------------------------------------------------------------------===//
+/// Represents the type of "backend" action to perform by the corresponding
+/// CodeGenAction. Note that from Flang's perspective, both LLVM and MLIR are
+/// "backends" that are used for generating LLVM IR/BC, assembly files or
+/// machine code. This enum captures "what" exactly one of these backends is to
+/// do. The names are similar to what is used in Clang - this allows us to
+/// maintain some level of consistency/similarity between the drivers.
+enum class BackendActionTy {
+  Backend_EmitAssembly, ///< Emit native assembly files
+  Backend_EmitObj, ///< Emit native object files
+  Backend_EmitBC, ///< Emit LLVM bitcode files
+  Backend_EmitLL, ///< Emit human-readable LLVM assembly
+  Backend_EmitMLIR ///< Emit MLIR files
+};
+
 /// 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;
+  void ExecuteAction() override;
   /// Runs prescan, parsing, sema and lowers to MLIR.
   bool BeginSourceFileAction() override;
+  void SetUpTargetMachine();
 
 protected:
+  CodeGenAction(BackendActionTy act) : action{act} {};
   /// @name MLIR
   /// {
   std::unique_ptr<mlir::ModuleOp> mlirModule;
   std::unique_ptr<mlir::MLIRContext> mlirCtx;
   /// }
 
   /// @name LLVM IR
   std::unique_ptr<llvm::LLVMContext> llvmCtx;
   std::unique_ptr<llvm::Module> llvmModule;
 
   /// Generates an LLVM IR module from CodeGenAction::mlirModule and saves it
   /// in CodeGenAction::llvmModule.
   void GenerateLLVMIR();
+
+  BackendActionTy action;
+
+  std::unique_ptr<llvm::TargetMachine> TM;
   /// }
+public:
+  ~CodeGenAction() override;
 };
 
 class EmitMLIRAction : public CodeGenAction {
-  void ExecuteAction() override;
+public:
+  EmitMLIRAction() : CodeGenAction(BackendActionTy::Backend_EmitMLIR) {}
 };
 
 class EmitLLVMAction : public CodeGenAction {
-  void ExecuteAction() override;
+public:
+  EmitLLVMAction() : CodeGenAction(BackendActionTy::Backend_EmitLL) {}
 };
 
 class EmitLLVMBitcodeAction : public CodeGenAction {
-  void ExecuteAction() override;
+public:
+  EmitLLVMBitcodeAction() : CodeGenAction(BackendActionTy::Backend_EmitBC) {}
 };
 
-class BackendAction : public CodeGenAction {
+class EmitObjAction : public CodeGenAction {
 public:
-  enum class BackendActionTy {
-    Backend_EmitAssembly, ///< Emit native assembly files
-    Backend_EmitObj ///< Emit native object files
-  };
+  EmitObjAction() : CodeGenAction(BackendActionTy::Backend_EmitObj) {}
 
-  BackendAction(BackendActionTy act) : action{act} {};
-
-private:
-  void ExecuteAction() override;
-
-  BackendActionTy action;
+class EmitAssemblyAction : public CodeGenAction {
+public:
+  EmitAssemblyAction() : CodeGenAction(BackendActionTy::Backend_EmitAssembly) {}
 };
 
 } // namespace Fortran::frontend
 
 #endif // LLVM_FLANG_FRONTEND_FRONTENDACTIONS_H

flang/lib/Frontend/FrontendActions.cpp

 #include "mlir/Pass/PassManager.h"
 #include "mlir/Target/LLVMIR/ModuleTranslation.h"
 #include "clang/Basic/DiagnosticFrontend.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/Bitcode/BitcodeWriterPass.h"
 #include "llvm/IR/LegacyPassManager.h"
+#include "llvm/IRReader/IRReader.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Passes/PassBuilder.h"
 #include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/SourceMgr.h"
 #include "llvm/Target/TargetMachine.h"
 #include <clang/Basic/Diagnostic.h>
 #include <memory>
 
 using namespace Fortran::frontend;
 
 //===----------------------------------------------------------------------===//
 // Custom BeginSourceFileAction
 //===----------------------------------------------------------------------===//
+
 bool PrescanAction::BeginSourceFileAction() { return RunPrescan(); }
 
 bool PrescanAndParseAction::BeginSourceFileAction() {
   return RunPrescan() && RunParse();
 }
 
 bool PrescanAndSemaAction::BeginSourceFileAction() {
   return RunPrescan() && RunParse() && RunSemanticChecks() &&
void GetSymbolsSourcesAction::ExecuteAction() {
   // Report and exit if fatal semantic errors are present
   if (reportFatalSemanticErrors()) {
     return;
   }
 
   ci.semantics().DumpSymbolsSources(llvm::outs());
 }
 
+//===----------------------------------------------------------------------===//
+// CodeGenActions
+//===----------------------------------------------------------------------===//
+
+CodeGenAction::~CodeGenAction() = default;
+
 #include "flang/Tools/CLOptions.inc"
 
 // Lower the previously generated MLIR module into an LLVM IR module
 void CodeGenAction::GenerateLLVMIR() {
   assert(mlirModule && "The MLIR module has not been generated yet.");
 
   CompilerInstance &ci = this->instance();
 
void CodeGenAction::GenerateLLVMIR() {
   if (!llvmModule) {
     unsigned diagID = ci.diagnostics().getCustomDiagID(
         clang::DiagnosticsEngine::Error, "failed to create the LLVM module");
     ci.diagnostics().Report(diagID);
     return;
   }
 }
 
-void EmitLLVMAction::ExecuteAction() {
-  CompilerInstance &ci = this->instance();
-  GenerateLLVMIR();
-
-  // If set, use the predefined outupt stream to print the generated module.
-  if (!ci.IsOutputStreamNull()) {
-    llvmModule->print(
-        ci.GetOutputStream(), /*AssemblyAnnotationWriter=*/nullptr);
-    return;
-  }
-
-  // No predefined output stream was set. Create an output file and dump the
-  // generated module there.
-  std::unique_ptr<llvm::raw_ostream> os = ci.CreateDefaultOutputFile(
-      /*Binary=*/false, /*InFile=*/GetCurrentFileOrBufferName(), "ll");
-  if (!os) {
-    unsigned diagID = ci.diagnostics().getCustomDiagID(
-        clang::DiagnosticsEngine::Error, "failed to create the output file");
-    ci.diagnostics().Report(diagID);
-    return;
-  }
-  llvmModule->print(*os, /*AssemblyAnnotationWriter=*/nullptr);
-}
-
-void EmitLLVMBitcodeAction::ExecuteAction() {
+void CodeGenAction::SetUpTargetMachine() {
   CompilerInstance &ci = this->instance();
-  // Generate an LLVM module if it's not already present (it will already be
-  // present if the input file is an LLVM IR/BC file).
-  if (!llvmModule)
-    GenerateLLVMIR();
 
   // Set the triple based on the CompilerInvocation set-up
   const std::string &theTriple = ci.invocation().targetOpts().triple;
   if (llvmModule->getTargetTriple() != theTriple) {
     ci.diagnostics().Report(clang::diag::warn_fe_override_module) << theTriple;
     llvmModule->setTargetTriple(theTriple);
   }
 
   // Create `Target`
   std::string error;
   const llvm::Target *theTarget =
       llvm::TargetRegistry::lookupTarget(theTriple, error);
   assert(theTarget && "Failed to create Target");
 
-  // Create and configure `TargetMachine`
-  std::unique_ptr<llvm::TargetMachine> TM(
-      theTarget->createTargetMachine(theTriple, /*CPU=*/"",
-          /*Features=*/"", llvm::TargetOptions(), llvm::None));
+  // Create `TargetMachine`
+  TM.reset(theTarget->createTargetMachine(theTriple, /*CPU=*/"",
+                                          /*Features=*/"",
+                                          llvm::TargetOptions(), llvm::None));
   assert(TM && "Failed to create TargetMachine");
   llvmModule->setDataLayout(TM->createDataLayout());
-
-  // Generate an output file
-  std::unique_ptr<llvm::raw_ostream> os = ci.CreateDefaultOutputFile(
-      /*Binary=*/true, /*InFile=*/GetCurrentFileOrBufferName(), "bc");
-  if (!os) {
-    unsigned diagID = ci.diagnostics().getCustomDiagID(
-        clang::DiagnosticsEngine::Error, "failed to create the output file");
-    ci.diagnostics().Report(diagID);
-    return;
-  }
 
-  // Set-up the pass manager
-  llvm::ModulePassManager MPM;
-  llvm::ModuleAnalysisManager MAM;
-  llvm::PassBuilder PB(TM.get());
-  PB.registerModuleAnalyses(MAM);
-  MPM.addPass(llvm::BitcodeWriterPass(*os));
+static std::unique_ptr<llvm::raw_pwrite_stream>
+GetOutputStream(CompilerInstance &ci, llvm::StringRef inFile,
+                BackendActionTy action) {
+  switch (action) {
+  case BackendActionTy::Backend_EmitAssembly:
+    return ci.CreateDefaultOutputFile(
+        /*Binary=*/false, inFile, /*extension=*/"s");
+  case BackendActionTy::Backend_EmitLL:
+    return ci.CreateDefaultOutputFile(
+        /*Binary=*/false, inFile, /*extension=*/"ll");
+  case BackendActionTy::Backend_EmitMLIR:
+    return ci.CreateDefaultOutputFile(
+        /*Binary=*/false, inFile, /*extension=*/"mlir");
+  case BackendActionTy::Backend_EmitBC:
+    return ci.CreateDefaultOutputFile(
+        /*Binary=*/true, inFile, /*extension=*/"bc");
+  case BackendActionTy::Backend_EmitObj:
+    return ci.CreateDefaultOutputFile(
+        /*Binary=*/true, inFile, /*extension=*/"o");
+  }
 
-  // Run the passes
-  MPM.run(*llvmModule, MAM);
+  llvm_unreachable("Invalid action!");
 }
 
-void EmitMLIRAction::ExecuteAction() {
-  CompilerInstance &ci = this->instance();
+/// Generate target-specific machine-code or assembly file from the input LLVM
+/// module.
+///
+/// \param [in] diags Diagnostics engine for reporting errors
+/// \param [in] TM Target machine to aid the code-gen pipeline set-up
+/// \param [in] act Backend act to run (assembly vs machine-code generation)
+/// \param [in] llvmModule LLVM module to lower to assembly/machine-code
+/// \param [out] os Output stream to emit the generated code to
+static void GenerateMachineCodeOrAssemblyImpl(clang::DiagnosticsEngine &diags,
+                                              llvm::TargetMachine &TM,
+                                              BackendActionTy act,
+                                              llvm::Module &llvmModule,
+                                              llvm::raw_pwrite_stream &os) {
+  assert((act == BackendActionTy::Backend_EmitObj) ||
+         (act == BackendActionTy::Backend_EmitAssembly) &&
+             "Unsupported action");
 
-  // Print the output. If a pre-defined output stream exists, dump the MLIR
-  // content there.
-  if (!ci.IsOutputStreamNull()) {
-    mlirModule->print(ci.GetOutputStream());
-    return;
-  }
+  // Set-up the pass manager, i.e create an LLVM code-gen pass pipeline.
+  // Currently only the legacy pass manager is supported.
+  // TODO: Switch to the new PM once it's available in the backend.
+  llvm::legacy::PassManager CodeGenPasses;
+  CodeGenPasses.add(
+      createTargetTransformInfoWrapperPass(TM.getTargetIRAnalysis()));
 
-  // ... 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);
+  llvm::Triple triple(llvmModule.getTargetTriple());
+  std::unique_ptr<llvm::TargetLibraryInfoImpl> TLII =
+      std::make_unique<llvm::TargetLibraryInfoImpl>(triple);
+  assert(TLII && "Failed to create TargetLibraryInfo");
+  CodeGenPasses.add(new llvm::TargetLibraryInfoWrapperPass(*TLII));
+
+  llvm::CodeGenFileType cgft = (act == BackendActionTy::Backend_EmitAssembly)
+                                   ? llvm::CodeGenFileType::CGFT_AssemblyFile
+                                   : llvm::CodeGenFileType::CGFT_ObjectFile;
+  if (TM.addPassesToEmitFile(CodeGenPasses, os, nullptr, cgft)) {
+    unsigned diagID =
+        diags.getCustomDiagID(clang::DiagnosticsEngine::Error,
+                              "emission of this file type is not supported");
+    diags.Report(diagID);
     return;
   }
 
-  mlirModule->print(*os);
+  // Run the passes
+  CodeGenPasses.run(llvmModule);
 }
 
-void BackendAction::ExecuteAction() {
-  CompilerInstance &ci = this->instance();
-  // Generate an LLVM module if it's not already present (it will already be
-  // present if the input file is an LLVM IR/BC file).
-  if (!llvmModule)
-    GenerateLLVMIR();
+/// Generate LLVM byte code file from the input LLVM module.
+///
+/// \param [in] TM Target machine to aid the code-gen pipeline set-up
+/// \param [in] llvmModule LLVM module to lower to assembly/machine-code
+/// \param [out] os Output stream to emit the generated code to
+static void GenerateLLVMBCImpl(llvm::TargetMachine &TM,
+                               llvm::Module &llvmModule,
+                               llvm::raw_pwrite_stream &os) {
+  // Set-up the pass manager
+  llvm::ModulePassManager MPM;
+  llvm::ModuleAnalysisManager MAM;
+  llvm::PassBuilder PB(&TM);
+  PB.registerModuleAnalyses(MAM);
+  MPM.addPass(llvm::BitcodeWriterPass(os));
 
-  // Set the triple based on the CompilerInvocation set-up
-  const std::string &theTriple = ci.invocation().targetOpts().triple;
-  if (llvmModule->getTargetTriple() != theTriple) {
-    ci.diagnostics().Report(clang::diag::warn_fe_override_module) << theTriple;
-    llvmModule->setTargetTriple(theTriple);
-  }
+  // Run the passes
+  MPM.run(llvmModule, MAM);
 
-  // Create `Target`
-  std::string error;
-  const llvm::Target *theTarget =
-      llvm::TargetRegistry::lookupTarget(theTriple, error);
-  assert(theTarget && "Failed to create Target");
-
-  // Create `TargetMachine`
-  std::unique_ptr<llvm::TargetMachine> TM(
-      theTarget->createTargetMachine(theTriple, /*CPU=*/"",
-          /*Features=*/"", llvm::TargetOptions(), llvm::None));
-  assert(TM && "Failed to create TargetMachine");
-  llvmModule->setDataLayout(TM->createDataLayout());
+void CodeGenAction::ExecuteAction() {
+  CompilerInstance &ci = this->instance();
 
   // If the output stream is a file, generate it and define the corresponding
   // output stream. If a pre-defined output stream is available, we will use
   // that instead.
   //
   // NOTE: `os` is a smart pointer that will be destroyed at the end of this
   // method. However, it won't be written to until `CodeGenPasses` is
   // destroyed. By defining `os` before `CodeGenPasses`, we make sure that the
   // output stream won't be destroyed before it is written to. This only
   // applies when an output file is used (i.e. there is no pre-defined output
   // stream).
   // TODO: Revisit once the new PM is ready (i.e. when `CodeGenPasses` is
   // updated to use it).
   std::unique_ptr<llvm::raw_pwrite_stream> os;
   if (ci.IsOutputStreamNull()) {
-    // Get the output buffer/file
-    switch (action) {
-    case BackendActionTy::Backend_EmitAssembly:
-      os = ci.CreateDefaultOutputFile(
-          /*Binary=*/false, /*InFile=*/GetCurrentFileOrBufferName(), "s");
-      break;
-    case BackendActionTy::Backend_EmitObj:
-      os = ci.CreateDefaultOutputFile(
-          /*Binary=*/true, /*InFile=*/GetCurrentFileOrBufferName(), "o");
-      break;
-    }
+    os = GetOutputStream(ci, GetCurrentFileOrBufferName(), action);
+
     if (!os) {
       unsigned diagID = ci.diagnostics().getCustomDiagID(
           clang::DiagnosticsEngine::Error, "failed to create the output file");
       ci.diagnostics().Report(diagID);
       return;
     }
   }
 
-  // Create an LLVM code-gen pass pipeline. Currently only the legacy pass
-  // manager is supported.
-  // TODO: Switch to the new PM once it's available in the backend.
-  llvm::legacy::PassManager CodeGenPasses;
-  CodeGenPasses.add(
-      createTargetTransformInfoWrapperPass(TM->getTargetIRAnalysis()));
-  llvm::Triple triple(theTriple);
+  if (action == BackendActionTy::Backend_EmitMLIR) {
+    mlirModule->print(ci.IsOutputStreamNull() ? *os : ci.GetOutputStream());
+    return;
+  }
 
-  std::unique_ptr<llvm::TargetLibraryInfoImpl> TLII =
-      std::make_unique<llvm::TargetLibraryInfoImpl>(triple);
-  assert(TLII && "Failed to create TargetLibraryInfo");
-  CodeGenPasses.add(new llvm::TargetLibraryInfoWrapperPass(*TLII));
+  // Generate an LLVM module if it's not already present (it will already be
+  // present if the input file is an LLVM IR/BC file).
+  if (!llvmModule)
+    GenerateLLVMIR();
 
-  llvm::CodeGenFileType cgft = (action == BackendActionTy::Backend_EmitAssembly)
-      ? llvm::CodeGenFileType::CGFT_AssemblyFile
-      : llvm::CodeGenFileType::CGFT_ObjectFile;
-  if (TM->addPassesToEmitFile(CodeGenPasses,
-          ci.IsOutputStreamNull() ? *os : ci.GetOutputStream(), nullptr,
-          cgft)) {
-    unsigned diagID =
-        ci.diagnostics().getCustomDiagID(clang::DiagnosticsEngine::Error,
-            "emission of this file type is not supported");
-    ci.diagnostics().Report(diagID);
+  if (action == BackendActionTy::Backend_EmitLL) {
+    llvmModule->print(ci.IsOutputStreamNull() ? *os : ci.GetOutputStream(),
+                      /*AssemblyAnnotationWriter=*/nullptr);
     return;
   }
 
-  // Run the code-gen passes
-  CodeGenPasses.run(*llvmModule);
+  SetUpTargetMachine();
+  if (action == BackendActionTy::Backend_EmitBC) {
+    GenerateLLVMBCImpl(*TM, *llvmModule, *os);
+    return;
+  }
+
+  if (action == BackendActionTy::Backend_EmitAssembly ||
+      action == BackendActionTy::Backend_EmitObj) {
+    GenerateMachineCodeOrAssemblyImpl(
+        ci.diagnostics(), *TM, action, *llvmModule,
+        ci.IsOutputStreamNull() ? *os : ci.GetOutputStream());
+    return;
+  }
 }
 
 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);
 }

flang/lib/FrontendTool/ExecuteCompilerInvocation.cpp

case ParseSyntaxOnly:
     return std::make_unique<ParseSyntaxOnlyAction>();
   case EmitMLIR:
     return std::make_unique<EmitMLIRAction>();
   case EmitLLVM:
     return std::make_unique<EmitLLVMAction>();
   case EmitLLVMBitcode:
     return std::make_unique<EmitLLVMBitcodeAction>();
   case EmitObj:
-    return std::make_unique<BackendAction>(
-        BackendAction::BackendActionTy::Backend_EmitObj);
+    return std::make_unique<EmitObjAction>();
   case EmitAssembly:
-    return std::make_unique<BackendAction>(
-        BackendAction::BackendActionTy::Backend_EmitAssembly);
+    return std::make_unique<EmitAssemblyAction>();
   case DebugUnparse:
     return std::make_unique<DebugUnparseAction>();
   case DebugUnparseNoSema:
     return std::make_unique<DebugUnparseNoSemaAction>();
   case DebugUnparseWithSymbols:
     return std::make_unique<DebugUnparseWithSymbolsAction>();
   case DebugDumpSymbols:
     return std::make_unique<DebugDumpSymbolsAction>();