[MergeFuncs] Simplify the merge process

[jfb]

Summary

NOTE: This patch is a WIP and is being submitted so it is available externally. Please ignore.

[• jrkoenig]

• [MergeFuncs] Simplify the merge process
• Deferred comparison of callsites

[jfb]

Not going forward, let's commandeer and close.

lib/Transforms/IPO/MergeFunctions.cpp

 #include "llvm/Support/raw_ostream.h"
 #include <vector>
 using namespace llvm;
 
 #define DEBUG_TYPE "mergefunc"
 
 STATISTIC(NumFunctionsMerged, "Number of functions merged");
 STATISTIC(NumThunksWritten, "Number of thunks generated");
-STATISTIC(NumAliasesWritten, "Number of aliases generated");
+STATISTIC(NumThunksSkipped, "Number of thunks skipped");
 STATISTIC(NumDoubleWeak, "Number of new functions created");
 
 static cl::opt<unsigned> NumFunctionsForSanityCheck(
     "mergefunc-sanity",
     cl::desc("How many functions in module could be used for "
              "MergeFunctions pass sanity check. "
              "'0' disables this check. Works only with '-debug' key."),
     cl::init(0), cl::Hidden);
 
 namespace {
 
 /// GlobalNumberState assigns an integer to each global value in the program,
 /// which is used by the comparison routine to order references to globals. This
 /// state must be preserved throughout the pass, because Functions and other
 /// globals need to maintain their relative order. Globals are assigned a number
 /// when they are first visited. This order is deterministic, and so the
 /// assigned numbers are as well. When two functions are merged, neither number
 /// is updated. If the symbols are weak, this would be incorrect. If they are
 /// strong, then one will be replaced at all references to the other, and so
 /// direct callsites will now see one or the other symbol, and no update is
 /// necessary. Note that if we were guaranteed unique names, we could just
 /// compare those, but this would not work for stripped bitcodes or for those
 /// few symbols without a name.
 class GlobalNumberState {
-  struct Config : ValueMapConfig<GlobalValue*> {
+  struct Config : ValueMapConfig<Constant *> {
     enum { FollowRAUW = false };
   };
   // Each GlobalValue is mapped to an identifier. The Config ensures when RAUW
   // occurs, the mapping does not change. Tracking changes is unnecessary, and
   // also problematic for weak symbols (which may be overwritten).
-  typedef ValueMap<GlobalValue *, uint64_t, Config> ValueNumberMap;
+  typedef ValueMap<Constant *, uint64_t, Config> ValueNumberMap;
   ValueNumberMap GlobalNumbers;
   // The next unused serial number to assign to a global.
   uint64_t NextNumber;
   public:
     GlobalNumberState() : GlobalNumbers(), NextNumber(0) {}
-    uint64_t getNumber(GlobalValue* Global) {
+    uint64_t getNumber(Constant *Global) {
       ValueNumberMap::iterator MapIter;
       bool Inserted;
       std::tie(MapIter, Inserted) = GlobalNumbers.insert({Global, NextNumber});
       if (Inserted)
         NextNumber++;
       return MapIter->second;
     }
 };
 
 /// FunctionComparator - Compares two functions to determine whether or not
 /// they will generate machine code with the same behaviour. DataLayout is
 /// used if available. The comparator always fails conservatively (erring on the
 /// side of claiming that two functions are different).
 class FunctionComparator {
 public:
   FunctionComparator(const Function *F1, const Function *F2,
                      GlobalNumberState* GN)
       : FnL(F1), FnR(F2), GlobalNumbers(GN) {}
 
   /// Test whether the two functions have equivalent behaviour.
   int compare();
+  /// Test whether the two functions are equivalent modulo callsites.
+  int compareStructure();
+  /// Compares the callsites of the two functions. Must be called after
+  /// compareStructure().
+  int compareDeferredCallsites();
+
   /// Hash a function. Equivalent functions will have the same hash, and unequal
   /// functions will have different hashes with high probability.
   typedef uint64_t FunctionHash;
   static FunctionHash functionHash(Function &);
 
 private:
   /// Test whether two basic blocks have equivalent behaviour.
   int cmpBasicBlocks(const BasicBlock *BBL, const BasicBlock *BBR);
private:
   /// If we compare two instruction operands: first is usage of local
   /// variable AL from function FL, and second is usage of local variable AR
   /// from FR, we could compare their origins and check whether they are
   /// defined at the same place.
   /// But, we are still not able to compare operands of PHI nodes, since those
   /// could be operands from further BBs we didn't scan yet.
   /// So it's impossible to use dominance properties in general.
   DenseMap<const Value*, int> sn_mapL, sn_mapR;
+  SmallVector<const CallInst*, 4> DeferredL, DeferredR;
 
   // The global state we will use
   GlobalNumberState* GlobalNumbers;
 };
 
 class FunctionNode {
   mutable AssertingVH<Function> F;
   FunctionComparator::FunctionHash Hash;

 int FunctionComparator::cmpBasicBlocks(const BasicBlock *BBL,
                                        const BasicBlock *BBR) {
   BasicBlock::const_iterator InstL = BBL->begin(), InstLE = BBL->end();
   BasicBlock::const_iterator InstR = BBR->begin(), InstRE = BBR->end();
 
   do {
     if (int Res = cmpValues(InstL, InstR))
       return Res;
+    // First, order by opcode. This means that we can dispatch only on InstL.
+    if (int Res = cmpNumbers(InstL->getOpcode(), InstR->getOpcode()))
+      return Res;
 
-    const GetElementPtrInst *GEPL = dyn_cast<GetElementPtrInst>(InstL);
-    const GetElementPtrInst *GEPR = dyn_cast<GetElementPtrInst>(InstR);
-
-    if (GEPL && !GEPR)
-      return 1;
-    if (GEPR && !GEPL)
-      return -1;
-
-    if (GEPL && GEPR) {
+    // GEPs need special logic because the number of operands can vary in the
+    // case of a equivalent GEPs which lower to a constant constant offset.
+    // cmpOperations requires the same number of operands, so can't be used.
+    if (const GetElementPtrInst *GEPL = dyn_cast<GetElementPtrInst>(InstL)) {
+      const GetElementPtrInst *GEPR = cast<GetElementPtrInst>(InstR);
       if (int Res =
               cmpValues(GEPL->getPointerOperand(), GEPR->getPointerOperand()))
         return Res;
       if (int Res = cmpGEPs(GEPL, GEPR))
         return Res;
+    } else if (const CallInst * CL = dyn_cast<CallInst>(InstL)) {
+      const CallInst * CR = cast<CallInst>(InstR);
+      if (int Res = cmpOperations(InstL, InstR))
+        return Res;
+      assert(CL->getNumArgOperands() == CR->getNumArgOperands());
+      for (unsigned i = 0, e = CL->getNumArgOperands(); i != e; ++i) {
+        if (int Res = cmpValues(CL->getArgOperand(i), CR->getArgOperand(i)))
+          return Res;
+      }
+      DeferredL.push_back(CL);
+      DeferredR.push_back(CR);
     } else {
       if (int Res = cmpOperations(InstL, InstR))
         return Res;
       assert(InstL->getNumOperands() == InstR->getNumOperands());
 
       for (unsigned i = 0, e = InstL->getNumOperands(); i != e; ++i) {
         Value *OpL = InstL->getOperand(i);
         Value *OpR = InstR->getOperand(i);
int FunctionComparator::cmpBasicBlocks(const BasicBlock *BBL,
   if (InstL != InstLE && InstR == InstRE)
     return 1;
   if (InstL == InstLE && InstR != InstRE)
     return -1;
   return 0;
 }
 
 // Test whether the two functions have equivalent behaviour.
-int FunctionComparator::compare() {
+int FunctionComparator::compareStructure() {
 
   sn_mapL.clear();
   sn_mapR.clear();
 
   if (int Res = cmpAttrs(FnL->getAttributes(), FnR->getAttributes()))
     return Res;
 
   if (int Res = cmpNumbers(FnL->hasGC(), FnR->hasGC()))
for (unsigned i = 0, e = TermL->getNumSuccessors(); i != e; ++i) {
 
       FnLBBs.push_back(TermL->getSuccessor(i));
       FnRBBs.push_back(TermR->getSuccessor(i));
     }
   }
   return 0;
 }
 
+int FunctionComparator::compareDeferredCallsites() {
+  assert(DeferredL.size() == DeferredR.size());
+  for(size_t I = 0, E = DeferredL.size(); I < E; ++I) {
+    if (int Res = cmpValues(DeferredL[I]->getCalledValue(),
+                            DeferredR[I]->getCalledValue()))
+      return Res;
+  }
+  return 0;
+}
+
+int FunctionComparator::compare() {
+  if (int Res = compareStructure())
+    return Res;
+  if (int Res = compareDeferredCallsites())
+    return Res;
+  return 0;
+}
+
 // Accumulate the hash of a sequence of 64-bit integers. This is similar to a
 // hash of a sequence of 64bit ints, but the entire input does not need to be
 // available at once. This interface is necessary for functionHash because it
 // needs to accumulate the hash as the structure of the function is traversed
 // without saving these values to an intermediate buffer. This form of hashing
 // is not often needed, as usually the object to hash is just read from a
 // buffer.
 class HashAccumulator64 {

 /// by considering all pointer types to be equivalent. Once identified,
 /// MergeFunctions will fold them by replacing a call to one to a call to a
 /// bitcast of the other.
 ///
 class MergeFunctions : public ModulePass {
 public:
   static char ID;
   MergeFunctions()
-    : ModulePass(ID), FnTree(FunctionNodeCmp(&GlobalNumbers)), FNodesInTree(),
-      HasGlobalAliases(false) {
+    : ModulePass(ID), FnTree(FunctionNodeCmp(&GlobalNumbers)), FNodesInTree() {
     initializeMergeFunctionsPass(*PassRegistry::getPassRegistry());
   }
 
   bool runOnModule(Module &M) override;
 
 private:
   // The function comparison operator is provided here so that FunctionNodes do
   // not need to become larger with another pointer.
private:
   /// Find the functions that use this Value and remove them from FnTree and
   /// queue the functions.
   void removeUsers(Value *V);
 
   /// Replace all direct calls of Old with calls of New. Will bitcast New if
   /// necessary to make types match.
   void replaceDirectCallers(Function *Old, Function *New);
 
+  /// Replace references to Old in bitcasts with New.
+  void replaceUseInConstants(Constant *Old, Constant *New);
+
   /// Merge two equivalent functions. Upon completion, G may be deleted, or may
   /// be converted into a thunk. In either case, it should never be visited
   /// again.
-  void mergeTwoFunctions(Function *F, Function *G);
+  bool mergeTwoFunctions(const FunctionNode &FN, Function *G);
 
-  /// Replace G with a thunk or an alias to F. Deletes G.
-  void writeThunkOrAlias(Function *F, Function *G);
+  /// Merge two equivalent functions. Upon completion, G may be deleted, or may
+  /// be converted into a thunk. In either case, it should never be visited
+  /// again.
+  bool mergeTwoWeakFunctions(Function *F, Function *G);
 
-  /// Replace G with a simple tail call to bitcast(F). Also replace direct uses
-  /// of G with bitcast(F). Deletes G.
+  /// Replace G with a simple tail call to bitcast(F).
   void writeThunk(Function *F, Function *G);
 
   /// Replace G with an alias to F. Deletes G.
   void writeAlias(Function *F, Function *G);
 
   /// Replace function F with function G in the function tree.
   void replaceFunctionInTree(const FunctionNode &FN, Function *G);
 
   /// The set of all distinct functions. Use the insert() and remove() methods
   /// to modify it. The map allows efficient lookup and deferring of Functions.
   FnTreeType FnTree;
   // Map functions to the iterators of the FunctionNode which contains them
   // in the FnTree. This must be updated carefully whenever the FnTree is
   // modified, i.e. in insert(), remove(), and replaceFunctionInTree(), to avoid
   // dangling iterators into FnTree. The invariant that preserves this is that
   // there is exactly one mapping F -> FN for each FunctionNode FN in FnTree.
   ValueMap<Function*, FnTreeType::iterator> FNodesInTree;
-
-  /// Whether or not the target supports global aliases.
-  bool HasGlobalAliases;
 };
 
 }  // end anonymous namespace
 
 char MergeFunctions::ID = 0;
 INITIALIZE_PASS(MergeFunctions, "mergefunc", "Merge Functions", false, false)
 
 ModulePass *llvm::createMergeFunctionsPass() {
do {
     std::vector<WeakVH> Worklist;
     Deferred.swap(Worklist);
 
     DEBUG(doSanityCheck(Worklist));
 
     DEBUG(dbgs() << "size of module: " << M.size() << '\n');
     DEBUG(dbgs() << "size of worklist: " << Worklist.size() << '\n');
 
-    // Insert only strong functions and merge them. Strong function merging
-    // always deletes one of them.
     for (std::vector<WeakVH>::iterator I = Worklist.begin(),
            E = Worklist.end(); I != E; ++I) {
       if (!*I) continue;
       Function *F = cast<Function>(*I);
-      if (!F->isDeclaration() && !F->hasAvailableExternallyLinkage() &&
-          !F->mayBeOverridden()) {
-        Changed |= insert(F);
-      }
-    }
 
-    // Insert only weak functions and merge them. By doing these second we
-    // create thunks to the strong function when possible. When two weak
-    // functions are identical, we create a new strong function with two weak
-    // weak thunks to it which are identical but not mergable.
-    for (std::vector<WeakVH>::iterator I = Worklist.begin(),
-           E = Worklist.end(); I != E; ++I) {
-      if (!*I) continue;
-      Function *F = cast<Function>(*I);
-      if (!F->isDeclaration() && !F->hasAvailableExternallyLinkage() &&
-          F->mayBeOverridden()) {
-        Changed |= insert(F);
-      }
-    }
     DEBUG(dbgs() << "size of FnTree: " << FnTree.size() << '\n');
   } while (!Deferred.empty());
 
   FnTree.clear();
 
   return Changed;
 }
 
if (CS && CS.isCallee(U)) {
       CS.setAttributes(CallSiteAttrs);
 
       remove(CS.getInstruction()->getParent()->getParent());
       U->set(BitcastNew);
     }
   }
 }
 
-// Replace G with an alias to F if possible, or else a thunk to F. Deletes G.
-void MergeFunctions::writeThunkOrAlias(Function *F, Function *G) {
-  if (HasGlobalAliases && G->hasUnnamedAddr()) {
-    if (G->hasExternalLinkage() || G->hasLocalLinkage() ||
-        G->hasWeakLinkage()) {
-      writeAlias(F, G);
-      return;
+void MergeFunctions::replaceUseInConstants(Constant *Old, Constant *New) {
+  for (auto UI = Old->use_begin(), UE = Old->use_end(); UI != UE;) {
+    Use *U = &*UI;
+    ++UI;
+    if (Constant* C = dyn_cast<Constant>(U->getUser())) {
+      if (!isa<GlobalValue>(C)) {
+        removeUsers(C);
+        C->handleOperandChange(Old, New, U);
+      } else if (GlobalAlias* Alias = dyn_cast<GlobalAlias>(C)) {
+        if (Alias->hasLocalLinkage() && !Alias->mayBeOverridden()) {
+          DEBUG(dbgs() << "Replacing alias " << Alias->getName() << "\n");
+          Constant *BitcastNew = ConstantExpr::getBitCast(New, Old->getType());
+          removeUsers(Alias);
+          Alias->replaceAllUsesWith(BitcastNew);
+          Alias->eraseFromParent();
+        }
+      }
     }
   }
-
-  writeThunk(F, G);
 }
 
 // Helper for writeThunk,
 // Selects proper bitcast operation,
 // but a bit simpler then CastInst::getCastOpcode.
 static Value *createCast(IRBuilder<false> &Builder, Value *V, Type *DestTy) {
   Type *SrcTy = V->getType();
   if (SrcTy->isStructTy()) {
static Value *createCast(IRBuilder<false> &Builder, Value *V, Type *DestTy) {
   if (SrcTy->isIntegerTy() && DestTy->isPointerTy())
     return Builder.CreateIntToPtr(V, DestTy);
   else if (SrcTy->isPointerTy() && DestTy->isIntegerTy())
     return Builder.CreatePtrToInt(V, DestTy);
   else
     return Builder.CreateBitCast(V, DestTy);
 }
 
-// Replace G with a simple tail call to bitcast(F). Also replace direct uses
-// of G with bitcast(F). Deletes G.
+// Replace G with a simple tail call to F. Deletes the former body of G.
 void MergeFunctions::writeThunk(Function *F, Function *G) {
-  if (!G->mayBeOverridden()) {
-    // Redirect direct callers of G to F.
-    replaceDirectCallers(G, F);
-  }
-
-  // If G was internal then we may have replaced all uses of G with F. If so,
-  // stop here and delete G. There's no need for a thunk.
-  if (G->hasLocalLinkage() && G->use_empty()) {
-    G->eraseFromParent();
-    return;
-  }
-
   Function *NewG = Function::Create(G->getFunctionType(), G->getLinkage(), "",
                                     G->getParent());
   BasicBlock *BB = BasicBlock::Create(F->getContext(), "", NewG);
   IRBuilder<false> Builder(BB);
 
   SmallVector<Value *, 16> Args;
   unsigned i = 0;
   FunctionType *FFTy = F->getFunctionType();
void MergeFunctions::writeThunk(Function *F, Function *G) {
   removeUsers(G);
   G->replaceAllUsesWith(NewG);
   G->eraseFromParent();
 
   DEBUG(dbgs() << "writeThunk: " << NewG->getName() << '\n');
   ++NumThunksWritten;
 }
 
-// Replace G with an alias to F and delete G.
-void MergeFunctions::writeAlias(Function *F, Function *G) {
-  PointerType *PTy = G->getType();
-  auto *GA = GlobalAlias::create(PTy, G->getLinkage(), "", F);
-  F->setAlignment(std::max(F->getAlignment(), G->getAlignment()));
-  GA->takeName(G);
-  GA->setVisibility(G->getVisibility());
-  removeUsers(G);
-  G->replaceAllUsesWith(GA);
-  G->eraseFromParent();
+enum FuncMergeKind {
+  Weak = 0,
+  Internal = 1,
+  Named = 2,
+  External = 3
+};
 
-  DEBUG(dbgs() << "writeAlias: " << GA->getName() << '\n');
-  ++NumAliasesWritten;
+FuncMergeKind functionMergeKind(Function *F) {
+  if (F->mayBeOverridden())
+    return Weak;
+  if (F->hasLocalLinkage()) {
+    if (F->hasUnnamedAddr())
+      return Internal;
+    return Named;
+  }
+  return External;
 }
 
-// Merge two equivalent functions. Upon completion, Function G is deleted.
-void MergeFunctions::mergeTwoFunctions(Function *F, Function *G) {
-  if (F->mayBeOverridden()) {
-    assert(G->mayBeOverridden());
-
-    // Make them both thunks to the same internal function.
-    Function *H = Function::Create(F->getFunctionType(), F->getLinkage(), "",
-                                   F->getParent());
-    H->copyAttributesFrom(F);
-    H->takeName(F);
-    removeUsers(F);
-    F->replaceAllUsesWith(H);
+bool MergeFunctions::mergeTwoWeakFunctions(Function* F, Function* G) {
 
-    unsigned MaxAlignment = std::max(G->getAlignment(), H->getAlignment());
 
-    if (HasGlobalAliases) {
-      writeAlias(F, G);
-      writeAlias(F, H);
-    } else {
-      writeThunk(F, G);
-      writeThunk(F, H);
-    }
 
-    F->setAlignment(MaxAlignment);
-    F->setLinkage(GlobalValue::PrivateLinkage);
-    ++NumDoubleWeak;
-  } else {
-    writeThunkOrAlias(F, G);
-  }
+  return true;
+}
+
+bool isFunctionThunkSized(Function& F) {
+  if (F.size() == 1) {
+    if (F.front().size() <= 2) {
+      return true;
+    }
+  }
+  return false;
 
+// Merge two equivalent functions. Upon completion, Function G is deleted.
+bool MergeFunctions::mergeTwoFunctions(const FunctionNode &FN, Function *G) {
+  
+  auto FMK = functionMergeKind(FN.getFunc()), GMK = functionMergeKind(G);
+  // If the functions are to small, skip merging. But if one is internal, then
+  // we can replace it without generating a thunk.
+  if (isFunctionThunkSized(*G) && !(FMK == Internal || GMK == Internal)) 
+    return false;
+  // Impose a total order (by name) on the replacement of functions. This is
+  // important when operating on more than one module independently to prevent
+  // cycles of thunks calling each other when the modules are linked together.
+  // When one function is weak and the other is strong there is an order imposed
+  // already.
+  bool Swap = (FMK == GMK && (FMK == Weak || FMK == External)
+              && FN.getFunc()->getName() > G->getName());
+  // Ensure the "weaker" function is merged into the "stronger" one.
+  Swap = Swap || (GMK > FMK);
+  
+  if (Swap) {
+    Function *F = FN.getFunc();
+    replaceFunctionInTree(FN, G);
+    G = F;
+    std::swap(FMK, GMK);
+  }
+  Function* F = FN.getFunc();
+  // First, check if it's two weak functions. In this case, we need to modify
+  // both.
+  if (FMK == Weak && GMK == Weak) {
+    mergeTwoWeakFunctions(F, G);
+    ++NumDoubleWeak;
+    ++NumFunctionsMerged;
+    return true;
+  }
+  // Otherwise, eliminate G in one of several ways depending on its type.
+  if (GMK != Weak)
+    replaceDirectCallers(G, F);
+  if (GMK == Internal) {
+    removeUsers(G);
+    replaceUseInConstants(G, F);
+  }
+  if (GMK != External && GMK != Weak && G->use_empty()) {
+    G->eraseFromParent();
     ++NumFunctionsMerged;
+  } else {
+    if(!isFunctionThunkSized(*G)) {
+      writeThunk(F, G);
+      ++NumFunctionsMerged;
+    } else {
+      ++NumThunksSkipped;
+    }
+  }
+  return true;
 }
 
 /// Replace function F by function G.
 void MergeFunctions::replaceFunctionInTree(const FunctionNode &FN,
                                            Function *G) {
   Function *F = FN.getFunc();
   assert(FunctionComparator(F, G, &GlobalNumbers).compare() == 0 &&
          "The two functions must be equal");
bool MergeFunctions::insert(Function *NewFunction) {
 
   if (Result.second) {
     assert(FNodesInTree.count(NewFunction) == 0);
     FNodesInTree.insert({NewFunction, Result.first});
     DEBUG(dbgs() << "Inserting as unique: " << NewFunction->getName() << '\n');
     return false;
   }
 
-  const FunctionNode &OldF = *Result.first;
+  const FunctionNode &OldFuncNode = *Result.first;
 
-  // Don't merge tiny functions, since it can just end up making the function
-  // larger.
-  // FIXME: Should still merge them if they are unnamed_addr and produce an
-  // alias.
-  if (NewFunction->size() == 1) {
-    if (NewFunction->front().size() <= 2) {
-      DEBUG(dbgs() << NewFunction->getName()
-                   << " is to small to bother merging\n");
-      return false;
-    }
-  }
-
-  // Impose a total order (by name) on the replacement of functions. This is
-  // important when operating on more than one module independently to prevent
-  // cycles of thunks calling each other when the modules are linked together.
-  //
-  // When one function is weak and the other is strong there is an order imposed
-  // already. We process strong functions before weak functions.
-  if ((OldF.getFunc()->mayBeOverridden() && NewFunction->mayBeOverridden()) ||
-      (!OldF.getFunc()->mayBeOverridden() && !NewFunction->mayBeOverridden()))
-    if (OldF.getFunc()->getName() > NewFunction->getName()) {
-      // Swap the two functions.
-      Function *F = OldF.getFunc();
-      replaceFunctionInTree(*Result.first, NewFunction);
-      NewFunction = F;
-      assert(OldF.getFunc() != F && "Must have swapped the functions.");
-    }
-
-  // Never thunk a strong function to a weak function.
-  assert(!OldF.getFunc()->mayBeOverridden() || NewFunction->mayBeOverridden());
-
-  DEBUG(dbgs() << "  " << OldF.getFunc()->getName()
+  DEBUG(dbgs() << "  " << OldFuncNode.getFunc()->getName()
                << " == " << NewFunction->getName() << '\n');
 
-  Function *DeleteF = NewFunction;
-  mergeTwoFunctions(OldF.getFunc(), DeleteF);
-  return true;
+  return mergeTwoFunctions(OldFuncNode, NewFunction);
 }
 
 // Remove a function from FnTree. If it was already in FnTree, add
 // it to Deferred so that we'll look at it in the next round.
 void MergeFunctions::remove(Function *F) {
   auto I = FNodesInTree.find(F);
   if (I != FNodesInTree.end()) {
     DEBUG(dbgs() << "Deferred " << F->getName()<< ".\n");

test/Transforms/MergeFunc/constant-entire-value.ll

 ; CHECK-LABEL: @add
   %sum = add i32 %x, %y
   %1 = extractvalue [3 x i32] [ i32 3, i32 0, i32 1 ], 2
   %sum2 = add i32 %sum, %1
   %sum3 = add i32 %sum2, %y
   ret i32 %sum3
 }
 
-define internal i32 @plus(i32 %x, i32 %y) {
-; NOPLUS-NOT: @plus
+define internal i32 @next(i32 %x, i32 %y) {
+; CHECK-LABEL: @next
   %sum = add i32 %x, %y
   %1 = extractvalue [3 x i32] [ i32 3, i32 0, i32 5 ], 2
   %sum2 = add i32 %sum, %1
   %sum3 = add i32 %sum2, %y
   ret i32 %sum3
 }
 
-define internal i32 @next(i32 %x, i32 %y) {
-; CHECK-LABEL: @next
+define internal i32 @plus(i32 %x, i32 %y) {
+; NOPLUS-NOT: @plus
   %sum = add i32 %x, %y
   %1 = extractvalue [3 x i32] [ i32 3, i32 0, i32 5 ], 2
   %sum2 = add i32 %sum, %1
   %sum3 = add i32 %sum2, %y
   ret i32 %sum3
 }