[NewPM][CodeGen] Port FreeMachineFunction to NPM

[jdoerfert]

Looks reasonable. Rubber stamp to unblock.

llvm/include/llvm/CodeGen/MachineModuleInfo.h

 namespace llvm {
 
 class BasicBlock;
 class CallInst;
 class Function;
 class LLVMTargetMachine;
 class MMIAddrLabelMap;
 class MachineFunction;
+class MachineFunctionAnalysisManager;
 class Module;
 
 //===----------------------------------------------------------------------===//
 /// This class can be derived from and used by targets to hold private
 /// target-specific information for each Module.  Objects of type are
 /// accessed/created with MachineModuleInfo::getObjFileInfo and destroyed when
 /// the MachineModuleInfo is destroyed.
 ///
public:
   using Result = MachineModuleInfo;
 
   MachineModuleAnalysis(const LLVMTargetMachine *TM) : TM(TM) {}
 
   /// Run the analysis pass and produce machine module information.
   MachineModuleInfo run(Module &M, ModuleAnalysisManager &);
 };
 
+struct FreeMachineFunctionPass : public PassInfoMixin<FreeMachineFunctionPass> {
+  PreservedAnalyses run(MachineFunction &MF,
+                        MachineFunctionAnalysisManager &MFAM);
+  static AnalysisKey Key;
+};
+
 } // end namespace llvm
 
 #endif // LLVM_CODEGEN_MACHINEMODULEINFO_H

llvm/lib/CodeGen/MachineModuleInfo.cpp

 //===-- llvm/CodeGen/MachineModuleInfo.cpp ----------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/PostOrderIterator.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/TinyPtrVector.h"
 #include "llvm/CodeGen/MachineFunction.h"
+#include "llvm/CodeGen/MachinePassManager.h"
 #include "llvm/CodeGen/Passes.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Value.h"
 #include "llvm/IR/ValueHandle.h"
 #include "llvm/InitializePasses.h"

 } // end anonymous namespace
 
 char FreeMachineFunction::ID;
 
 FunctionPass *llvm::createFreeMachineFunctionPass() {
   return new FreeMachineFunction();
 }
 
+PreservedAnalyses
+FreeMachineFunctionPass::run(MachineFunction &MF,
+                             MachineFunctionAnalysisManager &MFAM) {
+  MF.getMMI().deleteMachineFunctionFor(MF.getFunction());
+  return PreservedAnalyses::all();
+}
+
+AnalysisKey FreeMachineFunctionPass::Key;
+
 MachineModuleInfoWrapperPass::MachineModuleInfoWrapperPass(
     const LLVMTargetMachine *TM)
     : ImmutablePass(ID), MMI(TM) {
   initializeMachineModuleInfoWrapperPassPass(*PassRegistry::getPassRegistry());
 }
 
 MachineModuleInfoWrapperPass::MachineModuleInfoWrapperPass(
     const LLVMTargetMachine *TM, MCContext *ExtContext)