[PM] WIP: Port ArgumentPromotion to the new pass manager.

[chandlerc]

Summary

This is a fresh attempt to port ArgumentPromotion to the new pass manager. The
key difference is that we now handle the deletion of reference edges when
promoting calls. This requires re-scanning the callers to compute the set of
*removed* references which turns this whole thing quadratic.

I'm not sure we want to go this route long term, and not even sure if this will
be an acceptable short-term direction, but sending out the work in progress to
aid discussions and experiments with others.

Note that this will crash if we end up deleting an edge in a way that
decomposes a RefSCC into multiple new RefSCCs. Code for that hasn't been added.

[davide]

I assume this is superseded by the new approach. If so, can you abandon/close this one?

[chandlerc]

Yes, sorry. I thought I had abandoned all of the ones superseded but I missed this one.

include/llvm/Analysis/LazyCallGraph.h

#endif
   /// same patterns as when we build the call graph.
 
   /// Recursively visits the defined functions whose address is reachable from
   /// every constant in the \p Worklist.
   ///
   /// Doesn't recurse through any constants already in the \p Visited set, and
   /// updates that set with every constant visited.
   ///
-  /// For each defined function, calls \p Callback with that function.
+  /// For each defined function, calls \p Callback with that function. If \p
+  /// Callback returns true, the visit is considered complete and this returns
+  /// immediately. To visit the full worklist, simply always return false.
   template <typename CallbackT>
   static void visitReferences(SmallVectorImpl<Constant *> &Worklist,
                               SmallPtrSetImpl<Constant *> &Visited,
                               CallbackT Callback) {
     while (!Worklist.empty()) {
       Constant *C = Worklist.pop_back_val();
 
       if (Function *F = dyn_cast<Function>(C)) {
         if (!F->isDeclaration())
-          Callback(*F);
+          if (Callback(*F))
+            return;
+
         continue;
       }
 
       if (BlockAddress *BA = dyn_cast<BlockAddress>(C)) {
         // The blockaddress constant expression is a weird special case, we
         // can't generically walk its operands the way we do for all other
         // constants.
         if (Visited.insert(BA->getFunction()).second)

include/llvm/Transforms/IPO/ArgumentPromotion.h

+//===- ArgumentPromotion.h - Promote by-reference arguments -----*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_IPO_ARGUMENTPROMOTION_H
+#define LLVM_TRANSFORMS_IPO_ARGUMENTPROMOTION_H
+
+#include "llvm/Analysis/CGSCCPassManager.h"
+#include "llvm/Analysis/LazyCallGraph.h"
+
+namespace llvm {
+
+/// Argument promotion pass.
+///
+/// This pass walks the functions in each SCC and for each one tries to
+/// transform it and all of its callers to replace indirect arguments with
+/// direct (by-value) arguments.
+class ArgumentPromotionPass : public PassInfoMixin<ArgumentPromotionPass> {
+public:
+  PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM,
+                        LazyCallGraph &CG, CGSCCUpdateResult &UR);
+};
+
+}
+
+#endif

lib/Analysis/CGSCCPassManager.cpp

LazyCallGraph::visitReferences(Worklist, Visited, [&](Function &Referee) {
     // FIXME: Similarly to new calls, we also currently preclude
     // introducing new references. See above for details.
     assert(E && "No function transformations should introduce *new* ref "
                 "edges! Any new ref edges would require IPO which "
                 "function passes aren't allowed to do!");
     RetainedEdges.insert(&Referee);
     if (E->isCall())
       DemotedCallTargets.insert(&Referee);
+
+    // Walk all of the references.
+    return false;
   });
 
   // First remove all of the edges that are no longer present in this function.
   // We have to build a list of dead targets first and then remove them as the
   // data structures will all be invalidated by removing them.
   SmallVector<PointerIntPair<Node *, 1, Edge::Kind>, 4> DeadTargets;
   for (Edge &E : N)
     if (!RetainedEdges.count(&E.getFunction()))

lib/Analysis/LazyCallGraph.cpp

for (Instruction &I : BB) {
             Worklist.push_back(C);
     }
 
   // We've collected all the constant (and thus potentially function or
   // function containing) operands to all of the instructions in the function.
   // Process them (recursively) collecting every function found.
   visitReferences(Worklist, Visited, [&](Function &F) {
     addEdge(Edges, EdgeIndexMap, F, LazyCallGraph::Edge::Ref);
+    // We aren't finished until all references are visited.
+    return false;
   });
 }
 
 void LazyCallGraph::Node::insertEdgeInternal(Function &Target, Edge::Kind EK) {
   if (Node *N = G->lookup(Target))
     return insertEdgeInternal(*N, EK);
 
   EdgeIndexMap.insert({&Target, Edges.size()});
for (GlobalVariable &GV : M.globals())
     if (GV.hasInitializer())
       if (Visited.insert(GV.getInitializer()).second)
         Worklist.push_back(GV.getInitializer());
 
   DEBUG(dbgs() << "  Adding functions referenced by global initializers to the "
                   "entry set.\n");
   visitReferences(Worklist, Visited, [&](Function &F) {
     addEdge(EntryEdges, EntryIndexMap, F, LazyCallGraph::Edge::Ref);
+    // We aren't finished until all references are visited.
+    return false;
   });
 }
 
 LazyCallGraph::LazyCallGraph(LazyCallGraph &&G)
     : BPA(std::move(G.BPA)), NodeMap(std::move(G.NodeMap)),
       EntryEdges(std::move(G.EntryEdges)),
       EntryIndexMap(std::move(G.EntryIndexMap)), SCCBPA(std::move(G.SCCBPA)),
       SCCMap(std::move(G.SCCMap)), LeafRefSCCs(std::move(G.LeafRefSCCs)),

lib/Passes/PassBuilder.cpp

 #include "llvm/IR/IRPrintingPasses.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Regex.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Transforms/GCOVProfiler.h"
 #include "llvm/Transforms/IPO/AlwaysInliner.h"
+#include "llvm/Transforms/IPO/ArgumentPromotion.h"
 #include "llvm/Transforms/IPO/ConstantMerge.h"
 #include "llvm/Transforms/IPO/CrossDSOCFI.h"
 #include "llvm/Transforms/IPO/DeadArgumentElimination.h"
 #include "llvm/Transforms/IPO/ElimAvailExtern.h"
 #include "llvm/Transforms/IPO/ForceFunctionAttrs.h"
 #include "llvm/Transforms/IPO/FunctionAttrs.h"
 #include "llvm/Transforms/IPO/FunctionImport.h"
 #include "llvm/Transforms/IPO/GlobalDCE.h"

lib/Passes/PassRegistry.def

 #endif
 CGSCC_ANALYSIS("no-op-cgscc", NoOpCGSCCAnalysis())
 CGSCC_ANALYSIS("fam-proxy", FunctionAnalysisManagerCGSCCProxy())
 #undef CGSCC_ANALYSIS
 
 #ifndef CGSCC_PASS
 #define CGSCC_PASS(NAME, CREATE_PASS)
 #endif
+CGSCC_PASS("argpromotion", ArgumentPromotionPass())
 CGSCC_PASS("invalidate<all>", InvalidateAllAnalysesPass())
 CGSCC_PASS("function-attrs", PostOrderFunctionAttrsPass())
 CGSCC_PASS("inline", InlinerPass())
 CGSCC_PASS("no-op-cgscc", NoOpCGSCCPass())
 #undef CGSCC_PASS
 
 #ifndef FUNCTION_ANALYSIS
 #define FUNCTION_ANALYSIS(NAME, CREATE_PASS)

lib/Transforms/IPO/ArgumentPromotion.cpp

 //
 // Note that this transformation could also be done for arguments that are only
 // stored to (returning the value instead), but does not currently.  This case
 // would be best handled when and if LLVM begins supporting multiple return
 // values from functions.
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/Transforms/IPO/ArgumentPromotion.h"
 #include "llvm/ADT/DepthFirstIterator.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/AssumptionCache.h"
 #include "llvm/Analysis/BasicAliasAnalysis.h"
 #include "llvm/Analysis/CallGraph.h"
 #include "llvm/Analysis/CallGraphSCCPass.h"
+#include "llvm/Analysis/LazyCallGraph.h"
 #include "llvm/Analysis/Loads.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/IR/CFG.h"
 #include "llvm/IR/CallSite.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/DerivedTypes.h"

 STATISTIC(NumArgumentsDead, "Number of dead pointer args eliminated");
 
 /// A vector used to hold the indices of a single GEP instruction
 typedef std::vector<uint64_t> IndicesVector;
 
 /// DoPromotion - This method actually performs the promotion of the specified
 /// arguments, and returns the new function.  At this point, we know that it's
 /// safe to do so.
-static CallGraphNode *
+static Function *
 doPromotion(Function *F, SmallPtrSetImpl<Argument *> &ArgsToPromote,
-            SmallPtrSetImpl<Argument *> &ByValArgsToTransform, CallGraph &CG) {
+            SmallPtrSetImpl<Argument *> &ByValArgsToTransform,
+            Optional<function_ref<void(CallSite OldCS, CallSite NewCS)>>
+                ReplaceCallSite) {
 
   // Start by computing a new prototype for the function, which is the same as
   // the old function, but has modified arguments.
   FunctionType *FTy = F->getFunctionType();
   std::vector<Type *> Params;
 
   typedef std::set<std::pair<Type *, IndicesVector>> ScalarizeTable;
 
doPromotion(Function *F, SmallPtrSetImpl<Argument *> &ArgsToPromote,
   // Recompute the parameter attributes list based on the new arguments for
   // the function.
   NF->setAttributes(AttributeSet::get(F->getContext(), AttributesVec));
   AttributesVec.clear();
 
   F->getParent()->getFunctionList().insert(F->getIterator(), NF);
   NF->takeName(F);
 
-  // Get a new callgraph node for NF.
-  CallGraphNode *NF_CGN = CG.getOrInsertFunction(NF);
-
   // Loop over all of the callers of the function, transforming the call sites
   // to pass in the loaded pointers.
   //
   SmallVector<Value *, 16> Args;
   while (!F->use_empty()) {
     CallSite CS(F->user_back());
     assert(CS.getCalledFunction() == F);
     Instruction *Call = CS.getInstruction();
if (InvokeInst *II = dyn_cast<InvokeInst>(Call)) {
       cast<CallInst>(New)->setTailCallKind(
           cast<CallInst>(Call)->getTailCallKind());
     }
     New->setDebugLoc(Call->getDebugLoc());
     Args.clear();
     AttributesVec.clear();
 
     // Update the callgraph to know that the callsite has been transformed.
-    CallGraphNode *CalleeNode = CG[Call->getParent()->getParent()];
-    CalleeNode->replaceCallEdge(CS, CallSite(New), NF_CGN);
+    if (ReplaceCallSite)
+      (*ReplaceCallSite)(CS, CallSite(New));
 
     if (!Call->use_empty()) {
       Call->replaceAllUsesWith(New);
       New->takeName(Call);
     }
 
     // Finally, remove the old call from the program, reducing the use-count of
     // F.
while (!I->use_empty()) {
         GEP->eraseFromParent();
       }
     }
 
     // Increment I2 past all of the arguments added for this promoted pointer.
     std::advance(I2, ArgIndices.size());
   }
 
-  NF_CGN->stealCalledFunctionsFrom(CG[F]);
-
-  // Now that the old function is dead, delete it.  If there is a dangling
-  // reference to the CallgraphNode, just leave the dead function around for
-  // someone else to nuke.
-  CallGraphNode *CGN = CG[F];
-  if (CGN->getNumReferences() == 0)
-    delete CG.removeFunctionFromModule(CGN);
-  else
-    F->setLinkage(Function::ExternalLinkage);
-
-  return NF_CGN;
+  return NF;
 }
 
 /// AllCallersPassInValidPointerForArgument - Return true if we can prove that
 /// all callees pass in a valid pointer for the specified function argument.
 static bool allCallersPassInValidPointerForArgument(Argument *Arg) {
   Function *Callee = Arg->getParent();
   const DataLayout &DL = Callee->getParent()->getDataLayout();
 
static bool canPaddingBeAccessed(Argument *arg) {
   return false;
 }
 
 /// PromoteArguments - This method checks the specified function to see if there
 /// are any promotable arguments and if it is safe to promote the function (for
 /// example, all callers are direct).  If safe to promote some arguments, it
 /// calls the DoPromotion method.
 ///
-static CallGraphNode *
-promoteArguments(CallGraphNode *CGN, CallGraph &CG,
-                 function_ref<AAResults &(Function &F)> AARGetter,
-                 unsigned MaxElements) {
-  Function *F = CGN->getFunction();
-
+static Function *
+promoteArguments(Function *F, function_ref<AAResults &(Function &F)> AARGetter,
+                 unsigned MaxElements,
+                 Optional<function_ref<void(CallSite OldCS, CallSite NewCS)>>
+                     ReplaceCallSite) {
   // Make sure that it is local to this module.
-  if (!F || !F->hasLocalLinkage())
+  if (!F->hasLocalLinkage())
     return nullptr;
 
   // Don't promote arguments for variadic functions. Adding, removing, or
   // changing non-pack parameters can change the classification of pack
   // parameters. Frontends encode that classification at the call site in the
   // IR, while in the callee the classification is determined dynamically based
   // on the number of registers consumed so far.
   if (F->isVarArg())
if (isSafeToPromoteArgument(PtrArg, PtrArg->hasByValOrInAllocaAttr(), AAR,
                                 MaxElements))
       ArgsToPromote.insert(PtrArg);
   }
 
   // No promotable pointer arguments.
   if (ArgsToPromote.empty() && ByValArgsToTransform.empty())
     return nullptr;
 
-  return doPromotion(F, ArgsToPromote, ByValArgsToTransform, CG);
+  return doPromotion(F, ArgsToPromote, ByValArgsToTransform, ReplaceCallSite);
+}
+
+static void updateCGAfterRemovingRefs(
+    LazyCallGraph &G, LazyCallGraph::Node &N /*,
+    CGSCCAnalysisManager &AM, CGSCCUpdateResult &UR*/) {
+  typedef LazyCallGraph::Edge Edge;
+  typedef LazyCallGraph::Node Node;
+  typedef LazyCallGraph::RefSCC RefSCC;
+
+  SmallPtrSet<Function *, 16> RefTargets;
+  for (Edge &E : N)
+    if (!E.isCall())
+      RefTargets.insert(&E.getFunction());
+  if (RefTargets.empty())
+    return;
+
+  SmallVector<Constant *, 16> Worklist;
+  SmallPtrSet<Constant *, 16> Visited;
+  for (Instruction &I : instructions(N.getFunction()))
+    for (Value *Op : I.operand_values())
+      if (auto *C = dyn_cast<Constant>(Op)) {
+        if (auto *F = dyn_cast<Function>(C)) {
+          if (RefTargets.erase(F))
+            if (RefTargets.empty())
+              // All targets accounted for, nothing to update.
+              return;
+
+          // No need to further recurse through functions.
+          continue;
+        }
+
+        // For arbitrary constants unique them into a worklist to recurse
+        // through.
+        if (Visited.insert(C).second)
+          Worklist.push_back(C);
+      }
+
+  LazyCallGraph::visitReferences(Worklist, Visited, [&](Function &F) {
+    if (RefTargets.erase(&F))
+      // We're finished visiting if we cover all ref targets.
+      return RefTargets.empty();
+
+    return false;
+  });
+
+  RefSCC &RC = *G.lookupRefSCC(N);
+  for (Function *TargetF : RefTargets) {
+    Node &TargetN = *G.lookup(*TargetF);
+    assert(&RC != G.lookupRefSCC(TargetN) &&
+           "Cannot delete an edge within a RefSCC!");
+    RC.removeOutgoingEdge(N, TargetN);
+    DEBUG(dbgs() << "Deleting outgoing edge from '" << N << "' to '" << TargetN
+                 << "'\n");
+  }
+}
+
+PreservedAnalyses ArgumentPromotionPass::run(LazyCallGraph::SCC &C,
+                                             CGSCCAnalysisManager &AM,
+                                             LazyCallGraph &CG,
+                                             CGSCCUpdateResult &UR) {
+  bool Changed = false, LocalChange;
+
+  // Iterate until we stop promoting from this SCC.
+  do {
+    LocalChange = false;
+
+    for (LazyCallGraph::Node &N : C) {
+      Function &OldF = N.getFunction();
+
+      FunctionAnalysisManager &FAM =
+          AM.getResult<FunctionAnalysisManagerCGSCCProxy>(C, CG).getManager();
+      // FIXME: This lambda must only be used with this function. We should
+      // skip the lambda and just get the AA results directly.
+      auto AARGetter = [&](Function &F) -> AAResults & {
+        assert(&F == &OldF && "Called with an unexpected function!");
+        return FAM.getResult<AAManager>(F);
+      };
+
+      Function *NewF = promoteArguments(&OldF, AARGetter, 3u, None);
+      if (!NewF)
+        continue;
+      LocalChange = true;
+
+      // Directly substitute the functions in the call graph. Note that this
+      // requires the old function to be completely dead and completely
+      // replaced by the new function. It does no call graph updates, it merely
+      // swaps out the particular function mapped to a particular node in the
+      // graph.
+      C.getOuterRefSCC().replaceNodeFunction(N, *NewF);
+      OldF.eraseFromParent();
+
+      // Promoting arguments may deleted some references to functions. We know
+      // that call edges are undisturbed and no new references can be
+      // introduced, so we can simply scan the function to account for all the
+      // remaining references and remove those no longer present. Note that
+      // this is just *removing* edges and so the order shouldn't matter.
+      for (User *U : NewF->users()) {
+        // Argument promotion only handles functions where all users are
+        // instructions.
+        auto &I = *cast<Instruction>(U);
+
+        Function &UserF = *I.getParent()->getParent();
+        LazyCallGraph::Node &UserN = *CG.lookup(UserF);
+        updateCGAfterRemovingRefs(CG, UserN);
+      }
+    }
+
+    Changed |= LocalChange;
+  } while (LocalChange);
+
+  if (!Changed)
+    return PreservedAnalyses::all();
+
+  return PreservedAnalyses::none();
 }
 
 namespace {
 /// ArgPromotion - The 'by reference' to 'by value' argument promotion pass.
 ///
 struct ArgPromotion : public CallGraphSCCPass {
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addRequired<AssumptionCacheTracker>();
bool ArgPromotion::runOnSCC(CallGraphSCC &SCC) {
 
   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.
     for (CallGraphNode *OldNode : SCC) {
-      if (CallGraphNode *NewNode =
-              promoteArguments(OldNode, CG, AARGetter, MaxElements)) {
+      Function *OldF = OldNode->getFunction();
+      if (!OldF)
+        continue;
+
+      auto ReplaceCallSite = [&](CallSite OldCS, CallSite NewCS) {
+        Function *Caller = OldCS.getInstruction()->getParent()->getParent();
+        CallGraphNode *NewCalleeNode =
+            CG.getOrInsertFunction(NewCS.getCalledFunction());
+        CallGraphNode *CallerNode = CG[Caller];
+        CallerNode->replaceCallEdge(OldCS, NewCS, NewCalleeNode);
+      };
+
+      if (Function *NewF =
+              promoteArguments(OldF, AARGetter, MaxElements, {ReplaceCallSite})) {
         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 updat ethe 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);
 }

test/Transforms/ArgumentPromotion/aggregate-promote.ll

 ; RUN: opt < %s -argpromotion -instcombine -S | not grep load
+; RUN: opt < %s -passes='cgscc(argpromotion,function(instcombine))' -S | not grep load
 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"
 
 %QuadTy = type { i32, i32, i32, i32 }
 @G = constant %QuadTy {
     i32 0, 
     i32 0, 
     i32 17, 
     i32 25 }            ; <%QuadTy*> [#uses=1]

test/Transforms/ArgumentPromotion/attrs.ll

 ; RUN: opt < %s -argpromotion -S | grep zeroext
+; RUN: opt < %s -passes=argpromotion -S | grep zeroext
 
   %struct.ss = type { i32, i64 }
 
 define internal void @f(%struct.ss* byval  %b, i32* byval %X, i32 %i) nounwind  {
 entry:
   %tmp = getelementptr %struct.ss, %struct.ss* %b, i32 0, i32 0
   %tmp1 = load i32, i32* %tmp, align 4
   %tmp2 = add i32 %tmp1, 1  

test/Transforms/ArgumentPromotion/byval-2.ll

 ; RUN: opt < %s -argpromotion -S | FileCheck %s
+; RUN: opt < %s -passes=argpromotion -S | FileCheck %s
 
 ; Arg promotion eliminates the struct argument.
 ; FIXME: Should it eliminate the i32* argument?
 
 %struct.ss = type { i32, i64 }
 
 define internal void @f(%struct.ss* byval  %b, i32* byval %X) nounwind  {
 ; CHECK-LABEL: define internal void @f(i32 %b.0, i64 %b.1, i32* byval %X)

test/Transforms/ArgumentPromotion/byval.ll

 ; RUN: opt < %s -argpromotion -S | FileCheck %s
+; RUN: opt < %s -passes=argpromotion -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"
 
 %struct.ss = type { i32, i64 }
 
 define internal void @f(%struct.ss* byval  %b) nounwind  {
 ; CHECK-LABEL: define internal void @f(i32 %b.0, i64 %b.1)
 entry:

test/Transforms/ArgumentPromotion/callgraph-update.ll

 ; RUN: opt < %s -argpromotion -simplifycfg -constmerge | llvm-dis
+; RUN: opt < %s -passes='cgscc(argpromotion,function(simplify-cfg)),constmerge' | llvm-dis
+
 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-darwin10.0"
 
 %struct.VEC2 = type { double, double, double }
 %struct.VERTEX = type { %struct.VEC2, %struct.VERTEX*, %struct.VERTEX* }
 %struct.edge_rec = type { %struct.VERTEX*, %struct.edge_rec*, i32, i8* }
 
 declare %struct.edge_rec* @alloc_edge() nounwind ssp

test/Transforms/ArgumentPromotion/chained.ll

 ; RUN: opt < %s -argpromotion -instcombine -S | not grep load
+; RUN: opt < %s -passes='cgscc(argpromotion,function(instcombine))' -S | not grep load
+
 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"
 
 @G1 = constant i32 0            ; <i32*> [#uses=1]
 @G2 = constant i32* @G1         ; <i32**> [#uses=1]
 
 define internal i32 @test(i32** %X) {
         %Y = load i32*, i32** %X              ; <i32*> [#uses=1]
         %X.upgrd.1 = load i32, i32* %Y               ; <i32> [#uses=1]
         ret i32 %X.upgrd.1
 }
 
 define i32 @caller(i32** %P) {
         %X = call i32 @test( i32** @G2 )                ; <i32> [#uses=1]
         ret i32 %X
 }
 

test/Transforms/ArgumentPromotion/control-flow.ll

 ; RUN: opt < %s -argpromotion -S | \
 ; RUN:    not grep "load i32* null"
+; RUN: opt < %s -passes=argpromotion -S | \
+; RUN:    not grep "load i32* null"
 
 define internal i32 @callee(i1 %C, i32* %P) {
         br i1 %C, label %T, label %F
 
 T:              ; preds = %0
         ret i32 17
 
 F:              ; preds = %0

test/Transforms/ArgumentPromotion/control-flow2.ll

 ; RUN: opt < %s -argpromotion -S | FileCheck %s
+; RUN: opt < %s -passes=argpromotion -S | FileCheck %s
 
 ; CHECK: load i32, i32* %A
 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 @callee(i1 %C, i32* %P) {
         br i1 %C, label %T, label %F
 
 T:              ; preds = %0

test/Transforms/ArgumentPromotion/crash.ll

-; RUN: opt -inline -argpromotion < %s
+; RUN: opt -S -inline -argpromotion < %s
+; RUN: opt -S -passes=inline,argpromotion < %s
 ; rdar://7879828
 
 define void @foo() personality i32 (...)* @__gxx_personality_v0 {
   invoke void @foo2()
           to label %if.end432 unwind label %for.end520 
 
 if.end432:  
   unreachable

test/Transforms/ArgumentPromotion/dbg.ll

 ; RUN: opt < %s -argpromotion -S | FileCheck %s
+; RUN: opt < %s -passes=argpromotion -S | FileCheck %s
 
 declare void @sink(i32)
 
 ; CHECK: define internal void @test({{.*}} !dbg [[SP:![0-9]+]]
 define internal void @test(i32** %X) !dbg !2 {
   %1 = load i32*, i32** %X, align 8
   %2 = load i32, i32* %1, align 8
   call void @sink(i32 %2)

test/Transforms/ArgumentPromotion/fp80.ll

 ; RUN: opt < %s -argpromotion -S | FileCheck %s
+; RUN: opt < %s -passes=argpromotion -S | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 %union.u = type { x86_fp80 }
 %struct.s = type { double, i16, i8, [5 x i8] }
 
 @b = internal global %struct.s { double 3.14, i16 9439, i8 25, [5 x i8] undef }, align 16

test/Transforms/ArgumentPromotion/inalloca.ll

 ; RUN: opt %s -argpromotion -sroa -S | FileCheck %s
+; RUN: opt %s -passes='argpromotion,function(sroa)' -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"
 
 %struct.ss = type { i32, i32 }
 
 ; Argpromote + sroa should change this to passing the two integers by value.
 define internal i32 @f(%struct.ss* inalloca  %s) {
 entry:

test/Transforms/ArgumentPromotion/pr27568.ll

 ; RUN: opt -S -argpromotion < %s | FileCheck %s
+; RUN: opt -S -passes=argpromotion < %s | FileCheck %s
 target triple = "x86_64-pc-windows-msvc"
 
 define internal void @callee(i8*) {
 entry:
   call void @thunk()
   ret void
 }
 

test/Transforms/ArgumentPromotion/reserve-tbaa.ll

 ; RUN: opt < %s -argpromotion -S
+; RUN: opt < %s -passes=argpromotion -S
 
 ; PR17906
 ; When we promote two arguments in a single function with different types,
 ; before the fix, we used the same tag for the newly-created two loads.
 ; This testing case makes sure that we correctly transfer the tbaa tags from the
 ; original loads to the newly-created loads when promoting pointer arguments.
 
 @a = global i32* null, align 8

test/Transforms/ArgumentPromotion/sret.ll

 ; RUN: opt < %s -argpromotion -S | FileCheck %s
+; RUN: opt < %s -passes=argpromotion -S | FileCheck %s
 
 target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-windows-msvc"
 
 ; CHECK: define internal void @add(i32 %[[THIS1:.*]], i32 %[[THIS2:.*]], i32* noalias %[[SR:.*]])
 define internal void @add({i32, i32}* %this, i32* sret %r) {
   %ap = getelementptr {i32, i32}, {i32, i32}* %this, i32 0, i32 0
   %bp = getelementptr {i32, i32}, {i32, i32}* %this, i32 0, i32 1

test/Transforms/ArgumentPromotion/tail.ll

 ; RUN: opt %s -argpromotion -S -o - | FileCheck %s
+; RUN: opt %s -passes=argpromotion -S -o - | FileCheck %s
 ; PR14710
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 %pair = type { i32, i32 }
 
 declare i8* @foo(%pair*)
 

test/Transforms/ArgumentPromotion/variadic.ll

 ; RUN: opt < %s -argpromotion -S | FileCheck %s
+; RUN: opt < %s -passes=argpromotion -S | FileCheck %s
 
 ; Unused arguments from variadic functions cannot be eliminated as that changes
 ; their classiciation according to the SysV amd64 ABI. Clang and other frontends
 ; bake in the classification when they use things like byval, as in this test.
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"