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

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.

Differential Revision: https://reviews.llvm.org/D124665

Author: banach-space

flang/include/flang/Frontend/FrontendActions.h

@@ -16,6 +16,7 @@
 #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 {
@@ -170,17 +171,33 @@ class DebugDumpAllAction : public PrescanAndSemaDebugAction {
 //===----------------------------------------------------------------------===//
 // 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;
@@ -194,34 +211,38 @@ class CodeGenAction : public FrontendAction {
   /// 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
-  };
-
-  BackendAction(BackendActionTy act) : action{act} {};
-
-private:
-  void ExecuteAction() override;
+  EmitObjAction() : CodeGenAction(BackendActionTy::Backend_EmitObj) {}
+};
 
-  BackendActionTy action;
+class EmitAssemblyAction : public CodeGenAction {
+public:
+  EmitAssemblyAction() : CodeGenAction(BackendActionTy::Backend_EmitAssembly) {}
 };
 
 } // namespace Fortran::frontend