[ArgPromotion] Remove legacy PM support

[nikic]

Summary

Support for the legacy pass manager in ArgPromotion causes complications in D125485. As the legacy pass manager for middle-end optimizations is unsupported, drop ArgPromotion from the legacy pipeline, rather than introducing additional complexity to deal with it.

llvm/bindings/go/llvm/transforms_ipo.go

 // helpers
 func boolToUnsigned(b bool) C.unsigned {
   if b {
     return 1
   }
   return 0
 }
 
-func (pm PassManager) AddArgumentPromotionPass()     { C.LLVMAddArgumentPromotionPass(pm.C) }
 func (pm PassManager) AddConstantMergePass()         { C.LLVMAddConstantMergePass(pm.C) }
 func (pm PassManager) AddDeadArgEliminationPass()    { C.LLVMAddDeadArgEliminationPass(pm.C) }
 func (pm PassManager) AddFunctionAttrsPass()         { C.LLVMAddFunctionAttrsPass(pm.C) }
 func (pm PassManager) AddFunctionInliningPass()      { C.LLVMAddFunctionInliningPass(pm.C) }
 func (pm PassManager) AddGlobalDCEPass()             { C.LLVMAddGlobalDCEPass(pm.C) }
 func (pm PassManager) AddGlobalOptimizerPass()       { C.LLVMAddGlobalOptimizerPass(pm.C) }
 func (pm PassManager) AddPruneEHPass()               { C.LLVMAddPruneEHPass(pm.C) }
 func (pm PassManager) AddIPSCCPPass()                { C.LLVMAddIPSCCPPass(pm.C) }
 func (pm PassManager) AddInternalizePass(allButMain bool) {
   C.LLVMAddInternalizePass(pm.C, boolToUnsigned(allButMain))
 }
 func (pm PassManager) AddStripDeadPrototypesPass() { C.LLVMAddStripDeadPrototypesPass(pm.C) }

llvm/bindings/ocaml/transforms/ipo/ipo_ocaml.c

 |*                                                                            *|
 \*===----------------------------------------------------------------------===*/
 
 #include "llvm-c/Transforms/IPO.h"
 #include "caml/mlvalues.h"
 #include "caml/misc.h"
 
 /* [`Module] Llvm.PassManager.t -> unit */
-value llvm_add_argument_promotion(LLVMPassManagerRef PM) {
-  LLVMAddArgumentPromotionPass(PM);
-  return Val_unit;
-}
-
-/* [`Module] Llvm.PassManager.t -> unit */
 value llvm_add_constant_merge(LLVMPassManagerRef PM) {
   LLVMAddConstantMergePass(PM);
   return Val_unit;
 }
 
 /* [`Module] Llvm.PassManager.t -> unit */
 value llvm_add_merge_functions(LLVMPassManagerRef PM) {
   LLVMAddMergeFunctionsPass(PM);

llvm/bindings/ocaml/transforms/ipo/llvm_ipo.ml

 (*===-- llvm_ipo.ml - LLVM OCaml Interface --------------------*- OCaml -*-===*
  *
  * 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
  *
  *===----------------------------------------------------------------------===*)
 
-external add_argument_promotion
-  : [ `Module ] Llvm.PassManager.t -> unit
-  = "llvm_add_argument_promotion"
 external add_constant_merge
   : [ `Module ] Llvm.PassManager.t -> unit
   = "llvm_add_constant_merge"
 external add_merge_functions
   : [ `Module ] Llvm.PassManager.t -> unit
   = "llvm_add_merge_functions"
 external add_dead_arg_elimination
   : [ `Module ] Llvm.PassManager.t -> unit

llvm/bindings/ocaml/transforms/ipo/llvm_ipo.mli

 (*===-- llvm_ipo.mli - LLVM OCaml Interface -------------------*- OCaml -*-===*
  *
  * 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
  *
  *===----------------------------------------------------------------------===*)
 
 (** IPO Transforms.
 
     This interface provides an OCaml API for LLVM interprocedural optimizations, the
     classes in the [LLVMIPO] library. *)
 
-(** See the [llvm::createAddArgumentPromotionPass] function. *)
-external add_argument_promotion
-  : [ `Module ] Llvm.PassManager.t -> unit
-  = "llvm_add_argument_promotion"
-
 (** See the [llvm::createConstantMergePass] function. *)
 external add_constant_merge
   : [ `Module ] Llvm.PassManager.t -> unit
   = "llvm_add_constant_merge"
 
 (** See the [llvm::createMergeFunctionsPass] function. *)
 external add_merge_functions
   : [ `Module ] Llvm.PassManager.t -> unit

llvm/include/llvm-c/Transforms/IPO.h

 
 /**
  * @defgroup LLVMCTransformsIPO Interprocedural transformations
  * @ingroup LLVMCTransforms
  *
  * @{
  */
 
-/** See llvm::createArgumentPromotionPass function. */
-void LLVMAddArgumentPromotionPass(LLVMPassManagerRef PM);
-
 /** See llvm::createConstantMergePass function. */
 void LLVMAddConstantMergePass(LLVMPassManagerRef PM);
 
 /** See llvm::createMergeFunctionsPass function. */
 void LLVMAddMergeFunctionsPass(LLVMPassManagerRef PM);
 
 /** See llvm::createCalledValuePropagationPass function. */
 void LLVMAddCalledValuePropagationPass(LLVMPassManagerRef PM);

llvm/include/llvm/InitializePasses.h

 void initializeAliasSetPrinterPass(PassRegistry&);
 void initializeAlignmentFromAssumptionsPass(PassRegistry&);
 void initializeAlwaysInlinerLegacyPassPass(PassRegistry&);
 void initializeAssumeSimplifyPassLegacyPassPass(PassRegistry &);
 void initializeAssumeBuilderPassLegacyPassPass(PassRegistry &);
 void initializeAnnotation2MetadataLegacyPass(PassRegistry &);
 void initializeAnnotationRemarksLegacyPass(PassRegistry &);
 void initializeOpenMPOptCGSCCLegacyPassPass(PassRegistry &);
-void initializeArgPromotionPass(PassRegistry&);
 void initializeAssumptionCacheTrackerPass(PassRegistry&);
 void initializeAtomicExpandPass(PassRegistry&);
 void initializeAttributorLegacyPassPass(PassRegistry&);
 void initializeAttributorCGSCCLegacyPassPass(PassRegistry &);
 void initializeBasicBlockSectionsProfileReaderPass(PassRegistry &);
 void initializeBasicBlockSectionsPass(PassRegistry &);
 void initializeBDCELegacyPassPass(PassRegistry&);
 void initializeBarrierNoopPass(PassRegistry&);

llvm/include/llvm/LinkAllPasses.h

ForcePassLinking() {
       if (std::getenv("bar") != (char*) -1)
         return;
 
       (void) llvm::createAAEvalPass();
       (void) llvm::createAggressiveDCEPass();
       (void) llvm::createAggressiveInstCombinerPass();
       (void) llvm::createBitTrackingDCEPass();
       (void)llvm::createOpenMPOptCGSCCLegacyPass();
-      (void) llvm::createArgumentPromotionPass();
       (void) llvm::createAlignmentFromAssumptionsPass();
       (void) llvm::createBasicAAWrapperPass();
       (void) llvm::createSCEVAAWrapperPass();
       (void) llvm::createTypeBasedAAWrapperPass();
       (void) llvm::createScopedNoAliasAAWrapperPass();
       (void) llvm::createBoundsCheckingLegacyPass();
       (void) llvm::createBreakCriticalEdgesPass();
       (void) llvm::createCallGraphDOTPrinterPass();

llvm/include/llvm/Transforms/IPO.h

 ModulePass *createDeadArgEliminationPass();
 
 /// DeadArgHacking pass - Same as DAE, but delete arguments of external
 /// functions as well.  This is definitely not safe, and should only be used by
 /// bugpoint.
 ModulePass *createDeadArgHackingPass();
 
 //===----------------------------------------------------------------------===//
-/// createArgumentPromotionPass - This pass promotes "by reference" arguments to
-/// be passed by value if the number of elements passed is smaller or
-/// equal to maxElements (maxElements == 0 means always promote).
-///
-Pass *createArgumentPromotionPass(unsigned maxElements = 3);
-
-//===----------------------------------------------------------------------===//
 /// createOpenMPOptLegacyPass - OpenMP specific optimizations.
 Pass *createOpenMPOptCGSCCLegacyPass();
 
 //===----------------------------------------------------------------------===//
 /// createIPSCCPPass - This pass propagates constants from call sites into the
 /// bodies of functions, and keeps track of whether basic blocks are executable
 /// in the process.
 ///

llvm/lib/Transforms/IPO/ArgumentPromotion.cpp

PreservedAnalyses ArgumentPromotionPass::run(LazyCallGraph::SCC &C,
 
   PreservedAnalyses PA;
   // We've cleared out analyses for deleted functions.
   PA.preserve<FunctionAnalysisManagerCGSCCProxy>();
   // We've manually invalidated analyses for functions we've modified.
   PA.preserveSet<AllAnalysesOn<Function>>();
   return PA;
 }
-
-namespace {
-
-/// ArgPromotion - The 'by reference' to 'by value' argument promotion pass.
-struct ArgPromotion : public CallGraphSCCPass {
-  // Pass identification, replacement for typeid
-  static char ID;
-
-  explicit ArgPromotion(unsigned MaxElements = 3)
-      : CallGraphSCCPass(ID), MaxElements(MaxElements) {
-    initializeArgPromotionPass(*PassRegistry::getPassRegistry());
-  }
-
-  void getAnalysisUsage(AnalysisUsage &AU) const override {
-    AU.addRequired<AssumptionCacheTracker>();
-    AU.addRequired<TargetLibraryInfoWrapperPass>();
-    AU.addRequired<TargetTransformInfoWrapperPass>();
-    getAAResultsAnalysisUsage(AU);
-    CallGraphSCCPass::getAnalysisUsage(AU);
-  }
-
-  bool runOnSCC(CallGraphSCC &SCC) override;
-
-private:
-  using llvm::Pass::doInitialization;
-
-  bool doInitialization(CallGraph &CG) override;
-
-  /// The maximum number of elements to expand, or 0 for unlimited.
-  unsigned MaxElements;
-};
-
-} // end anonymous namespace
-
-char ArgPromotion::ID = 0;
-
-INITIALIZE_PASS_BEGIN(ArgPromotion, "argpromotion",
-                      "Promote 'by reference' arguments to scalars", false,
-                      false)
-INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
-INITIALIZE_PASS_DEPENDENCY(CallGraphWrapperPass)
-INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)
-INITIALIZE_PASS_DEPENDENCY(TargetTransformInfoWrapperPass)
-INITIALIZE_PASS_END(ArgPromotion, "argpromotion",
-                    "Promote 'by reference' arguments to scalars", false, false)
-
-Pass *llvm::createArgumentPromotionPass(unsigned MaxElements) {
-  return new ArgPromotion(MaxElements);
-}
-
-bool ArgPromotion::runOnSCC(CallGraphSCC &SCC) {
-  if (skipSCC(SCC))
-    return false;
-
-  // Get the callgraph information that we need to update to reflect our
-  // changes.
-  CallGraph &CG = getAnalysis<CallGraphWrapperPass>().getCallGraph();
-
-  LegacyAARGetter AARGetter(*this);
-
-  bool Changed = false, LocalChange;
-
-  // Iterate until we stop promoting from this SCC.
-  do {
-    LocalChange = false;
-    // Attempt to promote arguments from all functions in this SCC.
-    bool IsRecursive = SCC.size() > 1;
-    for (CallGraphNode *OldNode : SCC) {
-      Function *OldF = OldNode->getFunction();
-      if (!OldF)
-        continue;
-
-      auto ReplaceCallSite = [&](CallBase &OldCS, CallBase &NewCS) {
-        Function *Caller = OldCS.getParent()->getParent();
-        CallGraphNode *NewCalleeNode =
-            CG.getOrInsertFunction(NewCS.getCalledFunction());
-        CallGraphNode *CallerNode = CG[Caller];
-        CallerNode->replaceCallEdge(cast<CallBase>(OldCS),
-                                    cast<CallBase>(NewCS), NewCalleeNode);
-      };
-
-      const TargetTransformInfo &TTI =
-          getAnalysis<TargetTransformInfoWrapperPass>().getTTI(*OldF);
-      if (Function *NewF =
-              promoteArguments(OldF, AARGetter, MaxElements, {ReplaceCallSite},
-                               TTI, IsRecursive)) {
-        LocalChange = true;
-
-        // Update the call graph for the newly promoted function.
-        CallGraphNode *NewNode = CG.getOrInsertFunction(NewF);
-        NewNode->stealCalledFunctionsFrom(OldNode);
-        if (OldNode->getNumReferences() == 0)
-          delete CG.removeFunctionFromModule(OldNode);
-        else
-          OldF->setLinkage(Function::ExternalLinkage);
-
-        // And update the SCC we're iterating as well.
-        SCC.ReplaceNode(OldNode, NewNode);
-      }
-    }
-    // Remember that we changed something.
-    Changed |= LocalChange;
-  } while (LocalChange);
-
-  return Changed;
-}
-
-bool ArgPromotion::doInitialization(CallGraph &CG) {
-  return CallGraphSCCPass::doInitialization(CG);
-}

llvm/lib/Transforms/IPO/IPO.cpp

 #include "llvm/Transforms/IPO.h"
 #include "llvm/Transforms/IPO/AlwaysInliner.h"
 #include "llvm/Transforms/IPO/FunctionAttrs.h"
 
 using namespace llvm;
 
 void llvm::initializeIPO(PassRegistry &Registry) {
   initializeOpenMPOptCGSCCLegacyPassPass(Registry);
-  initializeArgPromotionPass(Registry);
   initializeAnnotation2MetadataLegacyPass(Registry);
   initializeCalledValuePropagationLegacyPassPass(Registry);
   initializeConstantMergeLegacyPassPass(Registry);
   initializeCrossDSOCFIPass(Registry);
   initializeDAEPass(Registry);
   initializeDAHPass(Registry);
   initializeForceFunctionAttrsLegacyPassPass(Registry);
   initializeFunctionSpecializationLegacyPassPass(Registry);
void llvm::initializeIPO(PassRegistry &Registry) {
   initializeFunctionImportLegacyPassPass(Registry);
   initializeWholeProgramDevirtPass(Registry);
 }
 
 void LLVMInitializeIPO(LLVMPassRegistryRef R) {
   initializeIPO(*unwrap(R));
 }
 
-void LLVMAddArgumentPromotionPass(LLVMPassManagerRef PM) {
-  unwrap(PM)->add(createArgumentPromotionPass());
-}
-
 void LLVMAddCalledValuePropagationPass(LLVMPassManagerRef PM) {
   unwrap(PM)->add(createCalledValuePropagationPass());
 }
 
 void LLVMAddConstantMergePass(LLVMPassManagerRef PM) {
   unwrap(PM)->add(createConstantMergePass());
 }
 

llvm/lib/Transforms/IPO/PassManagerBuilder.cpp

if (AttributorRun & AttributorRunOption::CGSCC)
     MPM.add(createAttributorCGSCCLegacyPass());
 
   // Try to perform OpenMP specific optimizations. This is a (quick!) no-op if
   // there are no OpenMP runtime calls present in the module.
   if (OptLevel > 1)
     MPM.add(createOpenMPOptCGSCCLegacyPass());
 
   MPM.add(createPostOrderFunctionAttrsLegacyPass());
-  if (OptLevel > 2)
-    MPM.add(createArgumentPromotionPass()); // Scalarize uninlined fn args
 
   addExtensionsToPM(EP_CGSCCOptimizerLate, MPM);
   addFunctionSimplificationPasses(MPM);
 
   // FIXME: This is a HACK! The inliner pass above implicitly creates a CGSCC
   // pass manager that we are specifically trying to avoid. To prevent this
   // we must insert a no-op module pass to reset the pass manager.
   MPM.add(createBarrierNoopPass());
void PassManagerBuilder::addLTOOptimizationPasses(legacy::PassManagerBase &PM) {
   if (OptLevel > 1)
     PM.add(createOpenMPOptCGSCCLegacyPass());
 
   // Optimize globals again if we ran the inliner.
   if (RunInliner)
     PM.add(createGlobalOptimizerPass());
   PM.add(createGlobalDCEPass()); // Remove dead functions.
 
-  // If we didn't decide to inline a function, check to see if we can
-  // transform it to pass arguments by value instead of by reference.
-  PM.add(createArgumentPromotionPass());
-
   // The IPO passes may leave cruft around.  Clean up after them.
   PM.add(createInstructionCombiningPass());
   addExtensionsToPM(EP_Peephole, PM);
   PM.add(createJumpThreadingPass());
 
   // Break up allocas
   PM.add(createSROAPass());
 

llvm/test/Analysis/TypeBasedAliasAnalysis/argument-promotion.ll

-; RUN: opt < %s -tbaa -basic-aa -argpromotion -mem2reg -S | FileCheck %s
+; RUN: opt < %s -passes=argpromotion,mem2reg -S | FileCheck %s
 
 target datalayout = "E-p:64:64:64"
 
 ; CHECK: test
 ; CHECK-NOT: alloca
 define internal i32 @test(i32* %X, i32* %Y, i32* %Q) {
   store i32 77, i32* %Q, !tbaa !2
   %A = load i32, i32* %X, !tbaa !1

llvm/test/Bindings/OCaml/ipo.ml

let test_transforms () =
   let fn = define_function "fn" fty m in
   let fn2 = define_function "fn2" fty m in begin
       ignore (build_ret (const_int i8_type 4) (builder_at_end context (entry_block fn)));
       let b = builder_at_end context  (entry_block fn2) in
       ignore (build_ret (build_call2 fty fn [| |] "" b) b);
   end;
 
   ignore (PassManager.create ()
-           ++ add_argument_promotion
            ++ add_constant_merge
            ++ add_dead_arg_elimination
            ++ add_function_attrs
            ++ add_function_inlining
            ++ add_always_inliner
            ++ add_global_dce
            ++ add_global_optimizer
            ++ add_prune_eh

llvm/test/CodeGen/PowerPC/arg_promotion.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -S -argpromotion -mtriple=powerpc64le-unknown-linux-gnu < %s | FileCheck %s
 ; RUN: opt -S -passes=argpromotion -mtriple=powerpc64le-unknown-linux-gnu < %s | FileCheck %s
 
 ; Test to check that we do not promote arguments when the
 ; type size is greater than 128 bits.
 
 define internal fastcc void @print_acc(<512 x i1>* nocapture readonly %a) nounwind {
 ; CHECK-LABEL: @print_acc(
 ; CHECK-NEXT:  entry:

llvm/test/CodeGen/X86/GC/argpromotion.ll

-; RUN: opt < %s -argpromotion
+; RUN: opt < %s -passes=argpromotion
 
 declare void @llvm.gcroot(ptr, ptr)
 
 define i32 @g() {
 entry:
   %var = alloca i32
   store i32 1, ptr %var
   %x = call i32 @f(ptr %var)

llvm/test/Transforms/ArgumentPromotion/2008-09-07-CGUpdate.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes
-; RUN: opt < %s -inline -argpromotion -disable-output
+; RUN: opt < %s -passes=inline,argpromotion -disable-output
 
 define internal fastcc i32 @hash(i32* %ts, i32 %mod) nounwind {
 entry:
   unreachable
 }
 
 define void @encode(i32* %m, i32* %ts, i32* %new) nounwind {
 entry:
   %0 = call fastcc i32 @hash( i32* %ts, i32 0 ) nounwind    ; <i32> [#uses=0]
   unreachable
 }

llvm/test/Transforms/ArgumentPromotion/X86/attributes.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes
-; RUN: opt -S -argpromotion < %s | FileCheck %s
 ; RUN: opt -S -passes=argpromotion < %s | FileCheck %s
 ; Test that we only promote arguments when the caller/callee have compatible
 ; function attrubtes.
 
 target triple = "x86_64-unknown-linux-gnu"
 
 define internal fastcc void @no_promote_avx2(<4 x i64>* %arg, <4 x i64>* readonly %arg1) #0 {
 ; CHECK-LABEL: define {{[^@]+}}@no_promote_avx2

llvm/test/Transforms/ArgumentPromotion/X86/min-legal-vector-width.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes
-; RUN: opt -S -argpromotion < %s | FileCheck %s
 ; RUN: opt -S -passes=argpromotion < %s | FileCheck %s
 ; Test that we only promote arguments when the caller/callee have compatible
 ; function attrubtes.
 
 target triple = "x86_64-unknown-linux-gnu"
 
 ; This should promote
 define internal fastcc void @callee_avx512_legal512_prefer512_call_avx512_legal512_prefer512(<8 x i64>* %arg, <8 x i64>* readonly %arg1) #0 {

llvm/test/Transforms/ArgumentPromotion/X86/thiscall.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes
 ; In PR41658, argpromotion put an inalloca in a position that per the
 ; calling convention is passed in a register. This test verifies that
 ; we don't do that anymore. It also verifies that the combination of
 ; globalopt and argpromotion is able to optimize the call safely.
 ;
-; RUN: opt -S -argpromotion %s | FileCheck %s --check-prefix=ARGPROMOTION
-; RUN: opt -S -globalopt -argpromotion %s | FileCheck %s --check-prefix=GLOBALOPT_ARGPROMOTION
+; RUN: opt -S -passes=argpromotion %s | FileCheck %s --check-prefix=ARGPROMOTION
+; RUN: opt -S -passes=globalopt,argpromotion %s | FileCheck %s --check-prefix=GLOBALOPT_ARGPROMOTION
 
 target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
 target triple = "i386-pc-windows-msvc19.11.0"
 
 %struct.a = type { i8 }
 
 define internal x86_thiscallcc void @internalfun(%struct.a* %this, <{ %struct.a }>* inalloca(<{ %struct.a }>)) {
 ; ARGPROMOTION-LABEL: define {{[^@]+}}@internalfun

llvm/test/Transforms/ArgumentPromotion/align.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes
-; RUN: opt -S -argpromotion < %s | FileCheck %s
+; RUN: opt -S -passes=argpromotion < %s | FileCheck %s
 
 define internal i32 @callee_must_exec(i32* %p) {
 ; CHECK-LABEL: define {{[^@]+}}@callee_must_exec
 ; CHECK-SAME: (i32 [[P_0_VAL:%.*]]) {
 ; CHECK-NEXT:    ret i32 [[P_0_VAL]]
 ;
   %x = load i32, i32* %p, align 16
   ret i32 %x

llvm/test/Transforms/ArgumentPromotion/basictest.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes
-; RUN: opt < %s -basic-aa -argpromotion -mem2reg -S | FileCheck %s
+; RUN: opt < %s -passes=argpromotion,mem2reg -S | FileCheck %s
 target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
 
 define internal i32 @test(i32* %X, i32* %Y) {
 ; CHECK-LABEL: define {{[^@]+}}@test
 ; CHECK-SAME: (i32 [[X_0_VAL:%.*]], i32 [[Y_0_VAL:%.*]]) {
 ; CHECK-NEXT:    [[C:%.*]] = add i32 [[X_0_VAL]], [[Y_0_VAL]]
 ; CHECK-NEXT:    ret i32 [[C]]
 ;

llvm/test/Transforms/ArgumentPromotion/bitcasts.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes
-; RUN: opt -S -argpromotion < %s | FileCheck %s
+; RUN: opt -S -passes=argpromotion < %s | FileCheck %s
 
 ; Test argument promotion involving bitcasts.
 
 %opaque = type opaque
 
 define internal i32 @callee_basic(i8* %p) {
 ; CHECK-LABEL: define {{[^@]+}}@callee_basic
 ; CHECK-SAME: (i32 [[P_0_VAL:%.*]], i32 [[P_4_VAL:%.*]]) {

llvm/test/Transforms/ArgumentPromotion/crash.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes
-; RUN: opt -S < %s -inline -argpromotion | FileCheck %s --check-prefixes=ARGPROMOTION,ALL_OLDPM --allow-unused-prefixes
-; RUN: opt -S < %s -passes=inline,argpromotion | FileCheck %s --check-prefixes=ARGPROMOTION,ALL_NEWPM --allow-unused-prefixes
+; RUN: opt -S < %s -passes=inline,argpromotion | FileCheck %s --check-prefix=ARGPROMOTION
 
 %S = type { %S* }
 
 ; Inlining should nuke the invoke (and any inlined calls) here even with
 ; argument promotion running along with it.
 define void @zot() personality i32 (...)* @wibble {
 ; ARGPROMOTION-LABEL: define {{[^@]+}}@zot() personality i32 (...)* @wibble {
 ; ARGPROMOTION-NEXT:  bb:

 ; ARGPROMOTION-NEXT:    unreachable
 ;
 bb:
   %temp = call zeroext i1 @barney(i8* %arg)
   unreachable
 }
 
 define internal i1 @barney(i8* %arg) {
-; ALL_OLDPM-LABEL: define {{[^@]+}}@barney() {
-; ALL_OLDPM-NEXT:  bb:
-; ALL_OLDPM-NEXT:    ret i1 undef
-;
 bb:
   ret i1 undef
 }
 
 define i32 @test_inf_promote_caller(i32 %arg) {
 ; ARGPROMOTION-LABEL: define {{[^@]+}}@test_inf_promote_caller
 ; ARGPROMOTION-SAME: (i32 [[ARG:%.*]]) {
 ; ARGPROMOTION-NEXT:  bb:

llvm/test/Transforms/ArgumentPromotion/load-after-non-willreturn-call.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes
-; RUN: opt -S -argpromotion < %s | FileCheck %s
+; RUN: opt -S -passes=argpromotion < %s | FileCheck %s
 
 declare void @may_not_return()
 
 ; The argument cannot be promoted, as we do not know whether the load can be
 ; speculatively executed.
 
 define internal i32 @callee(i32* %p) {
 ; CHECK-LABEL: define {{[^@]+}}@callee

llvm/test/Transforms/ArgumentPromotion/metadata.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes
-; RUN: opt < %s -argpromotion -S | FileCheck %s
+; RUN: opt < %s -passes=argpromotion -S | FileCheck %s
 
 declare void @use.i32(i32)
 declare void @use.p32(i32*)
 
 define internal void @callee(i32* %p1, i32** %p2, i32** %p3, i32** %p4, i32** %p5, i32** %p6) {
 ; CHECK-LABEL: define {{[^@]+}}@callee
 ; CHECK-SAME: (i32 [[P1_0_VAL:%.*]], i32* [[P2_0_VAL:%.*]], i32* [[P3_0_VAL:%.*]], i32* [[P4_0_VAL:%.*]], i32* [[P5_0_VAL:%.*]], i32* [[P6_0_VAL:%.*]]) {
 ; CHECK-NEXT:    call void @use.i32(i32 [[P1_0_VAL]])

llvm/test/Transforms/ArgumentPromotion/opaque-ptr.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes
-; RUN: opt -S -argpromotion -opaque-pointers < %s | FileCheck %s
+; RUN: opt -S -passes=argpromotion < %s | FileCheck %s
 
 define internal i32 @callee_basic(ptr %p) {
 ; CHECK-LABEL: define {{[^@]+}}@callee_basic
 ; CHECK-SAME: (i32 [[P_0_VAL:%.*]], i32 [[P_4_VAL:%.*]]) {
 ; CHECK-NEXT:    [[Z:%.*]] = add i32 [[P_0_VAL]], [[P_4_VAL]]
 ; CHECK-NEXT:    ret i32 [[Z]]
 ;
   %x = load i32, ptr %p

llvm/test/Transforms/ArgumentPromotion/pr32917.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes
-; RUN: opt < %s -argpromotion -S | FileCheck %s
+; RUN: opt < %s -passes=argpromotion -S | FileCheck %s
 ; PR 32917
 
 @b = common local_unnamed_addr global i32 0, align 4
 @a = common local_unnamed_addr global i32 0, align 4
 
 define i32 @fn2() local_unnamed_addr {
 ; CHECK-LABEL: define {{[^@]+}}@fn2() local_unnamed_addr {
 ; CHECK-NEXT:    [[TMP1:%.*]] = load i32, i32* @b, align 4

llvm/test/Transforms/ArgumentPromotion/pr42028-recursion.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature
-; RUN: opt -S < %s -argpromotion | FileCheck %s
+; RUN: opt -S < %s -passes=argpromotion | FileCheck %s
 
 ; This shouldn't get infinitely promoted.
 
 %S = type { %S* }
 
 define i32 @test_inf_promote_caller(i32 %arg) {
 ; CHECK-LABEL: define {{[^@]+}}@test_inf_promote_caller
 ; CHECK-SAME: (i32 [[ARG:%.*]]) {

llvm/test/Transforms/ArgumentPromotion/profile.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes
-; RUN: opt -argpromotion -mem2reg -S < %s | FileCheck %s
+; RUN: opt -passes=argpromotion,mem2reg -S < %s | FileCheck %s
 target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
 
 ; Checks if !prof metadata is corret in deadargelim.
 
 define void @caller() #0 {
 ; CHECK-LABEL: define {{[^@]+}}@caller() {
 ; CHECK-NEXT:    call void @promote_i32_ptr(i32 42), !prof [[PROF0:![0-9]+]]
 ; CHECK-NEXT:    ret void

llvm/test/Transforms/ArgumentPromotion/volatile-atomic.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -S -argpromotion < %s | FileCheck %s
+; RUN: opt -S -passes=argpromotion < %s | FileCheck %s
 
 ; Make sure volatile and atomic loads are not promoted.
 
 define internal i32 @callee_volatile(i32* %p) {
 ; CHECK-LABEL: @callee_volatile(
 ; CHECK-NEXT:    [[V:%.*]] = load volatile i32, i32* [[P:%.*]], align 4
 ; CHECK-NEXT:    ret i32 [[V]]
 ;

llvm/test/Transforms/CodeExtractor/LoopExtractor_crash.ll

-; RUN: opt < %s -inline -loop-simplify -loop-extract -S | FileCheck %s
-; RUN: opt < %s -argpromotion -loop-simplify -loop-extract -S | FileCheck %s
+; RUN: opt < %s -passes='cgscc(inline,loop-simplify),loop-extract' -S | FileCheck %s
+; RUN: opt < %s -passes='cgscc(argpromotion,loop-simplify),loop-extract' -S | FileCheck %s
 
 ; This test used to trigger an assert (PR8929).
 
 define void @test() {
 ; CHECK-LABEL: define void @test()
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br label %codeRepl
 ; CHECK:       codeRepl:

llvm/test/Transforms/Inline/2009-01-13-RecursiveInlineCrash.ll

-; RUN: opt < %s -inline -argpromotion -disable-output
+; RUN: opt < %s -passes=inline,argpromotion -disable-output
 ; ModuleID = '<stdin>'
 target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
 target triple = "i386-apple-darwin9.6"
   %struct.quad_struct = type { i32, i32, %struct.quad_struct*, %struct.quad_struct*, %struct.quad_struct*, %struct.quad_struct*, %struct.quad_struct* }
 @NumNodes = external global i32   ; <i32*> [#uses=0]
 @"\01LC" = external constant [43 x i8]    ; <[43 x i8]*> [#uses=0]
 @"\01LC1" = external constant [19 x i8]    ; <[19 x i8]*> [#uses=0]
 @"\01LC2" = external constant [17 x i8]    ; <[17 x i8]*> [#uses=0]

llvm/test/Transforms/Inline/crash.ll

-; RUN: opt < %s -inline -argpromotion -instcombine -disable-output
+; RUN: opt < %s -passes=inline,argpromotion,instcombine -disable-output
 
 ; This test was failing because the inliner would inline @list_DeleteElement
 ; into @list_DeleteDuplicates and then into @inf_GetBackwardPartnerLits,
 ; turning the indirect call into a direct one.  This allowed instcombine to see
 ; the bitcast and eliminate it, deleting the original call and introducing
 ; another one.  This crashed the inliner because the new call was not in the
 ; callgraph.