Moved the MC emission APIs to TargetMachine again to keep the PR changes to a minimum.

Author: matinraayai

clang/lib/CodeGen/BackendUtil.cpp

@@ -225,7 +225,7 @@ class EmitAssemblyHelper {
       BuryPointer(std::move(TM));
   }
 
-  std::unique_ptr<LLVMTargetMachine> TM;
+  std::unique_ptr<TargetMachine> TM;
 
   // Emit output using the new pass manager for the optimization pipeline.
   void EmitAssembly(BackendAction Action, std::unique_ptr<raw_pwrite_stream> OS,
@@ -609,8 +609,8 @@ void EmitAssemblyHelper::CreateTargetMachine(bool MustCreateTM) {
   if (!initTargetOptions(Diags, Options, CodeGenOpts, TargetOpts, LangOpts,
                          HSOpts))
     return;
-  TM.reset(static_cast<LLVMTargetMachine *>(TheTarget->createTargetMachine(
-      Triple, TargetOpts.CPU, FeaturesStr, Options, RM, CM, OptLevel)));
+  TM.reset(TheTarget->createTargetMachine(Triple, TargetOpts.CPU, FeaturesStr,
+                                          Options, RM, CM, OptLevel));
   TM->setLargeDataThreshold(CodeGenOpts.LargeDataThreshold);
 }
 
@@ -1179,7 +1179,8 @@ void EmitAssemblyHelper::RunCodegenPipeline(
       if (!DwoOS)
         return;
     }
-    MMI = std::make_unique<MachineModuleInfo>(TM.get());
+    MMI = std::make_unique<MachineModuleInfo>(
+        static_cast<LLVMTargetMachine *>(TM.get()));
     if (!AddEmitPasses(CodeGenPasses, *MMI, Action, *OS,
                        DwoOS ? &DwoOS->os() : nullptr))
       // FIXME: Should we handle this error differently?

flang/lib/Frontend/FrontendActions.cpp

@@ -920,7 +920,7 @@ getOutputStream(CompilerInstance &ci, llvm::StringRef inFile,
 /// \param [in] codeGenOpts options configuring codegen pipeline
 /// \param [out] os Output stream to emit the generated code to
 static void generateMachineCodeOrAssemblyImpl(clang::DiagnosticsEngine &diags,
-                                              llvm::LLVMTargetMachine &tm,
+                                              llvm::TargetMachine &tm,
                                               BackendActionTy act,
                                               llvm::Module &llvmModule,
                                               const CodeGenOptions &codeGenOpts,
@@ -933,7 +933,7 @@ static void generateMachineCodeOrAssemblyImpl(clang::DiagnosticsEngine &diags,
   // 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;
-  llvm::MachineModuleInfo mmi(&tm);
+  llvm::MachineModuleInfo mmi(static_cast<llvm::LLVMTargetMachine *>(&tm));
   codeGenPasses.add(
       createTargetTransformInfoWrapperPass(tm.getTargetIRAnalysis()));
 
@@ -1371,8 +1371,7 @@ void CodeGenAction::executeAction() {
   if (action == BackendActionTy::Backend_EmitAssembly ||
       action == BackendActionTy::Backend_EmitObj) {
     generateMachineCodeOrAssemblyImpl(
-        diags, *static_cast<llvm::LLVMTargetMachine *>(&targetMachine), action,
-        *llvmModule, codeGenOpts,
+        diags, targetMachine, action, *llvmModule, codeGenOpts,
         ci.isOutputStreamNull() ? *os : ci.getOutputStream());
     return;
   }

llvm/include/llvm/Target/TargetMachine.h

@@ -375,6 +375,25 @@ class TargetMachine {
   /// with the new pass manager. Only affects the "default" AAManager.
   virtual void registerDefaultAliasAnalyses(AAManager &) {}
 
+  /// Add passes to the specified pass manager to get the specified file
+  /// emitted. Typically this will involve several steps of code generation.
+  /// This method should return true if emission of this file type is not
+  /// supported, or false on success.
+  virtual bool addPassesToEmitFile(PassManagerBase &, MachineModuleInfo &,
+                                   raw_pwrite_stream &, raw_pwrite_stream *,
+                                   CodeGenFileType,
+                                   bool /*DisableVerify*/ = true) {
+    return true;
+  }
+
+  /// Add passes to the specified pass manager to get machine code emitted with
+  /// the MCJIT. This method returns true if machine code is not supported.
+  virtual bool addPassesToEmitMC(PassManagerBase &, MachineModuleInfo &,
+                                 raw_pwrite_stream &,
+                                 bool /*DisableVerify*/ = true) {
+    return true;
+  }
+
   /// True if subtarget inserts the final scheduling pass on its own.
   ///
   /// Branch relaxation, which must happen after block placement, can
@@ -438,11 +457,10 @@ class LLVMTargetMachine : public TargetMachine {
   /// emitted. Typically this will involve several steps of code generation.
   /// This method should return true if emission of this file type is not
   /// supported, or false on success.
-  virtual bool addPassesToEmitFile(PassManagerBase &PM, MachineModuleInfo &MMI,
-                                   raw_pwrite_stream &Out,
-                                   raw_pwrite_stream *DwoOut,
-                                   CodeGenFileType FileType,
-                                   bool DisableVerify = true);
+  bool addPassesToEmitFile(PassManagerBase &PM, MachineModuleInfo &MMI,
+                           raw_pwrite_stream &Out, raw_pwrite_stream *DwoOut,
+                           CodeGenFileType FileType,
+                           bool DisableVerify = true) override;
 
   virtual Error buildCodeGenPipeline(ModulePassManager &, raw_pwrite_stream &,
                                      raw_pwrite_stream *, CodeGenFileType,
@@ -454,9 +472,9 @@ class LLVMTargetMachine : public TargetMachine {
 
   /// Add passes to the specified pass manager to get machine code emitted with
   /// the MCJIT. This method returns true if machine code is not supported.
-  virtual bool addPassesToEmitMC(PassManagerBase &PM, MachineModuleInfo &MMI,
-                                 raw_pwrite_stream &Out,
-                                 bool DisableVerify = true);
+  bool addPassesToEmitMC(PassManagerBase &PM, MachineModuleInfo &MMI,
+                         raw_pwrite_stream &Out,
+                         bool DisableVerify = true) override;
 
   /// Returns true if the target is expected to pass all machine verifier
   /// checks. This is a stopgap measure to fix targets one by one. We will

llvm/lib/ExecutionEngine/Orc/CompileUtils.cpp

@@ -47,9 +47,8 @@ Expected<SimpleCompiler::CompileResult> SimpleCompiler::operator()(Module &M) {
     raw_svector_ostream ObjStream(ObjBufferSV);
 
     legacy::PassManager PM;
-    auto *LLVMTM = static_cast<LLVMTargetMachine *>(&TM);
-    MachineModuleInfo MMI(LLVMTM);
-    if (LLVMTM->addPassesToEmitMC(PM, MMI, ObjStream))
+    MachineModuleInfo MMI(static_cast<LLVMTargetMachine *>(&TM));
+    if (TM.addPassesToEmitMC(PM, MMI, ObjStream))
       return make_error<StringError>("Target does not support MC emission",
                                      inconvertibleErrorCode());
     PM.run(M);

llvm/lib/LTO/LTOBackend.cpp

@@ -20,6 +20,7 @@
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Bitcode/BitcodeReader.h"
 #include "llvm/Bitcode/BitcodeWriter.h"
+#include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/IR/LLVMRemarkStreamer.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/PassManager.h"