[ObjCARC] Remove legacy PM versions of optimization passes

[aeubanks]

Summary

This doesn't touch objc-arc-contract because that's in the codegen pipeline.
However, this does move its corresponding initialize function into initializeCodegen().

[nikic]

llvm/test/Transforms/ObjCARC/apelim.ll

0–1

Duplicate test line

llvm/test/Transforms/ObjCARC/move-and-merge-autorelease.ll

1

Unusual spelling, surprised this even works

[aeubanks]

fix tests

[aeubanks]

llvm/test/Transforms/ObjCARC/move-and-merge-autorelease.ll

1

it happened to pass with just objc-arc-contract, but anyway made it closer to the original test

[asbirlea]

Test updates could have been a separate NFC so review centers on the LPM passes removal / move to codegen only.

llvm/test/Transforms/ObjCARC/contract-end-of-use-list.ll

1

Add to single -passes= pipeline?

[aeubanks]

rebase past test changes commit

[asbirlea]

Changes LGTM.

[uabelho]

llvm/lib/Transforms/ObjCARC/ObjCARCOpts.cpp

2486

Looks like this method is unused after this patch.
gcc warns with

00:13:01 ../lib/Transforms/ObjCARC/ObjCARCOpts.cpp:2486:6: warning: 'void {anonymous}::ObjCARCOpt::releaseMemory()' defined but not used [-Wunused-function]
00:13:01  2486 | void ObjCARCOpt::releaseMemory() {
00:13:01       |      ^~~~~~~~~~

Can we remove it or is will it be used somewhere?

[aeubanks]

llvm/lib/Transforms/ObjCARC/ObjCARCOpts.cpp

2486

sorry about that, somebody fixed this in https://reviews.llvm.org/D136665

llvm/bindings/python/llvm/core.py

def register_library(library):
     library.LLVMInitializeCore.restype = None
 
     library.LLVMInitializeTransformUtils.argtypes = [PassRegistry]
     library.LLVMInitializeTransformUtils.restype = None
 
     library.LLVMInitializeScalarOpts.argtypes = [PassRegistry]
     library.LLVMInitializeScalarOpts.restype = None
 
-    library.LLVMInitializeObjCARCOpts.argtypes = [PassRegistry]
-    library.LLVMInitializeObjCARCOpts.restype = None
-
     library.LLVMInitializeVectorization.argtypes = [PassRegistry]
     library.LLVMInitializeVectorization.restype = None
 
     library.LLVMInitializeInstCombine.argtypes = [PassRegistry]
     library.LLVMInitializeInstCombine.restype = None
 
     library.LLVMInitializeAggressiveInstCombiner.argtypes = [PassRegistry]
     library.LLVMInitializeAggressiveInstCombiner.restype = None
def register_enumerations():
     return enums
 
 def initialize_llvm():
     Context.GetGlobalContext()
     p = PassRegistry()
     lib.LLVMInitializeCore(p)
     lib.LLVMInitializeTransformUtils(p)
     lib.LLVMInitializeScalarOpts(p)
-    lib.LLVMInitializeObjCARCOpts(p)
     lib.LLVMInitializeVectorization(p)
     lib.LLVMInitializeInstCombine(p)
     lib.LLVMInitializeIPO(p)
     lib.LLVMInitializeInstrumentation(p)
     lib.LLVMInitializeAnalysis(p)
     lib.LLVMInitializeCodeGen(p)
     lib.LLVMInitializeTarget(p)
 
 register_library(lib)
 Enums = register_enumerations()
 initialize_llvm()

llvm/include/llvm-c/Initialization.h

  * This module contains routines used to initialize the LLVM system.
  *
  * @{
  */
 
 void LLVMInitializeCore(LLVMPassRegistryRef R);
 void LLVMInitializeTransformUtils(LLVMPassRegistryRef R);
 void LLVMInitializeScalarOpts(LLVMPassRegistryRef R);
-void LLVMInitializeObjCARCOpts(LLVMPassRegistryRef R);
 void LLVMInitializeVectorization(LLVMPassRegistryRef R);
 void LLVMInitializeInstCombine(LLVMPassRegistryRef R);
 void LLVMInitializeAggressiveInstCombiner(LLVMPassRegistryRef R);
 void LLVMInitializeIPO(LLVMPassRegistryRef R);
 void LLVMInitializeInstrumentation(LLVMPassRegistryRef R);
 void LLVMInitializeAnalysis(LLVMPassRegistryRef R);
 void LLVMInitializeIPA(LLVMPassRegistryRef R);
 void LLVMInitializeCodeGen(LLVMPassRegistryRef R);

llvm/include/llvm/Analysis/ObjCARCAliasAnalysis.h

class ObjCARCAA : public AnalysisInfoMixin<ObjCARCAA> {
   static AnalysisKey Key;
 
 public:
   typedef ObjCARCAAResult Result;
 
   ObjCARCAAResult run(Function &F, FunctionAnalysisManager &AM);
 };
 
-/// Legacy wrapper pass to provide the ObjCARCAAResult object.
-class ObjCARCAAWrapperPass : public ImmutablePass {
-  std::unique_ptr<ObjCARCAAResult> Result;
-
-public:
-  static char ID;
-
-  ObjCARCAAWrapperPass();
-
-  ObjCARCAAResult &getResult() { return *Result; }
-  const ObjCARCAAResult &getResult() const { return *Result; }
-
-  bool doInitialization(Module &M) override;
-  bool doFinalization(Module &M) override;
-  void getAnalysisUsage(AnalysisUsage &AU) const override;
-};
-
 } // namespace objcarc
 } // namespace llvm
 
 #endif

llvm/include/llvm/Analysis/Passes.h

 
 namespace llvm {
   class FunctionPass;
   class ImmutablePass;
   class ModulePass;
 
   //===--------------------------------------------------------------------===//
   //
-  // createObjCARCAAWrapperPass - This pass implements ObjC-ARC-based
-  // alias analysis.
-  //
-  ImmutablePass *createObjCARCAAWrapperPass();
-
-  //===--------------------------------------------------------------------===//
-  //
   /// createLazyValueInfoPass - This creates an instance of the LazyValueInfo
   /// pass.
   FunctionPass *createLazyValueInfoPass();
 
   //===--------------------------------------------------------------------===//
   //
   // createDependenceAnalysisWrapperPass - This creates an instance of the
   // DependenceAnalysisWrapper pass.

llvm/include/llvm/InitializePasses.h

 void initializeCore(PassRegistry&);
 
 /// Initialize all passes linked into the TransformUtils library.
 void initializeTransformUtils(PassRegistry&);
 
 /// Initialize all passes linked into the ScalarOpts library.
 void initializeScalarOpts(PassRegistry&);
 
-/// Initialize all passes linked into the ObjCARCOpts library.
-void initializeObjCARCOpts(PassRegistry&);
-
 /// Initialize all passes linked into the Vectorize library.
 void initializeVectorization(PassRegistry&);
 
 /// Initialize all passes linked into the InstCombine library.
 void initializeInstCombine(PassRegistry&);
 
 /// Initialize all passes linked into the AggressiveInstCombine library.
 void initializeAggressiveInstCombine(PassRegistry&);

 void initializeModuleDebugInfoLegacyPrinterPass(PassRegistry &);
 void initializeModuleMemProfilerLegacyPassPass(PassRegistry &);
 void initializeModuleSummaryIndexWrapperPassPass(PassRegistry&);
 void initializeModuloScheduleTestPass(PassRegistry&);
 void initializeMustExecutePrinterPass(PassRegistry&);
 void initializeMustBeExecutedContextPrinterPass(PassRegistry&);
 void initializeNaryReassociateLegacyPassPass(PassRegistry&);
 void initializeNewGVNLegacyPassPass(PassRegistry&);
-void initializeObjCARCAAWrapperPassPass(PassRegistry&);
-void initializeObjCARCAPElimPass(PassRegistry&);
 void initializeObjCARCContractLegacyPassPass(PassRegistry &);
-void initializeObjCARCExpandPass(PassRegistry&);
-void initializeObjCARCOptLegacyPassPass(PassRegistry &);
 void initializeOptimizationRemarkEmitterWrapperPassPass(PassRegistry&);
 void initializeOptimizePHIsPass(PassRegistry&);
 void initializePEIPass(PassRegistry&);
 void initializePHIEliminationPass(PassRegistry&);
 void initializePartialInlinerLegacyPassPass(PassRegistry&);
 void initializePartiallyInlineLibCallsLegacyPassPass(PassRegistry&);
 void initializePatchableFunctionPass(PassRegistry&);
 void initializePeepholeOptimizerPass(PassRegistry&);

llvm/include/llvm/LinkAllPasses.h

ForcePassLinking() {
       (void) llvm::createLoopIdiomPass();
       (void) llvm::createLoopRotatePass();
       (void) llvm::createLowerConstantIntrinsicsPass();
       (void) llvm::createLowerExpectIntrinsicPass();
       (void) llvm::createLowerGlobalDtorsLegacyPass();
       (void) llvm::createLowerInvokePass();
       (void) llvm::createLowerSwitchPass();
       (void) llvm::createNaryReassociatePass();
-      (void) llvm::createObjCARCAAWrapperPass();
-      (void) llvm::createObjCARCAPElimPass();
-      (void) llvm::createObjCARCExpandPass();
       (void) llvm::createObjCARCContractPass();
-      (void) llvm::createObjCARCOptPass();
       (void) llvm::createPromoteMemoryToRegisterPass();
       (void) llvm::createDemoteRegisterToMemoryPass();
       (void)llvm::createPostDomOnlyPrinterWrapperPassPass();
       (void)llvm::createPostDomPrinterWrapperPassPass();
       (void)llvm::createPostDomOnlyViewerWrapperPassPass();
       (void)llvm::createPostDomViewerWrapperPassPass();
       (void) llvm::createReassociatePass();
       (void) llvm::createRedundantDbgInstEliminationPass();

llvm/lib/Analysis/AliasAnalysis.cpp

 
 INITIALIZE_PASS_BEGIN(AAResultsWrapperPass, "aa",
                       "Function Alias Analysis Results", false, true)
 INITIALIZE_PASS_DEPENDENCY(BasicAAWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(CFLAndersAAWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(CFLSteensAAWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(ExternalAAWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(GlobalsAAWrapperPass)
-INITIALIZE_PASS_DEPENDENCY(ObjCARCAAWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(SCEVAAWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(ScopedNoAliasAAWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(TypeBasedAAWrapperPass)
 INITIALIZE_PASS_END(AAResultsWrapperPass, "aa",
                     "Function Alias Analysis Results", false, true)
 
 FunctionPass *llvm::createAAResultsWrapperPass() {
   return new AAResultsWrapperPass();
bool AAResultsWrapperPass::runOnFunction(Function &F) {
   if (!DisableBasicAA)
     AAR->addAAResult(getAnalysis<BasicAAWrapperPass>().getResult());
 
   // Populate the results with the currently available AAs.
   if (auto *WrapperPass = getAnalysisIfAvailable<ScopedNoAliasAAWrapperPass>())
     AAR->addAAResult(WrapperPass->getResult());
   if (auto *WrapperPass = getAnalysisIfAvailable<TypeBasedAAWrapperPass>())
     AAR->addAAResult(WrapperPass->getResult());
-  if (auto *WrapperPass =
-          getAnalysisIfAvailable<objcarc::ObjCARCAAWrapperPass>())
-    AAR->addAAResult(WrapperPass->getResult());
   if (auto *WrapperPass = getAnalysisIfAvailable<GlobalsAAWrapperPass>())
     AAR->addAAResult(WrapperPass->getResult());
   if (auto *WrapperPass = getAnalysisIfAvailable<SCEVAAWrapperPass>())
     AAR->addAAResult(WrapperPass->getResult());
   if (auto *WrapperPass = getAnalysisIfAvailable<CFLAndersAAWrapperPass>())
     AAR->addAAResult(WrapperPass->getResult());
   if (auto *WrapperPass = getAnalysisIfAvailable<CFLSteensAAWrapperPass>())
     AAR->addAAResult(WrapperPass->getResult());
void AAResultsWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.addRequiredTransitive<TargetLibraryInfoWrapperPass>();
 
   // We also need to mark all the alias analysis passes we will potentially
   // probe in runOnFunction as used here to ensure the legacy pass manager
   // preserves them. This hard coding of lists of alias analyses is specific to
   // the legacy pass manager.
   AU.addUsedIfAvailable<ScopedNoAliasAAWrapperPass>();
   AU.addUsedIfAvailable<TypeBasedAAWrapperPass>();
-  AU.addUsedIfAvailable<objcarc::ObjCARCAAWrapperPass>();
   AU.addUsedIfAvailable<GlobalsAAWrapperPass>();
   AU.addUsedIfAvailable<SCEVAAWrapperPass>();
   AU.addUsedIfAvailable<CFLAndersAAWrapperPass>();
   AU.addUsedIfAvailable<CFLSteensAAWrapperPass>();
   AU.addUsedIfAvailable<ExternalAAWrapperPass>();
 }
 
 AAManager::Result AAManager::run(Function &F, FunctionAnalysisManager &AM) {
if (!DisableBasicAA)
     AAR.addAAResult(BAR);
 
   // Populate the results with the other currently available AAs.
   if (auto *WrapperPass =
           P.getAnalysisIfAvailable<ScopedNoAliasAAWrapperPass>())
     AAR.addAAResult(WrapperPass->getResult());
   if (auto *WrapperPass = P.getAnalysisIfAvailable<TypeBasedAAWrapperPass>())
     AAR.addAAResult(WrapperPass->getResult());
-  if (auto *WrapperPass =
-          P.getAnalysisIfAvailable<objcarc::ObjCARCAAWrapperPass>())
-    AAR.addAAResult(WrapperPass->getResult());
   if (auto *WrapperPass = P.getAnalysisIfAvailable<GlobalsAAWrapperPass>())
     AAR.addAAResult(WrapperPass->getResult());
   if (auto *WrapperPass = P.getAnalysisIfAvailable<CFLAndersAAWrapperPass>())
     AAR.addAAResult(WrapperPass->getResult());
   if (auto *WrapperPass = P.getAnalysisIfAvailable<CFLSteensAAWrapperPass>())
     AAR.addAAResult(WrapperPass->getResult());
   if (auto *WrapperPass = P.getAnalysisIfAvailable<ExternalAAWrapperPass>())
     if (WrapperPass->CB)

 
 void llvm::getAAResultsAnalysisUsage(AnalysisUsage &AU) {
   // This function needs to be in sync with llvm::createLegacyPMAAResults -- if
   // more alias analyses are added to llvm::createLegacyPMAAResults, they need
   // to be added here also.
   AU.addRequired<TargetLibraryInfoWrapperPass>();
   AU.addUsedIfAvailable<ScopedNoAliasAAWrapperPass>();
   AU.addUsedIfAvailable<TypeBasedAAWrapperPass>();
-  AU.addUsedIfAvailable<objcarc::ObjCARCAAWrapperPass>();
   AU.addUsedIfAvailable<GlobalsAAWrapperPass>();
   AU.addUsedIfAvailable<CFLAndersAAWrapperPass>();
   AU.addUsedIfAvailable<CFLSteensAAWrapperPass>();
   AU.addUsedIfAvailable<ExternalAAWrapperPass>();
 }

llvm/lib/Analysis/Analysis.cpp

void llvm::initializeAnalysis(PassRegistry &Registry) {
   initializeLoopInfoWrapperPassPass(Registry);
   initializeMemDepPrinterPass(Registry);
   initializeMemDerefPrinterPass(Registry);
   initializeMemoryDependenceWrapperPassPass(Registry);
   initializeModuleDebugInfoLegacyPrinterPass(Registry);
   initializeModuleSummaryIndexWrapperPassPass(Registry);
   initializeMustExecutePrinterPass(Registry);
   initializeMustBeExecutedContextPrinterPass(Registry);
-  initializeObjCARCAAWrapperPassPass(Registry);
   initializeOptimizationRemarkEmitterWrapperPassPass(Registry);
   initializePhiValuesWrapperPassPass(Registry);
   initializePostDominatorTreeWrapperPassPass(Registry);
   initializeRegionInfoPassPass(Registry);
   initializeRegionViewerPass(Registry);
   initializeRegionPrinterPass(Registry);
   initializeRegionOnlyViewerPass(Registry);
   initializeRegionOnlyPrinterPass(Registry);

llvm/lib/Analysis/ObjCARCAliasAnalysis.cpp

ModRefInfo ObjCARCAAResult::getModRefInfo(const CallBase *Call,
   return AAResultBase::getModRefInfo(Call, Loc, AAQI);
 }
 
 AnalysisKey ObjCARCAA::Key;
 
 ObjCARCAAResult ObjCARCAA::run(Function &F, FunctionAnalysisManager &AM) {
   return ObjCARCAAResult(F.getParent()->getDataLayout());
 }
-
-char ObjCARCAAWrapperPass::ID = 0;
-INITIALIZE_PASS(ObjCARCAAWrapperPass, "objc-arc-aa",
-                "ObjC-ARC-Based Alias Analysis", false, true)
-
-ImmutablePass *llvm::createObjCARCAAWrapperPass() {
-  return new ObjCARCAAWrapperPass();
-}
-
-ObjCARCAAWrapperPass::ObjCARCAAWrapperPass() : ImmutablePass(ID) {
-  initializeObjCARCAAWrapperPassPass(*PassRegistry::getPassRegistry());
-}
-
-bool ObjCARCAAWrapperPass::doInitialization(Module &M) {
-  Result.reset(new ObjCARCAAResult(M.getDataLayout()));
-  return false;
-}
-
-bool ObjCARCAAWrapperPass::doFinalization(Module &M) {
-  Result.reset();
-  return false;
-}
-
-void ObjCARCAAWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
-  AU.setPreservesAll();
-}

llvm/lib/CodeGen/CMakeLists.txt

add_llvm_component_library(LLVMCodeGen
   ${MLDeps}
 
   LINK_COMPONENTS
   Analysis
   BitReader
   BitWriter
   Core
   MC
+  ObjCARC
   ProfileData
   Scalar
   Support
   Target
   TransformUtils
   )
 
 add_subdirectory(SelectionDAG)
 add_subdirectory(AsmPrinter)
 add_subdirectory(MIRParser)
 add_subdirectory(GlobalISel)

llvm/lib/CodeGen/CodeGen.cpp

void llvm::initializeCodeGen(PassRegistry &Registry) {
   initializeMachineOutlinerPass(Registry);
   initializeMachinePipelinerPass(Registry);
   initializeModuloScheduleTestPass(Registry);
   initializeMachinePostDominatorTreePass(Registry);
   initializeMachineRegionInfoPassPass(Registry);
   initializeMachineSchedulerPass(Registry);
   initializeMachineSinkingPass(Registry);
   initializeMachineVerifierPassPass(Registry);
+  initializeObjCARCContractLegacyPassPass(Registry);
   initializeOptimizePHIsPass(Registry);
   initializePEIPass(Registry);
   initializePHIEliminationPass(Registry);
   initializePatchableFunctionPass(Registry);
   initializePeepholeOptimizerPass(Registry);
   initializePostMachineSchedulerPass(Registry);
   initializePostRAHazardRecognizerPass(Registry);
   initializePostRAMachineSinkingPass(Registry);

llvm/lib/Transforms/ObjCARC/ObjCARC.cpp

 //===-- ObjCARC.cpp -------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements common infrastructure for libLLVMObjCARCOpts.a, which
 // implements several scalar transformations over the LLVM intermediate
 // representation, including the C bindings for that library.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ObjCARC.h"
-#include "llvm-c/Initialization.h"
 #include "llvm/Analysis/ObjCARCUtil.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/Instructions.h"
-#include "llvm/InitializePasses.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
 
-namespace llvm {
-  class PassRegistry;
-}
-
 using namespace llvm;
 using namespace llvm::objcarc;
 
-/// initializeObjCARCOptsPasses - Initialize all passes linked into the
-/// ObjCARCOpts library.
-void llvm::initializeObjCARCOpts(PassRegistry &Registry) {
-  initializeObjCARCAAWrapperPassPass(Registry);
-  initializeObjCARCAPElimPass(Registry);
-  initializeObjCARCExpandPass(Registry);
-  initializeObjCARCContractLegacyPassPass(Registry);
-  initializeObjCARCOptLegacyPassPass(Registry);
-}
-
-void LLVMInitializeObjCARCOpts(LLVMPassRegistryRef R) {
-  initializeObjCARCOpts(*unwrap(R));
-}
-
 CallInst *objcarc::createCallInstWithColors(
     FunctionCallee Func, ArrayRef<Value *> Args, const Twine &NameStr,
     Instruction *InsertBefore,
     const DenseMap<BasicBlock *, ColorVector> &BlockColors) {
   FunctionType *FTy = Func.getFunctionType();
   Value *Callee = Func.getCallee();
   SmallVector<OperandBundleDef, 1> OpBundles;
 

llvm/lib/Transforms/ObjCARC/ObjCARCAPElim.cpp

 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Analysis/ObjCARCAnalysisUtils.h"
 #include "llvm/Analysis/ObjCARCInstKind.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/PassManager.h"
-#include "llvm/InitializePasses.h"
-#include "llvm/Pass.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Transforms/ObjCARC.h"
 
 using namespace llvm;
 using namespace llvm::objcarc;
 
 #define DEBUG_TYPE "objc-arc-ap-elim"
if (std::next(F->begin()) != F->end())
       continue;
     // Ok, a single-block constructor function definition. Try to optimize it.
     Changed |= OptimizeBB(&F->front());
   }
 
   return Changed;
 }
 
-/// Autorelease pool elimination.
-class ObjCARCAPElim : public ModulePass {
-  void getAnalysisUsage(AnalysisUsage &AU) const override;
-  bool runOnModule(Module &M) override;
-
-public:
-  static char ID;
-  ObjCARCAPElim() : ModulePass(ID) {
-    initializeObjCARCAPElimPass(*PassRegistry::getPassRegistry());
-  }
-};
 } // namespace
 
-char ObjCARCAPElim::ID = 0;
-INITIALIZE_PASS(ObjCARCAPElim, "objc-arc-apelim",
-                "ObjC ARC autorelease pool elimination", false, false)
-
-Pass *llvm::createObjCARCAPElimPass() { return new ObjCARCAPElim(); }
-
-void ObjCARCAPElim::getAnalysisUsage(AnalysisUsage &AU) const {
-  AU.setPreservesCFG();
-}
-
-bool ObjCARCAPElim::runOnModule(Module &M) {
-  if (skipModule(M))
-    return false;
-  return runImpl(M);
-}
-
 PreservedAnalyses ObjCARCAPElimPass::run(Module &M, ModuleAnalysisManager &AM) {
   if (!runImpl(M))
     return PreservedAnalyses::all();
   PreservedAnalyses PA;
   PA.preserveSet<CFGAnalyses>();
   return PA;
 }

llvm/lib/Transforms/ObjCARC/ObjCARCExpand.cpp

 
 #include "llvm/Analysis/ObjCARCAnalysisUtils.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/InstIterator.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/IR/Value.h"
-#include "llvm/InitializePasses.h"
-#include "llvm/Pass.h"
-#include "llvm/PassRegistry.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Transforms/ObjCARC.h"
 
 #define DEBUG_TYPE "objc-arc-expand"
 
 using namespace llvm;
for (Instruction &Inst : instructions(&F)) {
     }
   }
 
   LLVM_DEBUG(dbgs() << "ObjCARCExpand: Finished List.\n\n");
 
   return Changed;
 }
 
-/// Early ARC transformations.
-class ObjCARCExpand : public FunctionPass {
-  void getAnalysisUsage(AnalysisUsage &AU) const override;
-  bool runOnFunction(Function &F) override;
-
-public:
-  static char ID;
-  ObjCARCExpand() : FunctionPass(ID) {
-    initializeObjCARCExpandPass(*PassRegistry::getPassRegistry());
-  }
-};
 } // namespace
 
-char ObjCARCExpand::ID = 0;
-INITIALIZE_PASS(ObjCARCExpand, "objc-arc-expand", "ObjC ARC expansion", false,
-                false)
-
-Pass *llvm::createObjCARCExpandPass() { return new ObjCARCExpand(); }
-
-void ObjCARCExpand::getAnalysisUsage(AnalysisUsage &AU) const {
-  AU.setPreservesCFG();
-}
-
-bool ObjCARCExpand::runOnFunction(Function &F) { return runImpl(F); }
-
 PreservedAnalyses ObjCARCExpandPass::run(Function &F,
                                          FunctionAnalysisManager &AM) {
   if (!runImpl(F))
     return PreservedAnalyses::all();
   PreservedAnalyses PA;
   PA.preserveSet<CFGAnalyses>();
   return PA;
 }

llvm/lib/Transforms/ObjCARC/ObjCARCOpts.cpp

 #include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/Type.h"
 #include "llvm/IR/User.h"
 #include "llvm/IR/Value.h"
-#include "llvm/InitializePasses.h"
-#include "llvm/Pass.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Transforms/ObjCARC.h"
 #include <cassert>

 #endif
 
   public:
     void init(Module &M);
     bool run(Function &F, AAResults &AA);
     void releaseMemory();
     bool hasCFGChanged() const { return CFGChanged; }
 };
-
-/// The main ARC optimization pass.
-class ObjCARCOptLegacyPass : public FunctionPass {
-public:
-  ObjCARCOptLegacyPass() : FunctionPass(ID) {
-    initializeObjCARCOptLegacyPassPass(*PassRegistry::getPassRegistry());
-  }
-  void getAnalysisUsage(AnalysisUsage &AU) const override;
-  bool doInitialization(Module &M) override {
-    OCAO.init(M);
-    return false;
-  }
-  bool runOnFunction(Function &F) override {
-    return OCAO.run(F, getAnalysis<AAResultsWrapperPass>().getAAResults());
-  }
-  void releaseMemory() override { OCAO.releaseMemory(); }
-  static char ID;
-
-private:
-  ObjCARCOpt OCAO;
-};
 } // end anonymous namespace
 
-char ObjCARCOptLegacyPass::ID = 0;
-
-INITIALIZE_PASS_BEGIN(ObjCARCOptLegacyPass, "objc-arc", "ObjC ARC optimization",
-                      false, false)
-INITIALIZE_PASS_DEPENDENCY(ObjCARCAAWrapperPass)
-INITIALIZE_PASS_END(ObjCARCOptLegacyPass, "objc-arc", "ObjC ARC optimization",
-                    false, false)
-
-Pass *llvm::createObjCARCOptPass() { return new ObjCARCOptLegacyPass(); }
-
-void ObjCARCOptLegacyPass::getAnalysisUsage(AnalysisUsage &AU) const {
-  AU.addRequired<ObjCARCAAWrapperPass>();
-  AU.addRequired<AAResultsWrapperPass>();
-}
-
 /// Turn objc_retainAutoreleasedReturnValue into objc_retain if the operand is
 /// not a return value.
 bool
 ObjCARCOpt::OptimizeRetainRVCall(Function &F, Instruction *RetainRV) {
   // Check for the argument being from an immediately preceding call or invoke.
   const Value *Arg = GetArgRCIdentityRoot(RetainRV);
   if (const Instruction *Call = dyn_cast<CallBase>(Arg)) {
     if (Call->getParent() == RetainRV->getParent()) {
#ifndef NDEBUG
   }
 #endif
 
   LLVM_DEBUG(dbgs() << "\n");
 
   return Changed;
 }
 
 void ObjCARCOpt::releaseMemory() {
   PA.clear();
 }
 
 /// @}
 ///
 
 PreservedAnalyses ObjCARCOptPass::run(Function &F,
                                       FunctionAnalysisManager &AM) {

llvm/test/Transforms/ObjCARC/allocas.ll

-; RUN: opt -objc-arc -S < %s | FileCheck %s
+; RUN: opt -passes=objc-arc -S < %s | FileCheck %s
 
 declare i8* @llvm.objc.retain(i8*)
 declare i8* @llvm.objc.retainAutoreleasedReturnValue(i8*)
 declare void @llvm.objc.release(i8*)
 declare i8* @llvm.objc.autorelease(i8*)
 declare i8* @llvm.objc.autoreleaseReturnValue(i8*)
 declare void @llvm.objc.autoreleasePoolPop(i8*)
 declare i8* @llvm.objc.autoreleasePoolPush()

llvm/test/Transforms/ObjCARC/apelim.ll

-; RUN: opt -S -objc-arc-apelim < %s | FileCheck %s
 ; RUN: opt -S -passes=objc-arc-apelim < %s | FileCheck %s
 ; rdar://10227311
 
 @llvm.global_ctors = appending global [2 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @_GLOBAL__I_x, i8* null }, { i32, void ()*, i8* } { i32 65535, void ()* @_GLOBAL__I_y, i8* null }]
 
 @x = global i32 0
 
 declare i32 @bar() nounwind
 

llvm/test/Transforms/ObjCARC/basic.ll

-; RUN: opt -basic-aa -objc-arc -S < %s | FileCheck %s
 ; RUN: opt -aa-pipeline=basic-aa -passes=objc-arc -S < %s | FileCheck %s
 
 target datalayout = "e-p:64:64:64"
 
 declare i8* @llvm.objc.retain(i8*)
 declare i8* @llvm.objc.retainAutoreleasedReturnValue(i8*)
 declare i8* @llvm.objc.unsafeClaimAutoreleasedReturnValue(i8*)
 declare void @llvm.objc.release(i8*)

llvm/test/Transforms/ObjCARC/cfg-hazards.ll

-; RUN: opt -S -objc-arc < %s | FileCheck %s
+; RUN: opt -S -passes=objc-arc < %s | FileCheck %s
 ; rdar://9503416
 
 ; Detect loop boundaries and don't move retains and releases
 ; across them.
 
 declare void @use_pointer(i8*)
 declare i8* @llvm.objc.retain(i8*)
 declare void @llvm.objc.release(i8*)

llvm/test/Transforms/ObjCARC/clang-arc-use-barrier.ll

-; RUN: opt -objc-arc -S %s | FileCheck %s
+; RUN: opt -passes=objc-arc -S %s | FileCheck %s
 
 %0 = type opaque
 
 ; Make sure ARC optimizer doesn't sink @obj_retain past @llvm.objc.clang.arc.use.
 
 ; CHECK: call i8* @llvm.objc.retain
 ; CHECK: call void (...) @llvm.objc.clang.arc.use(
 ; CHECK: call i8* @llvm.objc.retain

llvm/test/Transforms/ObjCARC/code-motion.ll

-; RUN: opt -objc-arc -S < %s | FileCheck %s
+; RUN: opt -passes=objc-arc -S < %s | FileCheck %s
 
 declare void @alterRefCount()
 declare void @use(i8*)
 declare void @readOnlyFunc(i8*, i8*)
 
 @g0 = global i8* null, align 8
 
 ; Check that ARC optimizer doesn't reverse the order of the retain call and the

llvm/test/Transforms/ObjCARC/comdat-ipo.ll

-; RUN: opt -S -objc-arc-apelim < %s | FileCheck %s
+; RUN: opt -S -passes=objc-arc-apelim < %s | FileCheck %s
 
 ; See PR26774
 
 @llvm.global_ctors = appending global [2 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @_GLOBAL__I_x, i8* null }, { i32, void ()*, i8* } { i32 65535, void ()* @_GLOBAL__I_y, i8* null }]
 
 @x = global i32 0
 
 declare i32 @bar() nounwind

llvm/test/Transforms/ObjCARC/contract-attached-call-no-marker.ll

-; RUN: opt -objc-arc-contract -S < %s | FileCheck %s
+; RUN: opt -passes=objc-arc-contract -S < %s | FileCheck %s
 ; RUN: opt -passes=objc-arc-contract -S < %s | FileCheck %s
 
 ; CHECK-LABEL: define void @test0() {
 ; CHECK: %[[CALL:.*]] = notail call i8* @foo() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
 ; CHECK-NEXT: ret void
 
 define void @test0() {
   %call1 = call i8* @foo() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]

llvm/test/Transforms/ObjCARC/contract-catchswitch.ll

-; RUN: opt -S -objc-arc-contract < %s | FileCheck %s
+; RUN: opt -S -passes=objc-arc-contract < %s | FileCheck %s
 
 target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
 target triple = "i686--windows-msvc19.11.0"
 
 %0 = type opaque
 
 declare i32 @__CxxFrameHandler3(...)
 declare dllimport void @llvm.objc.release(i8*) local_unnamed_addr

llvm/test/Transforms/ObjCARC/contract-end-of-use-list.ll

-; RUN: opt -S < %s -objc-arc-expand -objc-arc-contract | FileCheck %s
+; RUN: opt -S < %s -passes=objc-arc-expand -passes=objc-arc-contract | FileCheck %s
 ; Don't crash.  Reproducer for a use_iterator bug from r203364.
 ; rdar://problem/16333235
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-darwin13.2.0"
 
 %struct = type { i8*, i8* }
 
 ; CHECK-LABEL: @foo() {

llvm/test/Transforms/ObjCARC/contract-marker-funclet.ll

-; RUN: opt -mtriple=i686-unknown-windows-msvc -objc-arc-contract -S -o - %s | FileCheck %s
+; RUN: opt -mtriple=i686-unknown-windows-msvc -passes=objc-arc-contract -S -o - %s | FileCheck %s
 
 ; Generated (and lightly modified and cleaned up) from the following source:
 ; id f();
 ; void g() {
 ;   try {
 ;     f();
 ;   } catch (...) {
 ;     f();

llvm/test/Transforms/ObjCARC/contract-marker.ll

-; RUN: opt -S -objc-arc-contract < %s | FileCheck %s
+; RUN: opt -S -passes=objc-arc-contract < %s | FileCheck %s
 
 ; CHECK-LABEL: define void @foo() {
 ; CHECK:      %call = tail call i32* @qux()
 ; CHECK-NEXT: %tcall = bitcast i32* %call to i8*
 ; CHECK-NEXT: call void asm sideeffect "mov\09r7, r7\09\09@ marker for return value optimization", ""()
 ; CHECK-NEXT: %0 = tail call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %tcall) [[NUW:#[0-9]+]]
 ; CHECK: }
 

llvm/test/Transforms/ObjCARC/contract-replace-arg-use.ll

-; RUN: opt -objc-arc-contract -S < %s | FileCheck %s
+; RUN: opt -passes=objc-arc-contract -S < %s | FileCheck %s
 
 declare i8* @llvm.objc.autoreleaseReturnValue(i8*)
 declare i8* @foo1()
 
 ; Check that ARC contraction replaces the function return with the value
 ; returned by @llvm.objc.autoreleaseReturnValue.
 
 ; CHECK-LABEL: define i32* @autoreleaseRVTailCall(

llvm/test/Transforms/ObjCARC/contract-rv-attr.ll

-; RUN: opt -objc-arc-contract -S < %s | FileCheck %s
+; RUN: opt -passes=objc-arc-contract -S < %s | FileCheck %s
 ; RUN: opt -passes=objc-arc-contract -S < %s | FileCheck %s
 
 ; CHECK-LABEL: define void @test0() {
 ; CHECK: %[[CALL:.*]] = notail call i8* @foo() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]
 ; CHECK-NOT: call i8* @llvm.objc.retainAutoreleasedReturnValue(
 
 define void @test0() {
   %call1 = call i8* @foo() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ]

llvm/test/Transforms/ObjCARC/contract-storestrong-funclet.ll

-; RUN: opt -mtriple=i686-unknown-windows-msvc -objc-arc-contract -S -o - %s | FileCheck %s
+; RUN: opt -mtriple=i686-unknown-windows-msvc -passes=objc-arc-contract -S -o - %s | FileCheck %s
 
 declare void @f()
 declare i32 @__CxxFrameHandler3(...)
 declare dllimport i8* @llvm.objc.retain(i8*)
 declare dllimport i8* @llvm.objc.retainAutoreleasedReturnValue(i8*)
 declare dllimport void @llvm.objc.release(i8*)
 
 @x = external global i8*

llvm/test/Transforms/ObjCARC/contract-storestrong-ivar.ll

-; RUN: opt -objc-arc-contract -S < %s | FileCheck %s
+; RUN: opt -passes=objc-arc-contract -S < %s | FileCheck %s
 
 ; CHECK: tail call void @llvm.objc.storeStrong(i8**
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
 target triple = "x86_64-apple-darwin11.0.0"
 
 %0 = type opaque
 %1 = type opaque

llvm/test/Transforms/ObjCARC/contract-storestrong.ll

-; RUN: opt -objc-arc-contract -S < %s | FileCheck %s
+; RUN: opt -passes=objc-arc-contract -S < %s | FileCheck %s
 
 target datalayout = "e-p:64:64:64"
 
 declare i8* @llvm.objc.retain(i8*)
 declare void @llvm.objc.release(i8*)
 declare void @use_pointer(i8*)
 
 @x = external global i8*

llvm/test/Transforms/ObjCARC/contract-testcases.ll

-; RUN: opt -objc-arc-contract -S < %s | FileCheck %s
+; RUN: opt -passes=objc-arc-contract -S < %s | FileCheck %s
 ; rdar://9511608
 
 %0 = type opaque
 %1 = type opaque
 %2 = type { i64, i64 }
 %4 = type opaque
 
 declare %0* @"\01-[NSAttributedString(Terminal) pathAtIndex:effectiveRange:]"(%1*, i8* nocapture, i64, %2*) optsize

llvm/test/Transforms/ObjCARC/contract.ll

-; RUN: opt -objc-arc-contract -S < %s | FileCheck %s
+; RUN: opt -passes=objc-arc-contract -S < %s | FileCheck %s
 ; RUN: opt -passes=objc-arc-contract -S < %s | FileCheck %s
 
 target datalayout = "e-p:64:64:64"
 
 declare i8* @llvm.objc.retain(i8*)
 declare void @llvm.objc.release(i8*)
 declare i8* @llvm.objc.autorelease(i8*)
 declare i8* @llvm.objc.autoreleaseReturnValue(i8*)

llvm/test/Transforms/ObjCARC/empty-block.ll

-; RUN: opt -S -objc-arc < %s | FileCheck %s
+; RUN: opt -S -passes=objc-arc < %s | FileCheck %s
 ; rdar://10210274
 
 %0 = type opaque
 
 declare i8* @llvm.objc.retain(i8*)
 
 declare void @llvm.objc.release(i8*)
 

llvm/test/Transforms/ObjCARC/ensure-that-exception-unwind-path-is-visited.ll

-; RUN: opt -objc-arc -S < %s | FileCheck %s
+; RUN: opt -passes=objc-arc -S < %s | FileCheck %s
 ; rdar://11744105
 ; bugzilla://14584
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.9.0"
 
 %0 = type opaque
 %struct._class_t = type { %struct._class_t*, %struct._class_t*, %struct._objc_cache*, i8* (i8*, i8*)**, %struct._class_ro_t* }

llvm/test/Transforms/ObjCARC/escape.ll

-; RUN: opt -objc-arc -S < %s | FileCheck %s
+; RUN: opt -passes=objc-arc -S < %s | FileCheck %s
 ; rdar://11229925
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 
 %struct.__block_byref_weakLogNTimes = type { i8*, %struct.__block_byref_weakLogNTimes*, i32, i32, i8*, i8*, void (...)* }
 %struct.__block_descriptor = type { i64, i64 }
 
 ; Don't optimize away the retainBlock, because the object's address "escapes"

llvm/test/Transforms/ObjCARC/expand.ll

-; RUN: opt -objc-arc-expand -S < %s | FileCheck %s
+; RUN: opt -passes=objc-arc-expand -S < %s | FileCheck %s
 ; RUN: opt -passes=objc-arc-expand -S < %s | FileCheck %s
 
 target datalayout = "e-p:64:64:64"
 
 declare i8* @llvm.objc.retain(i8*)
 declare i8* @llvm.objc.autorelease(i8*)
 declare i8* @llvm.objc.retainAutoreleasedReturnValue(i8*)
 declare i8* @llvm.objc.autoreleaseReturnValue(i8*)

llvm/test/Transforms/ObjCARC/funclet.ll

-; RUN: opt -mtriple x86_64-unknown-windows-msvc -objc-arc -S -o - %s | FileCheck %s
+; RUN: opt -mtriple x86_64-unknown-windows-msvc -passes=objc-arc -S -o - %s | FileCheck %s
 
 ; bool g();
 ; id h();
 ;
 ; void f() {
 ;   id a = nullptr;
 ;   if (g())
 ;     a = h();

llvm/test/Transforms/ObjCARC/gvn.ll

-; RUN: opt -S -basic-aa -objc-arc-aa -gvn < %s | FileCheck %s
 ; RUN: opt -S -aa-pipeline=basic-aa,objc-arc-aa -passes=gvn < %s | FileCheck %s
 
 @x = common global i8* null, align 8
 
 declare i8* @llvm.objc.retain(i8*)
 declare i32 @llvm.objc.sync.enter(i8*)
 declare i32 @llvm.objc.sync.exit(i8*)
 

llvm/test/Transforms/ObjCARC/inert-global.ll

-; RUN: opt -objc-arc -S < %s | FileCheck %s
+; RUN: opt -passes=objc-arc -S < %s | FileCheck %s
 
 %0 = type opaque
 %struct.__NSConstantString_tag = type { i32*, i32, i8*, i64 }
 %struct.__block_descriptor = type { i64, i64 }
 
 @__CFConstantStringClassReference = external global [0 x i32]
 @.str = private unnamed_addr constant [4 x i8] c"abc\00", section "__TEXT,__cstring,cstring_literals", align 1
 @.str1 = private unnamed_addr constant [4 x i8] c"def\00", section "__TEXT,__cstring,cstring_literals", align 1

llvm/test/Transforms/ObjCARC/inlined-autorelease-return-value.ll

-; RUN: opt -basic-aa -objc-arc -S < %s | FileCheck %s
+; RUN: opt -passes=objc-arc -S < %s | FileCheck %s
 
 target datalayout = "e-p:64:64:64"
 
 declare i8* @llvm.objc.retain(i8*)
 declare i8* @llvm.objc.autoreleaseReturnValue(i8*)
 declare i8* @llvm.objc.retainAutoreleasedReturnValue(i8*)
 declare i8* @llvm.objc.unsafeClaimAutoreleasedReturnValue(i8*)
 declare void @opaque()

llvm/test/Transforms/ObjCARC/intrinsic-use-isolated.ll

-; RUN: opt -objc-arc-contract -S < %s | FileCheck %s
+; RUN: opt -passes=objc-arc-contract -S < %s | FileCheck %s
 
 ; This file makes sure that clang.arc.used is removed even if no other ARC
 ; interesting calls are in the module.
 
 declare void @llvm.objc.clang.arc.use(...) nounwind
 
 ; Kill calls to @llvm.objc.clang.arc.use(...)
 ; CHECK-LABEL: define void @test0(
 ; CHECK-NOT: clang.arc.use
 ; CHECK: }
 define void @test0(i8* %a, i8* %b) {
   call void (...) @llvm.objc.clang.arc.use(i8* %a, i8* %b) nounwind
   ret void
 }
 

llvm/test/Transforms/ObjCARC/intrinsic-use.ll

-; RUN: opt -basic-aa -objc-arc -S < %s | FileCheck %s
+; RUN: opt -passes=objc-arc -S < %s | FileCheck %s
 
 target datalayout = "e-p:64:64:64"
 
 declare i8* @llvm.objc.retain(i8*)
 declare i8* @llvm.objc.retainAutorelease(i8*)
 declare void @llvm.objc.release(i8*)
 declare i8* @llvm.objc.autorelease(i8*)
 

llvm/test/Transforms/ObjCARC/invoke-2.ll

-; RUN: opt -mtriple x86_64-unknown-windows-msvc -objc-arc -o - %s | llvm-dis -o - - | FileCheck %s
+; RUN: opt -mtriple x86_64-unknown-windows-msvc -passes=objc-arc -o - %s | llvm-dis -o - - | FileCheck %s
 
 target triple = "x86_64-unknown-windows-msvc"
 
 declare i32 @__CxxFrameHandler3(...)
 
 declare dllimport i8* @objc_msgSend(i8*, i8*, ...) local_unnamed_addr
 
 declare dllimport i8* @llvm.objc.retain(i8* returned) local_unnamed_addr

llvm/test/Transforms/ObjCARC/invoke.ll

-; RUN: opt -S -objc-arc < %s | FileCheck %s
+; RUN: opt -S -passes=objc-arc < %s | FileCheck %s
 
 declare i8* @llvm.objc.retain(i8*)
 declare void @llvm.objc.release(i8*)
 declare i8* @llvm.objc.retainAutoreleasedReturnValue(i8*)
 declare i8* @objc_msgSend(i8*, i8*, ...)
 declare void @use_pointer(i8*)
 declare void @callee()
 declare i8* @returner()

llvm/test/Transforms/ObjCARC/move-and-form-retain-autorelease.ll

-; RUN: opt -S -objc-arc-contract < %s | FileCheck %s
+; RUN: opt -S -passes=objc-arc-contract < %s | FileCheck %s
 
 ; The optimizer should be able to move the autorelease past a control triangle
 ; and various scary looking things and fold it into an objc_retainAutorelease.
 
 ; CHECK: bb57:
 ; CHECK: tail call i8* @llvm.objc.retainAutorelease(i8* %tmp71x) [[NUW:#[0-9]+]]
 ; CHECK: bb99:
 

llvm/test/Transforms/ObjCARC/move-and-merge-autorelease.ll

-; RUN: opt -S -objc-arc -objc-arc-contract < %s | FileCheck %s
+; RUN: opt -S -passes=objc-arc,objc-arc-contract < %s | FileCheck %s
 
 ; The optimizer should be able to move the autorelease past two phi nodes
 ; and fold it with the release in bb65.
 
 ; CHECK: bb65:
 ; CHECK: call i8* @llvm.objc.retainAutorelease
 ; CHECK: br label %bb76
 

llvm/test/Transforms/ObjCARC/nested.ll

-; RUN: opt -objc-arc -S < %s | FileCheck %s
+; RUN: opt -passes=objc-arc -S < %s | FileCheck %s
 
 %struct.__objcFastEnumerationState = type { i64, i8**, i64*, [5 x i64] }
 
 @"\01L_OBJC_METH_VAR_NAME_" = internal global [43 x i8] c"countByEnumeratingWithState:objects:count:\00", section "__TEXT,__objc_methname,cstring_literals", align 1
 @"\01L_OBJC_SELECTOR_REFERENCES_" = internal global i8* getelementptr inbounds ([43 x i8], [43 x i8]* @"\01L_OBJC_METH_VAR_NAME_", i64 0, i64 0), section "__DATA, __objc_selrefs, literal_pointers, no_dead_strip"
 @g = common global i8* null, align 8
 @"\01L_OBJC_IMAGE_INFO" = internal constant [2 x i32] [i32 0, i32 16], section "__DATA, __objc_imageinfo, regular, no_dead_strip"
 

llvm/test/Transforms/ObjCARC/opt-catchswitch.ll

-; RUN: opt -S -objc-arc < %s | FileCheck %s
+; RUN: opt -S -passes=objc-arc < %s | FileCheck %s
 
 target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
 target triple = "i686--windows-msvc"
 
 declare i8* @f(i8*, i8*)
 
 declare i32 @__CxxFrameHandler3(...)
 

llvm/test/Transforms/ObjCARC/opt-max-ptr-states.ll

-; RUN: opt -objc-arc -S < %s | FileCheck -check-prefix=ENABLE -check-prefix=CHECK %s
-; RUN: opt -objc-arc -arc-opt-max-ptr-states=1 -S < %s | FileCheck -check-prefix=DISABLE -check-prefix=CHECK %s
+; RUN: opt -passes=objc-arc -S < %s | FileCheck -check-prefix=ENABLE -check-prefix=CHECK %s
+; RUN: opt -passes=objc-arc -arc-opt-max-ptr-states=1 -S < %s | FileCheck -check-prefix=DISABLE -check-prefix=CHECK %s
 
 @g0 = common global i8* null, align 8
 
 ; CHECK: call i8* @llvm.objc.retain
 ; ENABLE-NOT: call i8* @llvm.objc.retain
 ; DISABLE: call i8* @llvm.objc.retain
 ; CHECK: call void @llvm.objc.release
 ; ENABLE-NOT: call void @llvm.objc.release

llvm/test/Transforms/ObjCARC/path-overflow.ll

-; RUN: opt -objc-arc -S < %s
+; RUN: opt -passes=objc-arc -S < %s
 ; rdar://12277446
 ; rdar://12480535
 ; rdar://14590914
 ; rdar://15377890
 
 ; The total number of paths grows exponentially with the number of branches, and a
 ; computation of this number can overflow any reasonable fixed-sized
 ; integer. This can occur in both the addition phase when we are adding up the

llvm/test/Transforms/ObjCARC/pointer-types.ll

-; RUN: opt -objc-arc -S < %s | FileCheck %s
+; RUN: opt -passes=objc-arc -S < %s | FileCheck %s
 
 ; Don't hoist @llvm.objc.release past a use of its pointer, even
 ; if the use has function type, because clang uses function types
 ; in dubious ways.
 ; rdar://10551239
 
 ; CHECK-LABEL: define void @test0(
 ; CHECK: %otherBlock = phi void ()* [ %b1, %if.then ], [ null, %entry ]

llvm/test/Transforms/ObjCARC/post-inlining.ll

-; RUN: opt -S -objc-arc < %s | FileCheck %s
+; RUN: opt -S -passes=objc-arc < %s | FileCheck %s
 
 declare void @use_pointer(i8*)
 declare i8* @returner()
 declare i8* @llvm.objc.retain(i8*)
 declare i8* @llvm.objc.autoreleaseReturnValue(i8*)
 declare i8* @llvm.objc.retainAutoreleasedReturnValue(i8*)
 
 ; Clean up residue left behind after inlining.

llvm/test/Transforms/ObjCARC/pr12270.ll

-; RUN: opt -disable-output -objc-arc-contract < %s
+; RUN: opt -disable-output -passes=objc-arc-contract < %s
 ; test that we don't crash on unreachable code
 %2 = type opaque
 
 define void @_i_Test__foo(%2 *%x) {
 entry:
   unreachable
 
 return:                                           ; No predecessors!

llvm/test/Transforms/ObjCARC/retain-block-side-effects.ll

-; RUN: opt -S -objc-arc-aa -basic-aa -gvn < %s | FileCheck %s
+; RUN: opt -S -aa-pipeline=objc-arc-aa,basic-aa -passes=gvn < %s | FileCheck %s
 ; rdar://10050579
 
 ; objc_retainBlock stores into %repeater so the load from after the
 ; call isn't forwardable from the store before the call.
 
 ; CHECK: %tmp16 = call i8* @llvm.objc.retainBlock(i8* %tmp15) [[NUW:#[0-9]+]]
 ; CHECK: %tmp17 = bitcast i8* %tmp16 to void ()*
 ; CHECK: %tmp18 = load %struct.__block_byref_repeater*, %struct.__block_byref_repeater** %byref.forwarding, align 8

llvm/test/Transforms/ObjCARC/retain-not-declared.ll

-; RUN: opt -S -objc-arc -objc-arc-contract < %s | FileCheck %s
+; RUN: opt -S -passes=objc-arc,objc-arc-contract < %s | FileCheck %s
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
 declare i8* @llvm.objc.unretainedObject(i8*)
 declare i8* @llvm.objc.retainAutoreleasedReturnValue(i8*)
 declare i8* @llvm.objc.autoreleaseReturnValue(i8*)
 declare i8* @objc_msgSend(i8*, i8*, ...)
 declare void @llvm.objc.release(i8*)
 

llvm/test/Transforms/ObjCARC/rle-s2l.ll

-; RUN: opt -S -basic-aa -objc-arc < %s | FileCheck %s
+; RUN: opt -S -passes=objc-arc < %s | FileCheck %s
 
 declare i8* @llvm.objc.loadWeak(i8**)
 declare i8* @llvm.objc.loadWeakRetained(i8**)
 declare i8* @llvm.objc.storeWeak(i8**, i8*)
 declare i8* @llvm.objc.initWeak(i8**, i8*)
 declare void @use_pointer(i8*)
 declare void @callee()
 

llvm/test/Transforms/ObjCARC/rv.ll

-; RUN: opt -objc-arc -S < %s | FileCheck %s
+; RUN: opt -passes=objc-arc -S < %s | FileCheck %s
 
 target datalayout = "e-p:64:64:64"
 
 declare i8* @llvm.objc.retain(i8*)
 declare i8* @llvm.objc.retainAutoreleasedReturnValue(i8*)
 declare void @llvm.objc.release(i8*)
 declare i8* @llvm.objc.autorelease(i8*)
 declare i8* @llvm.objc.autoreleaseReturnValue(i8*)

llvm/test/Transforms/ObjCARC/split-backedge.ll

-; RUN: opt -S -objc-arc < %s | FileCheck %s
+; RUN: opt -S -passes=objc-arc < %s | FileCheck %s
 
 ; Handle a retain+release pair entirely contained within a split loop backedge.
 ; rdar://11256239
 
 ; CHECK-LABEL: define void @test0(
 ; CHECK: call i8* @llvm.objc.retain(i8* %call) [[NUW:#[0-9]+]]
 ; CHECK: call i8* @llvm.objc.retain(i8* %call) [[NUW]]
 ; CHECK: call i8* @llvm.objc.retain(i8* %cond) [[NUW]]

llvm/test/Transforms/ObjCARC/tail-call-invariant-enforcement.ll

-; RUN: opt -objc-arc -S < %s | FileCheck %s
+; RUN: opt -passes=objc-arc -S < %s | FileCheck %s
 
 declare void @llvm.objc.release(i8* %x)
 declare i8* @llvm.objc.retain(i8* %x)
 declare i8* @llvm.objc.autorelease(i8* %x)
 declare i8* @llvm.objc.autoreleaseReturnValue(i8* %x)
 declare i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %x)
 declare i8* @llvm.objc.unsafeClaimAutoreleasedReturnValue(i8* %x)
 declare i8* @tmp(i8*)

llvm/test/Transforms/ObjCARC/unsafe-claim-rv.ll

-; RUN: opt -objc-arc -S < %s | FileCheck %s
+; RUN: opt -passes=objc-arc -S < %s | FileCheck %s
 
 ; Generated by compiling:
 ;
 ; id baz(void *X) { return (__bridge_transfer id)X; }
 ; 
 ; void foo(id X) {
 ; void *Y = 0;
 ; if (X)

llvm/test/Transforms/ObjCARC/weak-contract.ll

-; RUN: opt -objc-arc-contract -S < %s | FileCheck %s
+; RUN: opt -passes=objc-arc-contract -S < %s | FileCheck %s
 
 declare i8* @llvm.objc.initWeak(i8**, i8*)
 
 ; Convert objc_initWeak(p, null) to *p = null.
 
 ; CHECK:      define i8* @test0(i8** %p) {
 ; CHECK-NEXT:   store i8* null, i8** %p
 ; CHECK-NEXT:   ret i8* null
 ; CHECK-NEXT: }
 define i8* @test0(i8** %p) {
   %t = call i8* @llvm.objc.initWeak(i8** %p, i8* null)
   ret i8* %t
 }

llvm/test/Transforms/ObjCARC/weak-copies.ll

-; RUN: opt -S -basic-aa -objc-arc < %s | FileCheck %s
+; RUN: opt -S -passes=objc-arc < %s | FileCheck %s
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
 target triple = "x86_64-apple-darwin11.0.0"
 
 %0 = type { i64, i64, i8*, i8*, i8*, i8* }
 %1 = type <{ i8*, i32, i32, i8*, %struct.__block_descriptor*, i8* }>
 %struct.__block_descriptor = type { i64, i64 }
 

llvm/test/Transforms/ObjCARC/weak-dce.ll

-; RUN: opt -S -basic-aa -objc-arc < %s | FileCheck %s
+; RUN: opt -S -passes=objc-arc < %s | FileCheck %s
 ; rdar://11434915
 
 ; Delete the weak calls and replace them with just the net retain.
 
 ;      CHECK: define void @test0(i8* %p) {
 ; CHECK-NEXT: call i8* @llvm.objc.retain(i8* %p)
 ; CHECK-NEXT: ret void
 

llvm/test/Transforms/ObjCARC/weak.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -objc-arc -S < %s | FileCheck %s
+; RUN: opt -passes=objc-arc -S < %s | FileCheck %s
 
 declare i8* @llvm.objc.initWeak(i8**, i8*)
 declare i8* @llvm.objc.storeWeak(i8**, i8*)
 declare i8* @llvm.objc.loadWeak(i8**)
 declare void @llvm.objc.destroyWeak(i8**)
 declare i8* @llvm.objc.loadWeakRetained(i8**)
 declare void @llvm.objc.moveWeak(i8**, i8**)
 declare void @llvm.objc.copyWeak(i8**, i8**)

llvm/tools/bugpoint/bugpoint.cpp

 #ifndef DEBUG_BUGPOINT
   InitLLVM X(argc, argv);
 #endif
 
   // Initialize passes
   PassRegistry &Registry = *PassRegistry::getPassRegistry();
   initializeCore(Registry);
   initializeScalarOpts(Registry);
-  initializeObjCARCOpts(Registry);
   initializeVectorization(Registry);
   initializeIPO(Registry);
   initializeAnalysis(Registry);
   initializeTransformUtils(Registry);
   initializeInstCombine(Registry);
   initializeAggressiveInstCombine(Registry);
   initializeInstrumentation(Registry);
   initializeTarget(Registry);

llvm/tools/llvm-opt-fuzzer/llvm-opt-fuzzer.cpp

extern "C" LLVM_ATTRIBUTE_USED int LLVMFuzzerInitialize(
   //
 
   InitializeAllTargets();
   InitializeAllTargetMCs();
 
   PassRegistry &Registry = *PassRegistry::getPassRegistry();
   initializeCore(Registry);
   initializeScalarOpts(Registry);
-  initializeObjCARCOpts(Registry);
   initializeVectorization(Registry);
   initializeIPO(Registry);
   initializeAnalysis(Registry);
   initializeTransformUtils(Registry);
   initializeInstCombine(Registry);
   initializeAggressiveInstCombine(Registry);
   initializeInstrumentation(Registry);
   initializeTarget(Registry);

llvm/tools/opt/opt.cpp

int main(int argc, char **argv) {
   InitializeAllTargetMCs();
   InitializeAllAsmPrinters();
   InitializeAllAsmParsers();
 
   // Initialize passes
   PassRegistry &Registry = *PassRegistry::getPassRegistry();
   initializeCore(Registry);
   initializeScalarOpts(Registry);
-  initializeObjCARCOpts(Registry);
   initializeVectorization(Registry);
   initializeIPO(Registry);
   initializeAnalysis(Registry);
   initializeTransformUtils(Registry);
   initializeInstCombine(Registry);
   initializeAggressiveInstCombine(Registry);
   initializeInstrumentation(Registry);
   initializeTarget(Registry);

llvm/utils/gn/secondary/llvm/lib/CodeGen/BUILD.gn

 static_library("CodeGen") {
   output_name = "LLVMCodeGen"
   public_deps = [
     # Must be a public_dep because CodeGen's headers include llvm-config.h.
     "//llvm/include/llvm/Config:llvm-config",
   ]
   deps = [
     "//llvm/lib/Analysis",
     "//llvm/lib/Bitcode/Reader",
     "//llvm/lib/Bitcode/Writer",
     "//llvm/lib/IR",
     "//llvm/lib/MC",
     "//llvm/lib/ProfileData",
     "//llvm/lib/Support",
     "//llvm/lib/Target",
+    "//llvm/lib/Transforms/ObjCARC",
     "//llvm/lib/Transforms/Scalar",
     "//llvm/lib/Transforms/Utils",
   ]
   sources = [
     "AggressiveAntiDepBreaker.cpp",
     "AllocationOrder.cpp",
     "Analysis.cpp",
     "AtomicExpandPass.cpp",