[IROutliner] Deduplicating functions that only require inputs.

[AndrewLitteken]

Summary

Extracted regions can have both inputs and outputs. In addition, the CodeExtractor removes inputs that are only used in llvm.assumes, and sunken allocas (values are used entirely in the extracted region as denoted by lifetime intrinsics). We also cannot combine sections that have different constants in the same structural location, and these constants will have to elevated to argument. This patch deduplicates extracted functions that only have inputs and non of the special cases.

[AndrewLitteken]

Updating for clang-format.

[AndrewLitteken]

Updating diff to reflect changes in other patches.

[jroelofs]

There's quite a few dead variables added in this patch. Do they belong in later patches in the series?

llvm/lib/Transforms/IPO/IROutliner.cpp

281

non-rhetorical question: should it be marked noduplicate too?

294

dead variable

464

ArrayRef

467

elsewhere you have usually called them IRSC

477

both of these variables are dead

479–481

489

I think this needs to be folded into the assertion to avoid -Wundef in Release builds.

493

emplace

543–545

Unless you need to filter them for some reason?

562

variable is dead

564

I'd sink this to where it's used.

569

Why is the first one skipped, and can this be a range-for?

[AndrewLitteken]

A lot of the dead variables belong to future patches, I'll make sure to weed them out in the next diff.

llvm/lib/Transforms/IPO/IROutliner.cpp

281

I'm not entirely sure, it seems like it might be a good idea for safety.

569

The first extracted function is used to construct the overall outlined function, so it is handled slightly differently.

[jroelofs]

👍

[AndrewLitteken]

Updating to reflect other patches.

[AndrewLitteken]

The URL was not included in commit message for 5cdc4f57e50bbe0d211c109517c17defe78e0b73. Closing manually.

llvm/include/llvm/Transforms/IPO/IROutliner.h

struct OutlinableRegion {
   IRSimilarityCandidate *Candidate;
 
   /// If this region is outlined, the front and back IRInstructionData could
   /// potentially become invalidated if the only new instruction is a call.
   /// This ensures that we replace in the instruction in the IRInstructionData.
   IRInstructionData *NewFront = nullptr;
   IRInstructionData *NewBack = nullptr;
 
+  /// The number of extracted inputs from the CodeExtractor.
+  unsigned NumExtractedInputs;
+
+  /// Mapping the extracted argument number to the argument number in the
+  /// overall function.  Since there will be inputs, such as elevated constants
+  /// that are not the same in each region in a SimilarityGroup, or values that
+  /// cannot be sunk into the extracted section in every region, we must keep
+  /// track of which extracted argument maps to which overall argument.
+  DenseMap<unsigned, unsigned> ExtractedArgToAgg;
+  DenseMap<unsigned, unsigned> AggArgToExtracted;
+
   /// Used to create an outlined function.
   CodeExtractor *CE = nullptr;
 
   /// The call site of the extracted region.
   CallInst *Call = nullptr;
 
   /// The function for the extracted region.
   Function *ExtractedFunction = nullptr;
private:
   /// Remove all the IRSimilarityCandidates from \p CandidateVec that have
   /// instructions contained in a previously outlined region and put the
   /// remaining regions in \p CurrentGroup.
   ///
   /// \param [in] CandidateVec - List of similarity candidates for regions with
   /// the same similarity structure.
   /// \param [in,out] CurrentGroup - Contains the potential sections to
   /// be outlined.
   void pruneIncompatibleRegions(
       std::vector<IRSimilarityCandidate> &CandidateVec,
       OutlinableGroup &CurrentGroup);
 
+  /// Create the function based on the overall types found in the current
+  /// regions being outlined.
+  ///
+  /// \param M - The module to outline from.
+  /// \param [in,out] CG - The OutlinableGroup for the regions to be outlined.
+  /// \param [in] FunctionNameSuffix - How many functions have we previously
+  /// created.
+  /// \returns the newly created function.
+  Function *createFunction(Module &M, OutlinableGroup &CG,
+                           unsigned FunctionNameSuffix);
 
   /// Identify the needed extracted inputs in a section, and add to the overall
   /// function if needed.
   ///
   /// \param [in] M - The module to outline from.
   /// \param [in,out] Region - The region to be extracted
   void findAddInputsOutputs(Module &M, OutlinableRegion &Region);
 
   /// Extract \p Region into its own function.
   ///
   /// \param [in] Region - The region to be extracted into its own function.
   /// \returns True if it was successfully outlined.
   bool extractSection(OutlinableRegion &Region);
 
+  /// For the similarities found, and the extracted sections, create a single
+  /// outlined function with appropriate output blocks as necessary.
+  ///
+  /// \param [in] M - The module to outline from
+  /// \param [in] CurrentGroup - The set of extracted sections to consolidate.
+  /// \param [in,out] FuncsToRemove - List of functions to remove from the
+  /// module after outlining is completed.
+  /// \param [in,out] OutlinedFunctionNum - the number of new outlined functions.
+  void deduplicateExtractedSections(
+      Module &M, OutlinableGroup &CurrentGroup,
+      std::vector<Function *> &FuncsToRemove, unsigned &OutlinedFunctionNum);
 
   /// The set of outlined Instructions, identified by their location in the
   /// sequential ordering of instructions in a Module.
   DenseSet<unsigned> Outlined;
 
   /// TargetTransformInfo lambda for target specific information.
   function_ref<TargetTransformInfo &(Function &)> getTTI;
 
   /// IRSimilarityIdentifier lambda to retrieve IRSimilarityIdentifier.
   function_ref<IRSimilarityIdentifier &(Module &)> getIRSI;
 
   /// The memory allocator used to allocate the OutlinableRegions and
   // CodeExtractors.
   BumpPtrAllocator OutlinerAllocator;
 
   /// Custom InstVisitor to classify different instructions for whether it can
   /// be analyzed for similarity.  This is needed as there may be instruction we
   /// can identify as having similarity, but are more complicated to outline.
   struct InstructionAllowed
       : public InstVisitor<InstructionAllowed, bool> {
     InstructionAllowed() {}
 
     // TODO: Determine a scheme to resolve when the label is similar enough.
     bool visitBranchInst(BranchInst &BI) { return false; }
     // TODO: Determine a scheme to resolve when the labels are similar enough.
     bool visitPHINode(PHINode &PN) { return false; }
     // TODO: Handle allocas.
     bool visitAllocaInst(AllocaInst &AI) { return false; }
     // VAArg instructions are not allowed since this could cause difficulty when
     // differentiating between different sets of variable instructions in
     // the deduplicated outlined regions.
     bool visitVAArgInst(VAArgInst &VI) { return false; }
     // We exclude all exception handling cases since they are so context
     // dependent.
     bool visitLandingPadInst(LandingPadInst &LPI) { return false; }
     bool visitFuncletPadInst(FuncletPadInst &FPI) { return false; }
     // DebugInfo should be included in the regions, but should not be
     // analyzed for similarity as it has no bearing on the outcome of the
     // program.
     bool visitDbgInfoIntrinsic(DbgInfoIntrinsic &DII) {
       return true;
     }
     // TODO: Handle GetElementPtrInsts
     bool visitGetElementPtrInst(GetElementPtrInst &GEPI) {
       return false;
     }
     // TODO: Handle specific intrinsics individually from those that can be
     // handled.
     bool IntrinsicInst(IntrinsicInst &II) { return false; }
     // TODO: Handle CallInsts, there will need to be handling for special kinds
     // of calls, as well as calls to intrinsics.
     bool visitCallInst(CallInst &CI) { return false; }
     // TODO: Handle FreezeInsts.  Since a frozen value could be frozen inside
     // the outlined region, and then returned as an output, this will have to be
     // handled differently.
     bool visitFreezeInst(FreezeInst &CI) { return false; }
     // TODO: We do not current handle similarity that changes the control flow.
     bool visitInvokeInst(InvokeInst &II) { return false; }
     // TODO: We do not current handle similarity that changes the control flow.
     bool visitCallBrInst(CallBrInst &CBI) { return false; }
     // TODO: Handle interblock similarity.
     bool visitTerminator(Instruction &I) { return false; }
     bool visitInstruction(Instruction &I) { 
       return true;
     }
   };
 
   /// A InstVisitor used to exclude certain instructions from being outlined.
   InstructionAllowed InstructionClassifier;
 };
 

llvm/lib/Transforms/IPO/IROutliner.cpp

 /// a set of regions that are structurally similar to one another, such as the
 /// types of the overall function, the output blocks, the sets of stores needed
 /// and a list of the different regions. This information is used in the
 /// deduplication of extracted regions with the same structure.
 struct OutlinableGroup {
   /// The sections that could be outlined
   std::vector<OutlinableRegion *> Regions;
 
+  /// The argument types for the function created as the overall function to
+  /// replace the extracted function for each region.
+  std::vector<Type *> ArgumentTypes;
+  /// The FunctionType for the overall function.
+  FunctionType *OutlinedFunctionType = nullptr;
+  /// The Function for the collective overall function.
+  Function *OutlinedFunction = nullptr;
 
   /// Flag for whether we should not consider this group of OutlinableRegions 
   /// for extraction.
   bool IgnoreGroup = false;
 
+  /// Flag for whether the \ref ArgumentTypes have been defined after the
+  /// exraction of the first region.
+  bool InputTypesSet = false;
+
+  /// The number of input values in \ref ArgumentTypes.  Anything after this
+  /// index in ArgumentTypes is an output argument.
+  unsigned NumAggregateInputs = 0;
+
   /// For the \ref Regions, we look at every Value.  If it is a constant,
   /// we check whether it is the same in Region.
   ///
   /// \param [in,out] NotSame contains the global value numbers where the
   /// constant is not always the same, and must be passed in as an argument.
   void findSameConstants(DenseSet<unsigned> &NotSame);
 };
 
void OutlinableRegion::splitCandidate() {
   // block:                 block:
   //   inst1                  inst1
   //   inst2                  inst2
   //   region1               br block_to_outline
   //   region2              block_to_outline:
   //   region3          ->    region1
   //   region4                region2
   //   inst3                  region3
   //   inst4                  region4 
   //                          br block_after_outline
   //                        block_after_outline:
   //                          inst3
   //                          inst4
 
   std::string OriginalName = PrevBB->getName().str();
 
   StartBB = PrevBB->splitBasicBlock(StartInst, OriginalName + "_to_outline");
constantMatches(Value *V, unsigned GVN,
   // If it was found and is not equal, it is not the same. We do not
   // handle this case yet, and exit early.
   if (Inserted || (GVNToConstantIt->second == CST))
     return true;
 
   return false;
 }
 
 /// Find whether \p Region matches the global value numbering to Constant mapping
 /// found so far.
 ///
 /// \param Region - The OutlinableRegion we are checking for constants
 /// \param NotSame - The set of global value numbers that do not have the same
 /// constant in each region.
 /// \returns true if all Constants are the same in every use of a Constant in \p
 /// Region and false if not
 static bool
 collectRegionsConstants(OutlinableRegion &Region,
                        DenseMap<unsigned, Constant *> &GVNToConstant,
                        DenseSet<unsigned> &NotSame) {
   IRSimilarityCandidate &C = *Region.Candidate;
   for (IRInstructionData &ID : C) {
 
     // Iterate over the operands in an instruction. If the global value number,
     // assigned by the IRSimilarityCandidate, has been seen before, we check if
     // the the number has been found to be not the same value in each instance.
     for (Value *V : ID.OperVals) {
void OutlinableGroup::findSameConstants(DenseSet<unsigned> &NotSame) {
 
   for (OutlinableRegion *Region : Regions)
     if (!collectRegionsConstants(*Region, GVNToConstant, NotSame)) {
       IgnoreGroup = true;
       return;
     }
 }
 
+Function *IROutliner::createFunction(Module &M,
+                                     OutlinableGroup &Group,
+                                     unsigned FunctionNameSuffix) {
+  assert(!Group.OutlinedFunction && "Function is already defined!");
+
+  Group.OutlinedFunctionType = FunctionType::get(
+      Type::getVoidTy(M.getContext()), Group.ArgumentTypes, false);
+
+  // These functions will only be called from within the same module, so
+  // we can set an internal linkage.
+  Group.OutlinedFunction = Function::Create(
+      Group.OutlinedFunctionType, GlobalValue::InternalLinkage,
+      "outlined_ir_func_" + std::to_string(FunctionNameSuffix), M);
+
+  Group.OutlinedFunction->addFnAttr(Attribute::OptimizeForSize);
+  Group.OutlinedFunction->addFnAttr(Attribute::MinSize);
+
+  return Group.OutlinedFunction;
+}
+
+/// Move each BasicBlock in \p Old to \p New.
+///
+/// \param [in] Old - the function to move the basic blocks from.
+/// \param [in] New - The function to move the basic blocks to.
+/// \returns the first return block for the function in New.
+static BasicBlock *moveFunctionData(Function &Old, Function &New) {
+  Function::iterator CurrBB, NextBB, FinalBB;
+  BasicBlock *NewEnd = nullptr;
+  std::vector<Instruction *> DebugInsts;
+  for (CurrBB = Old.begin(), FinalBB = Old.end(); CurrBB != FinalBB;
+       CurrBB = NextBB) {
+    NextBB = std::next(CurrBB);
+    CurrBB->removeFromParent();
+    CurrBB->insertInto(&New);
+    Instruction *I = CurrBB->getTerminator();
+    if (ReturnInst *RI = dyn_cast<ReturnInst>(I))
+      NewEnd = &(*CurrBB);
+  }
+
+  assert(NewEnd && "No return instruction for new function?");
+  return NewEnd;
+}
+
 /// Find the GVN for the inputs that have been found by the CodeExtractor,
 /// excluding the ones that will be removed by llvm.assumes as these will be
 /// removed by the CodeExtractor.
 ///
 /// \param [in] C - The IRSimilarityCandidate containing the region we are
 /// analyzing.
 /// \param [in] CurrentInputs - The set of inputs found by the
 /// CodeExtractor.
 /// \param [out] CurrentInputNumbers - The global value numbers for the extracted
 /// arguments.
 static void mapInputsToGVNs(IRSimilarityCandidate &C,
                             SetVector<Value *> &CurrentInputs,
                             std::vector<unsigned> &EndInputNumbers) {
   // Get the global value number for each input.
   for (Value *Input : CurrentInputs) {
     assert(Input && "Have a nullptr as an input");
     assert(C.getGVN(Input).hasValue() &&
static void getCodeExtractorArguments(OutlinableRegion &Region,
   if (ArgInputs.size() != OverallInputs.size()) {
     Region.IgnoreRegion = true;
     return;
   }
 
   mapInputsToGVNs(C, OverallInputs, InputGVNs);
 }
 
+/// Look over the inputs and map each input argument to an argument in the
+/// overall function for the regions.  This creates a way to replace the
+/// arguments of the extracted function, with the arguments of the new overall
+/// function.
+///
+/// \param [in,out] Region - The region of code to be analyzed.
+/// \param [in] InputsGVNs - The global value numbering of the input values
+/// collected.
+/// \param [in] ArgInputs - The values of the arguments to the extracted
+/// function.
+static void findExtractedInputToOverallInputMapping(
+    OutlinableRegion &Region, std::vector<unsigned> InputGVNs,
+    SetVector<Value *> &ArgInputs) {
+
+  IRSimilarityCandidate &C = *Region.Candidate;
+  OutlinableGroup &Group = *Region.Parent;
+
+  // This counts the argument number in the overall function.
+  unsigned TypeIndex = 0;
+
+  // This counts the argument number in the extracted function.
+  unsigned OriginalIndex = 0;
+
+  // Find the mapping of the extracted arguments to the arguments for the
+  // overall function.
+  for (unsigned InputVal : InputGVNs) {
+    Optional<Value *> InputOpt = C.fromGVN(InputVal);
+    assert(InputOpt.hasValue() && "Global value number not found?");
+    Value *Input = InputOpt.getValue();
+
+    if (!Group.InputTypesSet)
+      Group.ArgumentTypes.push_back(Input->getType());
+
+    // It is not a constant, check if it is a sunken alloca.  If it is not,
+    // create the mapping from extracted to overall.  If it is, create the
+    // mapping of the index to the value.
+    unsigned Found = ArgInputs.count(Input);
+    assert(Found && "Input cannot be found!");
+
+    Region.ExtractedArgToAgg.insert(std::make_pair(OriginalIndex, TypeIndex));
+    Region.AggArgToExtracted.insert(std::make_pair(TypeIndex, OriginalIndex));
+    OriginalIndex++;
+    TypeIndex++;
+  }
+
+  // If we do not have definitions for the OutlinableGroup holding the region,
+  // set the length of the inputs here.  We should have the same inputs for
+  // all of the different regions contained in the OutlinableGroup since they
+  // are all structurally similar to one another
+  if (!Group.InputTypesSet) {
+    Group.NumAggregateInputs = TypeIndex;
+    Group.InputTypesSet = true;
+  }
+
+  Region.NumExtractedInputs = OriginalIndex;
+}
+
 void IROutliner::findAddInputsOutputs(
     Module &M, OutlinableRegion &Region) {
   std::vector<unsigned> Inputs;
   SetVector<Value *> ArgInputs;
 
   getCodeExtractorArguments(Region, Inputs, ArgInputs);
 
   if (Region.IgnoreRegion)
     return;
+
+  // Map the inputs found by the CodeExtractor to the arguments found for
+  // the overall function.
+  findExtractedInputToOverallInputMapping(Region, Inputs, ArgInputs);
+}
+
+/// Replace the extracted function in the Region with a call to the overall
+/// function constructed from the deduplicated similar regions, replacing and
+/// remapping the values passed to the extracted function as arguments to the
+/// new arguments of the overall function.
+///
+/// \param [in] M - The module to outline from.
+/// \param [in] Region - The regions of extracted code to be replaced with a new
+/// function.
+/// \returns a call instruction with the replaced function.
+CallInst *replaceCalledFunction(Module &M,
+                                OutlinableRegion &Region) {
+  std::vector<Value *> NewCallArgs;
+  DenseMap<unsigned, unsigned>::iterator ArgPair;
+
+  OutlinableGroup &Group = *Region.Parent;
+  CallInst *Call = Region.Call;
+  assert(Call && "Call to replace is nullptr?");
+  Function *AggFunc = Group.OutlinedFunction;
+  assert(AggFunc && "Function to replace with is nullptr?");
+
+  // If the arguments are the same size, there are not values that need to be
+  // made argument, or different output registers to handle.  We can simply
+  // replace the called function in this case.
+  assert(AggFunc->arg_size() == Call->arg_size() &&
+         "Can only replace calls with the same number of arguments!");
+
+  LLVM_DEBUG(dbgs() << "Replace call to " << *Call << " with call to "
+                    << *AggFunc << " with same number of arguments\n");
+  Call->setCalledFunction(AggFunc);
+  return Call;
+}
+
+// Within an extracted function, replace the argument uses of the extracted
+// region with the arguments of the function for an OutlinableGroup.
+//
+// \param OS [in] - The region of extracted code to be changed.
+static void replaceArgumentUses(OutlinableRegion &Region) {
+  OutlinableGroup &Group = *Region.Parent;
+  assert(Region.ExtractedFunction && "Region has no extracted function?");
+
+  for (unsigned ArgIdx = 0; ArgIdx < Region.ExtractedFunction->arg_size();
+       ArgIdx++) {
+    assert(Region.ExtractedArgToAgg.find(ArgIdx) !=
+               Region.ExtractedArgToAgg.end() &&
+           "No mapping from extracted to outlined?");
+    unsigned AggArgIdx = Region.ExtractedArgToAgg.find(ArgIdx)->second;
+    Argument *AggArg = Group.OutlinedFunction->getArg(AggArgIdx);
+    Argument *Arg = Region.ExtractedFunction->getArg(ArgIdx);
+    // The argument is an input, so we can simply replace it with the overall
+    // argument value
+    LLVM_DEBUG(dbgs() << "Replacing uses of input " << *Arg << " in function "
+                      << *Region.ExtractedFunction << " with " << *AggArg
+                      << " in function " << *Group.OutlinedFunction << "\n");
+    Arg->replaceAllUsesWith(AggArg);
+  }
+}
+
+/// Fill the new function that will serve as the replacement function for all of
+/// the extracted regions of a certain structure from the first region in the
+/// list of regions.  Replace this first region's extracted function with the
+/// new overall function.
+///
+/// \param M [in] - The module we are outlining from.
+/// \param CurrentGroup [in] - The group of regions to be outlined.
+/// \param FuncsToRemove [in,out] - Extracted functions to erase from module
+/// once outlining is complete.
+static void fillOverallFunction(Module &M, OutlinableGroup &CurrentGroup,
+                         std::vector<Function *> &FuncsToRemove) {
+  OutlinableRegion *CurrentOS = CurrentGroup.Regions[0];
+
+  // Move first extracted function's instructions into new function
+  LLVM_DEBUG(dbgs() << "Move instructions from "
+                    << *CurrentOS->ExtractedFunction << " to instruction "
+                    << *CurrentGroup.OutlinedFunction << "\n");
+  moveFunctionData(*CurrentOS->ExtractedFunction,
+                   *CurrentGroup.OutlinedFunction);
+
+  // Transfer the attributes
+  for (Attribute A :
+       CurrentOS->ExtractedFunction->getAttributes().getFnAttributes())
+    CurrentGroup.OutlinedFunction->addFnAttr(A);
+
+  replaceArgumentUses(*CurrentOS);
+
+  // Replace the call to the extracted function with the outlined function.
+  CurrentOS->Call = replaceCalledFunction(M, *CurrentOS);
+
+  // We only delete the extracted funcitons at the end since we may need to
+  // reference instructions contained in them for mapping purposes.
+  FuncsToRemove.push_back(CurrentOS->ExtractedFunction);
+}
+
+void IROutliner::deduplicateExtractedSections(
+    Module &M, OutlinableGroup &CurrentGroup,
+    std::vector<Function *> &FuncsToRemove, unsigned &OutlinedFunctionNum) {
+  createFunction(M, CurrentGroup, OutlinedFunctionNum);
+
+  std::vector<BasicBlock *> OutputStoreBBs;
+
+  OutlinableRegion *CurrentOS;
+
+  fillOverallFunction(M, CurrentGroup, FuncsToRemove);
+
+  // Do the same for the other extracted functions
+  for (unsigned Idx = 1; Idx < CurrentGroup.Regions.size(); Idx++) {
+    CurrentOS = CurrentGroup.Regions[Idx];
+
+    replaceArgumentUses(*CurrentOS);
+    CurrentOS->Call = replaceCalledFunction(M, *CurrentOS);
+    FuncsToRemove.push_back(CurrentOS->ExtractedFunction);
+  }
+
+  OutlinedFunctionNum++;
 }
 
 void IROutliner::pruneIncompatibleRegions(
     std::vector<IRSimilarityCandidate> &CandidateVec,
     OutlinableGroup &CurrentGroup) {
   bool PreviouslyOutlined;
 
   // Sort from beginning to end, so the IRSimilarityCandidates are in order.
   stable_sort(CandidateVec, [](const IRSimilarityCandidate &LHS,
                                        const IRSimilarityCandidate &RHS) {
     return LHS.getStartIdx() < RHS.getStartIdx();
   });
 
   unsigned CurrentEndIdx = 0;
   for (IRSimilarityCandidate &IRSC : CandidateVec) {
     PreviouslyOutlined = false;
     unsigned StartIdx = IRSC.getStartIdx();
     unsigned EndIdx = IRSC.getEndIdx();
for (IRSimilarityCandidate &IRSC : CandidateVec) {
     if (BadInst)
       continue;
 
     OutlinableRegion *OS = new (OutlinerAllocator.Allocate<OutlinableRegion>())
         OutlinableRegion(IRSC, CurrentGroup);
     CurrentGroup.Regions.push_back(OS);
 
     CurrentEndIdx = EndIdx;
 
   }
 }
 
 bool IROutliner::extractSection(OutlinableRegion &Region) {
   assert(Region.StartBB != nullptr &&
          "StartBB for the OutlinableRegion is nullptr!");
   assert(Region.FollowBB != nullptr &&
          "StartBB for the OutlinableRegion is nullptr!");
if (SimilarityCandidates.size() > 1)
     llvm::stable_sort(SimilarityCandidates,
                       [](const std::vector<IRSimilarityCandidate> &LHS,
                          const std::vector<IRSimilarityCandidate> &RHS) {
                         return LHS[0].getLength() * LHS.size() >
                                RHS[0].getLength() * RHS.size();
                       });
 
   DenseSet<unsigned> NotSame;
+  std::vector<Function *> FuncsToRemove;
   // Iterate over the possible sets of similarity.
   for (SimilarityGroup &CandidateVec : SimilarityCandidates) {
     OutlinableGroup CurrentGroup;
 
     // Remove entries that were previously outlined
     pruneIncompatibleRegions(CandidateVec, CurrentGroup);
 
     // We pruned the number of regions to 0 to 1, meaning that it's not worth
for (OutlinableRegion *OS : CurrentGroup.Regions) {
         OS->reattachCandidate();
     }
 
     CurrentGroup.Regions = OutlinedRegions;
 
     // Create functions out of all the sections, and mark them as outlined
     OutlinedRegions.clear();
     for (OutlinableRegion *OS : CurrentGroup.Regions) {
-      OutlinedFunctionNum++;
       bool FunctionOutlined = extractSection(*OS);
       if (FunctionOutlined) {
         unsigned StartIdx = OS->Candidate->getStartIdx();
         unsigned EndIdx = OS->Candidate->getEndIdx();
         for (unsigned Idx = StartIdx; Idx <= EndIdx; Idx++)
           Outlined.insert(Idx);
         
         OutlinedRegions.push_back(OS);
       }
     }
 
     CurrentGroup.Regions = OutlinedRegions;
+
+    if (CurrentGroup.Regions.empty())
+      continue;
+
+    deduplicateExtractedSections(M, CurrentGroup, FuncsToRemove,
+                                 OutlinedFunctionNum);
   }
 
+  for (Function *F : FuncsToRemove)
+    F->eraseFromParent();
+
   return OutlinedFunctionNum;
 }
 
 bool IROutliner::run(Module &M) {
   return doOutline(M) > 0;
 }
 
 // Pass Manager Boilerplate
 class IROutlinerLegacyPass : public ModulePass {
 public:
   static char ID;
   IROutlinerLegacyPass() : ModulePass(ID) {

 bool IROutlinerLegacyPass::runOnModule(Module &M) {
   if (skipModule(M))
     return false;
 
   auto GTTI = [this](Function &F) -> TargetTransformInfo & {
     return this->getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F);
   };
 
   auto GIRSI = [this](Module &) -> IRSimilarityIdentifier &  {
     return this->getAnalysis<IRSimilarityIdentifierWrapperPass>().getIRSI();
   };
 
   return IROutliner(GTTI, GIRSI).run(M);
 }
 
 PreservedAnalyses IROutlinerPass::run(Module &M, ModuleAnalysisManager &AM) {
   auto &FAM = AM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();

llvm/test/Transforms/IROutliner/extraction.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -verify -iroutliner < %s | FileCheck %s
 
 ; This test makes sure we are extracting the found similarity sections
 ; correctly at the call site.
 
 define void @extract1() {
 ; CHECK-LABEL: @extract1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[B:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT:    call void @extract1.outlined(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT:    call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]])
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %a = alloca i32, align 4
   %b = alloca i32, align 4
   %c = alloca i32, align 4
   store i32 2, i32* %a, align 4
   store i32 3, i32* %b, align 4
   store i32 4, i32* %c, align 4
   %al = load i32, i32* %a
   %bl = load i32, i32* %b
   %cl = load i32, i32* %c
   ret void
 }
 
 define void @extract2() {
 ; CHECK-LABEL: @extract2(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[B:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT:    call void @extract2.outlined(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT:    call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]])
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %a = alloca i32, align 4
   %b = alloca i32, align 4
   %c = alloca i32, align 4
   store i32 2, i32* %a, align 4
   store i32 3, i32* %b, align 4

 ; CHECK-NEXT:    store i32 2, i32* [[A]], align 4
 ; CHECK-NEXT:    store i32 3, i32* [[B]], align 4
 ; CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* [[A]], align 4
 ; CHECK-NEXT:    [[TMP1:%.*]] = load i32, i32* [[B]], align 4
 ; CHECK-NEXT:    [[ADD:%.*]] = add i32 [[TMP0]], [[TMP1]]
 ; CHECK-NEXT:    store i32 [[ADD]], i32* [[OUTPUT]], align 4
 ; CHECK-NEXT:    [[TMP2:%.*]] = load i32, i32* [[OUTPUT]], align 4
 ; CHECK-NEXT:    [[TMP3:%.*]] = load i32, i32* [[OUTPUT]], align 4
-; CHECK-NEXT:    call void @extract_outs1.outlined(i32 [[TMP2]], i32 [[ADD]], i32* [[RESULT]])
+; CHECK-NEXT:    call void @outlined_ir_func_1(i32 [[TMP2]], i32 [[ADD]], i32* [[RESULT]])
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %a = alloca i32, align 4
   %b = alloca i32, align 4
   %output = alloca i32, align 4
   %result = alloca i32, align 4
   store i32 2, i32* %a, align 4

 ; CHECK-NEXT:    [[RESULT:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    store i32 2, i32* [[A]], align 4
 ; CHECK-NEXT:    store i32 3, i32* [[B]], align 4
 ; CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* [[A]], align 4
 ; CHECK-NEXT:    [[TMP1:%.*]] = load i32, i32* [[B]], align 4
 ; CHECK-NEXT:    [[ADD:%.*]] = add i32 [[TMP0]], [[TMP1]]
 ; CHECK-NEXT:    store i32 [[ADD]], i32* [[OUTPUT]], align 4
 ; CHECK-NEXT:    [[TMP2:%.*]] = load i32, i32* [[OUTPUT]], align 4
-; CHECK-NEXT:    call void @extract_outs2.outlined(i32 [[TMP2]], i32 [[ADD]], i32* [[RESULT]])
+; CHECK-NEXT:    call void @outlined_ir_func_1(i32 [[TMP2]], i32 [[ADD]], i32* [[RESULT]])
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %a = alloca i32, align 4
   %b = alloca i32, align 4
   %output = alloca i32, align 4
   %result = alloca i32, align 4
   store i32 2, i32* %a, align 4
   store i32 3, i32* %b, align 4
   %0 = load i32, i32* %a, align 4
   %1 = load i32, i32* %b, align 4
   %add = add i32 %0, %1
   store i32 %add, i32* %output, align 4
   %2 = load i32, i32* %output, align 4
   %mul = mul i32 %2, %add
   store i32 %mul, i32* %result, align 4
   ret void
-}
+}
 

llvm/test/Transforms/IROutliner/illegal-assumes.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -verify -iroutliner < %s | FileCheck %s
 
 ; This test ensures that we do not include llvm.assumes.  There are exceptions
 ; in the CodeExtractor's algorithm for llvm.assumes, so we ignore it for now.
 
 define void @outline_assumes() {
 ; CHECK-LABEL: @outline_assumes(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[B:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[C:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[D:%.*]] = alloca i1, align 4
 ; CHECK-NEXT:    store i1 true, i1* [[D]], align 4
 ; CHECK-NEXT:    [[DL:%.*]] = load i1, i1* [[D]], align 1
 ; CHECK-NEXT:    [[SPLIT_INST:%.*]] = sub i1 [[DL]], [[DL]]
-; CHECK-NEXT:    call void @outline_assumes.outlined(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT:    call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]])
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[DL]])
-; CHECK-NEXT:    call void @outline_assumes.outlined.1(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT:    call void @outlined_ir_func_1(i32* [[A]], i32* [[B]], i32* [[C]])
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %a = alloca i32, align 4
   %b = alloca i32, align 4
   %c = alloca i32, align 4
   %d = alloca i1, align 4
   store i1 1, i1* %d, align 4

 ; CHECK-LABEL: @outline_assumes2(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[B:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[C:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[D:%.*]] = alloca i1, align 4
 ; CHECK-NEXT:    store i1 false, i1* [[D]], align 4
 ; CHECK-NEXT:    [[DL:%.*]] = load i1, i1* [[D]], align 1
-; CHECK-NEXT:    call void @outline_assumes2.outlined(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT:    call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]])
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[DL]])
-; CHECK-NEXT:    call void @outline_assumes2.outlined.2(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT:    call void @outlined_ir_func_1(i32* [[A]], i32* [[B]], i32* [[C]])
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %a = alloca i32, align 4
   %b = alloca i32, align 4
   %c = alloca i32, align 4
   %d = alloca i1, align 4
   store i1 0, i1* %d, align 4

 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[B:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[C:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[D:%.*]] = alloca i1, align 4
 ; CHECK-NEXT:    store i1 true, i1* [[D]], align 4
 ; CHECK-NEXT:    [[DL:%.*]] = load i1, i1* [[D]], align 1
 ; CHECK-NEXT:    [[SPLIT_INST:%.*]] = add i1 [[DL]], [[DL]]
-; CHECK-NEXT:    call void @outline_assumes3.outlined(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT:    call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]])
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[DL]])
-; CHECK-NEXT:    call void @outline_assumes3.outlined.3(i32* [[A]])
+; CHECK-NEXT:    call void @outlined_ir_func_2(i32* [[A]])
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %a = alloca i32, align 4
   %b = alloca i32, align 4
   %c = alloca i32, align 4
   %d = alloca i1, align 4
   store i1 1, i1* %d, align 4

 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[B:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[C:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[D:%.*]] = alloca i1, align 4
 ; CHECK-NEXT:    store i1 false, i1* [[D]], align 4
 ; CHECK-NEXT:    [[DL:%.*]] = load i1, i1* [[D]], align 1
 ; CHECK-NEXT:    [[SPLIT_INST:%.*]] = add i1 [[DL]], [[DL]]
-; CHECK-NEXT:    call void @outline_assumes4.outlined(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT:    call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]])
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[DL]])
-; CHECK-NEXT:    call void @outline_assumes4.outlined.4(i32* [[A]])
+; CHECK-NEXT:    call void @outlined_ir_func_2(i32* [[A]])
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %a = alloca i32, align 4
   %b = alloca i32, align 4
   %c = alloca i32, align 4
   %d = alloca i1, align 4
   store i1 0, i1* %d, align 4

llvm/test/Transforms/IROutliner/illegal-branches.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -verify -iroutliner < %s | FileCheck %s
 
 ; Show that we do not extract sections with branches as it would require extra
 ; label and control flow checking.
 
 define void @function1() {
 ; CHECK-LABEL: @function1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[B:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT:    call void @function1.outlined(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT:    call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]])
 ; CHECK-NEXT:    br label [[NEXT:%.*]]
 ; CHECK:       next:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %a = alloca i32, align 4
   %b = alloca i32, align 4
   %c = alloca i32, align 4
   store i32 2, i32* %a, align 4
   store i32 3, i32* %b, align 4
   store i32 4, i32* %c, align 4
   br label %next
 next:
   ret void
 }
 
 define void @function2() {
 ; CHECK-LABEL: @function2(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[B:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT:    call void @function2.outlined(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT:    call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]])
 ; CHECK-NEXT:    br label [[NEXT:%.*]]
 ; CHECK:       next:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %a = alloca i32, align 4
   %b = alloca i32, align 4
   %c = alloca i32, align 4
   store i32 2, i32* %a, align 4
   store i32 3, i32* %b, align 4
   store i32 4, i32* %c, align 4
   br label %next
 next:
   ret void
 }

llvm/test/Transforms/IROutliner/illegal-callbr.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -verify -iroutliner < %s | FileCheck %s
 
 ; This test checks that we do not outline callbr instruction since as we do not
 ; outline any control flow change instructions.
 
 
 define i32 @function1(i32 %a, i32 %b) {
 ; CHECK-LABEL: @function1(
 ; CHECK-NEXT:  bb0:
 ; CHECK-NEXT:    [[TMP0:%.*]] = add i32 [[A:%.*]], 4
-; CHECK-NEXT:    call void @function1.outlined(i32 [[B:%.*]])
+; CHECK-NEXT:    call void @outlined_ir_func_0(i32 [[B:%.*]])
 ; CHECK-NEXT:    callbr void asm "xorl $0, $0
 ; CHECK-NEXT:    to label [[NORMAL:%.*]] [label %fail1]
 ; CHECK:       normal:
-; CHECK-NEXT:    call void @function1.outlined.1(i32 [[B]])
+; CHECK-NEXT:    call void @outlined_ir_func_0(i32 [[B]])
 ; CHECK-NEXT:    ret i32 0
 ; CHECK:       fail1:
 ; CHECK-NEXT:    [[TMP1:%.*]] = add i32 [[B]], 1
 ; CHECK-NEXT:    [[TMP2:%.*]] = add i32 [[B]], 1
 ; CHECK-NEXT:    ret i32 0
 ;
 bb0:
   %0 = add i32 %a, 4
fail1:
   %6 = add i32 %b, 1
   ret i32 0
 }
 
 define i32 @function2(i32 %a, i32 %b) {
 ; CHECK-LABEL: @function2(
 ; CHECK-NEXT:  bb0:
 ; CHECK-NEXT:    [[TMP0:%.*]] = add i32 [[A:%.*]], 4
-; CHECK-NEXT:    call void @function2.outlined(i32 [[B:%.*]])
+; CHECK-NEXT:    call void @outlined_ir_func_0(i32 [[B:%.*]])
 ; CHECK-NEXT:    callbr void asm "xorl $0, $0
 ; CHECK-NEXT:    to label [[NORMAL:%.*]] [label %fail1]
 ; CHECK:       normal:
-; CHECK-NEXT:    call void @function2.outlined.2(i32 [[B]])
+; CHECK-NEXT:    call void @outlined_ir_func_0(i32 [[B]])
 ; CHECK-NEXT:    ret i32 0
 ; CHECK:       fail1:
 ; CHECK-NEXT:    [[TMP1:%.*]] = add i32 [[B]], 1
 ; CHECK-NEXT:    [[TMP2:%.*]] = add i32 [[B]], 1
 ; CHECK-NEXT:    ret i32 0
 ;
 bb0:
   %0 = add i32 %a, 4

llvm/test/Transforms/IROutliner/illegal-calls.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -verify -iroutliner < %s | FileCheck %s
 
 ; This test checks that we do not outline calls.  Special calls, such as
 ; indirect or nameless calls require extra handling to ensure that there
 ; are no inconsistencies when outlining and consolidating regions.
 
 declare void @f1(i32*, i32*);
 
 define void @outline_constants1() {
 ; CHECK-LABEL: @outline_constants1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[B:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT:    call void @outline_constants1.outlined.1(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT:    call void @outlined_ir_func_1(i32* [[A]], i32* [[B]], i32* [[C]])
 ; CHECK-NEXT:    call void @f1(i32* [[A]], i32* [[B]])
-; CHECK-NEXT:    call void @outline_constants1.outlined(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT:    call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]])
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %a = alloca i32, align 4
   %b = alloca i32, align 4
   %c = alloca i32, align 4
   store i32 2, i32* %a, align 4
   store i32 3, i32* %b, align 4
   store i32 4, i32* %c, align 4
   call void @f1(i32* %a, i32* %b)
   %al = load i32, i32* %a
   %bl = load i32, i32* %b
   %cl = load i32, i32* %c
   ret void
 }
 
 define void @outline_constants2() {
 ; CHECK-LABEL: @outline_constants2(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[B:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT:    call void @outline_constants2.outlined.2(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT:    call void @outlined_ir_func_1(i32* [[A]], i32* [[B]], i32* [[C]])
 ; CHECK-NEXT:    call void @f1(i32* [[A]], i32* [[B]])
-; CHECK-NEXT:    call void @outline_constants2.outlined(i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT:    call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]])
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %a = alloca i32, align 4
   %b = alloca i32, align 4
   %c = alloca i32, align 4
   store i32 2, i32* %a, align 4
   store i32 3, i32* %b, align 4
   store i32 4, i32* %c, align 4
   call void @f1(i32* %a, i32* %b)
   %al = load i32, i32* %a
   %bl = load i32, i32* %b
   %cl = load i32, i32* %c
   ret void
 }

llvm/test/Transforms/IROutliner/illegal-catchpad.ll

 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[B:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    invoke void @llvm.donothing()
 ; CHECK-NEXT:    to label [[NORMAL:%.*]] unwind label [[EXCEPTION:%.*]]
 ; CHECK:       exception:
 ; CHECK-NEXT:    [[CS1:%.*]] = catchswitch within none [label %catchpad1] unwind to caller
 ; CHECK:       catchpad1:
 ; CHECK-NEXT:    [[TMP0:%.*]] = catchpad within [[CS1]] []
-; CHECK-NEXT:    call void @function1.outlined(i32* [[A]], i32* [[B]])
+; CHECK-NEXT:    call void @outlined_ir_func_0(i32* [[A]], i32* [[B]])
 ; CHECK-NEXT:    br label [[NORMAL]]
 ; CHECK:       normal:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %a = alloca i32, align 4
   %b = alloca i32, align 4
   invoke void @llvm.donothing() to label %normal unwind label %exception

 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[B:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    invoke void @llvm.donothing()
 ; CHECK-NEXT:    to label [[NORMAL:%.*]] unwind label [[EXCEPTION:%.*]]
 ; CHECK:       exception:
 ; CHECK-NEXT:    [[CS1:%.*]] = catchswitch within none [label %catchpad1] unwind to caller
 ; CHECK:       catchpad1:
 ; CHECK-NEXT:    [[TMP0:%.*]] = catchpad within [[CS1]] []
-; CHECK-NEXT:    call void @function2.outlined(i32* [[A]], i32* [[B]])
+; CHECK-NEXT:    call void @outlined_ir_func_0(i32* [[A]], i32* [[B]])
 ; CHECK-NEXT:    br label [[NORMAL]]
 ; CHECK:       normal:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %a = alloca i32, align 4
   %b = alloca i32, align 4
   invoke void @llvm.donothing() to label %normal unwind label %exception

llvm/test/Transforms/IROutliner/illegal-cleanup.ll

 ; CHECK-LABEL: @function1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[B:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    invoke void @llvm.donothing()
 ; CHECK-NEXT:    to label [[NORMAL:%.*]] unwind label [[EXCEPTION:%.*]]
 ; CHECK:       exception:
 ; CHECK-NEXT:    [[CLEAN:%.*]] = cleanuppad within none []
-; CHECK-NEXT:    call void @function1.outlined(i32* [[A]], i32* [[B]])
+; CHECK-NEXT:    call void @outlined_ir_func_0(i32* [[A]], i32* [[B]])
 ; CHECK-NEXT:    br label [[NORMAL]]
 ; CHECK:       normal:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %a = alloca i32, align 4
   %b = alloca i32, align 4
   invoke void @llvm.donothing() to label %normal unwind label %exception

 ; CHECK-LABEL: @function2(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[B:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    invoke void @llvm.donothing()
 ; CHECK-NEXT:    to label [[NORMAL:%.*]] unwind label [[EXCEPTION:%.*]]
 ; CHECK:       exception:
 ; CHECK-NEXT:    [[CLEAN:%.*]] = cleanuppad within none []
-; CHECK-NEXT:    call void @function2.outlined(i32* [[A]], i32* [[B]])
+; CHECK-NEXT:    call void @outlined_ir_func_0(i32* [[A]], i32* [[B]])
 ; CHECK-NEXT:    br label [[NORMAL]]
 ; CHECK:       normal:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %a = alloca i32, align 4
   %b = alloca i32, align 4
   invoke void @llvm.donothing() to label %normal unwind label %exception
 exception:
   %clean = cleanuppad within none []
   store i32 2, i32* %a, align 4
   store i32 3, i32* %b, align 4
   br label %normal
 normal:
   ret void
 }

llvm/test/Transforms/IROutliner/illegal-frozen.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -verify -iroutliner < %s | FileCheck %s
 
 ; Show that we do not extract freeze instructions, since extra handling is
 ; required to mark any outputs used with freeze.
 
 define void @function1(i32* %a, i32* %b) {
 ; CHECK-LABEL: @function1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br label [[FIRST:%.*]]
 ; CHECK:       first:
 ; CHECK-NEXT:    [[C:%.*]] = freeze i32* [[A:%.*]]
-; CHECK-NEXT:    call void @function1.outlined(i32* [[C]], i32* [[B:%.*]])
+; CHECK-NEXT:    call void @outlined_ir_func_0(i32* [[C]], i32* [[B:%.*]])
 ; CHECK-NEXT:    ret void
 ; CHECK:       next:
 ; CHECK-NEXT:    br label [[FIRST]]
 ;
 entry:
   br label %first
 first:
   %c = freeze i32* %a
   store i32 2, i32* %c, align 4
   store i32 3, i32* %b, align 4
   ret void
 next:
   br label %first
 }
 
 define void @function2(i32* %a, i32* %b) {
 ; CHECK-LABEL: @function2(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br label [[FIRST:%.*]]
 ; CHECK:       first:
 ; CHECK-NEXT:    [[C:%.*]] = freeze i32* [[A:%.*]]
-; CHECK-NEXT:    call void @function2.outlined(i32* [[C]], i32* [[B:%.*]])
+; CHECK-NEXT:    call void @outlined_ir_func_0(i32* [[C]], i32* [[B:%.*]])
 ; CHECK-NEXT:    ret void
 ; CHECK:       next:
 ; CHECK-NEXT:    br label [[FIRST]]
 ;
 entry:
   br label %first
 first:
   %c = freeze i32* %a
   store i32 2, i32* %c, align 4
   store i32 3, i32* %b, align 4
   ret void
 next:
   br label %first
 }

llvm/test/Transforms/IROutliner/illegal-gep.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -verify -iroutliner < %s | FileCheck %s
 
 ; This test checks to make sure that we do not outline getelementptr
 ; instructions since we must make extra checks on the final operands.
 
 %struct.RT = type { i8, [10 x [20 x i32]], i8 }
 %struct.ST = type { i32, double, %struct.RT }
 
 define void @function1(%struct.ST* %s, i64 %t) {
 ; CHECK-LABEL: @function1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[B:%.*]] = alloca i32, align 4
-; CHECK-NEXT:    call void @function1.outlined(i32* [[A]], i32* [[B]])
+; CHECK-NEXT:    call void @outlined_ir_func_0(i32* [[A]], i32* [[B]])
 ; CHECK-NEXT:    [[TMP0:%.*]] = getelementptr inbounds [[STRUCT_ST:%.*]], %struct.ST* [[S:%.*]], i64 1
 ; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr inbounds [[STRUCT_ST]], %struct.ST* [[S]], i64 [[T:%.*]]
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %a = alloca i32, align 4
   %b = alloca i32, align 4
   store i32 2, i32* %a, align 4
   store i32 3, i32* %b, align 4
   %0 = getelementptr inbounds %struct.ST, %struct.ST* %s, i64 1
   %1 = getelementptr inbounds %struct.ST, %struct.ST* %s, i64 %t
   ret void
 }
 
 define void @function2(%struct.ST* %s, i64 %t) {
 ; CHECK-LABEL: @function2(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[B:%.*]] = alloca i32, align 4
-; CHECK-NEXT:    call void @function2.outlined(i32* [[A]], i32* [[B]])
+; CHECK-NEXT:    call void @outlined_ir_func_0(i32* [[A]], i32* [[B]])
 ; CHECK-NEXT:    [[TMP0:%.*]] = getelementptr inbounds [[STRUCT_ST:%.*]], %struct.ST* [[S:%.*]], i64 1
 ; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr inbounds [[STRUCT_ST]], %struct.ST* [[S]], i64 [[T:%.*]]
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %a = alloca i32, align 4
   %b = alloca i32, align 4
   store i32 2, i32* %a, align 4
   store i32 3, i32* %b, align 4
   %0 = getelementptr inbounds %struct.ST, %struct.ST* %s, i64 1
   %1 = getelementptr inbounds %struct.ST, %struct.ST* %s, i64 %t
   ret void
 }

llvm/test/Transforms/IROutliner/illegal-invoke.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -verify -iroutliner < %s | FileCheck %s
 
 ; This test checks that invoke instructions are not outlined even if they
 ; in a similar section.  Outlining does not currently handle control flow
 ; changes.
 
 declare void @llvm.donothing() nounwind readnone
 
 define void @function1() personality i8 3 {
 ; CHECK-LABEL: @function1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[B:%.*]] = alloca i32, align 4
-; CHECK-NEXT:    call void @function1.outlined(i32* [[A]], i32* [[B]])
+; CHECK-NEXT:    call void @outlined_ir_func_0(i32* [[A]], i32* [[B]])
 ; CHECK-NEXT:    invoke void @llvm.donothing()
 ; CHECK-NEXT:    to label [[NORMAL:%.*]] unwind label [[EXCEPTION:%.*]]
 ; CHECK:       exception:
 ; CHECK-NEXT:    [[CLEANUP:%.*]] = landingpad i8
 ; CHECK-NEXT:    cleanup
 ; CHECK-NEXT:    br label [[NORMAL]]
 ; CHECK:       normal:
 ; CHECK-NEXT:    ret void
normal:
   ret void
 }
 
 define void @function2() personality i8 3 {
 ; CHECK-LABEL: @function2(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[B:%.*]] = alloca i32, align 4
-; CHECK-NEXT:    call void @function2.outlined(i32* [[A]], i32* [[B]])
+; CHECK-NEXT:    call void @outlined_ir_func_0(i32* [[A]], i32* [[B]])
 ; CHECK-NEXT:    invoke void @llvm.donothing()
 ; CHECK-NEXT:    to label [[NORMAL:%.*]] unwind label [[EXCEPTION:%.*]]
 ; CHECK:       exception:
 ; CHECK-NEXT:    [[CLEANUP:%.*]] = landingpad i8
 ; CHECK-NEXT:    cleanup
 ; CHECK-NEXT:    br label [[NORMAL]]
 ; CHECK:       normal:
 ; CHECK-NEXT:    ret void

llvm/test/Transforms/IROutliner/illegal-landingpad.ll

 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[B:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    invoke void @llvm.donothing()
 ; CHECK-NEXT:    to label [[NORMAL:%.*]] unwind label [[EXCEPTION:%.*]]
 ; CHECK:       exception:
 ; CHECK-NEXT:    [[CLEANUP:%.*]] = landingpad i8
 ; CHECK-NEXT:    cleanup
-; CHECK-NEXT:    call void @function1.outlined(i32* [[A]], i32* [[B]])
+; CHECK-NEXT:    call void @outlined_ir_func_0(i32* [[A]], i32* [[B]])
 ; CHECK-NEXT:    br label [[NORMAL]]
 ; CHECK:       normal:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %a = alloca i32, align 4
   %b = alloca i32, align 4
   invoke void @llvm.donothing() to label %normal unwind label %exception

 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[B:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    invoke void @llvm.donothing()
 ; CHECK-NEXT:    to label [[NORMAL:%.*]] unwind label [[EXCEPTION:%.*]]
 ; CHECK:       exception:
 ; CHECK-NEXT:    [[CLEANUP:%.*]] = landingpad i8
 ; CHECK-NEXT:    cleanup
-; CHECK-NEXT:    call void @function2.outlined(i32* [[A]], i32* [[B]])
+; CHECK-NEXT:    call void @outlined_ir_func_0(i32* [[A]], i32* [[B]])
 ; CHECK-NEXT:    br label [[NORMAL]]
 ; CHECK:       normal:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %a = alloca i32, align 4
   %b = alloca i32, align 4
   invoke void @llvm.donothing() to label %normal unwind label %exception
 exception:
   %cleanup = landingpad i8 cleanup
   store i32 2, i32* %a, align 4
   store i32 3, i32* %b, align 4
   br label %normal
 normal:
   ret void
 }

llvm/test/Transforms/IROutliner/illegal-memset.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -verify -iroutliner < %s | FileCheck %s
 
 ; This test checks that we do not outline memset intrinsics since it requires
 ; extra address space checks.
 
 declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i32, i1)
 
 define i64 @function1(i64 %x, i64 %z, i64 %n) {
 ; CHECK-LABEL: @function1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[POOL:%.*]] = alloca [59 x i64], align 4
 ; CHECK-NEXT:    [[TMP:%.*]] = bitcast [59 x i64]* [[POOL]] to i8*
 ; CHECK-NEXT:    call void @llvm.memset.p0i8.i64(i8* align 4 [[TMP]], i8 0, i64 236, i1 false)
-; CHECK-NEXT:    call void @function1.outlined(i64 [[N:%.*]], i64 [[X:%.*]], i64 [[Z:%.*]])
+; CHECK-NEXT:    call void @outlined_ir_func_0(i64 [[N:%.*]], i64 [[X:%.*]], i64 [[Z:%.*]])
 ; CHECK-NEXT:    ret i64 0
 ;
 entry:
   %pool = alloca [59 x i64], align 4
   %tmp = bitcast [59 x i64]* %pool to i8*
   call void @llvm.memset.p0i8.i64(i8* nonnull %tmp, i8 0, i64 236, i32 4, i1 false)
   %cmp3 = icmp eq i64 %n, 0
   %a = add i64 %x, %z
   %c = add i64 %x, %z
   ret i64 0
 }
 
 define i64 @function2(i64 %x, i64 %z, i64 %n) {
 ; CHECK-LABEL: @function2(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[POOL:%.*]] = alloca [59 x i64], align 4
 ; CHECK-NEXT:    [[TMP:%.*]] = bitcast [59 x i64]* [[POOL]] to i8*
 ; CHECK-NEXT:    call void @llvm.memset.p0i8.i64(i8* align 4 [[TMP]], i8 0, i64 236, i1 false)
-; CHECK-NEXT:    call void @function2.outlined(i64 [[N:%.*]], i64 [[X:%.*]], i64 [[Z:%.*]])
+; CHECK-NEXT:    call void @outlined_ir_func_0(i64 [[N:%.*]], i64 [[X:%.*]], i64 [[Z:%.*]])
 ; CHECK-NEXT:    ret i64 0
 ;
 entry:
   %pool = alloca [59 x i64], align 4
   %tmp = bitcast [59 x i64]* %pool to i8*
   call void @llvm.memset.p0i8.i64(i8* nonnull %tmp, i8 0, i64 236, i32 4, i1 false)
   %cmp3 = icmp eq i64 %n, 0
   %a = add i64 %x, %z
   %c = add i64 %x, %z
   ret i64 0
 }

llvm/test/Transforms/IROutliner/illegal-phi-nodes.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -verify -iroutliner < %s | FileCheck %s
 
 ; Show that we do not extract phi nodes as it would require extra label and
 ; control flow checking.
 
 define void @function1(i32* %a, i32* %b) {
 ; CHECK-LABEL: @function1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br label [[FIRST:%.*]]
 ; CHECK:       first:
 ; CHECK-NEXT:    [[TMP0:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ 3, [[NEXT:%.*]] ]
-; CHECK-NEXT:    call void @function1.outlined(i32* [[A:%.*]], i32* [[B:%.*]])
+; CHECK-NEXT:    call void @outlined_ir_func_0(i32* [[A:%.*]], i32* [[B:%.*]])
 ; CHECK-NEXT:    ret void
 ; CHECK:       next:
 ; CHECK-NEXT:    br label [[FIRST]]
 ;
 entry:
   br label %first
 first:
   %0 = phi i32 [ 0, %entry ], [ 3, %next ]
   store i32 2, i32* %a, align 4
   store i32 3, i32* %b, align 4
   ret void
 next:
   br label %first
 }
 
 define void @function2(i32* %a, i32* %b) {
 ; CHECK-LABEL: @function2(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br label [[FIRST:%.*]]
 ; CHECK:       first:
 ; CHECK-NEXT:    [[TMP0:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ 3, [[NEXT:%.*]] ]
-; CHECK-NEXT:    call void @function2.outlined(i32* [[A:%.*]], i32* [[B:%.*]])
+; CHECK-NEXT:    call void @outlined_ir_func_0(i32* [[A:%.*]], i32* [[B:%.*]])
 ; CHECK-NEXT:    ret void
 ; CHECK:       next:
 ; CHECK-NEXT:    br label [[FIRST]]
 ;
 entry:
   br label %first
 first:
   %0 = phi i32 [ 0, %entry ], [ 3, %next ]
   store i32 2, i32* %a, align 4
   store i32 3, i32* %b, align 4
   ret void
 next:
   br label %first
 }

llvm/test/Transforms/IROutliner/legal-debug.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -verify -iroutliner < %s | FileCheck %s
 
 ; This test looks ahecks that debug info is extracted along with the other
 ; instructions.
 
 define void @function1() !dbg !6 {
 ; CHECK-LABEL: @function1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4, [[DBG17:!dbg !.*]]
 ; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32* [[A]], [[META9:metadata !.*]], metadata !DIExpression()), [[DBG17]]
 ; CHECK-NEXT:    [[B:%.*]] = alloca i32, align 4, [[DBG18:!dbg !.*]]
 ; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32* [[B]], [[META11:metadata !.*]], metadata !DIExpression()), [[DBG18]]
 ; CHECK-NEXT:    [[C:%.*]] = alloca i32, align 4, [[DBG19:!dbg !.*]]
 ; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32* [[C]], [[META12:metadata !.*]], metadata !DIExpression()), [[DBG19]]
-; CHECK-NEXT:    call void @function1.outlined(i32* [[A]], i32* [[B]], i32* [[C]]), [[DBG20:!dbg !.*]]
+; CHECK-NEXT:    call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]]), [[DBG20:!dbg !.*]]
 ; CHECK-NEXT:    ret void, [[DBG21:!dbg !.*]]
 ;
 entry:
   %a = alloca i32, align 4, !dbg !17
   call void @llvm.dbg.value(metadata i32* %a, metadata !9, metadata !DIExpression()), !dbg !17
   %b = alloca i32, align 4, !dbg !18
   call void @llvm.dbg.value(metadata i32* %b, metadata !11, metadata !DIExpression()), !dbg !18
   %c = alloca i32, align 4, !dbg !19

 ; CHECK-LABEL: @function2(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4, [[DBG30:!dbg !.*]]
 ; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32* [[A]], [[META24:metadata !.*]], metadata !DIExpression()), [[DBG30]]
 ; CHECK-NEXT:    [[B:%.*]] = alloca i32, align 4, [[DBG31:!dbg !.*]]
 ; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32* [[B]], [[META25:metadata !.*]], metadata !DIExpression()), [[DBG31]]
 ; CHECK-NEXT:    [[C:%.*]] = alloca i32, align 4, [[DBG32:!dbg !.*]]
 ; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32* [[C]], [[META26:metadata !.*]], metadata !DIExpression()), [[DBG32]]
-; CHECK-NEXT:    call void @function2.outlined(i32* [[A]], i32* [[B]], i32* [[C]]), [[DBG33:!dbg !.*]]
+; CHECK-NEXT:    call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]]), [[DBG33:!dbg !.*]]
 ; CHECK-NEXT:    ret void, [[DBG34:!dbg !.*]]
 ;
 entry:
   %a = alloca i32, align 4, !dbg !35
   call void @llvm.dbg.value(metadata i32* %a, metadata !29, metadata !DIExpression()), !dbg !35
   %b = alloca i32, align 4, !dbg !36
   call void @llvm.dbg.value(metadata i32* %b, metadata !30, metadata !DIExpression()), !dbg !36
   %c = alloca i32, align 4, !dbg !37

llvm/test/Transforms/IROutliner/outlining-address-taken.ll

 }
 
 define void @outline_2() {
 ; CHECK-LABEL: @outline_2(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[B:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT:    call void @[[FUNCTION_2:.*]](i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT:    call void @[[FUNCTION_1]](i32* [[A]], i32* [[B]], i32* [[C]])
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %a = alloca i32, align 4
   %b = alloca i32, align 4
   %c = alloca i32, align 4
   store i32 2, i32* %a, align 4
   store i32 3, i32* %b, align 4
new_block:
   store i32 3, i32* %b, align 4
   store i32 4, i32* %c, align 4
   %al = load i32, i32* %a
   %bl = load i32, i32* %b
   %cl = load i32, i32* %c
   ret void
 }
 
-; CHECK: define internal void @[[FUNCTION_2]](i32* [[ARG0:%.*]], i32* [[ARG1:%.*]], i32* [[ARG2:%.*]])
+; CHECK: define internal void @[[FUNCTION_1]](i32* [[ARG0:%.*]], i32* [[ARG1:%.*]], i32* [[ARG2:%.*]])
 ; CHECK: entry_to_outline:
 ; CHECK-NEXT:    store i32 2, i32* [[ARG0]], align 4
 ; CHECK-NEXT:    store i32 3, i32* [[ARG1]], align 4
 ; CHECK-NEXT:    store i32 4, i32* [[ARG2]], align 4
 ; CHECK-NEXT:    [[AL:%.*]] = load i32, i32* [[ARG0]], align 4
 ; CHECK-NEXT:    [[BL:%.*]] = load i32, i32* [[ARG1]], align 4
 ; CHECK-NEXT:    [[CL:%.*]] = load i32, i32* [[ARG2]], align 4

llvm/test/Transforms/IROutliner/outlining-different-constants.ll

 ; CHECK-LABEL: @outline_constants2(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[B:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[C:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    store i32 2, i32* [[A]], align 4
 ; CHECK-NEXT:    store i32 3, i32* [[B]], align 4
 ; CHECK-NEXT:    store i32 4, i32* [[C]], align 4
-; CHECK-NEXT:    call void @[[FUNCTION_1:.*]](i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT:    call void @[[FUNCTION_0]](i32* [[A]], i32* [[B]], i32* [[C]])
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %a = alloca i32, align 4
   %b = alloca i32, align 4
   %c = alloca i32, align 4
   store i32 2, i32* %a, align 4
   store i32 3, i32* %b, align 4

llvm/test/Transforms/IROutliner/outlining-different-structure.ll

 ; CHECK-LABEL: @outline_constants2(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[B:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[C:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    store i32 2, i32* [[A]], align 4
 ; CHECK-NEXT:    store i32 3, i32* [[B]], align 4
 ; CHECK-NEXT:    store i32 4, i32* [[C]], align 4
-; CHECK-NEXT:    call void @[[FUNCTION_1:.*]](i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT:    call void @[[FUNCTION_0]](i32* [[A]], i32* [[B]], i32* [[C]])
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %a = alloca i32, align 4
   %b = alloca i32, align 4
   %c = alloca i32, align 4
   store i32 2, i32* %a, align 4
   store i32 3, i32* %b, align 4

llvm/test/Transforms/IROutliner/outlining-same-constants.ll

 }
 
 define void @outline_constants2() {
 ; CHECK-LABEL: @outline_constants2(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[B:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    [[C:%.*]] = alloca i32, align 4
-; CHECK-NEXT:    call void @[[FUNCTION_1:.*]](i32* [[A]], i32* [[B]], i32* [[C]])
+; CHECK-NEXT:    call void @[[FUNCTION_0]](i32* [[A]], i32* [[B]], i32* [[C]])
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %a = alloca i32, align 4
   %b = alloca i32, align 4
   %c = alloca i32, align 4
   store i32 2, i32* %a, align 4
   store i32 3, i32* %b, align 4

llvm/test/Transforms/IROutliner/outlining-same-globals.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -verify -iroutliner < %s | FileCheck %s
 
 @global1 = global i32 1, align 4
 @global2 = global i32 2, align 4
 
 ; This test looks at the globals in the regions, and if it they are the
 ; same it outlines the region without elevating the globals to arguments.
 
 define void @outline_globals1() {
 ; CHECK-LABEL: @outline_globals1(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    call void @[[FUNCTION_0:.*]]()
+; CHECK-NEXT:    call void @outlined_ir_func_0()
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %0 = load i32, i32* @global1
   %1 = load i32, i32* @global2
   %2 = add i32 %0, %1
   ret void
 }
 
 define void @outline_globals2() {
 ; CHECK-LABEL: @outline_globals2(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    call void @[[FUNCTION_1:.*]]()
+; CHECK-NEXT:    call void @outlined_ir_func_0()
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %0 = load i32, i32* @global1
   %1 = load i32, i32* @global2
   %2 = add i32 %0, %1
   ret void
 }
 
-; CHECK: define internal void @[[FUNCTION_0]]()
-; CHECK: entry_to_outline:
-; CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* @global1, align 4
-; CHECK-NEXT: [[TMP2:%.*]] = load i32, i32* @global2, align 4
-; CHECK-NEXT: [[ADD:%.*]] = add i32 [[TMP1]], [[TMP2]]
-
-
-; CHECK: define internal void @[[FUNCTION_1]]()
+; CHECK: define internal void @outlined_ir_func_0()
 ; CHECK: entry_to_outline:
 ; CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* @global1, align 4
 ; CHECK-NEXT: [[TMP2:%.*]] = load i32, i32* @global2, align 4
 ; CHECK-NEXT: [[ADD:%.*]] = add i32 [[TMP1]], [[TMP2]]